/**********************************************************************
 * This file is part of "Object Teams Development Tooling"-Software
 *
 * Copyright 2004, 2006 Fraunhofer Gesellschaft, Munich, Germany,
 * for its Fraunhofer Institute for Computer Architecture and Software
 * Technology (FIRST), Berlin, Germany and Technical University Berlin,
 * Germany.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 * $Id: AnchorListAttribute.java 23416 2010-02-03 19:59:31Z stephan $
 *
 * Please visit http://www.eclipse.org/objectteams for updates and contact.
 *
 * Contributors:
 * Fraunhofer FIRST - Initial API and implementation
 * Technical University Berlin - Initial API and implementation
 **********************************************************************/
package org.eclipse.objectteams.otdt.internal.core.compiler.bytecode;

import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.jdt.internal.compiler.classfmt.MethodInfo;
import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment;
import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.objectteams.otdt.core.compiler.IOTConstants;
import org.eclipse.objectteams.otdt.internal.core.compiler.lookup.CallinCalloutScope;
import org.eclipse.objectteams.otdt.internal.core.compiler.lookup.DependentTypeBinding;
import org.eclipse.objectteams.otdt.internal.core.compiler.lookup.ITeamAnchor;
import org.eclipse.objectteams.otdt.internal.core.compiler.lookup.RoleTypeBinding;
import org.eclipse.objectteams.otdt.internal.core.compiler.lookup.TThisBinding;
import org.eclipse.objectteams.otdt.internal.core.compiler.lookup.DependentTypeBinding.IMethodProvider;
import org.eclipse.objectteams.otdt.internal.core.compiler.model.MethodModel;
import org.eclipse.objectteams.otdt.internal.core.compiler.util.RoleTypeCreator;

/**
 * Keep a list of all type anchors of one method signature
 * in order to make them persistent in class files.
 * Later when reading the byte code, anchored types are restored from this list.
 * Note that list positions are 1-based. 0 represents the return type.
 *
 * @author stephan
 * @version $Id: AnchorListAttribute.java 23416 2010-02-03 19:59:31Z stephan $
 */
public class AnchorListAttribute extends ListValueAttribute {

    private MethodBinding _method;
    private char[][]   _anchors;
    private static final char[] NO_ANCHOR = "_OT$NoAnchor".toCharArray(); //$NON-NLS-1$
    private static final String ARG_ANCHOR_PREFIX = "_OT$param"; //$NON-NLS-1$

    /**
     * Create an attribute from source:
     * @param method
     */
    public AnchorListAttribute(MethodBinding method) {
        super(IOTConstants.TYPE_ANCHOR_LIST, 0, 2);
        this._method = method;
        this._count = method.parameters.length+1;
    }

    /**
     * Create an attribute from byte code.
     *
     * (Invoked from AbstractAttribute.readAttribute(char[],MethodInfo,int,int,int[]))
     */
    public AnchorListAttribute(
            MethodInfo  info,
            int         readOffset,
            int         structOffset,
            int[]       constantPoolOffsets)
    {
        super(IOTConstants.TYPE_ANCHOR_LIST, 0, 2);
        this._methodInfo = info;
        readList(info, readOffset, structOffset, constantPoolOffsets);
    }

    /* (non-Javadoc)
     * @see org.eclipse.objectteams.otdt.internal.core.compiler.bytecode.ListValueAttribute#writeElementValue(int)
     */
    @Override
	void writeElementValue(int i) {
        if (i==0) {
            writeElement(this._method.returnType);
        } else {
            writeElement(this._method.parameters[i-1]);
        }
    }

    /**
     * Write one list element: encode the type anchor as this:
     * (a) NO_ANCHOR    -> not an externalized role type
     * (b) name         -> best-name (path) to be resolved to a variable binding (see TeamAnchor.getBestName())
     * (c) _OT$param'n' -> argument 'n' of this method is the type anchor.
     *
     * @param type
     */
    private void writeElement(TypeBinding type) {
        if (type.isArrayType())
            type = type.leafComponentType();
        if (type instanceof DependentTypeBinding) {
            DependentTypeBinding roleType = (DependentTypeBinding)type;
            ITeamAnchor anchor = roleType._teamAnchor;
            if (anchor instanceof TThisBinding)
                writeName(NO_ANCHOR);
            else {
                if (roleType._argumentPosition > -1)
                    writeName((ARG_ANCHOR_PREFIX+roleType._argumentPosition).toCharArray());
                else
                    writeName(anchor.getBestName());
            }
        } else {
            writeName(NO_ANCHOR);
        }
    }

    /**
     * PHASE 1 of reading:
     * Read one list element from byte code: Read names and store
     * them in our array _anchors.
     *
     * (Invoked from MethodInfo.readDeprecatedAndSyntheticAttributes
     *     .. -> <init>(MethodInfo,int,int,int[]) -> ListValueAttribute.readList()
     * )
     */
    @Override
	void read(int i)
    {
        if (i==0)
            this._anchors = new char[this._count][];

        char[] name = consumeName();
        if (!CharOperation.equals(name, NO_ANCHOR))
            this._anchors[i] = name;
    }

    /* (non-Javadoc)
     * @see org.eclipse.objectteams.otdt.internal.core.compiler.bytecode.AbstractAttribute#evaluate(org.eclipse.jdt.internal.compiler.lookup.Binding, org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment)
     */
    @Override
	public void evaluate(Binding binding, LookupEnvironment environment, char[][][] missingTypeNames) {
        assert(false);
    }

