/*******************************************************************************
 * Copyright (c) 2009, 2012 SAP AG and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     SAP AG - initial API and implementation
 ******************************************************************************/
package org.eclipse.ocl.examples.impactanalyzer.instanceScope;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.Stack;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EOperation;
import org.eclipse.emf.ecore.EParameter;
import org.eclipse.ocl.ecore.EcoreEnvironment;
import org.eclipse.ocl.ecore.IterateExp;
import org.eclipse.ocl.ecore.LetExp;
import org.eclipse.ocl.ecore.LoopExp;
import org.eclipse.ocl.ecore.OCLExpression;
import org.eclipse.ocl.ecore.OperationCallExp;
import org.eclipse.ocl.ecore.Variable;
import org.eclipse.ocl.ecore.VariableExp;
import org.eclipse.ocl.examples.impactanalyzer.impl.OperationBodyToCallMapper;
import org.eclipse.ocl.examples.impactanalyzer.util.OCLFactory;
import org.eclipse.ocl.utilities.PredefinedType;


/**
 * Computes a {@link NavigationStep} for a {@link VariableExp} which, given an element constituting a value the variable
 * shall assume, infers a set of elements which, when used as the value of the outermost expression's <code>self</code> variable,
 * may lead the variable considered here to assume the expected value.<p>
 * 
 * OCL knows occurrences of different "stereotypes" of variables, depending on where/how the variable is defined:
 * <ul>
 *   <li>a <code>self</code> variable occurring within the body of an operation</li>
 *   <li>a <code>self</code> variable occurring outside the body of an operation</li>
 *   <li>an operation's formal parameter</li>
 *   <li>an iterator variable</li>
 *   <li>the result variable of an {@link IterateExp}</li>
 *   <li>the variable assigned by a {@link LetExp}</li>
 * </ul>
 * 
 * In all cases, traceback continues with the expression defining the possible values that the variable may assume. In all
 * cases, this leaves the scope in which the variable is visible. This becomes important when considering how variable values
 * travel through the computation of the <code>unused</code> function, trying to prove for each expression visited by traceback,
 * whether or not it is used, given what is known about variable values.
 * 
 * @author Axel Uhl (D043530)
 *
 */
// TODO refactor into several subclasses, one for each is... case, and let tracer factory in InstanceScopeAnalysis.createTracer choose the appropriate one
public class VariableExpTracer extends AbstractTracer<VariableExp> {
    public VariableExpTracer(VariableExp expression, Stack<String> tuplePartNames, OCLFactory oclFactory) {
        super(expression, tuplePartNames, oclFactory);
    }

    private Variable getVariableDeclaration() {
        return (Variable) getExpression().getReferredVariable();
    }

    private boolean isLetVariable() {
        // let variables are contained in the letExp
        Variable exp = getVariableDeclaration();
        return exp.eContainer() instanceof LetExp && ((LetExp) exp.eContainer()).getVariable() == exp;
    }

    private boolean isOperationParameter() {
        return getVariableDeclaration().getRepresentedParameter() != null;
    }

    private boolean isIterateResultVariable() {
        // result variables are contained in iterateExp
        Variable exp = getVariableDeclaration();
        return (exp.eContainer() instanceof IterateExp && ((IterateExp) exp.eContainer()).getResult() == exp);
    }

    private boolean isIteratorVariable() {
        Variable exp = getVariableDeclaration();
        return (exp.eContainer() instanceof LoopExp && ((LoopExp) exp.eContainer()).getIterator().contains(exp));
    }

    private boolean isSelf() {
        return getVariableDeclaration().getName().equals(EcoreEnvironment.SELF_VARIABLE_NAME);
    }

