/*
    * 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.Collections;
  import java.util.Comparator;
  import java.util.List;
  import java.util.ListIterator;
  import java.util.Set;
  
  import org.apache.commons.cli2.Argument;
  import org.apache.commons.cli2.DisplaySetting;
  import org.apache.commons.cli2.Group;
  import org.apache.commons.cli2.Option;
  import org.apache.commons.cli2.OptionException;
  import org.apache.commons.cli2.Parent;
  import org.apache.commons.cli2.WriteableCommandLine;
  
  /**
   * A base implementation of Parent providing limited ground work for further
   * Parent implementations.
   */
  public abstract class ParentImpl
      extends OptionImpl implements Parent {
      private static final char NUL = '\0';
      private final Group children;
      private final Argument argument;
      private final String description;
  
      protected ParentImpl(final Argument argument,
                           final Group children,
                           final String description,
                           final int id,
                           final boolean required) {
          super(id, required);
          this.children = children;
          this.argument = argument;
          this.description = description;
      }
  
      /*
       * (non-Javadoc)
       *
       * @see org.apache.commons.cli2.Option#process(org.apache.commons.cli2.CommandLine,
       *      java.util.ListIterator)
       */
      public void process(final WriteableCommandLine commandLine,
                          final ListIterator arguments)
          throws OptionException {
          if (argument != null) {
              handleInitialSeparator(arguments, argument.getInitialSeparator());
          }
  
          processParent(commandLine, arguments);
  
          if (argument != null) {
              argument.processValues(commandLine, arguments, this);
          }
  
          if ((children != null) && children.canProcess(commandLine, arguments)) {
              children.process(commandLine, arguments);
          }
      }
  
      /*
       * (non-Javadoc)
       *
       * @see org.apache.commons.cli2.Option#canProcess(java.lang.String)
       */
      public boolean canProcess(final WriteableCommandLine commandLine,
                                final String arg) {
          final Set triggers = getTriggers();
  
          if (argument != null) {
              final char separator = argument.getInitialSeparator();
  
              // if there is a valid separator character
              if (separator != NUL) {
                  final int initialIndex = arg.indexOf(separator);
  
                  // if there is a separator present
                  if (initialIndex > 0) {
                      return triggers.contains(arg.substring(0, initialIndex));
                  }
             }
         }
 
         return triggers.contains(arg);
     }
 
     /*
      * (non-Javadoc)
      *
      * @see org.apache.commons.cli2.Option#prefixes()
      */
     public Set getPrefixes() {
         return (children == null) ? Collections.EMPTY_SET : children.getPrefixes();
     }
 
     /*
      * (non-Javadoc)
      *
      * @see org.apache.commons.cli2.Option#validate(org.apache.commons.cli2.CommandLine)
      */
     public void validate(WriteableCommandLine commandLine)
         throws OptionException {
         if (commandLine.hasOption(this)) {
             if (argument != null) {
                 argument.validate(commandLine, this);
             }
 
             if (children != null) {
                 children.validate(commandLine);
             }
         }
     }
 
     /*
      * (non-Javadoc)
      *
      * @see org.apache.commons.cli2.Option#appendUsage(java.lang.StringBuffer,
      *      java.util.Set, java.util.Comparator)
      */
     public void appendUsage(final StringBuffer buffer,
                             final Set helpSettings,
                             final Comparator comp) {
         final boolean displayArgument =
             (this.argument != null) &&
             helpSettings.contains(DisplaySetting.DISPLAY_PARENT_ARGUMENT);
         final boolean displayChildren =
             (this.children != null) &&
             helpSettings.contains(DisplaySetting.DISPLAY_PARENT_CHILDREN);
 
         if (displayArgument) {
             buffer.append(' ');
             argument.appendUsage(buffer, helpSettings, comp);
         }
 
         if (displayChildren) {
             buffer.append(' ');
             children.appendUsage(buffer, helpSettings, comp);
         }
     }
 
     /**
      * @return a description of this parent option
      */
     public String getDescription() {
         return description;
     }
 
     /*
      * (non-Javadoc)
      *
      * @see org.apache.commons.cli2.Option#helpLines(int, java.util.Set,
      *      java.util.Comparator)
      */
     public List helpLines(final int depth,
                           final Set helpSettings,
                           final Comparator comp) {
         final List helpLines = new ArrayList();
         helpLines.add(new HelpLineImpl(this, depth));
 
         if (helpSettings.contains(DisplaySetting.DISPLAY_PARENT_ARGUMENT) && (argument != null)) {
             helpLines.addAll(argument.helpLines(depth + 1, helpSettings, comp));
         }
 
         if (helpSettings.contains(DisplaySetting.DISPLAY_PARENT_CHILDREN) && (children != null)) {
             helpLines.addAll(children.helpLines(depth + 1, helpSettings, comp));
         }
 
         return helpLines;
     }
 
     /**
      * @return Returns the argument.
      */
     public Argument getArgument() {
         return argument;
     }
 
     /**
      * @return Returns the children.
      */
     public Group getChildren() {
         return children;
     }
 
     /**
      * Split the token using the specified separator character.
      * @param arguments the current position in the arguments iterator
      * @param separator the separator char to split on
      */
     private void handleInitialSeparator(final ListIterator arguments,
                                         final char separator) {
         // next token
         final String newArgument = (String) arguments.next();
 
         // split the token
         final int initialIndex = newArgument.indexOf(separator);
 
         if (initialIndex > 0) {
             arguments.remove();
             arguments.add(newArgument.substring(0, initialIndex));
             String value = newArgument.substring(initialIndex + 1);
             // The value obviously isn't an option, so we need to quote it if looks like an option.
             // The quotes will be removed later
             if (value.startsWith("-")) {
                 value = '"' + value + '"';
             }
             arguments.add(value);
             arguments.previous();
         }
 
         arguments.previous();
     }
 
     /*
      * @see org.apache.commons.cli2.Option#findOption(java.lang.String)
      */
     public Option findOption(final String trigger) {
         final Option found = super.findOption(trigger);
 
         if ((found == null) && (children != null)) {
             return children.findOption(trigger);
         } else {
             return found;
         }
     }
 
     public void defaults(final WriteableCommandLine commandLine) {
         super.defaults(commandLine);
 
         if (argument != null) {
             argument.defaultValues(commandLine, this);
         }
 
         if (children != null) {
             children.defaults(commandLine);
         }
     }
 }