/**
 *  Copyright (C) 2016 Gary Gregory. All rights reserved.
 *
 *  See the NOTICE.txt file distributed with this work for additional
 *  information regarding copyright ownership.
 *  
 *  Licensed 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 com.garygregory.jcommander.converters;

import java.net.URI;
import java.util.Objects;

import com.beust.jcommander.ParameterException;
import com.beust.jcommander.converters.BaseConverter;
import com.beust.jcommander.converters.IntegerConverter;
import com.garygregory.jcommander.converters.net.URIConverter;

/**
 * Provides common services for converters in this package
 * 
 * @param <T>
 *            the target type of the conversion.
 * @since 1.0.0
 * @author <a href="mailto:ggregory@garygregory.com">Gary Gregory</a>
 */
public abstract class AbstractBaseConverter<T> extends BaseConverter<T> {

    /**
     * The target class to convert strings.
     */
    protected final Class<T> targetClass;

    /**
     * Whether or not a null conversion failure throws a ParameterException.
     */
    protected final boolean failOnNull;

    /**
     * Constructs a new instance for the given option and target class.
     * 
     * @param optionName
     *            The option name, may be null.
     * @param targetClass
     *            must not be null
     */
    public AbstractBaseConverter(final String optionName, final Class<T> targetClass) {
        this(optionName, targetClass, true);
    }

    /**
     * Constructs a new instance for the given option, target class and fail-on-null.
     * 
     * @param optionName
     *            may be null
     * @param targetClass
     *            must not be null
     * @param failOnNull
     *            if true, the converter fails when the conversion results in a null value
     */
    public AbstractBaseConverter(final String optionName, final Class<T> targetClass, final boolean failOnNull) {
        super(optionName);
        this.failOnNull = failOnNull;
        this.targetClass = Objects.requireNonNull(targetClass, "targetClass for " + getClass());
    }

    /**
     * Converts the given value or throws a {@link ParameterException}. Delegates the actual conversion to subclasses with
     * {@link #convertImpl(String)}.
     * 
     * @param value
     *            the value to convert.
     * @throws ParameterException
     *             for a conversion problem
     */
    @Override
    public T convert(final String value) {
        try {
            final T result = convertImpl(value);
            if (result == null && failOnNull) {
                throw newParameterException(value);
            }
            return result;
        } catch (final Exception e) {
            throw newParameterException(value, e);
        }
    }

    /**
     * Converts a value.
     * 
     * @param value
     *            the value to convert
     * @return the converted value
     * @throws Exception
     *             subclasses can throw any Exception
     */
    protected abstract T convertImpl(String value) throws Exception;

    /**
     * Builds an error message for the given value in error
     * 
     * @param value
     *            the value that cause the error
     * @return an error message
     */
    protected String getErrorString(final String value) {
        return getClass().getName() + " could not convert \"" + value + "\" to an instance of " + targetClass + " for option "
                + getOptionName();
    }

    /**
     * Returns true if the array is of size 1, false otherwise.
     * 
     * @param split
     *            an array
     * @return true if the array is of size 1, false otherwise.
     */
    protected boolean isSingle(final String[] split) {
        return split.length == 1;
    }

    /**
     * Creates a new {@link ParameterException} for the given value.
     * 
     * @param value
     *            the value in error
     * @return a new ParameterException
     */
    protected ParameterException newParameterException(final String value) {
        return new ParameterException(getErrorString(value));
    }

    /**
     * Creates a new {@link ParameterException} for the given value and throwable
     * 
     * @param value
     *            the value in error
     * @param t
     *            the throwable
     * @return a new ParameterException
     */
    protected ParameterException newParameterException(final String value, final Throwable t) {
        return new ParameterException(getErrorString(value), t);
    }

    /**
     * Splits the given string using {@link ConverterConstants#VALUE_SEPARATOR} as the boundary.
     * 
     * @param value
     *            the string to split
     * @return the split array result
     */
    protected String[] split(final String value) {
        return value.split(ConverterConstants.VALUE_SEPARATOR);
    }

    /**
     * Converts the given value to an int for the given option.
     * 
     * @param optionName
     *            the option name
     * @param value
     *            the value to parse
     * @return the int result
     */
    protected int toInt(final String optionName, final String value) {
        return new IntegerConverter(optionName).convert(value).intValue();
    }

    /**
     * Converts the given string into a URI
     * 
     * @param optionName
     *            the option name
     * @param value
     *            a string
     * 
     * @return a new URI
     * @see java.net.URI
     */
    protected URI toURI(final String optionName, final String value) {
        return new URIConverter(null).convert(value);
    }

}