/*

  * 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.commandline;

 import java.util.LinkedList;

 import java.util.List;

 import java.util.ListIterator;

 import org.apache.commons.cli2.CommandLine;

 import org.apache.commons.cli2.Group;

 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;

 import org.apache.commons.cli2.util.HelpFormatter;

 /**

  * A class that implements the <code>Parser</code> interface can parse a

  * String array according to the {@link Group}specified and return a

  * {@link CommandLine}.

  *

  * @author John Keyes (john at integralsource.com)

  */

 public class Parser {

     private HelpFormatter helpFormatter = new HelpFormatter();

     private Option helpOption = null;

     private String helpTrigger = null;

     private Group group = null;

     /**

      * Parse the arguments according to the specified options and properties.

      *

      * @param arguments

      *            the command line arguments

      *

      * @return the list of atomic option and value tokens

      * @throws OptionException

      *             if there are any problems encountered while parsing the

      *             command line tokens.

      */

     public CommandLine parse(final String[] arguments)

         throws OptionException {

         // build a mutable list for the arguments

         final List argumentList = new LinkedList();

         // copy the arguments into the new list

         for (int i = 0; i < arguments.length; i++) {

             final String argument = arguments[i];

             // ensure non intern'd strings are used

             // so that == comparisons work as expected

             argumentList.add(new String(argument));

         }

         // wet up a command line for this group

         final WriteableCommandLine commandLine = new WriteableCommandLineImpl(group, argumentList);

         // pick up any defaults from the model

         group.defaults(commandLine);

         // process the options as far as possible

         final ListIterator iterator = argumentList.listIterator();

         Object previous = null;

         while (group.canProcess(commandLine, iterator)) {

             // peek at the next item and backtrack

             final Object next = iterator.next();

             iterator.previous();

             // if we have just tried to process this instance

             if (next == previous) {

                 // abort

                 break;

             }

             // remember previous

             previous = next;

             group.process(commandLine, iterator);

         }

         // if there are more arguments we have a problem

         if (iterator.hasNext()) {

             final String arg = (String) iterator.next();

             throw new OptionException(group, ResourceConstants.UNEXPECTED_TOKEN, arg);

         }

         // no need to validate if the help option is present

         if (!commandLine.hasOption(helpOption) && !commandLine.hasOption(helpTrigger)) {

             group.validate(commandLine);

         }

         return commandLine;

     }

     /**

      * Parse the arguments according to the specified options and properties and

      * displays the usage screen if the CommandLine is not valid or the help

      * option was specified.

      *

      * @param arguments the command line arguments

      * @return a valid CommandLine or null if the parse was unsuccessful

      */

     public CommandLine parseAndHelp(final String[] arguments) {

         helpFormatter.setGroup(group);

         try {

             // attempt to parse the command line

             final CommandLine commandLine = parse(arguments);

             if (!commandLine.hasOption(helpOption) && !commandLine.hasOption(helpTrigger)) {

                 return commandLine;

             }

         } catch (final OptionException oe) {

             // display help regarding the exception

             helpFormatter.setException(oe);

         }

         // print help

         helpFormatter.print();

         return null;

     }

     /**

      * Sets the Group of options to parse against

      * @param group the group of options to parse against

      */

     public void setGroup(final Group group) {

         this.group = group;

     }

     /**

      * Sets the HelpFormatter to use with the simplified parsing.

      * @see #parseAndHelp(String[])

      * @param helpFormatter the HelpFormatter to use with the simplified parsing

      */

     public void setHelpFormatter(final HelpFormatter helpFormatter) {

         this.helpFormatter = helpFormatter;

     }

     /**

      * Sets the help option to use with the simplified parsing.  For example

      * <code>--help</code>, <code>-h</code> and <code>-?</code> are often used.

      * @see #parseAndHelp(String[])

      * @param helpOption the help Option

      */

     public void setHelpOption(final Option helpOption) {

         this.helpOption = helpOption;

     }

     /**

      * Sets the help option to use with the simplified parsing.  For example

      * <code>--help</code>, <code>-h</code> and <code>-?</code> are often used.

      * @see #parseAndHelp(String[])

      * @param helpTrigger the trigger of the help Option

      */

     public void setHelpTrigger(final String helpTrigger) {

         this.helpTrigger = helpTrigger;

     }

 }