/**
    * 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.builder;
  
  import java.util.Iterator;
  import java.util.LinkedHashSet;
  import java.util.Set;
  
  import org.apache.commons.cli2.Argument;
  import org.apache.commons.cli2.Option;
  import org.apache.commons.cli2.validation.ClassValidator;
  import org.apache.commons.cli2.validation.DateValidator;
  import org.apache.commons.cli2.validation.FileValidator;
  import org.apache.commons.cli2.validation.NumberValidator;
  import org.apache.commons.cli2.validation.UrlValidator;
  import org.apache.commons.cli2.validation.Validator;
  
  /**
   * Builds Options using a String pattern
   */
  //TODO Document and link to the acceptable patterns
  public class PatternBuilder {
  
      private final GroupBuilder gbuilder;
      private final DefaultOptionBuilder obuilder;
      private final ArgumentBuilder abuilder;
  
      /**
       * Creates a new PatternBuilder
       */
      public PatternBuilder() {
          this(
              new GroupBuilder(),
              new DefaultOptionBuilder(),
              new ArgumentBuilder());
      }
  
      /**
       * Creates a new PatternBuilder
       * @param gbuilder the GroupBuilder to use
       * @param obuilder the DefaultOptionBuilder to use
       * @param abuilder the ArgumentBuilder to use
       */
      public PatternBuilder(
          final GroupBuilder gbuilder,
          final DefaultOptionBuilder obuilder,
          final ArgumentBuilder abuilder) {
          this.gbuilder = gbuilder;
          this.obuilder = obuilder;
          this.abuilder = abuilder;
      }
  
      private final Set options = new LinkedHashSet();
  
      /**
       * Creates a new Option instance.
       * @return a new Option instance
       */
      public Option create() {
          final Option option;
  
          if (options.size() == 1) {
              option = (Option)options.iterator().next();
          }
          else {
              gbuilder.reset();
              for (final Iterator i = options.iterator(); i.hasNext();) {
                  gbuilder.withOption((Option)i.next());
              }
              option = gbuilder.create();
          }
  
          reset();
  
          return option;
      }
  
      /**
       * Resets this builder.
       * @return this builder
       */
      public PatternBuilder reset() {
          options.clear();
          return this;
      }
 
     private void createOption(
         final char type,
         final boolean required,
         final char opt) {
         final Argument argument;
         if (type != ' ') {
             abuilder.reset();
             abuilder.withValidator(validator(type));
             if (required) {
                 abuilder.withMinimum(1);
             }
             if (type != '*') {
                 abuilder.withMaximum(1);
             }
             argument = abuilder.create();
         }
         else {
             argument = null;
         }
 
         obuilder.reset();
         obuilder.withArgument(argument);
         obuilder.withShortName(String.valueOf(opt));
         obuilder.withRequired(required);
 
         options.add(obuilder.create());
     }
 
     /**
      * Builds an Option using a pattern string.
      * @param pattern the pattern to build from
      */
     public void withPattern(final String pattern) {
         int sz = pattern.length();
 
         char opt = ' ';
         char ch = ' ';
         char type = ' ';
         boolean required = false;
 
         for (int i = 0; i < sz; i++) {
             ch = pattern.charAt(i);
 
             switch (ch) {
                 case '!' :
                     required = true;
                     break;
                 case '@' :
                 case ':' :
                 case '%' :
                 case '+' :
                 case '#' :
                 case '<' :
                 case '>' :
                 case '*' :
                 case '/' :
                     type = ch;
                     break;
                 default :
                     if (opt != ' ') {
                         createOption(type, required, opt);
                         required = false;
                         type = ' ';
                     }
 
                     opt = ch;
             }
         }
 
         if (opt != ' ') {
             createOption(type, required, opt);
         }
     }
 
     private static Validator validator(final char c) {
         switch (c) {
             case '@' :
                 final ClassValidator classv = new ClassValidator();
                 classv.setInstance(true);
                 return classv;
             case '+' :
                 final ClassValidator instancev = new ClassValidator();
                 return instancev;
                 //case ':':// no validator needed for a string
             case '%' :
                 return NumberValidator.getNumberInstance();
             case '#' :
                 return DateValidator.getDateInstance();
             case '<' :
                 final FileValidator existingv = new FileValidator();
                 existingv.setExisting(true);
                 existingv.setFile(true);
                 return existingv;
             case '>' :
             case '*' :
                 return new FileValidator();
             case '/' :
                 return new UrlValidator();
             default :
                 return null;
         }
     }
 }