/*
    * 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.documentation.options;
  
  import java.util.HashMap;
  import java.util.Locale;
  import java.util.Map;
  import java.util.Optional;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import org.apache.commons.cli.Option;
  import org.apache.commons.lang3.StringUtils;
  import org.apache.rat.OptionCollection;
  import org.apache.rat.commandline.Arg;
  
  import static java.lang.String.format;
  
  /**
   * Abstract class that provides the framework for UI-specific RAT options.
   * In this context UI option means an option expressed in the specific UI, such as:
   * @see AntOption
   * @see MavenOption
   * @see CLIOption
   */
  public abstract class AbstractOption {
      /** The pattern to match CLI options in text */
      protected static final Pattern PATTERN = Pattern.compile("-(-[a-z0-9]+)+");
      /** The actual UI-specific name for the option */
      protected final Option option;
      /** The name for the option */
      protected final String name;
      /** The argument type for this option */
      protected final OptionCollection.ArgumentType argumentType;
  
      /**
       * Constructor.
       *
       * @param option The CLI option
       * @param name the UI-specific name for the option.
       */
      AbstractOption(final Option option, final String name) {
          this.option = option;
          this.name = name;
          argumentType = option.hasArg() ?
                  option.getArgName() == null ? OptionCollection.ArgumentType.ARG :
                  OptionCollection.ArgumentType.valueOf(option.getArgName().toUpperCase(Locale.ROOT)) :
                  OptionCollection.ArgumentType.NONE;
      }
  
      /**
       * Gets the option this abstract option is wrapping.
       * @return the original Option.
       */
      public Option getOption() {
          return option;
      }
  
      /**
       * Return default value.
       * @return default value or {@code null} if no argument given.
       */
      public String getDefaultValue() {
          Arg arg = Arg.findArg(option);
          return arg == null ? null : arg.defaultValue();
      }
  
      /**
       * Provide means to wrap the given option depending on the UI-specific option implementation.
       * @param option The CLI option
       * @return the cleaned up option name.
       */
      protected abstract String cleanupName(Option option);
  
      /**
       * Gets an example of how to use this option in the native UI.
       * @return An example of how to use this option in the native UI.
       */
      public abstract String getExample();
  
      /**
       * Gets this option's cleaned up name.
       * @return This option's cleaned up name.
      */
     public String cleanupName() {
         return cleanupName(option);
     }
 
     /**
      * Replaces CLI pattern options with implementation specific pattern options.
      * @param str the string to clean.
      * @return the string with CLI names replaced with implementation specific names.
      */
     public String cleanup(final String str) {
         String workingStr = str;
         if (StringUtils.isNotBlank(workingStr)) {
             Map<String, String> maps = new HashMap<>();
             Matcher matcher = PATTERN.matcher(workingStr);
             while (matcher.find()) {
                 String key = matcher.group();
                 String optKey = key.substring(2);
                 Optional<Option> maybeResult = Arg.getOptions().getOptions().stream()
                         .filter(o -> optKey.equals(o.getOpt()) || optKey.equals(o.getLongOpt())).findFirst();
                 maybeResult.ifPresent(value -> maps.put(key, cleanupName(value)));
             }
             for (Map.Entry<String, String> entry : maps.entrySet()) {
                 workingStr = workingStr.replaceAll(Pattern.quote(format("%s", entry.getKey())), entry.getValue());
             }
         }
         return workingStr;
     }
 
     /**
      * Gets the implementation specific name for the CLI option.
      * @return The implementation specific name for the CLI option.
      */
     public final String getName() {
         return name;
     }
 
     /**
      * return a string showing long and short options if they are available. Will return
      * a string.
      * @return A string showing long and short options if they are available. Never {@code null}.
      */
     public abstract String getText();
 
     /**
      * Gets the description in implementation specific format.
      *
      * @return the description or an empty string.
      */
     public final String getDescription() {
         return cleanup(option.getDescription());
     }
 
     /**
      * Gets the simple class name for the data type for this option.
      * Normally "String".
      * @return the simple class name for the type.
      */
     public final Class<?> getType() {
         return option.hasArg() ? ((Class<?>) option.getType()) : boolean.class;
     }
 
     /**
      * Gets the argument name if there is one.
      * @return the Argument name
      */
     public final String getArgName() {
         return argumentType.getDisplayName();
     }
 
     /**
      * Gets the argument type if there is one.
      * @return the Argument name
      */
     public final OptionCollection.ArgumentType getArgType() {
         return argumentType;
     }
 
     /**
      * Determines if the option is deprecated.
      * @return {@code true} if the option is deprecated
      */
     public final boolean isDeprecated() {
         return option.isDeprecated();
     }
 
     /**
      * Determines if the option is required.
      * @return {@code true} if the option is required.
      */
     public final boolean isRequired() {
         return option.isRequired();
     }
 
     /**
      * Determine if the enclosed option expects an argument.
      * @return {@code true} if the enclosed option expects at least one argument.
      */
     public final boolean hasArg() {
         return option.hasArg();
     }
 
     /**
      * Returns {@code true} if the option has multiple arguments.
      * @return {@code true} if the option has multiple arguments.
      */
     public final boolean hasArgs() {
         return option.hasArgs();
     }
 
     /**
      * Returns the number of arguments.
      * @return The number of arguments.
      */
     public final int argCount() {
         return option.getArgs();
     }
 
     /**
      * The key value for the option.
      * @return the key value for the CLI argument map.
      */
     public final String keyValue() {
         return format("\"%s\"", StringUtils.defaultIfEmpty(option.getLongOpt(), option.getOpt()));
     }
 
     /**
      * Gets the deprecated string if the option is deprecated, or an empty string otherwise.
      * @return the deprecated string if the option is deprecated, or an empty string otherwise.
      */
     public final String getDeprecated() {
         return  option.isDeprecated() ? cleanup(StringUtils.defaultIfEmpty(option.getDeprecated().toString(), StringUtils.EMPTY)) : StringUtils.EMPTY;
     }
 }