/*
 * 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.HashSet;
import java.util.Iterator;
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.OptionException;
import org.apache.commons.cli2.WriteableCommandLine;
import org.apache.commons.cli2.resource.ResourceConstants;
import org.apache.commons.cli2.resource.ResourceHelper;

/**
 * Represents a cvs "update" style command line option.
 *
 * Like all Parents, Commands can have child options and can be part of
 * Arguments
 */
public class Command
    extends ParentImpl {
    /** The display name for the command */
    private final String preferredName;

    /** The aliases for this command */
    private final Set aliases;

    /** All the names for this command */
    private final Set triggers;

    /**
     * Creates a new Command instance.
     *
     * @param preferredName
     *            The name normally used to refer to the Command
     * @param description
     *            A description of the Command
     * @param aliases
     *            Alternative names for the Command
     * @param required
     *            Whether the Command is required
     * @param argument
     *            An Argument that the command takes
     * @param children
     *            The Group of child options for this Command
     * @param id
     *            A unique id for the Command
     *
     * @see ParentImpl#ParentImpl(Argument, Group, String, int, boolean)
     */
    public Command(final String preferredName,
                   final String description,
                   final Set aliases,
                   final boolean required,
                   final Argument argument,
                   final Group children,
                   final int id) {
        super(argument, children, description, id, required);

        // check the preferred name is valid
        if ((preferredName == null) || (preferredName.length() < 1)) {
            throw new IllegalArgumentException(ResourceHelper.getResourceHelper().getMessage(ResourceConstants.COMMAND_PREFERRED_NAME_TOO_SHORT));
        }

        this.preferredName = preferredName;

        // gracefully and defensively handle aliases
        this.aliases =
            (aliases == null) ? Collections.EMPTY_SET
                              : Collections.unmodifiableSet(new HashSet(aliases));

        // populate the triggers Set
        final Set newTriggers = new HashSet();
        newTriggers.add(preferredName);
        newTriggers.addAll(this.aliases);
        this.triggers = Collections.unmodifiableSet(newTriggers);
    }

    public void processParent(final WriteableCommandLine commandLine,
                              final ListIterator arguments)
        throws OptionException {
        // grab the argument to process
        final String arg = (String) arguments.next();

        // if we can process it
        if (canProcess(commandLine, arg)) {
            // then note the option
            commandLine.addOption(this);

            // normalise the argument list
            arguments.set(preferredName);
        } else {
            throw new OptionException(this, ResourceConstants.UNEXPECTED_TOKEN, arg);
        }
    }

    public Set getTriggers() {
        return triggers;
    }

    public void validate(WriteableCommandLine commandLine)
        throws OptionException {
        if (isRequired() && !commandLine.hasOption(this)) {
            throw new OptionException(this, ResourceConstants.OPTION_MISSING_REQUIRED,
                                      getPreferredName());
        }

        super.validate(commandLine);
    }

    public void appendUsage(final StringBuffer buffer,
                            final Set helpSettings,
                            final Comparator comp) {
        // do we display optionality
        final boolean optional =
            !isRequired() && helpSettings.contains(DisplaySetting.DISPLAY_OPTIONAL);
        final boolean displayAliases = helpSettings.contains(DisplaySetting.DISPLAY_ALIASES);

        if (optional) {
            buffer.append('[');
        }

        buffer.append(preferredName);

        if (displayAliases && !aliases.isEmpty()) {
            buffer.append(" (");

            final List list = new ArrayList(aliases);
            Collections.sort(list);

            for (final Iterator i = list.iterator(); i.hasNext();) {
                final String alias = (String) i.next();
                buffer.append(alias);

                if (i.hasNext()) {
                    buffer.append(',');
                }
            }

            buffer.append(')');
        }

        super.appendUsage(buffer, helpSettings, comp);

        if (optional) {
            buffer.append(']');
        }
    }

    public String getPreferredName() {
        return preferredName;
    }
}