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