/**********************************************************************
 * 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: BaseAllocationExpression.java 23401 2010-02-02 23:56:05Z 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.ast;

import static org.eclipse.objectteams.otdt.core.compiler.IOTConstants.CREATOR_PREFIX_NAME;
import static org.eclipse.objectteams.otdt.core.compiler.IOTConstants._OT_BASE;

import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.ASTVisitor;
import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.AllocationExpression;
import org.eclipse.jdt.internal.compiler.ast.ArrayAllocationExpression;
import org.eclipse.jdt.internal.compiler.ast.Assignment;
import org.eclipse.jdt.internal.compiler.ast.CastExpression;
import org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration;
import org.eclipse.jdt.internal.compiler.ast.ExplicitConstructorCall;
import org.eclipse.jdt.internal.compiler.ast.Expression;
import org.eclipse.jdt.internal.compiler.ast.IntLiteral;
import org.eclipse.jdt.internal.compiler.ast.MessageSend;
import org.eclipse.jdt.internal.compiler.ast.QualifiedAllocationExpression;
import org.eclipse.jdt.internal.compiler.ast.Reference;
import org.eclipse.jdt.internal.compiler.ast.SingleNameReference;
import org.eclipse.jdt.internal.compiler.ast.Statement;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
import org.eclipse.jdt.internal.compiler.ast.TypeReference;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
import org.eclipse.jdt.internal.compiler.flow.FlowContext;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.impl.ReferenceContext;
import org.eclipse.jdt.internal.compiler.lookup.ArrayBinding;
import org.eclipse.jdt.internal.compiler.lookup.BaseTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.MemberTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
import org.eclipse.jdt.internal.compiler.lookup.Scope;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
import org.eclipse.objectteams.otdt.core.compiler.IOTConstants;
import org.eclipse.objectteams.otdt.core.exceptions.InternalCompilerError;
import org.eclipse.objectteams.otdt.internal.core.compiler.control.ITranslationStates;
import org.eclipse.objectteams.otdt.internal.core.compiler.control.StateHelper;
import org.eclipse.objectteams.otdt.internal.core.compiler.lifting.Lifting;
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.mappings.CalloutImplementorDyn;
import org.eclipse.objectteams.otdt.internal.core.compiler.model.MethodModel;
import org.eclipse.objectteams.otdt.internal.core.compiler.model.RoleModel;
import org.eclipse.objectteams.otdt.internal.core.compiler.model.TeamModel.UpdatableIntLiteral;
import org.eclipse.objectteams.otdt.internal.core.compiler.util.AstGenerator;

/**
 * A base constructor invocation "base(args)";
 * Translated to "_OT$base = new BaseClass(args);"
 *
 * @author stephan
 * @version $Id: BaseAllocationExpression.java 23401 2010-02-02 23:56:05Z stephan $
 */
public class BaseAllocationExpression extends Assignment {

    // intermediate store, before transfering this to the AllocationExpression.
    public Expression[] arguments;
    public Expression enclosingInstance;

    public boolean isExpression = false;
    private boolean isAstCreated = false;
	private Boolean checkResult = null; // three-valued logic (incl null)

    /**
     *
     */
    public BaseAllocationExpression(int start, int end) {
        // only set the lhs yet, expression is constructed later.
        super(new SingleNameReference(_OT_BASE, 0), null, end);
        this.sourceStart = start;
    }

	@Override
	public FlowInfo analyseCode(
			BlockScope currentScope,
			FlowContext flowContext,
			FlowInfo flowInfo)
	{
		if (this.isExpression) // don't treat as assignment
			return this.expression.analyseCode(currentScope, flowContext, flowInfo);
		// in case of error assume it might relate to duplicate base() calls, don't report again.
		if (((AbstractMethodDeclaration)currentScope.methodScope().referenceContext).ignoreFurtherInvestigation)
			return flowInfo;
		return super.analyseCode(currentScope, flowContext, flowInfo);
	}

