/*******************************************************************************
 * Copyright (c) 2004-2008 Peter Pasztor, Akos Horvath, Gergely Varro, Istvan Rath and Daniel Varro
 * 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:
 *    Peter Pasztor, Akos Horvath, Gergely Varro, Istvan Rath - initial API and implementation
 *******************************************************************************/

package org.eclipse.viatra2.gtasm.interpreter.term.rules;


import org.eclipse.viatra2.core.IEntity;
import org.eclipse.viatra2.core.IModelElement;
import org.eclipse.viatra2.core.IRelation;
import org.eclipse.viatra2.gtasm.interpreter.exception.ViatraTransformationException;
import org.eclipse.viatra2.gtasm.interpreter.executionEnvironment.IExecutionEnvironment;
import org.eclipse.viatra2.gtasm.interpreter.term.internal.TermInterpreterErrorString;
import org.eclipse.viatra2.gtasm.interpreter.term.internal.TermInterpreterException;
import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.asm.enums.ValueKind;
import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.asm.terms.ModelElementQuery;
import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.asm.terms.Term;
import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.modelmanagement.queryFunctions.Aggregate;
import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.modelmanagement.queryFunctions.ElementReference;
import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.modelmanagement.queryFunctions.FullyQualifiedName;
import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.modelmanagement.queryFunctions.Inverse;
import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.modelmanagement.queryFunctions.Multiplicity;
import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.modelmanagement.queryFunctions.Name;
import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.modelmanagement.queryFunctions.Source;
import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.modelmanagement.queryFunctions.Target;
import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.modelmanagement.queryFunctions.Value;

/**All model query operations evaluation are handled by the class
 * @author Peter Pasztor, Akos Horvath
 *
 */
public class ModelElementQueryEvaluator extends TermEvaluator {
	private static ModelElementQueryEvaluator _instance = new ModelElementQueryEvaluator();

	private ModelElementQueryEvaluator() {
		;
	}

	public static ModelElementQueryEvaluator getInstance() {
		return _instance;
	}

