/*
-----------------------------------------------------------------------
--          			CHESS M2M plugin							 --
--                                                                   --
--                    Copyright (C) 2011-2012                        --
--                 University of Padova, ITALY                       --
--                                                                   --
-- Authors: -Alessandro Zovi         azovi@math.unipd.it 
--          -Intecs
--                                                                   --
-- 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-v20.html                         --
-----------------------------------------------------------------------
*/

package org.polarsys.chess.m2m.handlers;

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

import org.polarsys.chess.chessmlprofile.Predictability.DeploymentConfiguration.HardwareBaseline.CH_HwProcessor;
import org.polarsys.chess.chessmlprofile.Predictability.RTComponentModel.CHRtPortSlot;
import org.polarsys.chess.core.util.CHESSProjectSupport;
import org.polarsys.chess.core.util.uml.ResourceUtils;
import org.polarsys.chess.core.util.uml.UMLUtils;
import org.polarsys.chess.core.views.ViewUtils;
import org.polarsys.chess.m2m.Activator;
import org.polarsys.chess.m2m.transformations.PIMPSMTransformationEnd2End;
import org.polarsys.chess.m2m.transformations.TransUtil;
import org.polarsys.chess.m2m.transformations.TransformationResultsData;
import org.polarsys.chess.m2m.ui.AnalysisContextSelectionDialog;
import org.polarsys.chess.m2m.ui.End2EndResultDialog;
import org.polarsys.chess.service.gui.utils.CHESSEditorUtils;
import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.IJobChangeEvent;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.core.runtime.jobs.JobChangeAdapter;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.window.Window;
import org.eclipse.m2m.internal.qvt.oml.emf.util.ModelContent;
import org.eclipse.papyrus.MARTE.MARTE_AnalysisModel.GQAM.GaWorkloadBehavior;
import org.eclipse.papyrus.MARTE.MARTE_AnalysisModel.SAM.SaAnalysisContext;
import org.eclipse.papyrus.MARTE.MARTE_AnalysisModel.SAM.SaEndtoEndFlow;
import org.eclipse.papyrus.MARTE.MARTE_Foundations.Alloc.Assign;
import org.eclipse.papyrus.editor.PapyrusMultiDiagramEditor;
import org.eclipse.papyrus.infra.core.services.ServiceException;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IFileEditorInput;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.handlers.HandlerUtil;
import org.eclipse.uml2.uml.Activity;
import org.eclipse.uml2.uml.ActivityNode;
import org.eclipse.uml2.uml.CallBehaviorAction;
import org.eclipse.uml2.uml.Class;
import org.eclipse.uml2.uml.Element;
import org.eclipse.uml2.uml.InstanceSpecification;
import org.eclipse.uml2.uml.Interaction;
import org.eclipse.uml2.uml.Message;
import org.eclipse.uml2.uml.Model;
import org.eclipse.uml2.uml.NamedElement;
import org.eclipse.uml2.uml.Operation;
import org.eclipse.uml2.uml.Package;
import org.eclipse.uml2.uml.Stereotype;


/**
 * The Class QVToUIHandlerEnd2End realizes the handler for the end-to-end analysis command.
 * @since 0.9
 */
public class QVToUIHandlerEnd2End extends AbstractHandler {

	/** The Constant SAANALYSISCONTEXT. */
	private static final String SAANALYSISCONTEXT = "MARTE::MARTE_AnalysisModel::SAM::SaAnalysisContext";
	
	/** The Constant SAENDTOENDFLOW. */
	private static final String SAENDTOENDFLOW = "MARTE::MARTE_AnalysisModel::SAM::SaEndtoEndFlow";
	
	/** The active shell. */
	private Shell activeShell = null;
	
	/** The in resource. */
	private Resource inResource = null;
	
	/** The context class. */
	private Class contextClass;
	
	/** The deadline. */
	private String deadline;
	
	/** The scenario. */
	private String scenario;
	
	/** The sa analysis name. */
	private String saAnalysisName;
	
	/** The sa e2 e flow name. */
	private String saE2EFlowName;
	
	/** The sa e2 e flow. */
	private SaEndtoEndFlow saE2EFlow;
	
	/** The sa analysis ctx. */
	private SaAnalysisContext saAnalysisCtx;
	
