/*******************************************************************************
 * Copyright (c) 2007, 2015 Borland Software Corporation 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:
 *     Borland Software Corporation - initial API and implementation
 *     Alex Paperno - bug 419299
 *******************************************************************************/
package org.eclipse.m2m.internal.qvt.oml.ast.env;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EcoreFactory;
import org.eclipse.emf.ecore.impl.EPackageRegistryImpl;
import org.eclipse.m2m.internal.qvt.oml.evaluator.ModelInstance;
import org.eclipse.m2m.internal.qvt.oml.evaluator.ModuleInstance;
import org.eclipse.m2m.internal.qvt.oml.evaluator.ModuleInstanceFactory;
import org.eclipse.m2m.internal.qvt.oml.evaluator.TransformationInstance;
import org.eclipse.m2m.internal.qvt.oml.expressions.ExpressionsFactory;
import org.eclipse.m2m.internal.qvt.oml.expressions.ExpressionsPackage;
import org.eclipse.m2m.internal.qvt.oml.expressions.ImportKind;
import org.eclipse.m2m.internal.qvt.oml.expressions.Library;
import org.eclipse.m2m.internal.qvt.oml.expressions.ModelType;
import org.eclipse.m2m.internal.qvt.oml.expressions.OperationalTransformation;
import org.eclipse.m2m.internal.qvt.oml.expressions.impl.ModuleImpl;
import org.eclipse.m2m.internal.qvt.oml.stdlib.AbstractContextualOperations;
import org.eclipse.m2m.internal.qvt.oml.stdlib.AbstractQVTStdlib;
import org.eclipse.m2m.internal.qvt.oml.stdlib.CollectionTypeOperations;
import org.eclipse.m2m.internal.qvt.oml.stdlib.DictionaryOperations;
import org.eclipse.m2m.internal.qvt.oml.stdlib.ElementOperations;
import org.eclipse.m2m.internal.qvt.oml.stdlib.ExceptionOperations;
import org.eclipse.m2m.internal.qvt.oml.stdlib.IntegerOperations;
import org.eclipse.m2m.internal.qvt.oml.stdlib.ListOperations;
import org.eclipse.m2m.internal.qvt.oml.stdlib.ModelOperations;
import org.eclipse.m2m.internal.qvt.oml.stdlib.ObjectOperations;
import org.eclipse.m2m.internal.qvt.oml.stdlib.OclAnyOperations;
import org.eclipse.m2m.internal.qvt.oml.stdlib.RealOperations;
import org.eclipse.m2m.internal.qvt.oml.stdlib.StatusOperations;
import org.eclipse.m2m.internal.qvt.oml.stdlib.StdlibModuleOperations;
import org.eclipse.m2m.internal.qvt.oml.stdlib.StringOperations;
import org.eclipse.m2m.internal.qvt.oml.stdlib.TransformationOperations;
import org.eclipse.m2m.internal.qvt.oml.stdlib.model.StdlibFactory;
import org.eclipse.m2m.qvt.oml.ecore.ImperativeOCL.DictionaryType;
import org.eclipse.m2m.qvt.oml.ecore.ImperativeOCL.ImperativeOCLFactory;
import org.eclipse.m2m.qvt.oml.ecore.ImperativeOCL.ListType;
import org.eclipse.m2m.qvt.oml.ecore.ImperativeOCL.OrderedTupleType;
import org.eclipse.ocl.ecore.EcoreOCLStandardLibrary;


public class QvtOperationalStdLibrary extends AbstractQVTStdlib implements QVTOStandardLibrary {
	
	public static final String NS_URI = "http://www.eclipse.org/m2m/qvt/oml/1.0.0/Stdlib"; //$NON-NLS-1$

	private static final String QVT_STDLIB_MODULE_NAME = "Stdlib"; //$NON-NLS-1$
	
	private static final EPackage ECORE_OCL_LIB = new EcoreOCLStandardLibrary().getOCLStdLibPackage();
	private static final String OCL_STDLIB_MODULE_NAME = ECORE_OCL_LIB.getName();

	
	public static final QvtOperationalStdLibrary INSTANCE = createLibrary();	
	static {
		try {
			INSTANCE.defineStandardOperations();
		} catch(Error e) {
			e.printStackTrace();
		}
	}
	
	private final EClassifier OBJECT;
	private final EClassifier ELEMENT;	
	private final EClass MODEL;
	private final EClass TRANSFORMATION;
	private EClass STATUS;
	private EClass EXCEPTION;
	private EClass ASSERTION_FAILED;
	private EClassifier LIST;
	private EClassifier KEY_T;
	private DictionaryType DICTIONARY;
	private OrderedTupleType ORDERED_TUPLE; 	
	
	private final Library fStdlibModule;
	private final StdlibFactory fFactory;
	
	private final QvtOperationalModuleEnv fEnv;
	private final Map<String, EClassifier> fTypeAliasMap;
	

