/*
 * 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;
    }
}