    /**
     * Initialize the type to create from the "playedBy" clause.
     * @param scope non-null
     */
    private void createAst(BlockScope scope) {
        if (this.isAstCreated) return; // already done.

        this.isAstCreated = true; // even if creation fails, don't try again.

        ReferenceBinding          enclType;
        AbstractMethodDeclaration enclMethodDecl;
        ReferenceBinding          baseclass = null;

        enclType = scope.enclosingSourceType();
        enclMethodDecl = (AbstractMethodDeclaration)scope.methodScope().referenceContext;

        if (enclType.isDirectRole())
            baseclass = ((MemberTypeBinding)enclType).baseclass();
        if (   baseclass == null
            || !enclMethodDecl.isConstructor())
        {
            scope.problemReporter().baseConstructorCallInWrongMethod(
                    this, scope.methodScope().referenceContext);
            return;
        }
        ConstructorDeclaration enclCtor = (ConstructorDeclaration)enclMethodDecl;
        if (this.isExpression) {
        	if (!isArgOfOtherCtor(enclCtor, scope))
        		scope.problemReporter().baseConstructorExpressionOutsideCtorCall(this);
        } else {
        	if (enclCtor.statements[0] != this) 
        		scope.problemReporter().baseConstructorCallIsNotFirst(this);
        }

        AstGenerator gen = new AstGenerator(this.sourceStart, this.sourceEnd);
        Expression allocation;
        if (this.enclosingInstance != null) {
        	this.enclosingInstance= new PotentialLowerExpression(this.enclosingInstance, baseclass.enclosingType());
        // FIXME(SH): check baseclass.enclosingType();
        }

        if (baseclass.isDirectRole()) {
        	// instead of new B() create:
        	// 		receiver._OT$createB():
        	Expression receiver;
        	if (RoleTypeBinding.isRoleWithExplicitAnchor(baseclass)) {
	        	RoleTypeBinding baseRole = (RoleTypeBinding)baseclass;
	        	ITeamAnchor anchor = baseRole._teamAnchor;
	        	ReferenceBinding startClass = anchor.getFirstDeclaringClass();
	        	char[][] tokens = anchor.tokens();
	        	if (startClass != null) {
	        		// relevant start class, create as receiver:
	        		//     EnclType.this.field1.
	        		TypeReference startReference = gen.typeReference(startClass);
	        		startReference.setBaseclassDecapsulation(DecapsulationState.ALLOWED);
	        		receiver = gen.qualifiedThisReference(startReference);
	        		for (int i = 0; i < tokens.length; i++) {
						receiver = gen.fieldReference(receiver, tokens[i]);
					}
	        	} else {
	        		// the best name path defines the receiver:
		        	receiver = gen.qualifiedNameReference(tokens);
	        	}
        	} else {
        		if (this.enclosingInstance != null) {
					receiver= this.enclosingInstance;
				}
				else {
					if (TypeBinding.equalsEquals(baseclass.enclosingType(), enclType.enclosingType()))
						receiver = gen.thisReference(); // creating a role of the same team as base instance??
					else
						receiver = gen.qualifiedThisReference(gen.typeReference(baseclass.enclosingType()));
				}
        	}
            char[] selector = CharOperation.concat(CREATOR_PREFIX_NAME, baseclass.sourceName());

        	MessageSend allocSend = new MessageSend() {
        		@Override
				public boolean isDecapsulationAllowed(Scope scope2) {
        			// this message send can decapsulate independent of scope
        			return true;
        		}
        		@Override
        		public DecapsulationState getBaseclassDecapsulation() {
        			return DecapsulationState.ALLOWED;
        		}
        	};
        	gen.setPositions(allocSend);
        	allocSend.receiver = receiver;
        	allocSend.selector = selector;
        	allocSend.arguments = this.arguments;
        	allocSend.accessId = -1; // request that MessageSend.resolveType() assigns a fresh accessId if decapsulation is detected
        	allocation = allocSend;
        } else {
            AllocationExpression alloc = newAllocation(baseclass, gen);
            alloc.type.setBaseclassDecapsulation(DecapsulationState.ALLOWED); // report individually
            alloc.arguments    = this.arguments;
            alloc.sourceStart  = this.sourceStart;
            alloc.sourceEnd    = this.sourceEnd;
            alloc.statementEnd = this.statementEnd;
            allocation = alloc;
        }
        this.arguments = null; // don't use any more.

        ExplicitConstructorCall selfcall = enclCtor.constructorCall;
        if (   selfcall.isImplicitSuper()
        	&& enclType.superclass().isDirectRole()
			&& enclType.superclass().baseclass() != null)
        {
        	// implement 2.4.2(c):
        	// transform "super(); base(args);" => "super(new MyBase(args)); nop;"
        	enclCtor.constructorCall = genLiftCtorCall(allocation);
        	enclCtor.statements[0] = new AstGenerator(this.sourceStart, this.sourceEnd).emptyStatement();
        	// pretend we are not calling base() because we already call the lifting-ctor.
        } else if (this.isExpression) {
        	// similar to above:
        	// translate "super(base(args), ...);" as "super(new MyBase(args), ...);"
        	this.expression = allocation; // and ignore the assignment flavor of this node.
        } else {
        	// needed by ASTConverter:
        	this.expression = allocation;
        	if (   !enclType.roleModel.hasBaseclassProblem()
        		&& !scope.referenceType().ignoreFurtherInvestigation)
        	{

	    		MethodModel.setCallsBaseCtor(enclCtor);

	    		// really creating base here, need to register this base object
	    		RoleModel boundRootRoleModel = enclType.roleModel.getBoundRootRole();
	    		if (boundRootRoleModel == null)
    				throw new InternalCompilerError("Unexpected: role has neither baseclassProblem nor boundRootRole"); //$NON-NLS-1$
	    		Statement[] regStats = Lifting.genRoleRegistrationStatements(scope,
	    																	 boundRootRoleModel,
	    																	 baseclass,
	    																	 enclCtor,
	    																	 gen);
	    		int len = enclCtor.statements.length;
	    		Statement[] newStats = new Statement[len+regStats.length];
	    		newStats[0] = this;
	    		System.arraycopy(regStats, 0, newStats, 1, regStats.length);
	    		System.arraycopy(enclCtor.statements, 1, newStats, regStats.length+1, len-1);
	    		enclCtor.setStatements(newStats);
    		}
        }
    }