	private QvtOperationalStdLibrary() {
		fStdlibModule = createLibrary(QVT_STDLIB_MODULE_NAME);
		fStdlibModule.setNsURI(NS_URI);
		
		fEnv = new QvtOperationalModuleEnv(new EPackageRegistryImpl(), null);
		fEnv.setContextModule(fStdlibModule);
		fFactory = new StdlibFactory(this);
		
		assert fStdlibModule.eResource() != null;
		fStdlibModule.eResource().setURI(URI.createURI(fStdlibModule.getNsURI()));		

		ELEMENT = createClass("Element", true); //$NON-NLS-1$
		EXCEPTION = createClass("Exception", false); //$NON-NLS-1$
		ASSERTION_FAILED = createClass("AssertionFailed", false); //$NON-NLS-1$
		ASSERTION_FAILED.getESuperTypes().add(EXCEPTION);
		MODEL = createClass("Model", true); //$NON-NLS-1$
		ORDERED_TUPLE = createOrderedTuple();		
		OBJECT = createClass("Object", true); //$NON-NLS-1$		
		STATUS = createClass("Status", false); //$NON-NLS-1$		
		TRANSFORMATION = createClass("Transformation", true); //$NON-NLS-1$ 

		LIST = createListType();
		DICTIONARY = createDictionaryType();

		fTypeAliasMap = createTypeAliasMap(fEnv);		
		
		// register stdlib package  
		EPackage.Registry.INSTANCE.put(fStdlibModule.getNsURI(), fStdlibModule);
	}	
	
	private void defineStandardOperations() {
		define(new StringOperations(this));
		define(new ModelOperations(this));
		define(new OclAnyOperations(this)); // non-standard legacy operations
		define(new ObjectOperations(this));		
		define(new ElementOperations(this));
		define(new StdlibModuleOperations(this));
		define(new IntegerOperations(this));		
		define(new RealOperations(this));
		define(new TransformationOperations(this));				
		define(new StatusOperations(this));
		define(new ListOperations(this));
		define(new DictionaryOperations(this));
		define(new ExceptionOperations(this));		

		define(CollectionTypeOperations.getAllOperations(this));		
		
		((ModuleImpl)fStdlibModule).freeze();		
	}
		
	/* (non-Javadoc)
	 * @see org.eclipse.m2m.internal.qvt.oml.ast.env.QVTOStandardLibrary#getEnvironment()
	 */
	@Override
	public QVTOEnvironment getEnvironment() {
		return fEnv;
	}
	
	@Override
	public StdlibFactory getStdlibFactory() {
		return fFactory;
	}
		
	public void importTo(QvtOperationalEnv env) {
		env.addImport(ImportKind.EXTENSION, fEnv);
	}
	    
