/*
    * 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
    *
   *   https://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.documentation.options;
  
  import java.io.File;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Objects;
  import java.util.Optional;
  import java.util.Set;
  import java.util.TreeMap;
  import java.util.stream.Collectors;
  
  import org.apache.commons.cli.Option;
  import org.apache.commons.lang3.StringUtils;
  import org.apache.commons.text.WordUtils;
  import org.apache.rat.OptionCollection;
  import org.apache.rat.commandline.Arg;
  import org.apache.rat.document.DocumentName;
  import org.apache.rat.ui.UIOptionCollection;
  
  import static java.lang.String.format;
  
  /**
   * The collection of AntOptions.
   */
  public final class AntOptionCollection extends UIOptionCollection<AntOption> {
      /** mapping of standard name to non-conflicting name. */
      static final Map<String, String> RENAME_MAP;
      /**
       * The format for an XML element.
       */
      private static final String DEFAULT_XML = "<%1$s>%%s</%1$s>%n";
      /** Attributes that are required for example data. */
      private static final Map<String, Map<String, String>> REQUIRED_ATTRIBUTES = new HashMap<>();
      /** The list of data types that are specified as XML attributes in Ant build.xml documents. */
      private static final List<Class<?>> ATTRIBUTE_TYPES = new ArrayList<>();
      /** The map of option name conversions. */
      private final Map<Option, Option> conversionMap;
  
      static {
          RENAME_MAP = new HashMap<>();
          RENAME_MAP.put("addLicense", "add-license");
  
          Map<String, String> attributes = new HashMap<>();
          attributes.put("editLicense", "true");
          REQUIRED_ATTRIBUTES.put("copyright", attributes);
          REQUIRED_ATTRIBUTES.put("editCopyright", attributes);
          REQUIRED_ATTRIBUTES.put("force", attributes);
          REQUIRED_ATTRIBUTES.put("editOverwrite", attributes);
  
          // Types that are specified as XML attributes in Ant.
          ATTRIBUTE_TYPES.add(String.class);
          ATTRIBUTE_TYPES.add(String[].class);
          ATTRIBUTE_TYPES.add(Integer.class);
          ATTRIBUTE_TYPES.add(Long.class);
          ATTRIBUTE_TYPES.add(File.class);
          ATTRIBUTE_TYPES.add(DocumentName.class);
      }
  
      /**
       * Gets the map of standard Option names that are renamed to fit the Ant naming process.
       * @return the map of renamed Options.
       */
      public static Map<String, String> getRenameMap() {
          return new TreeMap<>(RENAME_MAP);
      }
  
      /**
       * Creates an instance of the AntOption Collection.
       */
      public AntOptionCollection() {
          this(new Builder());
      }
  
      /**
       * Create an instance.
       */
      private AntOptionCollection(final Builder builder) {
          super(new Builder());
          conversionMap = builder.conversions;
     }
 
     @Override
     public String rename(final Option option) {
         String key = super.rename(option);
         return StringUtils.defaultIfEmpty(RENAME_MAP.get(key), key);
     }
 
     /**
      * Returns the set of AntOptions that the argument was converted from.
      * @param antOption the AntOption to check.
      * @return returns a Set of AntOptions that were converted to the argument. May be an empty set.
      */
     public Set<AntOption> convertedFrom(final AntOption antOption) {
         return conversionMap.entrySet().stream().filter(e -> e.getValue().equals(antOption.getOption()))
                 .map(e -> getMappedOption(e.getKey()))
                 .filter(Optional::isPresent)
                 .map(Optional::get)
                 .collect(Collectors.toSet());
     }
 
     /**
      * If this option is converted to another option return that option otherwise
      * return this option.
      * @return the converted option.
      */
     public AntOption getActualAntOption(final AntOption antOption) {
         Option opt = conversionMap.get(antOption.getOption());
         return opt == null ? antOption : getMappedOption(opt).orElse(antOption);
     }
 
     /**
      * Returns {@code true} if this argument is an attribute to the Ant RAT call.
      * @param antOption the AntOption to check.
      * @return {@code true} if this argument is an attribute to the Ant RAT call.
      */
     public boolean isAttribute(final AntOption antOption) {
         Option opt = antOption.getOption();
         return (!opt.hasArg() || opt.getArgs() == 1) && convertedFrom(antOption).isEmpty() &&
                 ATTRIBUTE_TYPES.contains(opt.getType());
     }
 
     /**
      * Gets a map of attributes that are required for the example data.
      * @param name the attribute name to lookup.
      * @return the map of attributes that are required for the example data.
      */
     public Map<String, String> getRequiredAttributes(final String name) {
         return REQUIRED_ATTRIBUTES.get(name);
     }
 
     /**
      * Gets the Ant build type for the ArgumentType
      * @param type ArgumentType to get the Ant build type for.
      * @return the Ant build type for the ArgumentType
      */
     BuildType buildType(final OptionCollection.ArgumentType type) {
         return switch (type) {
             case FILE, DIRORARCHIVE -> new BuildType("filename") {
                 @Override
                 protected String getMethodFormat(final AntOption antOption) {
                     return "  <fileset file='%s' />\n";
                 }
             };
             case NONE -> new BuildType("");
             case COUNTERPATTERN -> new BuildType("cntr");
             case EXPRESSION -> new BuildType("expr");
             case STANDARDCOLLECTION -> new BuildType("std");
             case LICENSEID, FAMILYID -> new BuildType("lst");
             default -> new BuildType(type.getDisplayName()) {
                 @Override
                 protected String getMethodFormat(final AntOption antOption) {
                     return String.format(DEFAULT_XML, WordUtils.uncapitalize(antOption.getArgName()));
                 }
             };
         };
     }
 
     /**
      * The Builder for the AntOptionCollection.
      */
     public static final class Builder extends UIOptionCollection.Builder<AntOption, Builder> {
         /** Convert key to value type when generating code */
         private final Map<Option, Option> conversions = new HashMap<>();
 
         private Builder() {
             super(AntOption.AntOptionBuilder::new);
             Arg.getOptions().getOptions()
                     .stream().filter(o -> Objects.isNull(o.getLongOpt()))
                     .forEach(this::unsupported);
             unsupported(Arg.LOG_LEVEL)
                     .unsupported(Arg.DIR)
                     .unsupported(Arg.SOURCE)
                     .unsupported(Arg.HELP_LICENSES)
                     // conversions
                     .convert(Arg.LICENSES_APPROVED_FILE, Arg.LICENSES_APPROVED)
                     .convert(Arg.LICENSES_DENIED_FILE, Arg.LICENSES_DENIED)
                     .convert(Arg.FAMILIES_APPROVED_FILE, Arg.FAMILIES_APPROVED)
                     .convert(Arg.FAMILIES_DENIED_FILE, Arg.FAMILIES_DENIED)
                     .convert(Arg.INCLUDE_FILE, Arg.INCLUDE)
                     .convert(Arg.INCLUDE_STD, Arg.INCLUDE)
                     .convert(Arg.EXCLUDE_FILE, Arg.EXCLUDE)
                     .convert(Arg.EXCLUDE_STD, Arg.EXCLUDE);
         }
 
         /**
          * Converts one Arg type to another.
          * @param from the Arg to convert from.
          * @param to the Arg to convert to.
          * @return this
          */
         public Builder convert(final Arg from, final Arg to) {
             Option mapTo = to.option();
             for (Option option : from.group().getOptions()) {
                 if (!option.equals(mapTo) && !option.isDeprecated()) {
                     conversions.put(option, mapTo);
                 }
             }
             return self();
         }
     }
 
     /**
      * A mapping of data type of XML format.
      */
     public static class BuildType {
         /**
          * The configuration tag for this build type.
          */
         private final String tag;
         /**
          * If {@code true} adds the tag as the test extension.
          */
         private final boolean addExt;
 
         /**
          * The constructor for the build type.
          *
          * @param tag the XML tag for this data type.
          */
         BuildType(final String tag) {
             this.tag = tag;
             this.addExt = StringUtils.isNotEmpty(tag);
         }
 
         /**
          * Gets the method based on how many arguments an Ant option requires.
          *
          * @param antOption the Ant option to check.
          * @return the method format for the option.
          */
         protected String getMethodFormat(final AntOption antOption) {
             return String.format(DEFAULT_XML, tag);
         }
 
         /**
          * Gets a string comprising the Ant XML pattern for this data type and the number of arguments expected by the Ant option.
          *
          * @param delegateOption the Ant option that the call is delegated to.
          * @param antOption      the actual Ant option.
          * @param data           the data for the actual Ant option.
          * @return the Ant XML pattern for this data type.
          */
         public String getXml(final AntOption delegateOption, final AntOption antOption, final String data) {
             String fmt = getMethodFormat(antOption);
             String value = data == null ? WordUtils.uncapitalize(antOption.getArgName()) : data;
             String inner = format(fmt, value);
             return format("<%1$s>%2$s</%1$s>%n", delegateOption.getName(), inner);
         }
 
         /**
          * Gets a string comprising the Ant XML pattern for the specified AntOption.
          * @param antOption the ant option to get XML example for
          * @param data the data for the option.
          * @return an ANT XML formatted option.
          */
         public String getXml(final AntOption antOption, final String data) {
             AntOption delegateOption = antOption.getActualAntOption();
             if (delegateOption.isAttribute()) {
                 return "";
             } else {
                 return format(getMethodFormat(antOption), data);
             }
         }
 
         /**
          * Gets a test name for the AntOption.
          * @param antOption the Ant Option being tested
          * @return the test name for this type.
          */
         public String testName(final AntOption antOption) {
             return addExt ? format("%s_%s", antOption.getName(), antOption.getArgName()) : antOption.getName();
         }
     }
 }