    /**
     * The step produced will be invoked with the value for the variable. This knowledge can be helpful when trying to perform
     * partial evaluations. Variables have an {@link OCLExpression} as their scope. For example, a let-variable has the
     * {@link LetExp#getIn() in} expression as its static scope. Additionally, scopes are dynamically instantiated during
     * expression evaluation. For example, during evaluation of an {@link IterateExp}, the body expression forms the static scope
     * for the {@link IterateExp#getResult() result variable}. During each iteration, a new dynamic scope is created and the same
     * static result variable may have a different value in each dynamic scope. It is important to understand that the navigation
     * step learns about the value of the variable only in one particular dynamic scope.
     * <p>
     * 
     * Dynamic scopes are identified by the {@link OCLExpression} object forming the static scope, combined with a unique
     * identifier, implemented as a simple counter.
     * <p>
     * 
     * It is also important to understand that variables of a collection type cannot have their value fully inferred by the
     * traceback process as only single elements are visited during the trace.
     */
    @Override
    public NavigationStep traceback(EClass context, PathCache pathCache, OperationBodyToCallMapper operationBodyToCallMapper) {
        NavigationStep result;
        if (isSelf()) {
            result = tracebackSelf(context, pathCache, operationBodyToCallMapper);
        } else if (isIteratorVariable()) {
            result = tracebackIteratorVariable(context, pathCache, operationBodyToCallMapper);
        } else if (isIterateResultVariable()) {
            result = tracebackIterateResultVariable(context, pathCache, operationBodyToCallMapper);
        } else if (isLetVariable()) {
            result = tracebackLetVariable(context, pathCache, operationBodyToCallMapper);
        } else if (isOperationParameter()) {
            result = tracebackOperationParameter(context, pathCache, operationBodyToCallMapper);
        } else {
            throw new RuntimeException("Unknown variable expression that is neither an iterator variable "
                    + "nor an iterate result variable nor an operation parameter nor a let variable nor self: "
                    + getExpression().getReferredVariable().getName());
        }
        applyScopesOnNavigationStep(result, operationBodyToCallMapper);
        return result;
    }

    private NavigationStep tracebackOperationParameter(EClass context, PathCache pathCache,
            OperationBodyToCallMapper operationBodyToCallMapper) {
        OCLExpression rootExpression = getRootExpression();
        // all operation bodies must have been reached through at least one call; all calls are
        // recorded in the filter synthesizer's cache. Therefore, we can determine the relationship
        // between body and EOperation.
        EOperation op = operationBodyToCallMapper.getCallsOf(rootExpression).iterator().next().getReferredOperation();
        int pos = getParameterPosition(op);
        List<NavigationStep> stepsPerCall = new ArrayList<NavigationStep>();
        IndirectingStep indirectingStep = pathCache.createIndirectingStepFor(getExpression(), getTupleLiteralPartNamesToLookFor());
        // As new operation calls change the set of OperationCallExp returned here for existing operations,
        // the PathCache cannot trivially be re-used across expression registrations. We would have to
        // invalidate all cache entries that depend on this step. Or we add steps produced for new calls to this
        // step as the calls get added; but that may require a re-assessment of the isAlwaysEmpty() calls.
        // This may not pay off.
        for (OperationCallExp call : operationBodyToCallMapper.getCallsOf(rootExpression)) {
            OCLExpression argumentExpression = (OCLExpression) call.getArgument().get(pos);
            NavigationStep stepForCall = pathCache.getOrCreateNavigationPath(argumentExpression, context, operationBodyToCallMapper,
                    getTupleLiteralPartNamesToLookFor(), oclFactory);
            // leaves all variables currently in scope because it'll jump into a new expression context;
            // the step enters into all scopes in which the argument expression in the operation call is nested,
            // starting from the root expression for the argument expression
            stepForCall.addLeavingScopes(getAllVariablesInScope(getExpression(), operationBodyToCallMapper));
            stepForCall.addEnteringScopes(getAllVariablesInScope(argumentExpression, operationBodyToCallMapper));
            stepsPerCall.add(stepForCall);
        }
        indirectingStep.setActualStep(pathCache.navigationStepForBranch(getInnermostElementType(getExpression().getType()),
                context, getExpression(), getTupleLiteralPartNamesToLookFor(), /* requireExactMatchForSourceType */ false, stepsPerCall.toArray(new NavigationStep[0])));
        return indirectingStep;
    }

