// 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 org.apache.tapestry5.ioc.internal.services;

import org.apache.tapestry5.ioc.internal.util.InternalUtils;
import org.apache.tapestry5.plastic.PlasticUtils;

import java.lang.reflect.Method;
import java.util.Arrays;

/**
 * A representation of a {@link java.lang.reflect.Method}, identifying the name, return type, parameter types and
 * exception types. Actual Method objects are tied to a particular class, and don't compare well with other otherwise
 * identical Methods from other classes or interface; MethodSignatures are distinct from classes and compare well.
 *
 * Because the intended purpose is to compare methods from interfaces (which are always public and abstract) we don't
 * bother to actually track the modifiers. In addition, at this time, MethodSignature <em>does not distinguish between
 * instance and static methods</em>.
 */
@SuppressWarnings("all")
public class MethodSignature
{
    private int hashCode = -1;

    private final Class returnType;

    private final String name;

    private final Class[] parameterTypes;

    private final Class[] exceptionTypes;

    private final Method method;

    public MethodSignature(Class returnType, String name, Class[] parameterTypes, Class[] exceptionTypes)
    {
        this(null, returnType, name, parameterTypes, exceptionTypes);
    }

    private MethodSignature(Method method, Class returnType, String name, Class[] parameterTypes, Class[] exceptionTypes)
    {
        this.method = method;
        assert returnType != null;
        this.returnType = returnType;
        assert InternalUtils.isNonBlank(name);
        this.name = name;

        // Can be null!
        this.parameterTypes = parameterTypes;
        this.exceptionTypes = exceptionTypes;
    }

    public MethodSignature(Method m)
    {
        this(m, m.getReturnType(), m.getName(), m.getParameterTypes(), m.getExceptionTypes());
    }

    /**
     * Returns the exceptions for this method. Caution: do not modify the returned array. May return null.
     */
    public Class[] getExceptionTypes()
    {
        return exceptionTypes;
    }

    public String getName()
    {
        return name;
    }

    /**
     * If this signature was created from a method, return that method.
     *
     * @since 5.3
     */
    public Method getMethod()
    {
        return method;
    }

    /**
     * Returns the parameter types for this method. May return null. Caution: do not modify the returned array.
     */
    public Class[] getParameterTypes()
    {
        return parameterTypes;
    }

    public Class getReturnType()
    {
        return returnType;
    }

    @Override
    public int hashCode()
    {
        if (hashCode == -1)
        {

            hashCode = returnType.hashCode();

            hashCode = 31 * hashCode + name.hashCode();

            int count = InternalUtils.size(parameterTypes);

            for (int i = 0; i < count; i++)
                hashCode = 31 * hashCode + parameterTypes[i].hashCode();

            count = InternalUtils.size(exceptionTypes);

            for (int i = 0; i < count; i++)
                hashCode = 31 * hashCode + exceptionTypes[i].hashCode();
        }

        return hashCode;
    }

    /**
     * Returns true if the other object is an instance of MethodSignature with <em>identical</em> values for return
     * type, name, parameter types and exception types.
     *
     * @see #isOverridingSignatureOf(MethodSignature)
     */
    @Override
    public boolean equals(Object o)
    {
        if (o == null || !(o instanceof MethodSignature))
            return false;

        MethodSignature ms = (MethodSignature) o;

        if (returnType != ms.returnType)
            return false;

        if (!name.equals(ms.name))
            return false;

        if (mismatch(parameterTypes, ms.parameterTypes))
            return false;

        return !mismatch(exceptionTypes, ms.exceptionTypes);
    }

    private boolean mismatch(Class[] a1, Class[] a2)
    {
        int a1Count = InternalUtils.size(a1);
        int a2Count = InternalUtils.size(a2);

        if (a1Count != a2Count)
            return true;

        // Hm. What if order is important (for exceptions)? We're really saying here that they
        // were derived from the name Method.

        for (int i = 0; i < a1Count; i++)
        {
            if (a1[i] != a2[i])
                return true;
        }

        return false;
    }

    @Override
    public String toString()
    {
        StringBuilder buffer = new StringBuilder();

        buffer.append(PlasticUtils.toTypeName(returnType));
        buffer.append(' ');
        buffer.append(name);
        buffer.append('(');

        for (int i = 0; i < InternalUtils.size(parameterTypes); i++)
        {
            if (i > 0)
                buffer.append(", ");

            buffer.append(PlasticUtils.toTypeName(parameterTypes[i]));
        }

        buffer.append(')');

        int _exceptionCount = InternalUtils.size(exceptionTypes);
        String _exceptionNames[] = new String[_exceptionCount];
        for (int i = 0; i < _exceptionCount; i++)
        {
            _exceptionNames[i] = exceptionTypes[i].getName();
        }

        Arrays.sort(_exceptionNames);

        for (int i = 0; i < _exceptionCount; i++)
        {
            if (i == 0)
                buffer.append(" throws ");
            else
                buffer.append(", ");

            buffer.append(_exceptionNames[i]);
        }

        return buffer.toString();
    }

    /**
     * Returns a string consisting of the name of the method and its parameter types. This is similar to
     * {@link #toString()}, but omits the return type and information about thrown exceptions. A unique id is used by
     * {@link org.apache.tapestry5.ioc.internal.services.MethodIterator} to identify overlapping methods (methods with the same name and parameter types but with
     * different thrown exceptions).
     *
     * @see #isOverridingSignatureOf(MethodSignature)
     */
    public String getUniqueId()
    {
        StringBuilder buffer = new StringBuilder(name);
        buffer.append('(');

        for (int i = 0; i < InternalUtils.size(parameterTypes); i++)
        {
            if (i > 0)
                buffer.append(',');

            buffer.append(PlasticUtils.toTypeName(parameterTypes[i]));
        }

        buffer.append(')');

        return buffer.toString();
    }

    /**
     * Returns true if this signature has the same return type, name and parameters types as the method signature passed
     * in, and this signature's exceptions "trump" (are the same as, or super-implementations of, all exceptions thrown
     * by the other method signature).
     */

    public boolean isOverridingSignatureOf(MethodSignature ms)
    {
        if (returnType != ms.returnType)
            return false;

        if (!name.equals(ms.name))
            return false;

        if (mismatch(parameterTypes, ms.parameterTypes))
            return false;

        return exceptionsEncompass(ms.exceptionTypes);
    }

    /**
     * The nuts and bolts of checking that another method signature's exceptions are a subset of this signature's.
     */

    @SuppressWarnings("unchecked")
    private boolean exceptionsEncompass(Class[] otherExceptions)
    {
        int ourCount = InternalUtils.size(exceptionTypes);
        int otherCount = InternalUtils.size(otherExceptions);

        // If we have no exceptions, then ours encompass theirs only if they
        // have no exceptions, either.

        if (ourCount == 0)
            return otherCount == 0;

        boolean[] matched = new boolean[otherCount];
        int unmatched = otherCount;

        for (int i = 0; i < ourCount && unmatched > 0; i++)
        {
            for (int j = 0; j < otherCount; j++)
            {
                // Ignore exceptions that have already been matched

                if (matched[j])
                    continue;

                // When one of our exceptions is a super-class of one of their exceptions,
                // then their exceptions is matched.

                if (exceptionTypes[i].isAssignableFrom(otherExceptions[j]))
                {
                    matched[j] = true;
                    unmatched--;
                }
            }
        }

        return unmatched == 0;
    }
}