/*
 * <copyright>
 *
 * Copyright (c) 2005-2008 Sven Efftinge 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:
 *     Sven Efftinge - Initial API and implementation
 *     Alexander Shatalin (Borland)
 *
 * </copyright>
 */
package org.eclipse.gmf.internal.xpand.model;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;

import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.gmf.internal.xpand.BufferOutput;
import org.eclipse.gmf.internal.xpand.ResourceManager;
import org.eclipse.gmf.internal.xpand.ResourceMarker;
import org.eclipse.gmf.internal.xpand.expression.ExecutionContextImpl;
import org.eclipse.gmf.internal.xpand.expression.PolymorphicResolver;
import org.eclipse.gmf.internal.xpand.expression.SyntaxConstants;
import org.eclipse.gmf.internal.xpand.expression.TypeNameUtil;
import org.eclipse.gmf.internal.xpand.expression.Variable;
import org.eclipse.gmf.internal.xpand.migration.Activator;

/**
 * *
 * 
 * @author Sven Efftinge *
 */
public class XpandExecutionContextImpl extends ExecutionContextImpl implements XpandExecutionContext {

    protected final Output output;
    
    protected final ProtectedRegionResolver protectedRegionResolver;
    
    private final List<XpandAdvice> registeredAdvices = new ArrayList<XpandAdvice>();

    public XpandExecutionContextImpl(ResourceManager resourceManager, Output output, ProtectedRegionResolver prs) {
        this (resourceManager, output, prs, null);
    }
    
    public XpandExecutionContextImpl(ResourceManager resourceManager, EPackage... fallbackVisibleModels) {
    	super(resourceManager, fallbackVisibleModels);
    	this.output = new BufferOutput(new StringBuilder());
    	this.protectedRegionResolver = null;
    }
    
    public XpandExecutionContextImpl(ResourceManager resourceManager, Output output, ProtectedRegionResolver prs, Collection<Variable> globalVars) {
        super(resourceManager, globalVars);
        this.output = output;
        this.protectedRegionResolver = prs;
    }

    protected XpandExecutionContextImpl (ResourceManager resourceManager, ResourceMarker currentResource, Collection<Variable> vars, 
            Collection<Variable> globalVars, Output output, ProtectedRegionResolver protectedRegionResolver) {
        super(resourceManager, currentResource, vars, globalVars);
        this.output = output;
        this.protectedRegionResolver = protectedRegionResolver;
    }

    /*copy constructor*/
    protected XpandExecutionContextImpl(XpandExecutionContextImpl original) {
    	super(original);
    	this.output = original.output;
    	this.protectedRegionResolver = original.protectedRegionResolver;
    }
    

    @Override
    public XpandExecutionContextImpl cloneContext() {
        final XpandExecutionContextImpl result = new XpandExecutionContextImpl(this);
        result.registeredAdvices.addAll(registeredAdvices); //todo: [aha] before I refactored, there was an assignment in this place. Is this modification correct?
        return result;
    }

    public XpandDefinition findDefinition(final String name, final EClassifier target, final EClassifier[] paramTypes) {
        String templateName;
        boolean localCall = name.indexOf(SyntaxConstants.NS_DELIM) < 0;
        if (localCall) {
        	templateName = ((XpandResource) currentResource()).getFullyQualifiedName();	//need an enclosing resource in case of composite
        } else {
        	templateName = TypeNameUtil.withoutLastSegment(name);
        }
        XpandResource tpl = findTemplate(templateName);
        if (tpl == null) {
        	if (localCall) {
        		tpl = (XpandResource) currentResource();
        	} else {
        		return null;
        	}
		}
        final XpandExecutionContext ctx = (XpandExecutionContext) cloneWithResource(tpl);
        XpandDefinition def = findDefinition(tpl.getDefinitions(), name, target, paramTypes, ctx);
        if (def == null) {
        	return null;
        }
        XpandAdvice[] advicesInResource = tpl.getAdvices();
        for (int x = advicesInResource.length - 1; x >= 0; x--) {
            final XpandAdvice adv = advicesInResource[x];
            if (adv.matches(def, this)) {
                def = new AdvicedDefinition(adv, def);
            }
        }
        for (int x = registeredAdvices.size() - 1; x >= 0; x--) {
            final XpandAdvice adv = registeredAdvices.get(x);
            if (adv.matches(def, this)) {
                def = new AdvicedDefinition(adv, def);
            }
        }
        return def;
    }