	/** The psm package name. */
	private String psmPackageName;
	
	/**
	 * Gets the active project.
	 *
	 * @param editor the editor
	 * @return the active project
	 */
	private IProject getActiveProject(IEditorPart editor) {
		IFileEditorInput input = (IFileEditorInput) editor.getEditorInput();
		IFile file = input.getFile();
		return file.getProject();
	}

	/**
	 * Executes the end-to-end response time analysis and shows the results.
	 * The end-to-end analysis context to be analyzed is asked to the user through a dedicated dialog.
	 * 
	 *
	 * @param event the event resulting from the command invocation
	 * @return null
	 * @throws ExecutionException the execution exception
	 * @see org.eclipse.core.commands.AbstractHandler#execute(org.eclipse.core.commands.ExecutionEvent)
	 * @see org.polarsys.chess.m2m.ui.AnalysisContextSelectionDialog
	 */
	public Object execute(final ExecutionEvent event) throws ExecutionException {
		final IEditorPart editor = HandlerUtil.getActiveEditor(event);
		if (!(CHESSEditorUtils.isCHESSProject(editor)))
			return null;

		IWorkbenchWindow window = HandlerUtil.getActiveWorkbenchWindowChecked(event);
		activeShell = window.getShell();

		try {
			inResource = ResourceUtils.getUMLResource(((PapyrusMultiDiagramEditor) editor).getServicesRegistry());
		} catch (ServiceException e) {
			e.printStackTrace();
		}

		//open a dialog to select the end-to-end analysis context to be analyzed
		//first get all the classes stereotyped as SaAnalysisContext
		final List<Class> selection = new ArrayList<Class>();
		final Model model = (Model) inResource.getContents().get(0);
		EList<Element> elemList = model.allOwnedElements();
		for (Element elem : elemList) {
			//we're looking for a class stereotyped <<saAnalysisContext>> and NOT in PSM
			if(elem instanceof Class && elem.getAppliedStereotype(SAANALYSISCONTEXT) != null
					&& !ViewUtils.isPSMView(ViewUtils.getView(elem))){
				//as additional constraint, at least one workload is specified
				SaAnalysisContext saAnalysisCtx = (SaAnalysisContext) elem.getStereotypeApplication
						(elem.getAppliedStereotype(SAANALYSISCONTEXT));		
				if(saAnalysisCtx.getWorkload().size() > 0){
					selection.add((Class) elem);
				}
			}
		}
		if(selection.size() == 0){
			MessageDialog.openWarning(activeShell, "CHESS", "no suitable analysis contexts in the model");
			return null;
		}
		//then open the dialog
		String contextQN = null;
		AnalysisContextSelectionDialog dialog = new AnalysisContextSelectionDialog(activeShell, selection, "Select End-To-End Context to analyze");
		if (dialog.open() == Window.OK) {
			contextQN = dialog.getContext();
			if(contextQN == null || contextQN.isEmpty()){
				return null;
			}
			for (Element elem : model.allOwnedElements()){
				if(elem.getAppliedStereotype(SAANALYSISCONTEXT) != null &&
						((NamedElement) elem).getQualifiedName().equals(contextQN)){
					contextClass = (Class) elem;
				}
			}
		}else{
			return null;
		}
		
		saAnalysisName = contextClass.getQualifiedName();
		psmPackageName = contextClass.getName() +"_PSM";
		Stereotype stereo = contextClass.getAppliedStereotype(SAANALYSISCONTEXT);
		saAnalysisCtx = (SaAnalysisContext) contextClass.getStereotypeApplication(stereo);		
		
		EList<GaWorkloadBehavior> workloadList = saAnalysisCtx.getWorkload();
		//assume there's only one workload
		if(workloadList.size() != 1){
			return null;
		}
		GaWorkloadBehavior workload = workloadList.get(0);
		NamedElement nelem = workload.getBase_NamedElement();
		if (!(nelem instanceof Activity)){
			return null;
		}
		Activity workloadActivity = (Activity) nelem;
		saE2EFlowName = workloadActivity.getQualifiedName();
		//check that the activity is also a SaEndToEndFlow (assumption)
		stereo = workloadActivity.getApplicableStereotype(SAENDTOENDFLOW);
		saE2EFlow = (SaEndtoEndFlow) workloadActivity.getStereotypeApplication(stereo);
		//deadline is to be passed to the QVTO transformation
		deadline = saE2EFlow.getEnd2EndD().get(0); //note: in MARTE this relationship is [0..1] not [0..*] as in Papyrus
		//assume the activity has exactly one callbehaviour node
		CallBehaviorAction callbehaviour = null;
		EList<ActivityNode> nodes = workloadActivity.getNodes();
		for (ActivityNode activityNode : nodes) {
			if(activityNode instanceof CallBehaviorAction){
				callbehaviour = (CallBehaviorAction)activityNode;
			}
		}
		
		if (!(callbehaviour.getBehavior() instanceof Interaction)){
			return null;
		}
		//scenario is to be passed to the QVTO transformation
		final Interaction interaction = ((Interaction) callbehaviour.getBehavior());
		scenario = interaction .getQualifiedName();
		
		final Job job = new Job("Transforming") {
			protected IStatus run(IProgressMonitor monitor) {
				try {
					
					TransformationResultsData result =null;
					try {
					
						result = QVToUIHandlerEnd2End.this.executeTimingAnalysis(editor, monitor);
						//Reopen the editor
						CHESSEditorUtils.reopenEditor(editor, false);
					} catch (Exception e) {
						throw e;
					} finally {
						getActiveProject(editor).refreshLocal(IResource.DEPTH_INFINITE, monitor);
						
					}
					
					//open sched analysis result
					
					try {
						//can active editor be different from just reopened CHESS ones? it should be not the case given that it has been just reopened
						//inResource = ResourceUtils.getUMLResource(((CHESSEditor) editor).getServicesRegistry());
						//Model model = (Model) inResource.getContents().get(0);
						
						ModelContent inModel = TransUtil.loadModel(result.umlFile);
						Model model = (Model) inModel.getContent().get(0);
						
						openE2EAnalysisReport(model, saAnalysisName, interaction);
					} catch (Exception e) {
						e.printStackTrace();
						throw new Exception("Unable to load the model and so open the schedAnalysisReport");
					}

		
				} catch (Exception e) {
					e.printStackTrace();
					return new Status(Status.ERROR, Activator.PLUGIN_ID, 1,
							"Error in transformation "+ e.getMessage(), null);
				}
				if (monitor.isCanceled())
					return Status.CANCEL_STATUS;
				return Status.OK_STATUS;
			}
		};
		job.addJobChangeListener(new JobChangeAdapter() {
			public void done(IJobChangeEvent event) {
				if (event.getResult().isOK())
					CHESSProjectSupport.printlnToCHESSConsole("Job completed successfully");
				else
					CHESSProjectSupport.printlnToCHESSConsole("Job did not complete successfully");
			}
		});
		job.setUser(true);
		job.setPriority(Job.SHORT);
		job.schedule();
		return null;
	}
	
