/*

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

 import java.util.Iterator;

 import java.util.List;

 import java.util.Set;

 import org.apache.commons.cli2.Argument;

 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.resource.ResourceHelper;

 /**

  * An Argument implementation that allows a variable size Argument to precede a

  * fixed size argument.  The canonical example of it's use is in the unix

  * <code>cp</code> command where a number of source can be specified with

  * exactly one destination specfied at the end.

  */

 public class SourceDestArgument

     extends ArgumentImpl {

     private final Argument source;

     private final Argument dest;

     /**

      * Creates a SourceDestArgument using defaults where possible.

      *

      * @param source the variable size Argument

      * @param dest the fixed size Argument

      */

     public SourceDestArgument(final Argument source,

                               final Argument dest) {

         this(source, dest, DEFAULT_INITIAL_SEPARATOR, DEFAULT_SUBSEQUENT_SEPARATOR,

              DEFAULT_CONSUME_REMAINING, null);

     }

     /**

      * Creates a SourceDestArgument using the specified parameters.

      *

      * @param source the variable size Argument

      * @param dest the fixed size Argument

      * @param initialSeparator the inistial separator to use

      * @param subsequentSeparator the subsequent separator to use

      * @param consumeRemaining the token triggering consume remaining behaviour

      * @param defaultValues the default values for the SourceDestArgument

      */

     public SourceDestArgument(final Argument source,

                               final Argument dest,

                               final char initialSeparator,

                               final char subsequentSeparator,

                               final String consumeRemaining,

                               final List defaultValues) {

         super("SourceDestArgument", null, sum(source.getMinimum(), dest.getMinimum()),

               sum(source.getMaximum(), dest.getMaximum()), initialSeparator, subsequentSeparator,

               null, consumeRemaining, defaultValues, 0);

         this.source = source;

         this.dest = dest;

         if (dest.getMinimum() != dest.getMaximum()) {

             throw new IllegalArgumentException(ResourceHelper.getResourceHelper().getMessage(ResourceConstants.SOURCE_DEST_MUST_ENFORCE_VALUES));

         }

     }

     private static int sum(final int a,

                            final int b) {

         return Math.max(a, Math.max(b, a + b));

     }

     public void appendUsage(final StringBuffer buffer,

                             final Set helpSettings,

                             final Comparator comp) {

         final int length = buffer.length();

         source.appendUsage(buffer, helpSettings, comp);

         if (buffer.length() != length) {

             buffer.append(' ');

         }

         dest.appendUsage(buffer, helpSettings, comp);

     }

     public List helpLines(int depth,

                           Set helpSettings,

                           Comparator comp) {

         final List helpLines = new ArrayList();

         helpLines.addAll(source.helpLines(depth, helpSettings, comp));

         helpLines.addAll(dest.helpLines(depth, helpSettings, comp));

         return helpLines;

     }

     public void validate(WriteableCommandLine commandLine,

                          Option option)

         throws OptionException {

         final List values = commandLine.getValues(option);

         final int limit = values.size() - dest.getMinimum();

         int count = 0;

         final Iterator i = values.iterator();

         while (count++ < limit) {

             commandLine.addValue(source, i.next());

         }

         while (i.hasNext()) {

             commandLine.addValue(dest, i.next());

         }

         source.validate(commandLine, source);

         dest.validate(commandLine, dest);

     }

     public boolean canProcess(final WriteableCommandLine commandLine,

                               final String arg) {

         return source.canProcess(commandLine, arg) || dest.canProcess(commandLine, arg);

     }

 }