	public void registerAdvices(final String fullyQualifiedName) {
        final XpandResource tpl = findTemplate(fullyQualifiedName);
        if (tpl == null) {
			throw new RuntimeException("Couldn't find template : " + fullyQualifiedName);
		}
        final XpandAdvice[] as = tpl.getAdvices();
        for (final XpandAdvice advice : as) {
            if (registeredAdvices.contains(advice)) {
                Activator.logWarn("advice " + advice.toString() + " allready registered!");
            } else {
                registeredAdvices.add(advice);
            }
        }
    }

    public ProtectedRegionResolver getProtectedRegionResolver() {
        return protectedRegionResolver;
    }

    public Output getOutput() {
        return output;
    }

    @Override
    protected String[] getImportedNamespaces() {
    	if (currentResource() instanceof XpandResource) {
    		return ((XpandResource) currentResource()).getImportedNamespaces();
    	}
    	return super.getImportedNamespaces();
    }

    @Override
    protected String[] getImportedExtensions() {
    	if (currentResource() instanceof XpandResource) {
    		return ((XpandResource) currentResource()).getImportedExtensions();
    	}
    	return super.getImportedExtensions();
    }

    public XpandResource findTemplate(final String templateName) {
    	if (getResourceManager() == null) {
    		return null;
    	}
    	// XXX findTemplate needs kinda file uri, while metamodel import needs nsURI
    	final List<String> possibleNames = getPossibleNames(templateName, getImportedNamespaces());
        for (String name : possibleNames) {
            final XpandResource tpl = getResourceManager().loadXpandResource(name);
            if (tpl != null) {
//            	installAspectsFor(templateName);
				return tpl;
			}
        }
        return null;
    }

//    private void installAspectsFor(String templateName) {
//    	String aspectsTemplateName = "aspects" + SyntaxConstants.NS_DELIM + templateName;
//    	XpandResource aspects = getResourceManager().loadXpandResource(aspectsTemplateName);
//    	if (aspects != null) {
//    		registeredAdvices.addAll(Arrays.asList(aspects.getAdvices()));
//    	}
//	}

	private List<String> getPossibleNames(final String name, final String[] importedNs) {
        final String typeName = TypeNameUtil.getTypeName(name);
        final String typesMetamodelName = TypeNameUtil.getMetaModelName(name);
        final String collectionTypeName = TypeNameUtil.getCollectionTypeName(name);

        final List<String> result = new ArrayList<String>();
        result.add(name);
        
        for (final String string : importedNs) {
            final StringBuffer s = new StringBuffer();
            if (collectionTypeName != null) {
                s.append(collectionTypeName).append("[");
            }
            if (typesMetamodelName != null) {
                s.append(typesMetamodelName).append("!");
            }
            s.append(string).append(SyntaxConstants.NS_DELIM).append(typeName);
            if (collectionTypeName != null) {
                s.append("]");
            }
            result.add(s.toString());
        }
        return result;
    }

    /**
     * resolves the correct definition (using parametric polymorphism)
	 * XXX: get rid of the ctx argument and redeclare as non-static?
     * @param definitions
     * @param target
     * @param paramTypes
     * @return
     */
    private static XpandDefinition findDefinition(final XpandDefinition[] definitions, final String name, final EClassifier target,
            EClassifier[] paramTypes, final XpandExecutionContext ctx) {
        if (paramTypes == null) {
            paramTypes = new EClassifier[0];
        }
        final String unqualifiedName = TypeNameUtil.getLastSegment(name);
        // XXX Instead of using map as a mere pair storage, do it like Extension does with init(ctx)
        // to resolve and keep typed arguments
        HashMap<XpandDefinition, List<EClassifier>> resolvedDefs = new HashMap<XpandDefinition, List<EClassifier>>();
        for (final XpandDefinition def : definitions) {
        	if (!def.getName().equals(unqualifiedName)) {
        		continue;
        	}
            if (def.getParams().length == paramTypes.length) {
                final LinkedList<EClassifier> defsParamTypes = new LinkedList<EClassifier>();
                EClassifier t = null;
                boolean complete = true;
                for (int j = 0; (j < paramTypes.length) && complete; j++) {
                    t = ctx.getTypeForName(def.getParams()[j].getType().getValue());
                    if (t == null) {
                        complete = false;
                    }
                    defsParamTypes.add(t);
                }
                t = ctx.getTypeForName(def.getTargetType());
                if (t == null) {
                    complete = false;
                } else {
                	defsParamTypes.addFirst(t);
                }
                if (complete) {
                	resolvedDefs.put(def, defsParamTypes);
                }
            }
        }
		return PolymorphicResolver.filterDefinition(resolvedDefs, target, Arrays.asList(paramTypes));
    }
}