	/**
	 * Collects all the needed information and invokes the PIMPSMTransformationEnd2End.performTimingAnalysisWithMAST method
	 *
	 * @param editor the current active editor
	 * @param monitor the progress monitor
	 * @return the string resulting from the MAST execution (i.e. the system is/not schedulable) and the modified model
	 * @throws Exception the exception
	 * @see org.polarsys.chess.m2m.transformations.PIMPSMTransformationEnd2End#performTimingAnalysisWithMAST(PapyrusMultiDiagramEditor, IFile, IProgressMonitor)
	 */
	public TransformationResultsData executeTimingAnalysis(IEditorPart editor, IProgressMonitor monitor) throws Exception {
		monitor.beginTask("Transforming", 4);
		if (!(CHESSEditorUtils.isCHESSProject(editor)))
			return null;

		IFile inputFile = CHESSProjectSupport.resourceToFile(inResource);
		
		//finally call the transformation
		PIMPSMTransformationEnd2End t = new PIMPSMTransformationEnd2End();
		t.setFolder(TransUtil.TRANSFORMATIONS_DIR_E2E);
		Map<String, String> configProps = new HashMap<String, String>();
		configProps.put("deadline", deadline);
		configProps.put("scenario", scenario);
		configProps.put("saAnalysis",saAnalysisName);
		configProps.put("saE2EFlow", saE2EFlowName);
		configProps.put("analysisType", "EndToEnd");
		t.setConfigProperty(configProps);
		t.setPsmPackageName(psmPackageName);
		TransformationResultsData result = t.performTimingAnalysisWithMAST((PapyrusMultiDiagramEditor) editor, inputFile, monitor);
				
		return result;
	}
	
