package org.apache.commons.beanutils2;

/*
 * 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.
 */

import static org.apache.commons.beanutils2.Assertions.checkArgument;
import static org.apache.commons.beanutils2.Assertions.checkNotNull;
import static org.apache.commons.beanutils2.TypeUtils.isAssignmentCompatible;

/**
 * An argument represents a value of some type that can be passed to a method or
 * constructor.
 *
 * @param <T> the type of the argument.
 */
public final class Argument<T>
{

    /**
     * Factory method for arguments. Creates an argument by taking a value and determining the type of the given value.
     *
     * @param value the value to be wrapped by the new argument object. Must not be {@code null}! If you want to create
     *            a null argument use {@link #nullArgument(Class)} instead.
     * @param <A> the type of the argument.
     * @return a new argument of type {@code value.getClass()}
     */
    public static <A> Argument<A> argument( A value )
    {
        value = checkNotNull( value, "Null not supported when specifying value only" );
        @SuppressWarnings( "unchecked" )
        Class<A> type = (Class<A>) value.getClass();
        return argument( type, value );
    }

    /**
     * Creates a new null argument of the given type. Shortcut for {@code argument( type, null )}.
     *
     * @param type the type of the new argument. Must not be {@code null}!
     * @param <A> the type of argument.
     * @return an argument with {@code value == null}.
     */
    public static <A> Argument<A> nullArgument( Class<A> type )
    {
        return argument( type, null );
    }

    /**
     * Creates a new argument of the given type with the given value.
     *
     * @param type the type of the new argument. Must not be {@code null}!
     * @param value the value of the new argument.
     * @param <T> the type of the argument.
     * @param <V> the type of the value of the argument.
     * @return a new argument of the given type with the given value.
     */
    public static <T, V extends T> Argument<T> argument( Class<T> type, V value )
    {
        type = checkNotNull( type, "type must be specified (while value is nullable)" );
        if ( value != null )
        {
            // this should never happen since the compiler prevents it. Check it anyway...
            checkArgument( isAssignmentCompatible( type, value.getClass() ),
                           "value type %s does not match the given type %s",
                           value.getClass().getName(),
                           type.getName() );
        }
        return new Argument<T>( type, value );
    }

    /**
     * Determines the types of the given arguments.
     *
     * @param arguments the arguments to determine the types of. None must be {@code null}!
     * @return an array of {@code Class} objects representing the types of the
     *         given arguments. The first {@code class} object represents the
     *         type of the first argument and so on.
     */
    static Class<?>[] getParameterTypes( Argument<?>...arguments )
    {
        int argumentsLength = arguments.length;
        Class<?>[] parameterTypes = new Class[argumentsLength];
        for ( int i = 0; i < argumentsLength; i++ )
        {
            parameterTypes[i] = arguments[i].getType();
        }
        return parameterTypes;
    }

    /**
     * Determines the objects of the given arguments.
     *
     * @param arguments the arguments to determine the types of. None must be {@code null}!
     * @return an array of {@code Object}s representing the values of the given arguments.
     */
    static Object[] getParameters( Argument<?>...arguments )
    {
        int argumentsLength = arguments.length;
        Object[] parameters = new Object[argumentsLength];
        for ( int i = 0; i < argumentsLength; i++ )
        {
            parameters[i] = arguments[i].getValue();
        }
        return parameters;
    }

    private final Class<T> type;

    private final T value;

    private Argument( Class<T> type, T value )
    {
        this.type = type;
        this.value = value;
    }

    /**
     * Returns the argument's type. Note that the type returned maybe a super type of the actual type of the value
     * returned by {@link #getValue()} depending on how the argument was created. For example:
     * </br>{@code argument( Number.class, Integer.valueOf( 4 ) );}</br>
     * will create an argument with an Integer as Value but Number.class as type.
     *
     * @return the argument's type
     */
    public Class<T> getType()
    {
        return type;
    }

    /**
     * Returns the value of the argument. Maybe {@code null} if this is a null argument.
     *
     * @return the value of the argument.
     */
    public T getValue()
    {
        return value;
    }

}