	@Override
	public Object evaluate(IExecutionEnvironment executionEnvironment,
			Term termToBeEvaluated) throws ViatraTransformationException {
		ModelElementQuery modelElementQuery = (ModelElementQuery) termToBeEvaluated;
		//evaluate the argument of the operation
		Object result = TermEvaluator.getInstance().evaluate(
				executionEnvironment, (modelElementQuery).getArgument());
	
		if (modelElementQuery instanceof Aggregate) {
			
			if (!(result instanceof IRelation)) {
				if (ValueKind.UNDEF_LITERAL.equals(result))
					{
					String[] context = {modelElementQuery.getName()};
					throw new TermInterpreterException(
							TermInterpreterErrorString.REF_NOT_EXIST_MODELELEMENTQUERY
							,context
							,termToBeEvaluated);
					}
				else
					{
					String[] context = {modelElementQuery.getName(), convertToJavaType(result)};
					throw new TermInterpreterException(
							TermInterpreterErrorString.REF_NOT_RELATION_MODELELEMENTQUERY
							,context
							,termToBeEvaluated);
					}
			}
			return ((IRelation) result).getIsAggregation();
		} else if (modelElementQuery instanceof FullyQualifiedName) {
			// result is a model element right now - if it's correct...
			if (!(result instanceof IModelElement)) {
				if (ValueKind.UNDEF_LITERAL.equals(result))
					{
					String[] context = {modelElementQuery.getName()};
					throw new TermInterpreterException(
							TermInterpreterErrorString.REF_NOT_EXIST_MODELELEMENTQUERY
							,context
							,termToBeEvaluated);
					}
				else
					{
					String[] context = {modelElementQuery.getName(), convertToJavaType(result)};
					throw new TermInterpreterException(
							TermInterpreterErrorString.REF_NOT_MODELELEMENT_MODELELEMENTQUERY
							,context
							,termToBeEvaluated);
					}
			}
			return ((IModelElement) result).getFullyQualifiedName();
		} else if (modelElementQuery instanceof Name) {
			if (!(result instanceof IModelElement)) {
				if (ValueKind.UNDEF_LITERAL.equals(result))
					{
					String[] context = {modelElementQuery.getName()};
					throw new TermInterpreterException(
							TermInterpreterErrorString.REF_NOT_EXIST_MODELELEMENTQUERY
							,context
							,termToBeEvaluated);
					}
				else
					{
					String[] context = {modelElementQuery.getName(), convertToJavaType(result)};
					throw new TermInterpreterException(
							TermInterpreterErrorString.REF_NOT_MODELELEMENT_MODELELEMENTQUERY
							,context
							,termToBeEvaluated);
					}
			}
			return ((IModelElement) result).getName();
		}
		else if (modelElementQuery instanceof ElementReference) {
			// result is definitely not null
			if (!(result instanceof String)) {
				if (ValueKind.UNDEF_LITERAL.equals(result))
					{
					String[] context = {modelElementQuery.getName()};
					throw new TermInterpreterException(
							TermInterpreterErrorString.REF_NOT_EXIST_MODELELEMENTQUERY
							,context
							,termToBeEvaluated);
					}
				else
					{
					String[] context = {modelElementQuery.getName(), convertToJavaType(result)};
					throw new TermInterpreterException(
							TermInterpreterErrorString.REF_NOT_STRING_MODELELEMENTQUERY
							,context
							,termToBeEvaluated);
					}
			}
			result = executionEnvironment.getFramework().getTopmodel()
					.getModelManager().getElementByName((String) result);

			return result != null ? result : ValueKind.UNDEF_LITERAL;
		} else if (modelElementQuery instanceof Value) {
			if (!(result instanceof IEntity)) {
				if (ValueKind.UNDEF_LITERAL.equals(result))
					{
					String[] context = {modelElementQuery.getName()};
					throw new TermInterpreterException(
							TermInterpreterErrorString.REF_NOT_EXIST_MODELELEMENTQUERY
							,context
							,termToBeEvaluated);
					}
				else
					{
					String[] context = {modelElementQuery.getName(), convertToJavaType(result)};
					throw new TermInterpreterException(
							TermInterpreterErrorString.REF_NOT_ENTITY_MODELELEMENTQUERY
							,context
							,termToBeEvaluated);
					}
			}

			return ((IEntity) result).getValue();

		} else if (modelElementQuery instanceof Multiplicity) {
			if (!(result instanceof IRelation)) {
				if (ValueKind.UNDEF_LITERAL.equals(result))
					{
					String[] context = {modelElementQuery.getName()};
					throw new TermInterpreterException(
							TermInterpreterErrorString.REF_NOT_EXIST_MODELELEMENTQUERY
							,context
							,termToBeEvaluated);
					}
				else
					{
					String[] context = {modelElementQuery.getName(), convertToJavaType(result)};
					throw new TermInterpreterException(
							TermInterpreterErrorString.REF_NOT_RELATION_MODELELEMENTQUERY
							,context
							,termToBeEvaluated);
					}
			}
			return ((IRelation) result).getMultiplicity();
		} else if (modelElementQuery instanceof Inverse) {
			if (!(result instanceof IRelation)) {
				if (ValueKind.UNDEF_LITERAL.equals(result))
					{
					String[] context = {modelElementQuery.getName()};
					throw new TermInterpreterException(
							TermInterpreterErrorString.REF_NOT_EXIST_MODELELEMENTQUERY
							,context
							,termToBeEvaluated);
					}
				else
					{
					String[] context = {modelElementQuery.getName(), convertToJavaType(result)};
					throw new TermInterpreterException(
							TermInterpreterErrorString.REF_NOT_RELATION_MODELELEMENTQUERY
							,context
							,termToBeEvaluated);
					}
			}

			return ((IRelation) result).getInverse();

		} else if (modelElementQuery instanceof Target) {
			if (!(result instanceof IRelation)) {
				if (ValueKind.UNDEF_LITERAL.equals(result))
					{
					String[] context = {modelElementQuery.getName()};
					throw new TermInterpreterException(
							TermInterpreterErrorString.REF_NOT_EXIST_MODELELEMENTQUERY
							,context
							,termToBeEvaluated);
					}
				else
					{
					String[] context = {modelElementQuery.getName(), convertToJavaType(result)};
					throw new TermInterpreterException(
							TermInterpreterErrorString.REF_NOT_RELATION_MODELELEMENTQUERY
							,context
							,termToBeEvaluated);
					}
			}

			result = ((IRelation) result).getTo();
			return result != null ? result : ValueKind.UNDEF_LITERAL;

		} else if (modelElementQuery instanceof Source) {
			if (!(result instanceof IRelation)) {
				if (ValueKind.UNDEF_LITERAL.equals(result))
					{
					String[] context = {modelElementQuery.getName()};
					throw new TermInterpreterException(
							TermInterpreterErrorString.REF_NOT_EXIST_MODELELEMENTQUERY
							,context
							,termToBeEvaluated);
					}
				else
					{
					String[] context = {modelElementQuery.getName(), convertToJavaType(result)};
					throw new TermInterpreterException(
							TermInterpreterErrorString.REF_NOT_RELATION_MODELELEMENTQUERY
							,context
							,termToBeEvaluated);
					}
			}

			result = ((IRelation) result).getFrom();
			return result != null ? result : ValueKind.UNDEF_LITERAL;
		}
		else
			{
			String[] context = {modelElementQuery.getName()};
			throw new TermInterpreterException(
					TermInterpreterErrorString.UNIMP_MODELQUERY
					,context
					,termToBeEvaluated);
			}
	}

}