	/**
	 * Opens the end-to-end analysis report dialog.
	 *
	 * @param model the model
	 * @param saAnalysisName the sa analysis name
	 * @param interaction the interaction
	 */
	public void openE2EAnalysisReport(final Model model, String saAnalysisName, Interaction interaction){
		//get all the e2e analysis result info from the model and open a simple, user-friendly report
		SaAnalysisContext saAnCtx = null;
		SaEndtoEndFlow saflow = null;
		Package anView = (Package) ViewUtils.getCHESSRtAnalysisPackage(model);
		for (Element elem : anView.allOwnedElements()) {
			if(elem instanceof Class && ((Class)elem).getQualifiedName().equals(saAnalysisName)){
				saAnCtx = UMLUtils.getStereotypeApplication(elem, SaAnalysisContext.class);
				if(saAnCtx.getWorkload().size() > 0){
					saflow = UMLUtils.getStereotypeApplication(saAnCtx.getWorkload().get(0).getBase_NamedElement(), SaEndtoEndFlow.class);
				}
			}
		}
		
		EList<Message> messages = interaction.getMessages();
		final List<Operation> e2eOperations = new ArrayList<Operation>();
		for (Message msg : messages) {
			Operation op = (Operation) msg.getSignature();
			if (op.eIsProxy()){
				op = (Operation) EcoreUtil.resolve(op, model.eResource().getResourceSet());
			}
			e2eOperations.add(op);
		}
		final List<CH_HwProcessor> cpus = new ArrayList<CH_HwProcessor>();
		final List<CHRtPortSlot> specifications = new ArrayList<CHRtPortSlot>();
		final List<Assign> assigns = new ArrayList<Assign>();
		for (Element elem : model.allOwnedElements()) {
			CHRtPortSlot chrtSlot = UMLUtils.getStereotypeApplication(elem, CHRtPortSlot.class);
			//if(chrtSlot != null && UMLUtils.getStereotypeApplication(chrtSlot.getBase_Slot().getOwner(), IdentifInstance.class) != null){
			if(chrtSlot != null){
				specifications.add(chrtSlot);
			}
			if(elem instanceof InstanceSpecification){
				CH_HwProcessor chHwProc = UMLUtils.getStereotypeApplication(elem, CH_HwProcessor.class);
				if(chHwProc != null){
					cpus.add(chHwProc);
				}
			}
			
			Assign assign = UMLUtils.getStereotypeApplication(elem, Assign.class);
			if(assign != null){
				assigns.add(assign);
			}
		};	
		launchDialog(model, cpus, saAnCtx, saflow, e2eOperations, assigns, specifications);
	}
	
	/**
	 * Launch dialog.
	 *
	 * @param model the model
	 * @param cpus the cpus
	 * @param saAnCtx the sa an ctx
	 * @param saflow the saflow
	 * @param e2eOperations the e2e operations
	 * @param assigns the assigns
	 * @param specifications the specifications
	 */
	private static void launchDialog(final Model model, final List<CH_HwProcessor> cpus, final SaAnalysisContext saAnCtx, final SaEndtoEndFlow saflow, final List<Operation> e2eOperations, final List<Assign> assigns, final List<CHRtPortSlot> specifications){
		final Display display = PlatformUI.getWorkbench().getDisplay();
		display.asyncExec(new Runnable() {
			@Override
			public void run() {
				Shell shell = new Shell(display);
				End2EndResultDialog e2eDialog = new End2EndResultDialog(shell, model);
				e2eDialog.setCpus(cpus);
				e2eDialog.setSpecifications(specifications);
				e2eDialog.setSaAnalysisCtx(saAnCtx);
				e2eDialog.setSaE2EFlow(saflow);
				e2eDialog.setMessages(e2eOperations);
				e2eDialog.setAssigns(assigns);
				if (e2eDialog.open() == Window.OK) {
				    System.out.println("OK");
				}
			}
		});
	}
	

}