package br.edu.ufcg.mdaveritas.mofscriptExecutor;

import java.io.File;
import java.io.IOException;
import java.util.Iterator;

import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.emf.ecore.xmi.XMIResource;
import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl;
import org.eclipse.emf.ecore.xmi.impl.XMIResourceImpl;
import org.eclipse.mofscript.parser.MofScriptParseError;
import org.eclipse.mofscript.parser.ParserUtil;
import org.eclipse.mofscript.runtime.ExecutionManager;
import org.eclipse.mofscript.runtime.ExecutionMessageListener;
import org.eclipse.mofscript.runtime.MofScriptExecutionException;

/**
 * @author Antonio Dias dos Santos Junior
 * 
 */
public class MOFScriptExecutor implements ExecutionMessageListener {

	private String compilepath;
	private String metamodel;
	private String metamodelname;
	private String model;
	private String transformation;
	private String outputdir;

	private String getMetamodelname() {
		return metamodelname;
	}

	private void setMetamodelname(String metamodelname) {
		this.metamodelname = metamodelname;
	}

	private String getCompilepath() {
		return compilepath;
	}

	private void setCompilepath(String compilepath) {
		this.compilepath = compilepath;
	}

	private String getMetamodel() {
		return metamodel;
	}

	private void setMetamodel(String metamodel) {
		this.metamodel = metamodel;
	}

	private String getModel() {
		return model;
	}

	private void setModel(String model) {
		this.model = model;
	}

	private String getTransformation() {
		return transformation;
	}

	private void setTransformation(String transformation) {
		this.transformation = transformation;
	}

	private String getOutputdir() {
		return outputdir;
	}

	private void setOutputdir(String outputdir) {
		this.outputdir = outputdir;
	}

	/**
	 * Sets the parameters necessary to the transformation.
	 * 
	 * @param compilepath
	 *            the compile path
	 * @param metamodel
	 *            the path to the metamodel file
	 * @param metamodelname
	 *            the name used to identify the metamodel in the MOFScript
	 *            transformation
	 * @param model
	 *            the path to the model file
	 * @param transformation
	 *            the path to the transformation file
	 * @param outputdir
	 *            the output directory, where the code will be generated
	 */
	public void setParameters(String compilepath, String metamodel,
			String metamodelname, String model, String transformation,
			String outputdir) {
		setCompilepath(compilepath);
		setMetamodel(metamodel);
		setMetamodelname(metamodelname);
		setModel(model);
		setTransformation(transformation);
		setOutputdir(outputdir);
	}

	private void makeTransformation() throws MofScriptExecutionException,
			IOException {
		ParserUtil parserUtil = new ParserUtil();
		ExecutionManager execMgr = ExecutionManager.getExecutionManager();

		execMgr.lookupAndAddSourceMetaModel("uml","http://www.eclipse.org/uml2/2.1.0/UML");

		parserUtil.setCompilePath(getCompilepath());

		parserUtil.parse(new File(getTransformation()), true);

		// check for errors:
		int errorCount = ParserUtil.getModelChecker().getErrorCount();
		Iterator<?> errorIt = ParserUtil.getModelChecker().getErrors();
		writeErroLog(errorCount, errorIt);

		execMgr.setRootDirectory(getOutputdir());

		registryFactoryToJAS();

		executeTransformation(execMgr, getModel());
	}

	private EObject loadSourceModel(String path) {
		XMIResourceFactoryImpl _xmiFac = new XMIResourceFactoryImpl();
		EObject sourceModel = null;
		File sourceModelFile = new File(path);
		ResourceSet rSet = new ResourceSetImpl();
		rSet.getResourceFactoryRegistry().getExtensionToFactoryMap().put("*",
				_xmiFac);
		URI uri = URI.createFileURI(sourceModelFile.getAbsolutePath());
		Resource resource = rSet.getResource(uri, true);

		if (resource != null) {
			if (resource.getContents().size() > 0) {
				sourceModel = (EObject) resource.getContents().get(0);
			}
		}
		return sourceModel;
	}

	private void executeTransformation(ExecutionManager execMgr, String fileLoad)
			throws MofScriptExecutionException {
		// load source model
		EObject sourceModel = loadSourceModel(fileLoad);

		// set the source model for the execution manager
		execMgr.addSourceModel(sourceModel);

		// if true, files are not generated to the file system, but populated
		// into a filemodel which can be fetched afterwards.
		// Value false will result in standard file generation
		execMgr.setUseFileModel(false);
		// Turns on/off system logging
		execMgr.setUseLog(false);
		// Adds an output listener for the transformation execution.
		execMgr.getExecutionStack().addOutputMessageListener(this);
		execMgr.executeTransformation();
		execMgr.clearModelTypeMap();
	}

	private void registryFactoryToJAS() {
		Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put(
				"txt", new XMIResourceFactoryImpl() {
					public Resource createResource(URI uri) {
						XMIResource xmiResource = new XMIResourceImpl(uri);
						return xmiResource;
					}
				});
	}

	private void writeErroLog(int errorCount, Iterator<?> errorIt) {
		System.out.println("Parsing result: " + errorCount + " errors");
		if (errorCount > 0) {
			for (; errorIt.hasNext();) {
				MofScriptParseError parseError = (MofScriptParseError) errorIt
						.next();
				System.out.println("\t \t: Error: " + parseError.toString());
			}
			return;
		}
	}

	public void executionMessage(String type, String description) {
		System.out.println(type + " - " + description);
	}

	/**
	 * Executes the transformation.
	 */
	public void executeTransformations() {
		try {
			makeTransformation();
		} catch (MofScriptExecutionException e) {
			new RuntimeException(e);
		} catch (IOException e) {
			new RuntimeException(e);
		}
	}

	public static void main(String[] args) {
		MOFScriptExecutor mof = new MOFScriptExecutor();
		mof
				.setParameters(
						"D:\\workspace\\MOFScriptExec",
						"",
						"uml", "D:\\workspace\\UML2Alloy\\My.uml",
						"D:\\workspace\\UML2Alloy\\UML2Alloy.m2t",
						"D:\\workspace\\MOFScriptExec");
		mof.executeTransformations();
	}
}