/*
    * 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.commons.cli2.option;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.List;
  import java.util.ListIterator;
  import java.util.Map;
  import java.util.Set;
  import java.util.SortedMap;
  import java.util.TreeMap;
  
  import org.apache.commons.cli2.Argument;
  import org.apache.commons.cli2.DisplaySetting;
  import org.apache.commons.cli2.Group;
  import org.apache.commons.cli2.HelpLine;
  import org.apache.commons.cli2.Option;
  import org.apache.commons.cli2.OptionException;
  import org.apache.commons.cli2.WriteableCommandLine;
  import org.apache.commons.cli2.resource.ResourceConstants;
  
  /**
   * An implementation of Group
   */
  public class GroupImpl
      extends OptionImpl implements Group {
      private final String name;
      private final String description;
      private final List options;
      private final int minimum;
      private final int maximum;
      private final List anonymous;
      private final SortedMap optionMap;
      private final Set prefixes;
  
      /**
       * Creates a new GroupImpl using the specified parameters.
       *
       * @param options the Options and Arguments that make up the Group
       * @param name the name of this Group, or null
       * @param description a description of this Group
       * @param minimum the minimum number of Options for a valid CommandLine
       * @param maximum the maximum number of Options for a valid CommandLine
       * @param required a flag whether this group is required
       */
      public GroupImpl(final List options,
                       final String name,
                       final String description,
                       final int minimum,
                       final int maximum,
                       final boolean required) {
          super(0, required);
  
          this.name = name;
          this.description = description;
          this.minimum = minimum;
          this.maximum = maximum;
  
          // store a copy of the options to be used by the
          // help methods
          this.options = Collections.unmodifiableList(options);
  
          // anonymous Argument temporary storage
          final List newAnonymous = new ArrayList();
  
          // map (key=trigger & value=Option) temporary storage
          final SortedMap newOptionMap = new TreeMap(ReverseStringComparator.getInstance());
  
          // prefixes temporary storage
          final Set newPrefixes = new HashSet();
  
          // process the options
          for (final Iterator i = options.iterator(); i.hasNext();) {
              final Option option = (Option) i.next();
              option.setParent(this);
  
              if (option instanceof Argument) {
                  i.remove();
                  newAnonymous.add(option);
              } else {
                 final Set triggers = option.getTriggers();
 
                 for (Iterator j = triggers.iterator(); j.hasNext();) {
                     newOptionMap.put(j.next(), option);
                 }
 
                 // store the prefixes
                 newPrefixes.addAll(option.getPrefixes());
             }
         }
 
         this.anonymous = Collections.unmodifiableList(newAnonymous);
         this.optionMap = Collections.unmodifiableSortedMap(newOptionMap);
         this.prefixes = Collections.unmodifiableSet(newPrefixes);
     }
 
     public boolean canProcess(final WriteableCommandLine commandLine,
                               final String arg) {
         if (arg == null) {
             return false;
         }
 
         // if arg does not require bursting
         if (optionMap.containsKey(arg)) {
             return true;
         }
 
         // filter
         final Map tailMap = optionMap.tailMap(arg);
 
         // check if bursting is required
         for (final Iterator iter = tailMap.values().iterator(); iter.hasNext();) {
             final Option option = (Option) iter.next();
 
             if (option.canProcess(commandLine, arg)) {
                 return true;
             }
         }
 
         if (looksLikeOption(commandLine, arg)) {
             return false;
         }
 
         // anonymous argument(s) means we can process it
         if (anonymous.size() > 0) {
             return true;
         }
 
         return false;
     }
 
     public Set getPrefixes() {
         return prefixes;
     }
 
     public Set getTriggers() {
         return optionMap.keySet();
     }
 
     public void process(final WriteableCommandLine commandLine,
                         final ListIterator arguments)
         throws OptionException {
         String previous = null;
 
         // [START process each command line token
         while (arguments.hasNext()) {
             // grab the next argument
             final String arg = (String) arguments.next();
 
             // if we have just tried to process this instance
             if (arg == previous) {
                 // rollback and abort
                 arguments.previous();
 
                 break;
             }
 
             // remember last processed instance
             previous = arg;
 
             final Option opt = (Option) optionMap.get(arg);
 
             // option found
             if (opt != null) {
                 arguments.previous();
                 opt.process(commandLine, arguments);
             }
             // [START option NOT found
             else {
                 // it might be an anonymous argument continue search
                 // [START argument may be anonymous
                 if (looksLikeOption(commandLine, arg)) {
                     // narrow the search
                     final Collection values = optionMap.tailMap(arg).values();
 
                     boolean foundMemberOption = false;
 
                     for (Iterator i = values.iterator(); i.hasNext() && !foundMemberOption;) {
                         final Option option = (Option) i.next();
 
                         if (option.canProcess(commandLine, arg)) {
                             foundMemberOption = true;
                             arguments.previous();
                             option.process(commandLine, arguments);
                         }
                     }
 
                     // back track and abort this group if necessary
                     if (!foundMemberOption) {
                         arguments.previous();
 
                         return;
                     }
                 } // [END argument may be anonymous
 
                 // [START argument is NOT anonymous
                 else {
                     // move iterator back, current value not used
                     arguments.previous();
 
                     // if there are no anonymous arguments then this group can't
                     // process the argument
                     if (anonymous.isEmpty()) {
                         break;
                     }
 
                     // TODO: why do we iterate over all anonymous arguments?
                     // canProcess will always return true?
                     for (final Iterator i = anonymous.iterator(); i.hasNext();) {
                         final Argument argument = (Argument) i.next();
 
                         if (argument.canProcess(commandLine, arguments)) {
                             argument.process(commandLine, arguments);
                         }
                     }
                 } // [END argument is NOT anonymous
             } // [END option NOT found
         } // [END process each command line token
     }
 
     public void validate(final WriteableCommandLine commandLine)
         throws OptionException {
         // number of options found
         int present = 0;
 
         // reference to first unexpected option
         Option unexpected = null;
 
         for (final Iterator i = options.iterator(); i.hasNext();) {
             final Option option = (Option) i.next();
 
             // needs validation?
             boolean validate = option.isRequired();
 
             // if the child option is present then validate it
             if (commandLine.hasOption(option)) {
                 if (++present > maximum) {
                     unexpected = option;
 
                     break;
                 }
                 validate = true;
             }
 
             if (validate) {
                 option.validate(commandLine);
             }
         }
 
         // too many options
         if (unexpected != null) {
             throw new OptionException(this, ResourceConstants.UNEXPECTED_TOKEN,
                                       unexpected.getPreferredName());
         }
 
         // too few option
         if (present < minimum) {
             throw new OptionException(this, ResourceConstants.MISSING_OPTION);
         }
 
         // validate each anonymous argument
         for (final Iterator i = anonymous.iterator(); i.hasNext();) {
             final Option option = (Option) i.next();
             option.validate(commandLine);
         }
     }
 
     public String getPreferredName() {
         return name;
     }
 
     public String getDescription() {
         return description;
     }
 
     public void appendUsage(final StringBuffer buffer,
                             final Set helpSettings,
                             final Comparator comp) {
         appendUsage(buffer, helpSettings, comp, "|");
     }
 
     public void appendUsage(final StringBuffer buffer,
                             final Set helpSettings,
                             final Comparator comp,
                             final String separator) {
         final Set helpSettingsCopy = new HashSet(helpSettings);
 
         final boolean optional = !isRequired()
                 && (helpSettingsCopy.contains(DisplaySetting.DISPLAY_OPTIONAL) ||
                         helpSettingsCopy.contains(DisplaySetting.DISPLAY_OPTIONAL_CHILD_GROUP));
 
         final boolean expanded =
             (name == null) || helpSettingsCopy.contains(DisplaySetting.DISPLAY_GROUP_EXPANDED);
 
         final boolean named =
             !expanded ||
             ((name != null) && helpSettingsCopy.contains(DisplaySetting.DISPLAY_GROUP_NAME));
 
         final boolean arguments = helpSettingsCopy.contains(DisplaySetting.DISPLAY_GROUP_ARGUMENT);
 
         final boolean outer = helpSettingsCopy.contains(DisplaySetting.DISPLAY_GROUP_OUTER);
 
         helpSettingsCopy.remove(DisplaySetting.DISPLAY_GROUP_OUTER);
 
         final boolean both = named && expanded;
 
         if (optional) {
             buffer.append('[');
         }
 
         if (named) {
             buffer.append(name);
         }
 
         if (both) {
             buffer.append(" (");
         }
 
         if (expanded) {
             final Set childSettings;
 
             if (!helpSettingsCopy.contains(DisplaySetting.DISPLAY_GROUP_EXPANDED)) {
                 childSettings = DisplaySetting.NONE;
             } else {
                 childSettings = new HashSet(helpSettingsCopy);
                 childSettings.remove(DisplaySetting.DISPLAY_OPTIONAL);
             }
 
             // grab a list of the group's options.
             final List list;
 
             if (comp == null) {
                 // default to using the initial order
                 list = options;
             } else {
                 // sort options if comparator is supplied
                 list = new ArrayList(options);
                 Collections.sort(list, comp);
             }
 
             // for each option.
             for (final Iterator i = list.iterator(); i.hasNext();) {
                 final Option option = (Option) i.next();
 
                 // append usage information
                 option.appendUsage(buffer, childSettings, comp);
 
                 // add separators as needed
                 if (i.hasNext()) {
                     buffer.append(separator);
                 }
             }
         }
 
         if (both) {
             buffer.append(')');
         }
 
         if (optional && outer) {
             buffer.append(']');
         }
 
         if (arguments) {
             for (final Iterator i = anonymous.iterator(); i.hasNext();) {
                 buffer.append(' ');
 
                 final Option option = (Option) i.next();
                 option.appendUsage(buffer, helpSettingsCopy, comp);
             }
         }
 
         if (optional && !outer) {
             buffer.append(']');
         }
     }
 
     public List helpLines(final int depth,
                           final Set helpSettings,
                           final Comparator comp) {
         final List helpLines = new ArrayList();
 
         if (helpSettings.contains(DisplaySetting.DISPLAY_GROUP_NAME)) {
             final HelpLine helpLine = new HelpLineImpl(this, depth);
             helpLines.add(helpLine);
         }
 
         if (helpSettings.contains(DisplaySetting.DISPLAY_GROUP_EXPANDED)) {
             // grab a list of the group's options.
             final List list;
 
             if (comp == null) {
                 // default to using the initial order
                 list = options;
             } else {
                 // sort options if comparator is supplied
                 list = new ArrayList(options);
                 Collections.sort(list, comp);
             }
 
             // for each option
             for (final Iterator i = list.iterator(); i.hasNext();) {
                 final Option option = (Option) i.next();
                 helpLines.addAll(option.helpLines(depth + 1, helpSettings, comp));
             }
         }
 
         if (helpSettings.contains(DisplaySetting.DISPLAY_GROUP_ARGUMENT)) {
             for (final Iterator i = anonymous.iterator(); i.hasNext();) {
                 final Option option = (Option) i.next();
                 helpLines.addAll(option.helpLines(depth + 1, helpSettings, comp));
             }
         }
 
         return helpLines;
     }
 
     /**
      * Gets the member Options of thie Group.
      * Note this does not include any Arguments
      * @return only the non Argument Options of the Group
      */
     public List getOptions() {
         return options;
     }
 
     /**
      * Gets the anonymous Arguments of this Group.
      * @return the Argument options of this Group
      */
     public List getAnonymous() {
         return anonymous;
     }
 
     public Option findOption(final String trigger) {
         final Iterator i = getOptions().iterator();
 
         while (i.hasNext()) {
             final Option option = (Option) i.next();
             final Option found = option.findOption(trigger);
 
             if (found != null) {
                 return found;
             }
         }
 
         return null;
     }
 
     public int getMinimum() {
         return minimum;
     }
 
     public int getMaximum() {
         return maximum;
     }
 
     /**
      * Tests whether this option is required. For groups we evaluate the
      * <code>required</code> flag common to all options, but also take the
      * minimum constraints into account.
      *
      * @return a flag whether this option is required
      */
     public boolean isRequired()
     {
         return (getParent() == null || super.isRequired()) && getMinimum() > 0;
     }
 
     public void defaults(final WriteableCommandLine commandLine) {
         super.defaults(commandLine);
 
         for (final Iterator i = options.iterator(); i.hasNext();) {
             final Option option = (Option) i.next();
             option.defaults(commandLine);
         }
 
         for (final Iterator i = anonymous.iterator(); i.hasNext();) {
             final Option option = (Option) i.next();
             option.defaults(commandLine);
         }
     }
 
     /**
      * Helper method for testing whether an element of the command line looks
      * like an option. This method queries the command line, but sets the
      * current option first.
      *
      * @param commandLine the command line
      * @param trigger the trigger to be checked
      * @return a flag whether this element looks like an option
      */
     private boolean looksLikeOption(final WriteableCommandLine commandLine,
             final String trigger) {
         Option oldOption = commandLine.getCurrentOption();
         try {
             commandLine.setCurrentOption(this);
             return commandLine.looksLikeOption(trigger);
         } finally {
             commandLine.setCurrentOption(oldOption);
         }
     }
 }
 
 
 class ReverseStringComparator implements Comparator {
     private static final Comparator instance = new ReverseStringComparator();
 
     private ReverseStringComparator() {
         // just making sure nobody else creates one
     }
 
     /**
      * Gets a singleton instance of a ReverseStringComparator
      * @return the singleton instance
      */
     public static final Comparator getInstance() {
         return instance;
     }
 
     public int compare(final Object o1,
                        final Object o2) {
         final String s1 = (String) o1;
         final String s2 = (String) o2;
 
         return -s1.compareTo(s2);
     }
 }