/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

public class UML2_2_JAVA extends AbstractPIMPSM_Factory
{
    private IInjector injector;
    private IExtractor extractor;
    private IReferenceModel sourceMetamodel;
    private IReferenceModel targetMetamodel;
    
    private String transformationFilepath = null;
    private String sourceMetaModelFilepath = null;
    private String targetMetaModelFilepath = null;
    private String sourceDataFilepath = null;
    private String targetDataFilepath = null;
    
    
    private IModel targetModel;
    private IModel sourceModel;
    private ModelFactory factory;
    private ILauncher launcher;
            
    public UML2_2_JAVA()
    {
        super();
    }

    
    public IModel getTargetModel()
    {
        return this.targetModel;
    }
    
           
    /// From now on, there are the functions
    public void doCore() throws ATLCoreException
    {
        CoreService.registerLauncher("EMF-specific VM", EMFVMLauncher.class);
        CoreService.registerFactory("EMF", EMFModelFactory.class); 
        CoreService.registerExtractor("EMF", EMFExtractor.class);
        CoreService.registerInjector("EMF", EMFInjector.class);
        injector = CoreService.getInjector("EMF"); 
        extractor = CoreService.getExtractor("EMF"); 			
            
        // Defaults
        this.factory = CoreService.getModelFactory("EMF");
        
        /*Resource specification*/
        Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put("ecore", new EcoreResourceFactoryImpl());
        Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put("xmi",  UMLResource.Factory.INSTANCE);
        Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put(UMLResource.FILE_EXTENSION, UMLResource.Factory.INSTANCE);
        
             
        /*Type specification*/
        EPackage.Registry.INSTANCE.put(UMLPackage.eNS_URI, UMLPackage.eINSTANCE);
        EPackage.Registry.INSTANCE.put("ecore", EcorePackage.eINSTANCE);
        EPackage.Registry.INSTANCE.put("h**p://www.omg.org/spec/UML/20110701", UMLPackage.eINSTANCE);
        EPackage.Registry.INSTANCE.put("h**p://www.omg.org/spec/XMI/20110701", UMLPackage.eINSTANCE);
        
               
        Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put("j2se5", new EcoreResourceFactoryImpl());
    }
    
    @Override
    public void doMetaModels(String sourceTargetMMPath) throws ATLCoreException
    { this.doMetaModels(sourceTargetMMPath, null); }
    
    
    
    @Override
    public void doMetaModels(String sourceMMPath, String targetMMPath) throws ATLCoreException
    {           
        // Metamodels
        this.sourceMetaModelFilepath = sourceMMPath;
        sourceMetamodel = factory.newReferenceModel();
        injector.inject(sourceMetamodel, UMLPackage.eNS_URI);
        

        if(targetMMPath != null) //This means, the metamodel is the same for both models (InputModel & OutputModel)
        {
            this.targetMetaModelFilepath =  targetMMPath;
            targetMetamodel = factory.newReferenceModel();                                              
            injector.inject(targetMetamodel, URI.createFileURI(targetMetaModelFilepath).toString());
        }
    }
    
     
    @Override
    public void doModels(String sourceDM) throws ATLCoreException
    {
         /// Creating models
        sourceModel = factory.newModel(sourceMetamodel);
       
        if(this.targetMetamodel == null)
        { targetModel = factory.newModel(this.sourceMetamodel);}
        else
        { targetModel = factory.newModel(this.targetMetamodel); }
        
        // Loading existing model
        this.sourceDataFilepath = sourceDM;
        injector.inject(sourceModel, URI.createFileURI(sourceDM).toString());         
    }
    
       
    
    public void doTrans(String transformationPath) throws ATLCoreException, MalformedURLException, IOException
    {
        // Getting launcher
        launcher = (EMFVMLauncher)CoreService.getLauncher("EMF-specific VM"); 
        launcher.initialize(Collections.<String, Object> emptyMap());

        // Launching //TODO: REVER ISTO
        launcher.addInModel(sourceModel,"IN", "UML");
        launcher.addOutModel(targetModel, "OUT", "JAVA");
        
        // the loadModule function requires an absolute path to the ASM file
        this.transformationFilepath = transformationPath;
        URL asmFile = new File(transformationPath).toURI().toURL();
        Object loadedModule = launcher.loadModule(asmFile.openStream());

        //launcher.addLibrary("libName", new File("path").toURI().toURL().openStream());
        
        Map <String, Object> optionsTransf = new  TreeMap <String, Object>();
        optionsTransf.put("showSummary", "true");
        optionsTransf.put("printExecutionTime", "true");
        optionsTransf.put("continueAfterError", "true");
        optionsTransf.put("allowInterModelReferences", "true");
        //optionsTransf.put("step", "true"); 
        launcher.launch(ILauncher.DEBUG_MODE, new NullProgressMonitor(), optionsTransf, loadedModule);           
    }
    
    
    /**
    * Saving model
    */
    public void doSave(String dataTargetfp) throws ATLCoreException
    {
        this.targetMetaModelFilepath = dataTargetfp;
        //extractor.extract(targetModel, System.out, null);
        extractor.extract(targetModel, URI.createFileURI(dataTargetfp).toString());
    }
}