    /**
     * Determines the position of the parameter of operation <tt>op</tt> that is named like the variable referred to by this
     * tracer's {@link #getExpression() variable expression).
     */
    private int getParameterPosition(EOperation op) {
        String variableName = getVariableDeclaration().getName();
        // determine position of formal IN_DIR parameter named variableName
        int pos = 0;
        EList<EObject> pList = op.eContents();
        for (EObject p : pList) {
            if (p instanceof EParameter) {
                if (variableName.equals(((EParameter) p).getName())) {
                    break;
                } else {
                    pos++;
                }
            }
        }
        return pos;
    }

    private NavigationStep tracebackLetVariable(EClass context, PathCache pathCache,
            OperationBodyToCallMapper operationBodyToCallMapper) {
        NavigationStep result = pathCache.getOrCreateNavigationPath((OCLExpression) getVariableDeclaration().getInitExpression(),
                context, operationBodyToCallMapper, getTupleLiteralPartNamesToLookFor(), oclFactory);
        return result;
    }

    private NavigationStep tracebackIterateResultVariable(EClass context, PathCache pathCache,
            OperationBodyToCallMapper operationBodyToCallMapper) {
        // the init expression can't reference the result variable, therefore no recursive reference may occur here:
        NavigationStep stepForInitExpression = pathCache.getOrCreateNavigationPath((OCLExpression) getVariableDeclaration()
                .getInitExpression(), context, operationBodyToCallMapper, getTupleLiteralPartNamesToLookFor(), oclFactory);
        // the body expression, however, may reference the result variable; computing the body's navigation step graph
        // may therefore recursively look up the navigation step graph for the result variable. We therefore need to
        // enter a placeholder into the cache before we start computing the navigation step graph for the body expression:
        IndirectingStep indirectingStep = pathCache.createIndirectingStepFor(
                getExpression(), getTupleLiteralPartNamesToLookFor());
        NavigationStep stepForBodyExpression = pathCache.getOrCreateNavigationPath(
                (OCLExpression) ((IterateExp) getVariableDeclaration().eContainer()).getBody(), context, operationBodyToCallMapper,
                getTupleLiteralPartNamesToLookFor(), oclFactory);
        NavigationStep actualStepForIterateResultVariableExp = pathCache.navigationStepForBranch(
                getInnermostElementType(getExpression().getType()), context, getExpression(),
                getTupleLiteralPartNamesToLookFor(), /* requireExactMatchForSourceType */ false, stepForInitExpression, stepForBodyExpression);
        indirectingStep.setActualStep(actualStepForIterateResultVariableExp);
        return indirectingStep;
    }

    private NavigationStep tracebackIteratorVariable(EClass context, PathCache pathCache,
            OperationBodyToCallMapper operationBodyToCallMapper) {
        LoopExp loopExp = (LoopExp) getVariableDeclaration().eContainer();
        // the source expression can't reference the iterator variable, therefore no recursive reference may occur here:
    	NavigationStep stepForSource = pathCache.getOrCreateNavigationPath(
                (OCLExpression) loopExp.getSource(), context, operationBodyToCallMapper,
                getTupleLiteralPartNamesToLookFor(), oclFactory);
        NavigationStep result;
        if (PredefinedType.CLOSURE_NAME.equals(loopExp.getName())) {
            // the body expression, however, may reference the iterator variable; computing the body's navigation step graph
            // may therefore recursively look up the navigation step graph for the iterator variable. We therefore need to
            // enter a placeholder into the cache before we start computing the navigation step graph for the body expression:
            IndirectingStep indirectingStep = pathCache.createIndirectingStepFor(
                    getExpression(), getTupleLiteralPartNamesToLookFor());
            NavigationStep stepForBodyExpression = pathCache.getOrCreateNavigationPath(
                    (OCLExpression) loopExp.getBody(), context, operationBodyToCallMapper,
                    getTupleLiteralPartNamesToLookFor(), oclFactory);
            NavigationStep actualStepForIterateResultVariableExp = pathCache.navigationStepForBranch(
                    getInnermostElementType(getExpression().getType()), context, getExpression(),
                    getTupleLiteralPartNamesToLookFor(), /* requireExactMatchForSourceType */ false, stepForSource, stepForBodyExpression);
            indirectingStep.setActualStep(actualStepForIterateResultVariableExp);
        	result = indirectingStep;
        } else {
			result = stepForSource;
        }
        return result;
    }

