/*
    * 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.anttasks;
  
  import org.apache.commons.cli.Option;
  import org.apache.commons.lang3.StringUtils;
  import org.apache.rat.commandline.Arg;
  import org.apache.rat.utils.CasedString;
  import org.apache.rat.utils.DefaultLog;
  import org.apache.rat.utils.Log;
  import org.apache.tools.ant.Task;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  import java.util.Objects;
  import java.util.stream.Collectors;
  
  /**
   * Generated class to provide Ant support for standard RAT command line options.
   *
   * DO NOT EDIT - GENERATED FILE
   */
  public abstract class BaseAntTask extends Task {
  
      private final static Map<String,String> xlateName = new HashMap<>();
  
      private final static List<String> unsupportedArgs = new ArrayList<>();
  
      static {
          xlateName.put("addLicense", "add-license");
          unsupportedArgs.add("log-level");
          unsupportedArgs.add("dir");
          unsupportedArgs.add("help");
      }
  
      public static String createName(String longOpt) {
          String name = StringUtils.defaultIfEmpty(xlateName.get(longOpt), longOpt).toLowerCase(Locale.ROOT);
          return new CasedString(CasedString.StringCase.KEBAB, name).toCase(CasedString.StringCase.CAMEL);
      }
  
      public static List<String> unsupportedArgs() {
          return Collections.unmodifiableList(unsupportedArgs);
      }
  
      ///////////////////////// Start common Arg manipulation code
  
      /**
       * A map of CLI based arguments to values.
       */
      protected final Map<String, List<String>> args = new HashMap<>();
  
      /**
       * Gets the list of arguments prepared for the CLI code to parse.
       * @return the List of arguments for the CLI command line.
       */
      protected List<String> args() {
          List<String> result = new ArrayList<>();
          for (Map.Entry<String, List<String>> entry : args.entrySet()) {
              result.add("--" + entry.getKey());
              result.addAll(entry.getValue().stream().filter(Objects::nonNull).collect(Collectors.toList()));
          }
          return result;
      }
  
      private String argsKey(Option opt) {
          return StringUtils.defaultIfEmpty(opt.getLongOpt(), opt.getKey());
      }
  
      private boolean validateSet(String key) {
          Arg arg = Arg.findArg(key);
          if (arg != null) {
              Option opt = arg.find(key);
              Option main = arg.option();
              if (opt.isDeprecated()) {
                  args.remove(argsKey(main));
                  // deprecated options must be explicitly set so let it go.
                  return true;
             }
             // non-deprecated options may have default so ignore it if another option has already been set.
             for (Option o : arg.group().getOptions()) {
                 if (!o.equals(main)) {
                     if (args.containsKey(argsKey(o))) {
                         return false;
                     }
                 }
             }
             return true;
         }
         return false;
     }
 
     /**
      * Set a key and value into the argument list.
      * Replaces any existing value.
      * @param key the key for the map.
      * @param value the value to set.
      */
     protected void setArg(String key, String value) {
         if (validateSet(key)) {
             List<String> values = new ArrayList<>();
             if (DefaultLog.getInstance().isEnabled(Log.Level.DEBUG)) {
                 DefaultLog.getInstance().debug(String.format("Adding [%s] to %s", String.join(", ", values), key));
             }
             values.add(value);
             args.put(key, values);
         }
     }
 
     /**
      * Get the list of values for a key.
      * @param key the key for the map.
      * @return the list of values for the key or {@code null} if not set.
      */
     public List<String> getArg(String key) {
         return args.get(key);
     }
 
     /**
      * Add values to the key in the argument list.
      * If the key does not exist, adds it.
      * @param key the key for the map.
      * @param value the value to set.
      */
     protected void addArg(String key, String[] value) {
         if (validateSet(key)) {
             if (DefaultLog.getInstance().isEnabled(Log.Level.DEBUG)) {
                 DefaultLog.getInstance().debug(String.format("Adding [%s] to %s", String.join(", ", Arrays.asList(value)), key));
             }
             List<String> values = args.get(key);
             if (values == null) {
                 values = new ArrayList<>();
                 args.put(key, values);
             }
             values.addAll(Arrays.asList(value));
         }
     }
 
     /**
      * Add a value to the key in the argument list.
      * If the key does not exist, adds it.
      * @param key the key for the map.
      * @param value the value to set.
      */
     protected void addArg(String key, String value) {
         if (validateSet(key)) {
             List<String> values = args.get(key);
             if (DefaultLog.getInstance().isEnabled(Log.Level.DEBUG)) {
                 DefaultLog.getInstance().debug(String.format("Adding [%s] to %s", String.join(", ", Arrays.asList(value)), key));
             }
             if (values == null) {
                 values = new ArrayList<>();
                 args.put(key, values);
             }
             values.add(value);
         }
     }
 
     /**
      * Remove a key from the argument list.
      * @param key the key to remove from the map.
      */
     protected void removeArg(String key) {
         args.remove(key);
     }
 
  ///////////////////////// End common Arg manipulation code
 
     protected BaseAntTask() {}
 
     /**
      * A child element.
      */
     protected class Child {
         final String key;
 
         /**
          * Constructor.
          * @param key The key for this child in the CLI map.
          */
         protected Child(String key) {
             this.key = key;
         }
 
         /**
          * Sets the text enclosed in the child element.
          * @param arg The text enclosed in the child element.
          */
         public void addText(String arg) {
             addArg(key, arg);
         }
     }
 
     /*  GENERATED METHODS */
 
     /**
      * The copyright message to use in the license headers.
      * Deprecated for removal since 0.17: Use --edit-copyright instead.
      * @deprecated
      * @param copyright The value to set
      */
     public void setCopyright(String copyright) {
         setArg("copyright", copyright);
 
     }
 
     /**
      * The copyright message to use in the license headers. Usually in the form of &quot;Copyright 2008 Foo&quot;.  Only valid with editLicense attribute
      * @param editCopyright The value to set
      */
     public void setEditCopyright(String editCopyright) {
         setArg("edit-copyright", editCopyright);
 
     }
 
     /**
      * Forces any changes in files to be written directly to the source files (i.e. new files are not created).
      * Deprecated for removal since 0.17: Use --edit-overwrite instead.
      * @deprecated
      */
     public void setForce(boolean force) {
         if (force) { setArg("force", null); } else { removeArg("force"); }
     }
 
     /**
      * Forces any changes in files to be written directly to the source files (i.e. new files are not created). Only valid with editLicense attribute
      */
     public void setEditOverwrite(boolean editOverwrite) {
         if (editOverwrite) { setArg("edit-overwrite", null); } else { removeArg("edit-overwrite"); }
     }
 
     /**
      * Add the default license header to any file with an unknown license that is not in the exclusion list.
      * Deprecated for removal since 0.17: Use --edit-license instead.
      * @deprecated
      */
     public void setAddLicense(boolean addLicense) {
         if (addLicense) { setArg("addLicense", null); } else { removeArg("addLicense"); }
     }
 
     /**
      * Add the default license header to any file with an unknown license that is not in the exclusion list. By default new files will be created with the license header, to force the modification of existing files use the editOverwrite attribute option.
      */
     public void setEditLicense(boolean editLicense) {
         if (editLicense) { setArg("edit-license", null); } else { removeArg("edit-license"); }
     }
 
     /**
      * Ignore default configuration.
      */
     public void setConfigurationNoDefaults(boolean configurationNoDefaults) {
         if (configurationNoDefaults) { setArg("configuration-no-defaults", null); } else { removeArg("configuration-no-defaults"); }
     }
 
     /**
      * Ignore default configuration.
      * Deprecated for removal since 0.17: Use --configuration-no-defaults instead.
      * @deprecated
      */
     public void setNoDefaultLicenses(boolean noDefaultLicenses) {
         if (noDefaultLicenses) { setArg("no-default-licenses", null); } else { removeArg("no-default-licenses"); }
     }
 
     /**
      * Name of file containing the approved License IDs.
      * @param licensesApprovedFile The value to set
      */
     public void setLicensesApprovedFile(String licensesApprovedFile) {
         setArg("licenses-approved-file", licensesApprovedFile);
 
     }
 
     /**
      * Name of file containing the approved family IDs.
      * @param licenseFamiliesApprovedFile The value to set
      */
     public void setLicenseFamiliesApprovedFile(String licenseFamiliesApprovedFile) {
         setArg("license-families-approved-file", licenseFamiliesApprovedFile);
 
     }
 
     /**
      * Name of file containing the denied license IDs.
      * @param licensesDeniedFile The value to set
      */
     public void setLicensesDeniedFile(String licensesDeniedFile) {
         setArg("licenses-denied-file", licensesDeniedFile);
 
     }
 
     /**
      * Name of file containing the denied license IDs.
      * @param licenseFamiliesDeniedFile The value to set
      */
     public void setLicenseFamiliesDeniedFile(String licenseFamiliesDeniedFile) {
         setArg("license-families-denied-file", licenseFamiliesDeniedFile);
 
     }
 
     /**
      * Reads &lt;Expression&gt; entries from a file. Entries will be excluded from processing.
      * Deprecated for removal since 0.17: Use --input-exclude-file instead.
      * @deprecated
      * @param excludeFile The value to set
      */
     public void setExcludeFile(String excludeFile) {
         setArg("exclude-file", excludeFile);
 
     }
 
     /**
      * Reads &lt;Expression&gt; entries from a file. Entries will be excluded from processing.
      * @param inputExcludeFile The value to set
      */
     public void setInputExcludeFile(String inputExcludeFile) {
         setArg("input-exclude-file", inputExcludeFile);
 
     }
 
     /**
      * Excludes files with sizes less than the given argument.
      * @param inputExcludeSize The value to set
      */
     public void setInputExcludeSize(String inputExcludeSize) {
         setArg("input-exclude-size", inputExcludeSize);
 
     }
 
     /**
      * Reads &lt;Expression&gt; entries from a file. Entries will override excluded files.
      * @param inputIncludeFile The value to set
      */
     public void setInputIncludeFile(String inputIncludeFile) {
         setArg("input-include-file", inputIncludeFile);
 
     }
 
     /**
      * Reads &lt;Expression&gt; entries from a file. Entries will be excluded from processing.
      * Deprecated for removal since 0.17: Use --input-include-file instead.
      * @deprecated
      * @param includesFile The value to set
      */
     public void setIncludesFile(String includesFile) {
         setArg("includes-file", includesFile);
 
     }
 
     /**
      * Scans hidden directories.
      * Deprecated for removal since 0.17: Use --input-include-std with 'HIDDEN_DIR' argument instead.
      * @deprecated
      */
     public void setScanHiddenDirectories(boolean scanHiddenDirectories) {
         if (scanHiddenDirectories) { setArg("scan-hidden-directories", null); } else { removeArg("scan-hidden-directories"); }
     }
 
     /**
      * XSLT stylesheet to use when creating the report. Either an external xsl file may be specified or one of the internal named sheets.
      * @param outputStyle The value to set
      */
     public void setOutputStyle(String outputStyle) {
         setArg("output-style", outputStyle);
 
     }
 
     /**
      * XSLT stylesheet to use when creating the report.
      * Deprecated for removal since 0.17: Use --output-style instead.
      * @deprecated
      * @param stylesheet The value to set
      */
     public void setStylesheet(String stylesheet) {
         setArg("stylesheet", stylesheet);
 
     }
 
     /**
      * forces XML output rather than the textual report.
      * Deprecated for removal since 0.17: Use --output-style with the 'xml' argument instead.
      * @deprecated
      */
     public void setXml(boolean xml) {
         if (xml) { setArg("xml", null); } else { removeArg("xml"); }
     }
 
     /**
      * List the defined licenses.
      * @param outputLicenses The value to set
      */
     public void setOutputLicenses(String outputLicenses) {
         setArg("output-licenses", outputLicenses);
 
     }
 
     /**
      * List the defined licenses.
      * Deprecated for removal since 0.17: Use --output-licenses instead.
      * @deprecated
      * @param listLicenses The value to set
      */
     public void setListLicenses(String listLicenses) {
         setArg("list-licenses", listLicenses);
 
     }
 
     /**
      * List the defined license families.
      * @param outputFamilies The value to set
      */
     public void setOutputFamilies(String outputFamilies) {
         setArg("output-families", outputFamilies);
 
     }
 
     /**
      * List the defined license families.
      * Deprecated for removal since 0.17: Use --output-families instead.
      * @deprecated
      * @param listFamilies The value to set
      */
     public void setListFamilies(String listFamilies) {
         setArg("list-families", listFamilies);
 
     }
 
     /**
      * If set do not update the files but generate the reports.
      */
     public void setDryRun(boolean dryRun) {
         if (dryRun) { setArg("dry-run", null); } else { removeArg("dry-run"); }
     }
 
     /**
      * Define the output file where to write a report to.
      * Deprecated for removal since 0.17: Use --output-file instead.
      * @deprecated
      * @param out The value to set
      */
     public void setOut(String out) {
         setArg("out", out);
 
     }
 
     /**
      * Define the output file where to write a report to.
      * @param outputFile The value to set
      */
     public void setOutputFile(String outputFile) {
         setArg("output-file", outputFile);
 
     }
 
     /**
      * Specifies the level of detail in ARCHIVE file reporting.
      * @param outputArchive The value to set
      */
     public void setOutputArchive(String outputArchive) {
         setArg("output-archive", outputArchive);
 
     }
 
     /**
      * Specifies the level of detail in STANDARD file reporting.
      * @param outputStandard The value to set
      */
     public void setOutputStandard(String outputStandard) {
         setArg("output-standard", outputStandard);
 
     }
 
     /**
      * Print information about registered licenses.
      */
     public void setHelpLicenses(boolean helpLicenses) {
         if (helpLicenses) { setArg("help-licenses", null); } else { removeArg("help-licenses"); }
     }
 
 
 
     /*  GENERATED CLASSES */
 
     /**
      * File names for system configuration.
      */
     public Config createConfig() {
         return new Config();
     }
 
     public class Config extends Child { Config() {super("config");}}
 
     /**
      * File names for system configuration.
      * Deprecated for removal since 0.17: Use --config instead.
      * @deprecated
      */
     public Licenses createLicenses() {
         return new Licenses();
     }
 
     public class Licenses extends Child { Licenses() {super("licenses");}}
 
     /**
      * The approved License IDs. These licenses will be added to the list of approved licenses.
      */
     public LicensesApproved createLicensesApproved() {
         return new LicensesApproved();
     }
 
     public class LicensesApproved extends Child { LicensesApproved() {super("licenses-approved");}}
 
     /**
      * Name of file containing the approved License IDs.
      */
     public LicensesApprovedFile createLicensesApprovedFile() {
         return new LicensesApprovedFile();
     }
 
     public class LicensesApprovedFile extends Child { LicensesApprovedFile() {super("licenses-approved-file");}}
 
     /**
      * The approved License Family IDs. These licenses families will be added to the list of approved licenses families.
      */
     public LicenseFamiliesApproved createLicenseFamiliesApproved() {
         return new LicenseFamiliesApproved();
     }
 
     public class LicenseFamiliesApproved extends Child { LicenseFamiliesApproved() {super("license-families-approved");}}
 
     /**
      * Name of file containing the approved family IDs.
      */
     public LicenseFamiliesApprovedFile createLicenseFamiliesApprovedFile() {
         return new LicenseFamiliesApprovedFile();
     }
 
     public class LicenseFamiliesApprovedFile extends Child { LicenseFamiliesApprovedFile() {super("license-families-approved-file");}}
 
     /**
      * The denied License IDs. These licenses will be removed from the list of approved licenses. Once licenses are removed they can not be added back.
      */
     public LicensesDenied createLicensesDenied() {
         return new LicensesDenied();
     }
 
     public class LicensesDenied extends Child { LicensesDenied() {super("licenses-denied");}}
 
     /**
      * Name of file containing the denied license IDs.
      */
     public LicensesDeniedFile createLicensesDeniedFile() {
         return new LicensesDeniedFile();
     }
 
     public class LicensesDeniedFile extends Child { LicensesDeniedFile() {super("licenses-denied-file");}}
 
     /**
      * The denied License family IDs. These license families will be removed from the list of approved licenses.
      */
     public LicenseFamiliesDenied createLicenseFamiliesDenied() {
         return new LicenseFamiliesDenied();
     }
 
     public class LicenseFamiliesDenied extends Child { LicenseFamiliesDenied() {super("license-families-denied");}}
 
     /**
      * Name of file containing the denied license IDs.
      */
     public LicenseFamiliesDeniedFile createLicenseFamiliesDeniedFile() {
         return new LicenseFamiliesDeniedFile();
     }
 
     public class LicenseFamiliesDeniedFile extends Child { LicenseFamiliesDeniedFile() {super("license-families-denied-file");}}
 
     /**
      * The acceptable maximum number for the specified counter. A value of '-1' specifies an unlimited number.
      */
     public CounterMax createCounterMax() {
         return new CounterMax();
     }
 
     public class CounterMax extends Child { CounterMax() {super("counter-max");}}
 
     /**
      * The minimum number for the specified counter.
      */
     public CounterMin createCounterMin() {
         return new CounterMin();
     }
 
     public class CounterMin extends Child { CounterMin() {super("counter-min");}}
 
     /**
      * A file containing file names to process. File names must use linux directory separator ('/') or none at all. File names that do not start with '/' are relative to the directory where the argument is located.
      */
     public InputSource createInputSource() {
         return new InputSource();
     }
 
     public class InputSource extends Child { InputSource() {super("input-source");}}
 
     /**
      * Excludes files matching &lt;Expression&gt;.
      * Deprecated for removal since 0.17: Use --input-exclude instead.
      * @deprecated
      */
     public Exclude createExclude() {
         return new Exclude();
     }
 
     public class Exclude extends Child { Exclude() {super("exclude");}}
 
     /**
      * Excludes files matching &lt;Expression&gt;.
      */
     public InputExclude createInputExclude() {
         return new InputExclude();
     }
 
     public class InputExclude extends Child { InputExclude() {super("input-exclude");}}
 
     /**
      * Reads &lt;Expression&gt; entries from a file. Entries will be excluded from processing.
      * Deprecated for removal since 0.17: Use --input-exclude-file instead.
      * @deprecated
      */
     public ExcludeFile createExcludeFile() {
         return new ExcludeFile();
     }
 
     public class ExcludeFile extends Child { ExcludeFile() {super("exclude-file");}}
 
     /**
      * Reads &lt;Expression&gt; entries from a file. Entries will be excluded from processing.
      */
     public InputExcludeFile createInputExcludeFile() {
         return new InputExcludeFile();
     }
 
     public class InputExcludeFile extends Child { InputExcludeFile() {super("input-exclude-file");}}
 
     /**
      * Excludes files defined in standard collections based on commonly occurring groups.
      */
     public InputExcludeStd createInputExcludeStd() {
         return new InputExcludeStd();
     }
 
     public class InputExcludeStd extends Child { InputExcludeStd() {super("input-exclude-std");}}
 
     /**
      * Excludes files with sizes less than the given argument.
      */
     public InputExcludeSize createInputExcludeSize() {
         return new InputExcludeSize();
     }
 
     public class InputExcludeSize extends Child { InputExcludeSize() {super("input-exclude-size");}}
 
     /**
      * Includes files matching &lt;Expression&gt;. Will override excluded files.
      */
     public InputInclude createInputInclude() {
         return new InputInclude();
     }
 
     public class InputInclude extends Child { InputInclude() {super("input-include");}}
 
     /**
      * Includes files matching &lt;Expression&gt;. Will override excluded files.
      * Deprecated for removal since 0.17: Use --input-include instead.
      * @deprecated
      */
     public Include createInclude() {
         return new Include();
     }
 
     public class Include extends Child { Include() {super("include");}}
 
     /**
      * Reads &lt;Expression&gt; entries from a file. Entries will override excluded files.
      */
     public InputIncludeFile createInputIncludeFile() {
         return new InputIncludeFile();
     }
 
     public class InputIncludeFile extends Child { InputIncludeFile() {super("input-include-file");}}
 
     /**
      * Reads &lt;Expression&gt; entries from a file. Entries will be excluded from processing.
      * Deprecated for removal since 0.17: Use --input-include-file instead.
      * @deprecated
      */
     public IncludesFile createIncludesFile() {
         return new IncludesFile();
     }
 
     public class IncludesFile extends Child { IncludesFile() {super("includes-file");}}
 
     /**
      * Includes files defined in standard collections based on commonly occurring groups. Will override excluded files.
      */
     public InputIncludeStd createInputIncludeStd() {
         return new InputIncludeStd();
     }
 
     public class InputIncludeStd extends Child { InputIncludeStd() {super("input-include-std");}}
 
     /**
      * Parse SCM based exclusion files to exclude specified files and directories.
      */
     public InputExcludeParsedScm createInputExcludeParsedScm() {
         return new InputExcludeParsedScm();
     }
 
     public class InputExcludeParsedScm extends Child { InputExcludeParsedScm() {super("input-exclude-parsed-scm");}}
 
     /**
      * Define the output file where to write a report to.
      * Deprecated for removal since 0.17: Use --output-file instead.
      * @deprecated
      */
     public Out createOut() {
         return new Out();
     }
 
     public class Out extends Child { Out() {super("out");}}
 
     /**
      * Define the output file where to write a report to.
      */
     public OutputFile createOutputFile() {
         return new OutputFile();
     }
 
     public class OutputFile extends Child { OutputFile() {super("output-file");}}
 
 
 }