    /**
     * PHASE 2 or reading:
     * Once the method binding is created, store the anchor list into the method binding.
     */
    @Override
	public boolean evaluate(MethodInfo info, MethodBinding methodBinding, LookupEnvironment environment)
    {
        if (info != this._methodInfo) return false;
        this._method = methodBinding;
        this._method.anchorList = this;
        return true;
    }

    /**
     *  PHASE 3 of reading:
     *  When types in the method signature are resolved, wrap them.
     *
     * (Hooked into RoleTypeBinding.wrapTypesInMethodSignature(..)).
     */
    public void wrapTypes(LookupEnvironment environment) {
        for (int i=0;i<this._count;i++) {
            if (this._anchors[i] != null) {
                if (i == 0)
                    this._method.returnType =
                        getWrappedType(
                           	this._method.returnType, this._anchors[i], this._method.declaringClass, this._method, environment);
                else
                    this._method.parameters[i-1] =
                        getWrappedType(
                        	this._method.parameters[i-1], this._anchors[i], this._method.declaringClass, this._method, environment);
            }
        }
    }

    /**
     * @param typeToWrap ReferenceBinding or array thereof
     * @param anchorName
     * @param site
     * @param declaringMethod where to look for arguments being used as type anchor.
     * @param environment
     * @return a wrapped version of typeToWrap
     */
    private TypeBinding getWrappedType(
    		TypeBinding typeToWrap, char[] anchorName,
			ReferenceBinding site, final MethodBinding declaringMethod, LookupEnvironment environment)
    {
    	assert !CharOperation.equals(anchorName, NO_ANCHOR) : "NO_ANCHOR should have been filtered out"; //$NON-NLS-1$

        ReferenceBinding type = (ReferenceBinding)typeToWrap.leafComponentType();
        if (CharOperation.prefixEquals(ARG_ANCHOR_PREFIX.toCharArray(), anchorName)) {
            // Type anchored to another argument:
            LocalVariableBinding anchor = new LocalVariableBinding(
                    anchorName, type.enclosingType(), 0, true); // name is irrelevant.
            // make sure this anchor can answer `anchor.declaringScope.referenceMethodBinding()`:
            anchor.declaringScope = new CallinCalloutScope(null, null) {
            	@Override
				public MethodBinding referenceMethodBinding() {
            		return declaringMethod;
            	}
            };
            TypeBinding wrappedType = anchor.getRoleTypeBinding(type, typeToWrap.dimensions());

            // argument position is relevant:
            char[] tail = CharOperation.subarray(anchorName, ARG_ANCHOR_PREFIX.length(), -1);
            RoleTypeBinding wrappedRole = (RoleTypeBinding)wrappedType.leafComponentType();
			wrappedRole._argumentPosition = Integer.parseInt(String.valueOf(tail));
			wrappedRole._declaringMethod = new IMethodProvider() {
				@Override
				public MethodBinding getMethod() { return declaringMethod; }
			};

            return wrappedType;
        } else {
        	return RoleTypeCreator.wrapTypeWithAnchorFromName(typeToWrap, anchorName, site, environment);
        }
    }

    /**
     * API: after resolving a method, check whether we need to store an
     * anchor list.
     *
     * @param decl
     */
    public static void checkAddAnchorList(AbstractMethodDeclaration decl) {
        if (decl.ignoreFurtherInvestigation)
            return;
        MethodBinding binding = decl.binding;
        if (binding.anchorList != null)
        	return;
        boolean relevantAnchorFound = false;
        if (binding.returnType != null)
        	relevantAnchorFound = hasRelevantAnchor(binding.returnType);
        int i=0;
        while (!relevantAnchorFound && i<binding.parameters.length) {
            relevantAnchorFound |= hasRelevantAnchor(binding.parameters[i++]);
        }
        if (relevantAnchorFound) {
            MethodModel model = MethodModel.getModel(decl);
            model.addAttribute(new AnchorListAttribute(binding));
        }
    }

    /**
     * Is `binding' an anchored type, whose anchor is not a TThisBinding?
     */
    private static boolean hasRelevantAnchor(TypeBinding binding) {
        if (binding.isArrayType())
            binding = binding.leafComponentType();
        if (binding.isBaseType())
            return false;
        ReferenceBinding refBinding = (ReferenceBinding)binding;
        if (!(refBinding instanceof DependentTypeBinding))
            return false;
        ITeamAnchor anchor = ((DependentTypeBinding)refBinding)._teamAnchor;
        return !(anchor instanceof TThisBinding);
    }

    /* (non-Javadoc)
     * @see org.eclipse.objectteams.otdt.internal.core.compiler.bytecode.ListValueAttribute#toString(int)
     */
    @Override
	String toString(int i) {
        if (this._anchors != null) {
            if (this._anchors[i] == null)
                return "<>";             //$NON-NLS-1$
            return new String(this._anchors[i]);
        }
        if (i==0)
            return toString(this._method.returnType);
        else
            return toString(this._method.parameters[i-1]);
    }

    private String toString(TypeBinding type) {
        if (type instanceof RoleTypeBinding)
            return ((RoleTypeBinding)type)._teamAnchor.toString();
        return "<>"; //$NON-NLS-1$
    }
}