	public static Expression convertToDynAccess(BlockScope scope, AllocationExpression expression, int accessId) {
		TypeBinding baseclass = expression.resolvedType;
		AstGenerator gen = new AstGenerator(expression);
    	Expression receiver = gen.typeReference(baseclass);
    	char[] selector = CalloutImplementorDyn.OT_ACCESS_STATIC;
    	int modifiers = ClassFileConstants.AccPublic|ClassFileConstants.AccStatic;
		Expression[] arguments = expression.arguments;
		Expression enclosingInstance = null;
		ReferenceBinding enclosingTeam = null;
		if (expression instanceof QualifiedAllocationExpression) {
			enclosingInstance = ((QualifiedAllocationExpression) expression).enclosingInstance;
			// TODO: enclosing team (for accessId-updating)?
		} else if (baseclass.isMemberType()) {
			// extract the enclosing base instance from an outer playedBy:
			enclosingTeam = scope.enclosingReceiverType().enclosingType();
			if (enclosingTeam != null
					&& TypeBinding.equalsEquals(baseclass.enclosingType(), enclosingTeam.baseclass)) {
				enclosingInstance = gen.fieldReference(
										gen.qualifiedThisReference(gen.typeReference(enclosingTeam)),
										IOTConstants._OT_BASE);
				enclosingInstance.resolve(scope);
			}
		}
		if (enclosingInstance != null) {
			if (arguments == null) {
				arguments = new Expression[] { enclosingInstance };
			} else {
				int len = arguments.length;
				System.arraycopy(arguments, 0, arguments = new Expression[len+1], 1, len);
				arguments[0] = enclosingInstance;
			}
		}
		MessageSend allocSend = new MessageSend() {
    		@Override
			public boolean isDecapsulationAllowed(Scope scope2) {
    			// this message send can decapsulate independent of scope
    			return true;
    		}
    		@Override
    		public DecapsulationState getBaseclassDecapsulation() {
    			return DecapsulationState.ALLOWED;
    		}
    	};
    	gen.setPositions(allocSend);
    	allocSend.receiver = receiver;
    	allocSend.selector = selector;
    	allocSend.constant = Constant.NotAConstant;
    	allocSend.actualReceiverType = baseclass;
    	allocSend.accessId = accessId;
   		allocSend.arguments = createResolvedAccessArguments(gen, accessId, arguments, enclosingTeam, scope);
    	allocSend.binding = new MethodBinding(modifiers, new TypeBinding[] {
    			TypeBinding.INT,
    			TypeBinding.INT,
    			scope.createArrayType(scope.getJavaLangObject(), 1),
    			scope.getOrgObjectteamsITeam()
    		}, 
    		Binding.NO_EXCEPTIONS,
    		(ReferenceBinding) baseclass);
    	allocSend.binding.returnType = scope.getJavaLangObject();
    	allocSend.binding.selector = selector;
    	return gen.resolvedCastExpression(allocSend, baseclass, CastExpression.RAW);
	}

