package trasform2singleton.actions;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.m2m.atl.core.ATLCoreException;
import org.eclipse.m2m.atl.core.IExtractor;
import org.eclipse.m2m.atl.core.IInjector;
import org.eclipse.m2m.atl.core.IModel;
import org.eclipse.m2m.atl.core.IReferenceModel;
import org.eclipse.m2m.atl.core.ModelFactory;
import org.eclipse.m2m.atl.core.launch.ILauncher;
import org.eclipse.m2m.atl.core.service.CoreService;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkbenchWindowActionDelegate;




/**
 * Our sample action implements workbench action delegate.
 * The action proxy will be created by the workbench and
 * shown in the UI. When the user tries to use the action,
 * this delegate will be created and execution will be 
 * delegated to it.
 * @see IWorkbenchWindowActionDelegate
 */
public class SingletonTransformation implements IWorkbenchWindowActionDelegate {
	private static IInjector injector;

	private static IExtractor extractor;

	private static IReferenceModel sourceTargetMetamodel;
	
	private static IReferenceModel XMLMetamodel;

	
	private static String transformationFilepath = "/home/thanasis/Desktop/data/transformation/modiscoJavaModelSingleton.asm";
	private static String libraryFilepath = "/home/thanasis/Desktop/data/transformation/XMLHelpers.asm";
	private static String dataSourceFilepath = "file:///home/thanasis/Desktop/data/toSingleton.javaxmi";
	private static String dataSourceXMLFilepath = "file:///home/thanasis/Desktop/data/parameters.xml";
	private static String dataTargetfilepath = "file:///home/thanasis/Desktop/data/newModel.javaxmi";

	static {
		// ATL public2private transformation
		try {
			injector = CoreService.getInjector("EMF"); //$NON-NLS-1$
			extractor = CoreService.getExtractor("EMF"); //$NON-NLS-1$			
		} catch (ATLCoreException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * The constructor.
	 */
	public SingletonTransformation() {
	}

	/**
	 * The action has been activated. The argument of the
	 * method represents the 'real' action sitting
	 * in the workbench UI.
	 * @see IWorkbenchWindowActionDelegate#run
	 */
	public void run(IAction action) {
		// parameters.xml creation
		try{
		    // Create file 
		    FileWriter fstream = new FileWriter("/home/thanasis/Desktop/data/parameters.xml");
		        BufferedWriter out = new BufferedWriter(fstream);
		    out.write("<parameters>\n	<param name=\"singletonClass\" value=\"Singleton\"/>\n</parameters>");
		    //Close the output stream
		    out.close();
		 }catch (Exception e){//Catch exception if any
		      System.err.println("Error: " + e.getMessage());
		 }
		 
		ModelFactory factory = null;
		try {
			factory = CoreService.getModelFactory("EMF");
			//launch options
			Map<String, Object> options = new HashMap<String, Object>();
			options.put("allowInterModelReferences", Boolean.TRUE);
			
			// Metamodels
			sourceTargetMetamodel = factory.newReferenceModel();
			XMLMetamodel = factory.newReferenceModel();
			injector.inject(XMLMetamodel, "http://www.eclipse.org/MoDisco/Xml/0.1.incubation/XML");
			injector.inject(sourceTargetMetamodel, "http://www.eclipse.org/MoDisco/Java/0.2.incubation/java");
	
			// Getting launcher
			ILauncher launcher = null;
			launcher = CoreService.getLauncher("EMF-specific VM"); //$NON-NLS-1$
			
			launcher.initialize(Collections.<String, Object> emptyMap());
	
			// Creating models
			IModel sourceModel = factory.newModel(sourceTargetMetamodel);
			IModel XMLModel = factory.newModel(XMLMetamodel);
			IModel targetModel = factory.newModel(sourceTargetMetamodel);
	
			// Loading existing model
			injector.inject(sourceModel, dataSourceFilepath);
			injector.inject(XMLModel, dataSourceXMLFilepath);
			
		
			// Launching
			launcher.addInModel(sourceModel, "IN", "MODISCOJAVA");
			launcher.addOutModel(targetModel, "OUT", "MODISCOJAVA");
			launcher.addInModel(XMLModel, "parameters", "XML");
			
			
			URL asmFile1 = new File(transformationFilepath).toURI().toURL();
			URL asmFile2 = new File(libraryFilepath).toURI().toURL();
			InputStream asmInputStream1 = (InputStream) asmFile1.openStream();
			InputStream asmInputStream2 = (InputStream) asmFile2.openStream();
			InputStream[] modules = new InputStream[2];
			modules[0] = asmInputStream1;
			modules[1] = asmInputStream2;
			
			//Object loadedModule = launcher.loadModule(asmFile.openStream());
	
			launcher.launch(ILauncher.RUN_MODE, new NullProgressMonitor(), options, (Object[])modules);
	
			// Saving model
			extractor.extract(targetModel, dataTargetfilepath); //the name of the generated model
			
		} catch (ATLCoreException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} //$NON-NLS-1$
		catch (MalformedURLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		System.out.println("Transformation Complete");
	}

	/**
	 * Selection in the workbench has been changed. We 
	 * can change the state of the 'real' action here
	 * if we want, but this can only happen after 
	 * the delegate has been created.
	 * @see IWorkbenchWindowActionDelegate#selectionChanged
	 */
	public void selectionChanged(IAction action, ISelection selection) {
	}

	/**
	 * We can use this method to dispose of any system
	 * resources we previously allocated.
	 * @see IWorkbenchWindowActionDelegate#dispose
	 */
	public void dispose() {
	}

	/**
	 * We will cache window object in order to
	 * be able to provide parent shell for the message dialog.
	 * @see IWorkbenchWindowActionDelegate#init
	 */
	public void init(IWorkbenchWindow window) {
	}
}

injector.inject(XMLMetamodel, "http://www.eclipse.org/MoDisco/Xml/0.1.incubation/XML");
injector.inject(sourceTargetMetamodel, "http://www.eclipse.org/MoDisco/Java/0.2.incubation/java");

module something;
create OUT : XML from IN : MyMetamodel