// 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.internal.plastic;

import java.util.Map;
import java.util.Set;

/**
 * Used to track which methods are implemented by a base class, which is often needed when transforming
 * a subclass.
 */
public class InheritanceData
{
    private final InheritanceData parent;

    private final String packageName;

    private final Set<String> methodNames = PlasticInternalUtils.newSet();
    private final Map<String, Boolean> methods = PlasticInternalUtils.newMap();
    private final Set<String> interfaceNames = PlasticInternalUtils.newSet();

    public InheritanceData(String packageName)
    {
        this(null, packageName);
    }

    private InheritanceData(InheritanceData parent, String packageName)
    {
        this.parent = parent;
        this.packageName = packageName;
    }

    /**
     * Is this bundle for a transformed class, or for a base class (typically Object)?
     *
     * @return true if this bundle is for transformed class, false otherwise
     */
    public boolean isTransformed()
    {
        return parent != null;
    }

    /**
     * Returns a new MethodBundle that represents the methods of a child class
     * of this bundle. The returned bundle will always be {@linkplain #isTransformed() transformed}.
     *
     * @param packageName
     *         the package that the child class will be created in
     * @return new method bundle
     */
    public InheritanceData createChild(String packageName)
    {
        return new InheritanceData(this, packageName);
    }

    /**
     * Adds a new instance method. Only non-private methods should be added (that is, methods which might
     * be overridden in subclasses). This can later be queried to see if any base class implements the method.
     *
     * @param name
     *         name of method
     * @param desc
     *         describes the parameters and return value of the method
     * @param samePackageOnly
     *         whether the method can only be overridden in classes that are in the same package
     */
    public void addMethod(String name, String desc, boolean samePackageOnly)
    {
        methods.put(toValue(name, desc), samePackageOnly);
        methodNames.add(name);
    }


    /**
     * Returns true if this class or a transformed parent class contains an implementation of,
     * or abstract placeholder for, the method.
     *
     * @param name
     *         method name
     * @param desc
     *         method descriptor
     * @return true if this class or a base class implements the method (including abstract methods)
     */
    public boolean isImplemented(String name, String desc)
    {
        return checkForMethod(toValue(name, desc), this);
    }

    /**
     * Returns true if the method is an override of a base class method
     *
     * @param name
     *         method name
     * @param desc
     *         method descriptor
     * @return true if a base class implements the method (including abstract methods)
     */
    public boolean isOverride(String name, String desc)
    {
        return checkForMethod(toValue(name, desc), parent);
    }

    private boolean checkForMethod(String value, InheritanceData cursor)
    {

        String thisPackageName = packageName;

        while (cursor != null)
        {
            if (cursor.methods.containsKey(value))
            {
                boolean mustBeInSamePackage = cursor.methods.get(value);

                if (!mustBeInSamePackage)
                {
                    return true;
                }
                boolean isInSamePackage = thisPackageName.equals(cursor.packageName);

                if (isInSamePackage)
                {
                    return true;
                }
            }

            cursor = cursor.parent;
        }

        return false;
    }

    /**
     * Returns true if the class represented by this data, or any parent data, implements
     * the named interface.
     */
    public boolean isInterfaceImplemented(String name)
    {
        InheritanceData cursor = this;

        while (cursor != null)
        {
            if (cursor.interfaceNames.contains(name))
            {
                return true;
            }

            cursor = cursor.parent;
        }

        return false;
    }

    public void addInterface(String name)
    {
        if (!interfaceNames.contains(name))
        {
            interfaceNames.add(name);
        }
    }

    /**
     * Combines a method name and its desc (which describes parameter types and return value) to form
     * a value, which is how methods are tracked.
     */
    private static String toValue(String name, String desc)
    {
        // TAP5-2268: ignore return-type to avoid methods with the same number (and type) of parameters but different
        //            return-types which is illegal in Java.
        // desc is something like "(I)Ljava/lang/String;", which means: takes an int, returns a String. We strip
        // everything after the parameter list.
        int endOfParameterSpecIdx = desc.indexOf(')');

        return name + ":" + desc.substring(0, endOfParameterSpecIdx+1);
    }

    /**
     * Returns the names of any methods in this bundle, or from any parent bundles.
     */
    public Set<String> methodNames()
    {
        Set<String> result = PlasticInternalUtils.newSet();

        InheritanceData cursor = this;

        while (cursor != null)
        {
            result.addAll(cursor.methodNames);
            cursor = cursor.parent;
        }

        return result;
    }
}