	private static Expression[] createResolvedAccessArguments(AstGenerator gen, int accessId, Expression[] arguments, ReferenceBinding enclosingTeam, BlockScope scope) {
		UpdatableIntLiteral accessIdLiteral = gen.updatableIntLiteral(accessId);
		accessIdLiteral.resolveType(scope);
		if (enclosingTeam != null)
			enclosingTeam.getTeamModel().recordUpdatableAccessId(accessIdLiteral);

		IntLiteral opKindLiteral = gen.intLiteral(0);
		opKindLiteral.resolveType(scope);
		
		Expression[] boxedArgs = null;
		if (arguments != null) {
			boxedArgs = new Expression[arguments.length];
			for (int i = 0; i < arguments.length; i++) {
				Expression argument = arguments[i];
				if (argument.resolvedType.isPrimitiveType()) {
					BaseTypeBinding baseType = (BaseTypeBinding) argument.resolvedType;
					MessageSend boxingSend = gen.createBoxing(argument, baseType);
					boxingSend.resolvedType = scope.environment().computeBoxingType(baseType);
					boxingSend.binding = scope.getMethod(boxingSend.resolvedType, TypeConstants.VALUEOF, new TypeBinding[]{baseType}, boxingSend);
					boxingSend.actualReceiverType = boxingSend.resolvedType;
					boxingSend.argumentTypes = new TypeBinding[] { baseType };
					boxingSend.constant = Constant.NotAConstant;
					argument = boxingSend;
				}
				boxedArgs[i] = argument;
			}
		}
		ArrayAllocationExpression packedArgs = gen.arrayAllocation(gen.qualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT), 
				boxedArgs != null ? 1 : 0, boxedArgs); // arguments are already resolved at this point
		ArrayBinding objectArray = scope.createArrayType(scope.getJavaLangObject(), 1);
		if (packedArgs.initializer != null)
			packedArgs.initializer.binding = objectArray;
		else
			packedArgs.dimensions[0].resolveType(scope);
		packedArgs.resolvedType = objectArray;
		packedArgs.constant = Constant.NotAConstant;

		Reference teamReference = gen.qualifiedThisReference(scope.enclosingSourceType().enclosingType());
		teamReference.resolveType(scope);
		