    private NavigationStep tracebackSelf(EClass context, PathCache pathCache,
            OperationBodyToCallMapper operationBodyToCallMapper) {
        IndirectingStep result;
        EOperation op = getOperationOfWhichRootExpressionIsTheBody(operationBodyToCallMapper);
        if (op != null) {
            // in an operation, self needs to be traced back to all source expressions of
            // calls to that operation
            Collection<OperationCallExp> calls = operationBodyToCallMapper.getCallsOf(getRootExpression());
            IndirectingStep indirectingStep = pathCache.createIndirectingStepFor(
                    getExpression(), getTupleLiteralPartNamesToLookFor());
            List<NavigationStep> stepsForCalls = new ArrayList<NavigationStep>();
            for (OperationCallExp call : calls) {
                OCLExpression callSource = (OCLExpression) call.getSource();
                NavigationStep stepForCall = pathCache.getOrCreateNavigationPath(callSource, context, operationBodyToCallMapper,
                        getTupleLiteralPartNamesToLookFor(), oclFactory);
                // leaves all variables currently in scope because it'll jump into a new expression context;
                // the step enters into all scopes in which the source expression in the operation call is nested,
                // starting from the root expression for the source expression
                stepForCall.addLeavingScopes(getAllVariablesInScope(getExpression(), operationBodyToCallMapper));
                stepForCall.addEnteringScopes(getAllVariablesInScope(callSource, operationBodyToCallMapper));
                stepsForCalls.add(stepForCall);
            }
            // the branching navigation step must not be cached or looked up in a cache because its
            // associated expression is the same as the one used for the IndirectingStep created and cached
            // above.
            indirectingStep.setActualStep(pathCache.navigationStepForBranch(getInnermostElementType(getExpression().getType()),
                    context, getExpression(), getTupleLiteralPartNamesToLookFor(), /* requireExactMatchForSourceType */ false, stepsForCalls.toArray(new NavigationStep[0])));
            result = indirectingStep;
        } else {
            // self occurred outside of an operation; it evaluates to s for s being the context
            result = pathCache.createIndirectingStepFor(getExpression(),
                    getTupleLiteralPartNamesToLookFor());
            result.setActualStep(new IdentityNavigationStep((EClass) getExpression().getType(), (EClass) getExpression()
                    .getType(), getExpression()));
        }
        return result;
    }

    private EOperation getOperationOfWhichRootExpressionIsTheBody(OperationBodyToCallMapper operationBodyToCallMapper) {
        // all operation bodies must have been reached through at least one call; all calls are
        // recorded in the filter synthesizer's cache. Therefore, we can determine the relationship
        // between body and EOperation.
        Set<OperationCallExp> filterSynthesizerCallCache = operationBodyToCallMapper.getCallsOf(getRootExpression());
        EOperation op = null;
        if (!filterSynthesizerCallCache.isEmpty()) {
            op = filterSynthesizerCallCache.iterator().next().getReferredOperation();
        }
        return op;
    }

    @Override
    protected Set<Variable> calculateLeavingScopes(OperationBodyToCallMapper operationBodyToCallMapper) {
        // when tracing back a VariableExp, a number of scopes may be left when navigating to the variable definition
        // leaving scopes are calculated by finding all scope creating expressions between the traced VariableExp
        // and the common composition parent of the VariableExp and its definition
        Set<Variable> result;
        if (isLetVariable()) {
            result = getVariablesIntroducedBetweenHereAnd((OCLExpression) ((LetExp) getVariableDeclaration().eContainer()).getIn(),
                    operationBodyToCallMapper);
        } else if (isIteratorVariable() || isIterateResultVariable()) {
            result = getVariablesIntroducedBetweenHereAnd((OCLExpression) ((LoopExp) getVariableDeclaration().eContainer()).getBody(),
                    operationBodyToCallMapper);
        } else if (isOperationParameter() || (isSelf() && getOperationOfWhichRootExpressionIsTheBody(operationBodyToCallMapper) != null)) {
            // for operation parameters or self inside an operation body, traceback continues with the call expression,
            // leaving all scopes
            result = getAllVariablesInScope(getExpression(), operationBodyToCallMapper);
        } else {
            result = Collections.emptySet();
        }
        return result;
    }
}