/*
   * Licensed to the Apache Software Foundation (ASF) under one   *
   * or more contributor license agreements.  See the NOTICE file *
   * distributed with this work for additional information        *
   * regarding copyright ownership.  The ASF licenses this file   *
   * to you under the Apache License, Version 2.0 (the            *
   * "License"); you may not use this file except in compliance   *
   * with the License.  You may obtain a copy of the License at   *
   *                                                              *
  *   http://www.apache.org/licenses/LICENSE-2.0                 *
  *                                                              *
  * Unless required by applicable law or agreed to in writing,   *
  * software distributed under the License is distributed on an  *
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
  * KIND, either express or implied.  See the License for the    *
  * specific language governing permissions and limitations      *
  * under the License.                                           *
  */
  
  package org.apache.rat.report.claim;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.ArrayList;
  import java.util.Comparator;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  import java.util.concurrent.ConcurrentHashMap;
  
  import javax.xml.parsers.DocumentBuilder;
  
  import org.apache.commons.io.function.IOSupplier;
  import org.apache.commons.lang3.StringUtils;
  import org.apache.rat.api.Document;
  import org.apache.rat.configuration.XMLConfigurationReader;
  import org.apache.rat.report.xml.writer.XmlWriter;
  import org.apache.rat.utils.StandardXmlFactory;
  import org.xml.sax.SAXException;
  
  /**
   * This class provides a numerical overview about
   * the report.
   */
  public class ClaimStatistic {
      // keep the counter types in alphabetical order
      /** The counter types */
      public enum Counter {
          /** count of approved files */
          APPROVED("A count of approved licenses.", -1, 0),
          /** count of archive files */
          ARCHIVES("A count of archive files.", -1, 0),
          /** count of binary  files */
          BINARIES("A count of binary files.", -1, 0),
          /** count of distinct document types */
          DOCUMENT_TYPES("A count of distinct document types.", -1, 1),
          /** count of generated/ignored files */
          IGNORED("A count of ignored files.", -1, 0),
          /** count of license categories */
          LICENSE_CATEGORIES("A count of distinct license categories.", -1, 1),
          /** count of distinct license names */
          LICENSE_NAMES("A count of distinct license names.", -1, 1),
          /** count of note files */
          NOTICES("A count of notice files.", -1, 0),
          /** count of standard files */
          STANDARDS("A count of standard files.", -1, 1),
          /** count of unapproved files */
          UNAPPROVED("A count of unapproved licenses.", 0, 0),
          /** count of unknown files */
          UNKNOWN("A count of unknown file types.", -1, 0);
  
          /** The description of the counter */
          private final String description;
          /** The default max value for the counter */
          private final int defaultMaxValue;
          /** The default minimum value for the counter */
          private final int defaultMinValue;
  
          Counter(final String description, final int defaultMaxValue, final int defaultMinValue) {
              this.description = description;
              this.defaultMaxValue = defaultMaxValue;
              this.defaultMinValue = defaultMinValue;
          }
  
          /**
           * Gets the description of the counter.
           * @return The description of the counter.
           */
          public String getDescription() {
              return description;
          }
  
          /**
           * Gets the default maximum value for the counter.
           * @return the default maximum value for the counter.
           */
          public int getDefaultMaxValue() {
              return defaultMaxValue;
          }
         /**
          * Gets the default minimum value for the counter.
          * @return the default maximum value for the counter.
          */
         public int getDefaultMinValue() {
             return defaultMinValue;
         }
 
         /**
          * Display name is capitalized and any underscores are replaced by spaces.
          * @return displayName of the counter, capitalized and without underscores.
          */
         public String displayName() {
             return StringUtils.capitalize(name().replace("_", " ").toLowerCase(Locale.ROOT));
         }
     }
 
     /** Count of license family name to counter */
     private final ConcurrentHashMap<String, IntCounter> licenseNameMap = new ConcurrentHashMap<>();
     /** Map of license family category to counter */
     private final ConcurrentHashMap<String, IntCounter> licenseFamilyCategoryMap = new ConcurrentHashMap<>();
     /** Map of document type to counter */
     private final ConcurrentHashMap<Document.Type, IntCounter> documentTypeMap = new ConcurrentHashMap<>();
     /** Map of counter type to value */
     private final ConcurrentHashMap<ClaimStatistic.Counter, IntCounter> counterMap = new ConcurrentHashMap<>();
 
     public SerDes serDes() {
         return new SerDes();
     }
     /**
      * Converts {@code null} counter to 0.
      *
      * @param counter the Counter to retrieve the value from.
      * @return 0 if counter is {@code null} or counter value otherwise.
      */
     private int getValue(final IntCounter counter) {
         return counter == null ? 0 : counter.value();
     }
 
     /**
      * Returns the counts for the counter.
      * @param counter the counter to get the value for.
      * @return the number times the counter type was seen.
      */
     public int getCounter(final Counter counter) {
         return getValue(counterMap.get(counter));
     }
 
     /**
      * Increments the counts for the counter.
      * @param counter the counter to increment.
      * @param value the value to increment the counter by.
      */
     public void incCounter(final Counter counter, final int value) {
         counterMap.compute(counter, (k, v) -> v == null ? new IntCounter().increment(value) : v.increment(value));
     }
 
     /**
      * Increments the counts for the counter.
      * @param counter the counter to increment.
      * @param value the value to increment the counter by.
      */
     public void setCounter(final Counter counter, final int value) {
         counterMap.put(counter, new IntCounter().increment(value));
     }
 
     /**
      * Gets the counts for the Document.Type.
      * @param documentType the Document.Type to get the counter for.
      * @return the number times the Document.Type was seen.
      */
     public int getCounter(final Document.Type documentType) {
         return getValue(documentTypeMap.get(documentType));
     }
 
     /**
      * Gets the list of Document.Types seen in the run.
      * @return the list of Document.Types seen in the run.
      */
     public List<Document.Type> getDocumentTypes() {
         List<Document.Type> result = new ArrayList<>(documentTypeMap.keySet());
         result.sort(Comparator.comparing(Enum::name));
         return result;
     }
 
     /**
      * Increments the number of times the Document.Type was seen.
      * @param documentType the Document.Type to increment.
      * @param value the value to increment the counter by.
      */
     public void incCounter(final Document.Type documentType, final int value) {
         documentTypeMap.compute(documentType, (k, v) -> updateCounter(Counter.DOCUMENT_TYPES, v, value));
         switch (documentType) {
             case STANDARD -> incCounter(Counter.STANDARDS, value);
             case ARCHIVE -> incCounter(Counter.ARCHIVES, value);
             case BINARY -> incCounter(Counter.BINARIES, value);
             case NOTICE -> incCounter(Counter.NOTICES, value);
             case UNKNOWN -> incCounter(Counter.UNKNOWN, value);
             case IGNORED -> incCounter(Counter.IGNORED, value);
         }
     }
 
     /**
      * Gets the counts for the license category.
      * @param licenseFamilyCategory the license family category to get the count for.
      * @return the number of times the license family category was seen.
      */
     public int getLicenseCategoryCount(final String licenseFamilyCategory) {
         return getValue(licenseFamilyCategoryMap.get(licenseFamilyCategory));
     }
 
     /**
      * Gets the counts for the license name.
      * @param licenseName the license name to get the count for.
      * @return the number of times the license family category was seen.
      */
     public int getLicenseNameCount(final String licenseName) {
         return getValue(licenseNameMap.get(licenseName));
     }
 
     /**
      * Updates the intCounter with the value and if the intCounter was {@code null} creates a new one and registers the
      * creation as a counter type.
      * @param counter the Type of the counter.
      * @param intCounter the IntCounter to update. May be {@code null}.
      * @param value the value to add to the int counter.
      * @return the intCounter if it was not {@code null}, a new IntCounter otherwise.
      */
     private IntCounter updateCounter(final Counter counter, final IntCounter intCounter, final int value) {
         if (intCounter == null) {
             incCounter(counter, 1);
             return new IntCounter().increment(value);
         } else {
             return intCounter.increment(value);
         }
     }
 
     /**
      * Increments the number of times a license family category was seen.
      * @param licenseFamilyCategory the License family category to increment.
      * @param value the value to increment the count by.
      */
     public void incLicenseCategoryCount(final String licenseFamilyCategory, final int value) {
         licenseFamilyCategoryMap.compute(licenseFamilyCategory, (k, v) -> updateCounter(Counter.LICENSE_CATEGORIES, v, value));
     }
 
     /**
      * Gets the set of license family categories that were seen.
      * @return A set of license family categories.
      */
     public List<String> getLicenseFamilyCategories() {
         List<String> result = new ArrayList<>(licenseFamilyCategoryMap.keySet());
         result.sort(String::compareTo);
         return result;
     }
 
     /**
      * Gets the license names sorted by name.
      * @return sorted list of license names.
      */
     public List<String> getLicenseNames() {
         List<String> result = new ArrayList<>(licenseNameMap.keySet());
         result.sort(String::compareTo);
         return result;
     }
 
     /**
      * Increments the license family name count.
      * @param licenseName the license name to increment.
      * @param value the value to increment the count by.
      */
     public void incLicenseNameCount(final String licenseName, final int value) {
         licenseNameMap.compute(licenseName, (k, v) -> updateCounter(Counter.LICENSE_NAMES, v, value));
     }
 
     /**
      * A class that wraps an int and allows easy increment and retrieval.
      */
     static class IntCounter {
         /**
          * The value of the counter
          */
         private int value;
 
         /**
          * Increment the count.
          * @param count the count to increment by (can be negative).
          * @return this.
          */
         public IntCounter increment(final int count) {
             value += count;
             return this;
         }
 
         /**
          * Retrieves the count.
          * @return the count contained by this counter.
          */
         public int value() {
             return value;
         }
 
         @Override
         public String toString() {
             return String.valueOf(value);
         }
     }
 
     /**
      * Serialize and deserialize the claim Statistic.
      */
     public class SerDes {
         /** The count attribute string. */
         private static final String COUNT = "count";
         /** The name attribute string. */
         private static final String NAME = "name";
 
         /**
          * Serializes the claim statistic into an appendable.
          * @param appendable the appendable to write to.
          * @throws IOException on error.
          */
         public void serialize(final Appendable appendable) throws IOException {
             try (XmlWriter writer = new XmlWriter(appendable)) {
                 writer.startDocument().startElement("ClaimStatistic")
                         .startElement("licenseNameMap");
                 for (Map.Entry<String, IntCounter> entry : licenseNameMap.entrySet()) {
                     if (entry.getValue().value > 0) {
                         writer.startElement("licenseName")
                                 .attribute(COUNT, entry.getValue().toString())
                                 .attribute(NAME, entry.getKey()).closeElement();
                     }
                 }
                 writer.closeElement()
                         .startElement("licenseFamilyCategoryMap");
                 for (Map.Entry<String, IntCounter> entry : licenseFamilyCategoryMap.entrySet()) {
                     if (entry.getValue().value > 0) {
                         writer.startElement("familyCategory")
                                 .attribute(COUNT, entry.getValue().toString())
                                 .attribute(NAME, entry.getKey()).closeElement();
                     }
                 }
                 writer.closeElement()
                         .startElement("documentTypeMap");
                 for (Map.Entry<Document.Type, IntCounter> entry : documentTypeMap.entrySet()) {
                     if (entry.getValue().value > 0) {
                         writer.startElement("documentType")
                                 .attribute(COUNT, entry.getValue().toString())
                                 .attribute(NAME, entry.getKey().name()).closeElement();
                     }
                 }
                 writer.closeElement()
                         .startElement("counterMap");
                 for (Map.Entry<ClaimStatistic.Counter, IntCounter> entry : counterMap.entrySet()) {
                     if (entry.getValue().value > 0) {
                         writer.startElement("counter")
                                 .attribute(COUNT, entry.getValue().toString())
                                 .attribute(NAME, entry.getKey().name()).closeElement();
                     }
                 }
                 writer.closeElement();
             }
         }
 
         /**
          * Deserializes a ClaimStatistic from an input stream.
          * @param inputStreamSupplier the supplier of the input stream to deserialize from.
          * @throws IOException on error.
          */
         public void deserialize(final IOSupplier<InputStream> inputStreamSupplier) throws IOException {
             DocumentBuilder builder = StandardXmlFactory.documentBuilder();
             org.w3c.dom.Document document;
 
             try (InputStream stream = inputStreamSupplier.get()) {
                 document = builder.parse(stream);
             } catch (SAXException e) {
                 throw new IOException("Unable to read input", e);
             }
 
             XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("licenseName"), node -> {
                 Map<String, String> attributes = XMLConfigurationReader.attributes(node);
                 incLicenseNameCount(attributes.get(NAME), Integer.parseInt(attributes.get(COUNT)));
             });
 
             XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("familyCategory"), node -> {
                 Map<String, String> attributes = XMLConfigurationReader.attributes(node);
                 incLicenseCategoryCount(attributes.get(NAME), Integer.parseInt(attributes.get(COUNT)));
             });
 
             XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("documentType"), node -> {
                 Map<String, String> attributes = XMLConfigurationReader.attributes(node);
                 Document.Type type = Document.Type.valueOf(attributes.get(NAME));
                 incCounter(type, Integer.parseInt(attributes.get(COUNT)));
             });
 
             XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("counter"), node -> {
                 Map<String, String> attributes = XMLConfigurationReader.attributes(node);
                 Counter type = Counter.valueOf(attributes.get(NAME));
                 setCounter(type, Integer.parseInt(attributes.get(COUNT)));
             });
         }
     }
 }