	/* (non-Javadoc)
	 * @see org.eclipse.m2m.internal.qvt.oml.ast.env.QVTOStandardLibrary#getStdLibModule()
	 */
	@Override
    public Library getStdLibModule() {
		return fStdlibModule;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.m2m.internal.qvt.oml.ast.env.QVTOStandardLibrary#getList()
	 */
	public EClassifier getList() {
		return LIST;
	}
		
	/* (non-Javadoc)
	 * @see org.eclipse.m2m.internal.qvt.oml.ast.env.QVTOStandardLibrary#getDictionary()
	 */
	public EClassifier getDictionary() {
		return DICTIONARY;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.m2m.internal.qvt.oml.ast.env.QVTOStandardLibrary#getOrderedTupleType()
	 */
	public EClassifier getOrderedTupleType() {	
		return ORDERED_TUPLE;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.m2m.internal.qvt.oml.ast.env.QVTOStandardLibrary#getKeyT()
	 */
	public EClassifier getKeyT() {		
		return KEY_T;
	};
		
	/* (non-Javadoc)
	 * @see org.eclipse.m2m.internal.qvt.oml.ast.env.QVTOStandardLibrary#getModelClass()
	 */
	public EClass getModelClass() {	
		return MODEL;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.m2m.internal.qvt.oml.ast.env.QVTOStandardLibrary#getStatusClass()
	 */
	public EClass getStatusClass() {
		return STATUS;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.m2m.internal.qvt.oml.ast.env.QVTOStandardLibrary#getExceptionClass()
	 */
	public EClass getExceptionClass() {
		return EXCEPTION;
	}
	
	public EClass getAssertionFailedClass() {
		return ASSERTION_FAILED;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.m2m.internal.qvt.oml.ast.env.QVTOStandardLibrary#getTransformationClass()
	 */
	public EClass getTransformationClass() {	
		return TRANSFORMATION;
	}	
		
	/* (non-Javadoc)
	 * @see org.eclipse.m2m.internal.qvt.oml.ast.env.QVTOStandardLibrary#getModuleType()
	 */
	public EClass getModuleType() {
		return ExpressionsPackage.eINSTANCE.getModule();
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.m2m.internal.qvt.oml.ast.env.QVTOStandardLibrary#getElementType()
	 */
	public EClassifier getElementType() {
		return ELEMENT;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.m2m.internal.qvt.oml.ast.env.QVTOStandardLibrary#getObject()
	 */
	public EClassifier getObject() {
		return OBJECT;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.m2m.internal.qvt.oml.ast.env.QVTOStandardLibrary#createModel(java.lang.String)
	 */
	public ModelType createModel(String name) {
		ModelType modelType = ExpressionsFactory.eINSTANCE.createModelType();
		modelType.setName(name);
		modelType.setInstanceClass(ModelInstance.class);		
		modelType.getESuperTypes().add(QvtOperationalStdLibrary.INSTANCE.getModelClass());		
		return modelType;
	}

	public static Library createLibrary(String name) {
		Library lib = ExpressionsFactory.eINSTANCE.createLibrary();
		lib.setInstanceClass(ModuleInstance.class);
		lib.setEFactoryInstance(new ModuleInstanceFactory());
		lib.setName(name);
		return lib;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.m2m.internal.qvt.oml.ast.env.QVTOStandardLibrary#createTransformation(java.lang.String)
	 */
	public OperationalTransformation createTransformation(String name) {	
		OperationalTransformation transf = ExpressionsFactory.eINSTANCE.createOperationalTransformation();
		transf.setInstanceClass(TransformationInstance.class);
		transf.setEFactoryInstance(new ModuleInstanceFactory());
		transf.setName(name);
		
		EClass transformationBase = getTransformationClass();		
		transf.getESuperTypes().add(transformationBase);
		
		return transf;
	}
		
	public EClassifier lookupClassifier(List<String> nameElements) {	
		int size = nameElements.size();
		if(size == 0 || size > 2) {
			return null;
		}
		
		if(size == 1 || QVT_STDLIB_MODULE_NAME.equals(nameElements.get(0))) {
			String typeName = nameElements.get(size - 1);
			EClassifier aliasedType = getTypeAlias(typeName);
			return (aliasedType != null) ? aliasedType : fStdlibModule.getEClassifier(typeName);
		}
		
		if(size == 2 && OCL_STDLIB_MODULE_NAME.equals(nameElements.get(0))) {
			String typeName = nameElements.get(size - 1);
			return ECORE_OCL_LIB.getEClassifier(typeName);
		}
		
		return null;
	}
	
		 
	private void define(AbstractContextualOperations... typeOperations) {
		for (AbstractContextualOperations nextOperations : typeOperations) {
			nextOperations.define(fEnv);	
		}		
	}
		
	private EClass createClass(String name, boolean isAbstract) {
		assert fStdlibModule != null;
		assert name != null;
		
		EClass result = EcoreFactory.eINSTANCE.createEClass();
		result.setName(name);
		result.setAbstract(isAbstract);
		fStdlibModule.getEClassifiers().add(result);

		return result;
	}
	
	private OrderedTupleType createOrderedTuple() {
		OrderedTupleType result = ImperativeOCLFactory.eINSTANCE.createOrderedTupleType();
		result.setName("OrderedTupleType(T)"); //$NON-NLS-1$
		result.getElementType().add(getOCLStdLib().getT());
		
		fStdlibModule.getEClassifiers().add(result);
		return result;
	}
	
	private ListType createListType() {
		ListType result = getStdlibFactory().createList(getOCLStdLib().getT());
		fStdlibModule.getEClassifiers().add(result);
		return result;
	}
	
	private DictionaryType createDictionaryType() {
		KEY_T = org.eclipse.ocl.ecore.EcoreFactory.eINSTANCE.createTemplateParameterType();
		KEY_T.setName("KeyT"); //$NON-NLS-1$
		fStdlibModule.getEClassifiers().add(KEY_T);
		
		DictionaryType result = fFactory.createDictionary(KEY_T, getOCLStdLib().getT());
		fStdlibModule.getEClassifiers().add(result);

		return result;
	}	
		
	private static QvtOperationalStdLibrary createLibrary() {
		try {
			QvtOperationalStdLibrary lib = new QvtOperationalStdLibrary();
			return lib;
		} catch(Error e) {
			e.printStackTrace();
			return null;
		}
	}
	
	private EClassifier getTypeAlias(String typeName) {
		return fTypeAliasMap.get(typeName);
	}

	private static Map<String, EClassifier> createTypeAliasMap(QvtOperationalEnv env) {
		Map<String, EClassifier> result = new HashMap<String, EClassifier>();
		result.put("Any", env.getOCLStandardLibrary().getOclAny()); //$NON-NLS-1$
		result.put("Void", env.getOCLStandardLibrary().getOclVoid()); //$NON-NLS-1$
		return result;
	}
}