		return new Expression[] { accessIdLiteral, opKindLiteral, packedArgs, teamReference };
	}

	private boolean isArgOfOtherCtor(ConstructorDeclaration constructorDecl, BlockScope scope) {
    	// two marker exception types:
    	@SuppressWarnings("serial") class FoundException extends RuntimeException { /*empty*/}
    	@SuppressWarnings("serial") class NotFoundException extends RuntimeException { /*empty*/ }
    	try {
    		constructorDecl.traverse(new ASTVisitor() {
    			int inCtorCall=0;
    			@Override
    			public boolean visit(ExplicitConstructorCall ctorCall, BlockScope aScope) {
    				this.inCtorCall++;
   					return super.visit(ctorCall, aScope);
    			}
    			@Override
    			public void endVisit(ExplicitConstructorCall explicitConstructor, BlockScope aScope) {
    				super.endVisit(explicitConstructor, aScope);
    				this.inCtorCall--;
    			}
    			@Override
    			public boolean visit(Assignment assig, BlockScope aScope) {
    				if (assig == BaseAllocationExpression.this) {
    					if (this.inCtorCall>0)
    						throw new FoundException();
    					else
    						throw new NotFoundException();
    				}
    				return super.visit(assig, aScope);
    			}
			},
			scope.classScope());
    	} catch (FoundException fe) {
    		return true;
    	} catch (NotFoundException nfe) {
    		return false;
    	}
    	return false;
    }

	private AllocationExpression newAllocation(ReferenceBinding baseclass, AstGenerator gen)
	{
		if (this.enclosingInstance == null) {
			AllocationExpression alloc= new AllocationExpression();
			alloc.type= gen.typeReference(baseclass);
			return alloc;
		} else {
			QualifiedAllocationExpression alloc= new QualifiedAllocationExpression();
			alloc.enclosingInstance= this.enclosingInstance;
			alloc.type= gen.singleTypeReference(baseclass.sourceName);
			return alloc;
		}
	}

    /**
	 * @param baseExpr
	 */
	private ExplicitConstructorCall genLiftCtorCall(Expression baseExpr) {
		ExplicitConstructorCall constructorCall = new ExplicitConstructorCall(ExplicitConstructorCall.Super);
		constructorCall.arguments = new Expression[] { baseExpr };
		constructorCall.sourceStart = this.sourceStart;
		constructorCall.sourceEnd   = this.sourceEnd;
		return constructorCall;
	}

	public boolean checkGenerate(BlockScope scope) {
		if (this.checkResult != null)
			return this.checkResult;
		this.checkResult = Boolean.TRUE; // preliminary, prevent re-entrance from isArgOfOtherCtor
		return this.checkResult = Boolean.valueOf(internalCheckGenerate(scope));
	}
	private boolean internalCheckGenerate(BlockScope scope) {
    	if (scope == null)
    		return false;
    	ReferenceContext referenceContext = scope.methodScope().referenceContext;
    	if (!(referenceContext instanceof AbstractMethodDeclaration)) {
    		scope.problemReporter().baseConstructorCallInWrongMethod(this, referenceContext);
    		return false;
    	}
    	AbstractMethodDeclaration enclosingMethodDeclaration = (AbstractMethodDeclaration)referenceContext;
		if (!enclosingMethodDeclaration.ignoreFurtherInvestigation)
		{
    		createAst(scope);
    		return this.expression != null;
		}
		return false;
    }

    @Override
	public void traverse(ASTVisitor visitor, BlockScope scope) {
        // we might be the first to analyse this expression:
        // (Actually triggered by TransformStatementsVisitor
    	//  - but don't do it before STATE_LENV_DONE_FIELDS_AND_METHODS,
    	//    which is needed to lookup baseclass()!)
    	TypeDeclaration enclType = (scope != null) ? scope.referenceType() : null;
    	if (   enclType != null
    		&& enclType.isDirectRole()
			&& StateHelper.hasState(enclType.binding, ITranslationStates.STATE_LENV_DONE_FIELDS_AND_METHODS))
    	{
	    	if (checkGenerate(scope)) { // only if successful:
	    		// when called from createAst->isArgOfOtherCtor we don't yet have the expression generated
	    		if (this.isExpression && this.expression != null)
	    			this.expression.traverse(visitor, scope);
	    		else
	    			super.traverse(visitor, scope);
	    	}
    	} else {
    		if (this.expression != null)
    			super.traverse(visitor, scope);
    	}
    }

    @Override
	public TypeBinding resolveType(BlockScope scope) {
    	TypeDeclaration roleDecl = scope.referenceType();
    	if (roleDecl != null && roleDecl.isRole() && roleDecl.getRoleModel()._playedByEnclosing) {
    		scope.problemReporter().baseAllocationDespiteBaseclassCycle(this, roleDecl);
    		return null;
    	}
        if (!checkGenerate(scope)) { // createAst failed.
            return null;
        }
		if (this.isExpression) // don't treat as assignment
			return this.resolvedType = this.expression.resolveType(scope);
		if (!scope.methodScope().referenceContext.hasErrors())
			return super.resolveType(scope);
		return null;
    }
    
    @Override
    public void computeConversion(Scope scope, TypeBinding runtimeType, TypeBinding compileTimeType) {
    	if (this.isExpression)
    		this.expression.computeConversion(scope, runtimeType, compileTimeType);
    	else
    		super.computeConversion(scope, runtimeType, compileTimeType);
    }

    @Override
    public void generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired) {
		if (this.isExpression) // don't treat as assignment
			this.expression.generateCode(currentScope, codeStream, valueRequired);
		else
			super.generateCode(currentScope, codeStream, valueRequired);
    }
    
    @Override
	public String toString() {
        if (this.expression == null)
            return "unresolved base() call"; //$NON-NLS-1$
        return this.expression.toString();
    }

    @Override
	public StringBuffer printExpression (int indent, StringBuffer output) {
    	if (this.expression != null)
    		return super.printExpression(indent, output);
    	return output.append("<no expression yet>"); //$NON-NLS-1$
    }

	@Override
	public StringBuffer printExpressionNoParenthesis(int indent, StringBuffer output) {
    	if (this.expression != null)
    		return super.printExpressionNoParenthesis(indent, output);
    	return output.append("<no expression yet>"); //$NON-NLS-1$
	}
}