/*
-----------------------------------------------------------------------
--          			CHESS validator plugin					     --
--                                                                   --
--                    Copyright (C) 2011-2012                        --
--                 University of Padova, ITALY                       --
--                                                                   --
-- Author: Alessandro Zovi         azovi@math.unipd.it 	             --
--	       Stefano Puri            stefano.puri@intecs.it            --
--                                                                   --
-- 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.validator.libs;


import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.command.CompoundCommand;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.impl.EReferenceImpl;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.edit.command.DeleteCommand;
import org.eclipse.emf.edit.command.SetCommand;
import org.eclipse.emf.transaction.RollbackException;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.gmf.runtime.common.core.command.CompositeCommand;
import org.eclipse.gmf.runtime.common.core.command.ICommand;
import org.eclipse.gmf.runtime.emf.type.core.commands.DestroyElementCommand;
import org.eclipse.gmf.runtime.emf.type.core.requests.DestroyElementRequest;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.papyrus.MARTE.MARTE_AnalysisModel.GQAM.GaAnalysisContext;
import org.eclipse.papyrus.MARTE.MARTE_AnalysisModel.SAM.SaAnalysisContext;
import org.eclipse.papyrus.MARTE.MARTE_AnalysisModel.SAM.impl.SaAnalysisContextImpl;
import org.eclipse.papyrus.MARTE.MARTE_DesignModel.GCM.ClientServerPort;
import org.eclipse.papyrus.MARTE.MARTE_DesignModel.GCM.FlowPort;
import org.eclipse.papyrus.MARTE.MARTE_Foundations.Alloc.Assign;
import org.eclipse.papyrus.MARTE.MARTE_Foundations.NFPs.NfpConstraint;
import org.eclipse.papyrus.commands.wrappers.EMFtoGMFCommandWrapper;
import org.eclipse.papyrus.commands.wrappers.GMFtoEMFCommandWrapper;
import org.eclipse.papyrus.editor.PapyrusMultiDiagramEditor;
import org.eclipse.papyrus.infra.core.resource.IModel;
import org.eclipse.papyrus.infra.core.resource.ModelSet;
import org.eclipse.papyrus.infra.core.services.ServiceException;
import org.eclipse.papyrus.infra.core.services.ServicesRegistry;
import org.eclipse.papyrus.infra.services.edit.service.ElementEditServiceUtils;
import org.eclipse.papyrus.infra.services.edit.service.IElementEditService;
import org.eclipse.papyrus.infra.ui.util.ServiceUtilsForActionHandlers;
import org.eclipse.papyrus.uml.tools.listeners.PapyrusStereotypeListener;
import org.eclipse.papyrus.uml.tools.model.ExtendedUmlModel;
import org.eclipse.papyrus.uml.tools.model.UmlModel;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.PlatformUI;
import org.eclipse.uml2.uml.Behavior;
import org.eclipse.uml2.uml.Classifier;
import org.eclipse.uml2.uml.Comment;
import org.eclipse.uml2.uml.Component;
import org.eclipse.uml2.uml.Constraint;
import org.eclipse.uml2.uml.Dependency;
import org.eclipse.uml2.uml.Element;
import org.eclipse.uml2.uml.InstanceSpecification;
import org.eclipse.uml2.uml.Interface;
import org.eclipse.uml2.uml.InterfaceRealization;
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.Parameter;
import org.eclipse.uml2.uml.Port;
import org.eclipse.uml2.uml.Property;
import org.eclipse.uml2.uml.Realization;
import org.eclipse.uml2.uml.Stereotype;
import org.eclipse.uml2.uml.Type;
import org.eclipse.uml2.uml.internal.impl.ClassImpl;
import org.eclipse.uml2.uml.resource.UMLResource;
import org.polarsys.chess.chessmlprofile.ComponentModel.FunctionalPartition;
import org.polarsys.chess.chessmlprofile.Core.CHESS;
import org.polarsys.chess.chessmlprofile.Core.PSMPackage;
import org.polarsys.chess.chessmlprofile.Core.CHESSViews.AnalysisView;
import org.polarsys.chess.chessmlprofile.Core.CHESSViews.ComponentView;
import org.polarsys.chess.chessmlprofile.Core.CHESSViews.DeploymentView;
import org.polarsys.chess.chessmlprofile.Core.CHESSViews.PSMView;
import org.polarsys.chess.chessmlprofile.Core.CHESSViews.RTAnalysisView;
import org.polarsys.chess.chessmlprofile.Predictability.DeploymentConfiguration.HardwareBaseline.CH_HwProcessor;
import org.polarsys.chess.chessmlprofile.Predictability.RTComponentModel.CHRtSpecification;
import org.polarsys.chess.chessmlprofile.util.Constants;
import org.polarsys.chess.validator.automatedActions.IAutomatedAction;
import org.polarsys.chess.core.profiles.CHESSProfileManager;
import org.polarsys.chess.core.util.CHESSProjectSupport;
import org.polarsys.chess.core.util.uml.ModelError;
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.service.gui.utils.CHESSEditorUtils;
import org.polarsys.chess.validator.Activator;
import org.polarsys.chess.validator.managers.AddDiagramElement;
import org.polarsys.chess.validator.messages.Messages;


/**
 * The Class ActionsLib contains the implementation of the Automated Actions
 */
public class ActionsLib {

	/** The port modification action. */
	public static IAutomatedAction portModificationAction = new IAutomatedAction() {
		@Override
		public Command compile(Notification notification, List<Notification> notificationList,
				TransactionalEditingDomain domain) {
			Object notifier = notification.getNotifier();
			// in case of modification of a clientserverport
			if (notifier instanceof Port
					&& notification.getEventType() == PapyrusStereotypeListener.MODIFIED_STEREOTYPE) {
				// if
				// (((EObject)notification.getNewValue()).eClass().getName().equals("ClientServerPort")){}
				if (notification.getNewValue() instanceof ClientServerPort) {
					if (((Port) notifier).getOwner() instanceof Component) {
						Component comp = (Component) ((Port) notifier).getOwner();
						if (!(UMLUtils.isComponentType(comp) && ViewUtils.isComponentView(ViewUtils.getView(comp))))
							return null;


						ClientServerPort port = (ClientServerPort) notification.getNewValue();

						EList<Dependency> cDependenciesToRemove = UMLUtils.computeDependenciesToRemove(comp);
						EList<InterfaceRealization> cRealizationsToRemove = UMLUtils.computeRealizationsToRemove(comp);

						// CompositeCommand cc = new
						// CompositeCommand("portAutomations");
						// cc.add(new
						// EMFtoGMFCommandWrapper(AddDiagramElement.destroyDependencies(domain,
						// cDependenciesToRemove)));
						// cc.add(new
						// EMFtoGMFCommandWrapper(AddDiagramElement.destroyDependencies(domain,
						// cRealizationsToRemove)));
						// cc.add(new
						// EMFtoGMFCommandWrapper(AddDiagramElement.createDependencies(domain,
						// comp, port)));
						// if (!cc.isEmpty()){
						// return new GMFToEMFCommand(ccc);
						// }

						CompoundCommand ccc = new CompoundCommand("portAutomations");
						ccc.append(AddDiagramElement.updateImplementationsPorts(domain, port));
						ccc.append(AddDiagramElement.destroyDependencies(domain, cDependenciesToRemove));
						ccc.append(AddDiagramElement.destroyDependencies(domain, cRealizationsToRemove));
						ccc.append(AddDiagramElement.createDependencies(domain,	comp, port));
						return ccc;
					}
				}

				else if(notification.getNewValue() instanceof FlowPort){
					if (((Port) notifier).getOwner() instanceof Component) {
						Component comp = (Component) ((Port) notifier).getOwner();
						if (!(UMLUtils.isComponentType(comp) && ViewUtils.isComponentView(ViewUtils.getView(comp))))
							return null;

						FlowPort flPort = (FlowPort) notification.getNewValue();

						CompoundCommand cc = new CompoundCommand("portAutomations");
						cc.append(AddDiagramElement.updateImplementationsFlowPorts(domain, flPort));
						return cc;
					}
				}
			}
			return null;
		}
		
	};

	/** The port removal action. */
	public static IAutomatedAction portRemovalAction = new IAutomatedAction() {
		@Override
		public Command compile(Notification notification, List<Notification> notificationList,
				TransactionalEditingDomain domain) {
			Object notifier = notification.getNotifier();
			// in case of removal of a clientserverport or FlowPort
			if ((notifier instanceof ClientServerPort || notifier instanceof FlowPort)
					&& notification.getEventType() == Notification.SET) {
				if (notification.getFeature() instanceof EReference	
						&& ((EReference) notification.getFeature()).getName().equals("base_Port")
						&& notification.getNewValue() == null) {
					Port p = (Port) notification.getOldValue();
					Element el = p.getOwner();

					if (!(el instanceof NamedElement 
							&& UMLUtils.isComponentType((NamedElement) el) 
							&& ViewUtils.isComponentView(ViewUtils.getView(el))))
						return null;
					Component comp = (Component) el;

					EList<Dependency> cDependenciesToRemove = UMLUtils.computeDependenciesToRemove(comp);
					EList<InterfaceRealization> cRealizationsToRemove = UMLUtils.computeRealizationsToRemove(comp);

					CompoundCommand ccc = new CompoundCommand("portAutomations");
					ccc.append(AddDiagramElement.removeImplementationsPorts(domain, p));
					ccc.append(AddDiagramElement.destroyDependencies(domain,
							cDependenciesToRemove));
					ccc.append(AddDiagramElement.destroyDependencies(domain,
							cRealizationsToRemove));
					return ccc;
				}
			}
			return null;
		}
	};

	/*
	 * inherited operations are automatically added
	 */
	/** The component interface realization action. */
	public static IAutomatedAction componentInterfaceRealizationAction = new IAutomatedAction() {
		@Override
		public Command compile(Notification notification, List<Notification> notificationList,
				TransactionalEditingDomain domain) {
			Object notifier = notification.getNotifier();
			if (notifier instanceof Component) {
				Component comp = (Component) notifier;
				if (notification.getEventType() == Notification.ADD && notification.getNewValue() instanceof InterfaceRealization) {
					InterfaceRealization link = (InterfaceRealization) notification.getNewValue();
					Interface contract = link.getContract();
					// cheks to be verified only in case the current component
					// belongs to the functional view
					if (ViewUtils.isComponentView(ViewUtils.getView(comp)) && UMLUtils.isComponentType(comp)) {
						return AddDiagramElement.addOperationCommand(domain, contract, comp);
					}
				}
			}
			return null;
		}
	};

	/** The component realization action. */
	public static IAutomatedAction componentRealizationAction = new IAutomatedAction() {
		@Override
		public Command compile(Notification notification, List<Notification> notificationList,
				TransactionalEditingDomain domain) {
			Object notifier = notification.getNotifier();
			Object feature = notification.getFeature();
			if(feature instanceof EReference){
				EReference ref = (EReference) feature;
				if(notifier instanceof Realization && ref.getName().equals("supplier")){
					Realization link = (Realization) notifier;
					//get the client (ComponentImplementation) - according to the notifications chain, the client is set before the supplier
					if (link.getClients().size() != 1)
						return null;
					Component clientComp = (Component) link.getClients().get(0);
					//now get the supplier (ComponentType)
					Object newVal = notification.getNewValue();
					if(newVal instanceof Component){
						Component supplierComp = (Component) newVal;
						//checks to be verified only in case the current ComponentImplementation belongs to the functional view
						if (!ViewUtils.isComponentView(ViewUtils.getView(clientComp)) || !UMLUtils.isComponentImplementation(clientComp))
							return null;
						//add operations and ports to the client (ComponentImplementation)
						CompositeCommand cc = new CompositeCommand("portAndOpCommand");
						Command cmd = AddDiagramElement.addOperationCommand(domain,	supplierComp, clientComp);
						cc.add(new EMFtoGMFCommandWrapper(cmd));
						Command cmd2 = AddDiagramElement.addAllPortsCommand(domain, supplierComp, clientComp);
						cc.add(new EMFtoGMFCommandWrapper(cmd2));
						if (!cc.isEmpty()) {
							return new GMFtoEMFCommandWrapper(cc);
						}
					}
				}
			}
			return null;
		}
	};

	/** The remove realization operations action. */
	public static IAutomatedAction removeRealizationOperationsAction = new IAutomatedAction() {

		private IStatus operationAborted = new Status(IStatus.ERROR,
				Activator.PLUGIN_ID, Messages.operationAborted);


		@Override
		public Command compile(Notification notification, List<Notification> notificationList,
				TransactionalEditingDomain domain) throws RollbackException {
			Object notifier = notification.getNotifier();
			if (notifier instanceof Component) {
				Component comp = (Component) notifier;

				// Deletion of a Realization link
				if (notification.getEventType() == Notification.REMOVE
						&& notification.getOldValue().getClass().equals(Realization.class) && notification.getFeature() instanceof EReference && ((EReference)notification.getFeature()).getName().equals("clientDependency")) {
					Package view = ViewUtils.getView((Component) notifier);
					// checks to be verified only in case the current component
					// belongs to the functional view
					Realization rel = (Realization) notification.getOldValue();
					if (!(ViewUtils.isComponentView(view) && UMLUtils.isComponentImplementation(comp)))
						return null;
					PapyrusMultiDiagramEditor editor = CHESSEditorUtils.getCHESSEditor();
					if (editor == null) 
						return null;
					MessageDialog md = CHESSEditorUtils.showConfirmDialog(editor, "Confirm", "Do you want to propagate the removal of the operations of this realization "+rel.getName()+"?");
					// * 0 - OK
					int result = md.open();
					if (result == 0){
						return deleteOperations(comp, view, domain);
					}
					// CANCEL
					if (result == 2){
						CHESSProjectSupport.CHESS_CONSOLE.println(operationAborted.getMessage());
						// TODO why?
						//throw new RollbackException(operationAborted);
					}	
				}
			}
			return null;
		}


		//TODO it needs to be checked 
		private Command deleteOperations(Component component, Package view,
				TransactionalEditingDomain domain) {
			CompositeCommand cmd = new CompositeCommand("delOpCommand");

			// Delete all the operations of the component
			// implementation
			ArrayList<Operation> opToDel = new ArrayList<Operation>();
			// Delete all the activity diagram
			ArrayList<Behavior> behaviorToDel = new ArrayList<Behavior>();
			// Delete all the owned port
			ArrayList<Port> portToDel = new ArrayList<Port>();
			// Delete all ChRtSpecification attached to the ports
			ArrayList<Comment> commentToDel = new ArrayList<Comment>();

			for (Operation op : component.getOwnedOperations()) {
				opToDel.add(op);
				behaviorToDel.addAll(op.getMethods());
			}

			for (Port p : component.getOwnedPorts()) {
				if (!UMLUtils.isClientServerPort(p))
					continue;
				portToDel.add(p);
				commentToDel.addAll(UMLUtils.getCHRtSpecificationComments(view, p));
			}

			behaviorToDel.addAll(component.getOwnedBehaviors());

			DeleteCommand delC = new DeleteCommand(domain, opToDel);
			cmd.add(new EMFtoGMFCommandWrapper(delC));

			if (portToDel.size() > 0) {

				for (int i = 0; i < portToDel.size(); i++) {
					IElementEditService provider = ElementEditServiceUtils
							.getCommandProvider(portToDel.get(i));

					if (provider == null) {

						continue;

					}
					// Retrieve delete command from the Element Edit
					// service

					DestroyElementRequest request = new DestroyElementRequest(
							portToDel.get(i), false);

					ICommand deleteCommand = provider
							.getEditCommand(request);

					cmd.add(deleteCommand);
				}
			}

			if (commentToDel.size() > 0) {

				for (int i = 0; i < commentToDel.size(); i++) {
					IElementEditService provider = ElementEditServiceUtils
							.getCommandProvider(commentToDel.get(i));

					if (provider == null) {
						continue;
					}
					// Retrieve delete command from the Element Edit
					// service

					DestroyElementRequest request = new DestroyElementRequest(
							commentToDel.get(i), false);

					ICommand deleteCommand = provider.getEditCommand(request);

					cmd.add(deleteCommand);
				}
			}

			// remove all the bahavior related to the selected
			// operation
			if (behaviorToDel.size() > 0) {

				for (int i = 0; i < behaviorToDel.size(); i++) {
					IElementEditService provider = ElementEditServiceUtils
							.getCommandProvider(behaviorToDel.get(i));

					if (provider == null) {
						continue;
					}
					// Retrieve delete command from the Element Edit
					// service

					DestroyElementRequest request = new DestroyElementRequest(
							behaviorToDel.get(i), false);

					ICommand deleteCommand = provider
							.getEditCommand(request);

					cmd.add(deleteCommand);
				}
			}

			if (!cmd.isEmpty())
				return new GMFtoEMFCommandWrapper(cmd);
			return null;
		}
	};

	/** The propagate operation modification. */
	public static IAutomatedAction propagateOperationModification = new IAutomatedAction() {

		@Override
		public Command compile(Notification notification, List<Notification> notificationList,
				TransactionalEditingDomain domain) throws RollbackException {
			Object notifier = notification.getNotifier();
			if (notifier instanceof Operation) {
				// in case of addition
				if (notification.getEventType() == Notification.SET) {
					Operation op = (Operation) notifier;
					EObject container = op.eContainer();
					//					if (container == null && notification.getOldValue() instanceof Interface){
					//						container = (EObject) notification.getOldValue();
					//					}

					if (!(container instanceof Interface))
						return null;
					if (!ViewUtils.isComponentView(ViewUtils.getView(container))) 
						return null;

					EList<Component> relationships = UMLUtils.getAllInterfaceComponents((Interface) container);
					if (relationships == null || relationships.isEmpty()) 
						return null;

					CompositeCommand cmd = new CompositeCommand("setCommand");
					for (Component comp : relationships) {
						propagateFeature(notification, domain, op, cmd,	comp);
					}
					if (!cmd.isEmpty())
						return new GMFtoEMFCommandWrapper(cmd);
				}
			}
			return null;
		}

		private void propagateFeature(Notification notification,
				TransactionalEditingDomain domain, Operation op,
				CompositeCommand cmd, Component comp) {
			String opName = op.getName();
			if (notification.getFeature() instanceof EAttribute && ((EAttribute)notification.getFeature()).getName().equals("name"))
				opName = (String) notification.getOldValue();
			for (Operation cOperation : comp.getOwnedOperations()) {
				if (cOperation.getName().equalsIgnoreCase(opName)) {
					if (UMLUtils.areParametersEquals(cOperation, op)) {
						SetCommand setC = new SetCommand(domain, cOperation, (EStructuralFeature) notification.getFeature(),
								notification.getNewValue());
						cmd.add(new EMFtoGMFCommandWrapper(setC));
					}
				}
			}
		}
		
	};


	/** The propagate interface modification. */
	public static IAutomatedAction propagateInterfaceModification = new IAutomatedAction() {

		private IStatus operationAborted = new Status(IStatus.ERROR,
				Activator.PLUGIN_ID, Messages.operationAborted);

		@Override
		public Command compile(Notification notification, List<Notification> notificationList,
				TransactionalEditingDomain domain) throws RollbackException {
			Object notifier = notification.getNotifier();
			if (notifier instanceof Interface) {
				Interface interfce = (Interface) notifier;

				if (notification.getEventType() == Notification.ADD
						&& notification.getNewValue() instanceof Operation) {

					Operation operation = (Operation) notification.getNewValue();
					// checks to be verified only in case the current component
					// belongs to the functional view
					if (ViewUtils.isComponentView(ViewUtils.getView(interfce))) {
						return AddDiagramElement.addOperationCommand1(domain, interfce, operation);
					}
				}

				// Deletion of an operation belonging to an interface
				if (notification.getEventType() == Notification.REMOVE
						&& notification.getOldValue() instanceof Operation) {
					Operation operation = (Operation) notification.getOldValue();
					if (!ViewUtils.isComponentView(ViewUtils.getView(interfce)))
						return null;

					PapyrusMultiDiagramEditor editor = CHESSEditorUtils.getCHESSEditor();
					if (editor == null) 
						return null;
					MessageDialog md = CHESSEditorUtils.showConfirmDialog(editor, "Confirm", "Do you want to propagate the removal of "+operation.getName()+" from all the  related model elements?");
					// * 0 - OK
					int result = md.open();


					// * 0 - OK
					// * 1 - No
					// * 2 - Cancel
					switch (result) {
					case 0:
						EList<Component> relationships = UMLUtils.getAllInterfaceComponents(interfce);
						CompositeCommand cmd = new CompositeCommand("delOpCommand");

						ArrayList<Operation> opToDel = new ArrayList<Operation>();
						ArrayList<Behavior> behaviorToDel = new ArrayList<Behavior>();


						//opToDel.add(operation);
						for (Component cmp : relationships) {
							for (Operation op : cmp.getOwnedOperations()) {
								if (UMLUtils.isOperationEquals(op, operation)) {
									opToDel.add(op);
									behaviorToDel.addAll(op.getMethods());
								}
							}
						}
						cmd.add(new EMFtoGMFCommandWrapper(new DeleteCommand(domain, opToDel)));
						// Remove all <<ChRtSpecification>> with the context
						// attribute set to the equivalent operation of the
						// component implementation
						// <<ChRtSpecification>> are only inside system
						ArrayList<Comment> commentToDel = new ArrayList<Comment>();
						for (Notification aNotification : notificationList) {
							if (aNotification.equals(notification))
								continue;
							if (aNotification.getNotifier() instanceof CHRtSpecification
									&& aNotification.getEventType() == Notification.SET) {
								if (aNotification.getOldValue() instanceof Operation && aNotification.getOldValue().equals(operation)) {
									commentToDel.add(((CHRtSpecification) aNotification.getNotifier()).getBase_Comment());
								}
							}
						}

						if (!commentToDel.isEmpty()) {
							for (Comment comment : commentToDel) {
								IElementEditService provider = ElementEditServiceUtils.getCommandProvider(comment);
								if (provider == null)
									continue;
								// Retrieve delete command from the Element Edit
								// service
								DestroyElementRequest request = new DestroyElementRequest(comment, false);
								ICommand deleteCommand = provider.getEditCommand(request);
								cmd.add(deleteCommand);
							}
						}

						// remove all the bahavior related to the selected
						// operation
						if (!behaviorToDel.isEmpty()) {
							for (Behavior behavior : behaviorToDel) {
								IElementEditService provider = ElementEditServiceUtils.getCommandProvider(behavior);

								if (provider == null)
									continue;

								DestroyElementRequest request = new DestroyElementRequest(behavior, false);
								ICommand deleteCommand = provider.getEditCommand(request);
								cmd.add(deleteCommand);
							}
						}

						if (!cmd.isEmpty())
							return new GMFtoEMFCommandWrapper(cmd);
						break;
					case 2:
						CHESSProjectSupport.CHESS_CONSOLE.println(operationAborted.getMessage());
						throw new RollbackException(operationAborted);
					}
				}
			}
			return null;
		}
	};


	/** The propagate parameter removal action. */
	public static IAutomatedAction propagateParameterRemovalAction = new IAutomatedAction() {

		@Override
		public Command compile(Notification notification,
				List<Notification> notificationList,
				TransactionalEditingDomain domain) throws RollbackException {
			Object notifier = notification.getNotifier();
			if (notifier instanceof Operation) {
				if ((notification.getEventType() == Notification.REMOVE && notification
						.getOldValue() instanceof Parameter)) {
					Parameter param = (Parameter) notification.getOldValue();
					Operation operation = (Operation) notifier;
					CompositeCommand cmd = new CompositeCommand("delCommand");

					EObject opCont = operation.eContainer();
					if (!(opCont instanceof Interface) || !ViewUtils.isComponentView(ViewUtils.getView(opCont)))
						return null;

					EList<Component> relationships = UMLUtils.getAllInterfaceComponents((Interface) opCont);
					if (relationships == null || relationships.isEmpty())
						return null;
					for (Component comp : relationships) {
						checkOperation:
							for (Operation op : comp.getOwnedOperations()) {
								if (!UMLUtils.areOperationsEqual(op, operation, param))
									continue;
								for (Parameter p : op.getOwnedParameters()) {
									if (UMLUtils.areParametersEqual(p, param)) {
										cmd.add(new DestroyElementCommand(new DestroyElementRequest(p, false)));
										break checkOperation;
									}
								}

							}

					}

					if (!cmd.isEmpty())
						return new GMFtoEMFCommandWrapper(cmd);
				}
				//case REMOVE_MANY
				if ((notification.getEventType() == Notification.REMOVE_MANY && notification
						.getOldValue() instanceof EList)) {

					@SuppressWarnings("rawtypes")
					EList paramList = (EList) notification.getOldValue();
					boolean test = true;
					for (Object ob : paramList){
						if ((ob instanceof Parameter)) {
							Parameter param = (Parameter) ob;
							Operation operation = (Operation) notifier;
							CompositeCommand cmd = new CompositeCommand("delCommand");

							EObject opCont = operation.eContainer();
							if (!(opCont instanceof Interface) || !ViewUtils.isComponentView(ViewUtils.getView(opCont)))
								return null;
							EList<Component> relationships = UMLUtils.getAllInterfaceComponents((Interface) opCont);
							for (Component comp : relationships) {
								checkOperation:
									for (Operation op : comp.getOwnedOperations()) {
										if (!UMLUtils.areOperationsEqual(op, operation, param))
											continue;
										for (Parameter p : op.getOwnedParameters()) {
											if (UMLUtils.areParametersEqual(p, param)) {
												cmd.add(new DestroyElementCommand(new DestroyElementRequest(p, false)));
												break checkOperation;
											}
										}

									}

							}
							if (!cmd.isEmpty())
								return new GMFtoEMFCommandWrapper(cmd);
						}
					}
				}


				// end case


			}
			return null;
		}
	};

	/** The propagate parameter addition action. */
	public static IAutomatedAction propagateParameterAdditionAction = new IAutomatedAction() {

		@Override
		public Command compile(Notification notification,
				List<Notification> notificationList,
				TransactionalEditingDomain domain) throws RollbackException {

			Object notifier = notification.getNotifier();
			if (notifier instanceof Operation) {
				if ((notification.getEventType() == Notification.ADD && notification
						.getNewValue() instanceof Parameter)) {
					Parameter param = (Parameter) notification.getNewValue();
					Operation operation = param.getOperation();

					EObject opCont = operation.eContainer();
					if ((opCont instanceof Interface) && ViewUtils.isComponentView(ViewUtils.getView(opCont)))
						return AddDiagramElement.addParameterCommand((Interface) opCont, param, operation, domain);
				}

				if (notification.getEventType() == Notification.ADD_MANY && notification.getNewValue() instanceof EList){

					@SuppressWarnings("rawtypes")
					EList paramList = (EList) notification.getNewValue();
					boolean test = true;
					EObject opCont = null;
					Operation operation = null;
					for (Object ob : paramList){
						if (!(ob instanceof Parameter)) {
							test = false;
							break;
						}else{
							Parameter par = (Parameter) ob;
							operation = par.getOperation();

							opCont = operation.eContainer();
							if (!(opCont instanceof Interface) || !(ViewUtils.isComponentView(ViewUtils.getView(opCont)))){
								test = false;
								break;
							}
						}
					}
					if (test){
						Parameter param = (Parameter) paramList.get(paramList.size() - 1);
						return AddDiagramElement.addParameterCommand((Interface) opCont, param, operation, domain);
					}
				}				
			}
			return null;
		}
	};


	/** The comment action. */
	public static IAutomatedAction commentAction = new IAutomatedAction() {

		@Override
		public Command compile(Notification notification,
				List<Notification> notificationList,
				TransactionalEditingDomain domain) throws RollbackException {
			if (notification.getNotifier() instanceof Comment) {
				Comment comment = (Comment) notification.getNotifier();
				if (notification.getEventType() == PapyrusStereotypeListener.APPLIED_STEREOTYPE) {
					return AddDiagramElement.addCommentCommand(domain, comment);
				}
				if (notification.getEventType() == PapyrusStereotypeListener.UNAPPLIED_STEREOTYPE) {
					return AddDiagramElement.removeCommentCommand(domain, comment);
				}
			}
			return null;
		}
	};

	/** The port addition action. */
	public static IAutomatedAction portAdditionAction = new IAutomatedAction() {
		@Override
		public Command compile(Notification notification,
				List<Notification> notificationList,
				TransactionalEditingDomain domain) throws RollbackException {
			if (notification.getNotifier() instanceof Port && notification.getEventType()==Notification.SET && notification.getFeature() instanceof EAttribute && ((EAttribute)notification.getFeature()).getName().equals("visibility")){
				Port port = (Port)notification.getNotifier();
				Element supplierComp = port.getOwner();
				if (!(UMLUtils.isClientServerPort(port) && UMLUtils.isComponentType(supplierComp)))
					return null;

				CompositeCommand cc = new CompositeCommand("portAndOpCommand");
				for(Component cImpl: UMLUtils.getComponentImplementations((Component) supplierComp)){
					Command cmd2 = AddDiagramElement.addPortCommand(domain, (Component) supplierComp, cImpl, port);
					cc.add(new EMFtoGMFCommandWrapper(cmd2));
				}

				if (!cc.isEmpty()) {
					return new GMFtoEMFCommandWrapper(cc);
				}
			}
			return null;
		}
	};


	/** The propagate port modification. */
	public static IAutomatedAction propagatePortModification = new IAutomatedAction() {

		@Override
		public Command compile(Notification notification, List<Notification> notificationList,
				TransactionalEditingDomain domain) throws RollbackException {
			Object notifier = notification.getNotifier();
			if (notifier instanceof Port) {
				// in case of addition
				if (notification.getEventType() == Notification.SET) {
					//PAPYRUS BUG: do NOT propagate the name "Port0"
					if (notification.getFeature() instanceof EAttribute && ((EAttribute)notification.getFeature()).getName().equals("name") && notification.getNewValue().equals("Port0"))
						return null;


					Port port = (Port) notifier;
					EObject container = port.eContainer();

					if (!(container instanceof Component))
						return null;
					if (!ViewUtils.isComponentView(ViewUtils.getView(container)) || !UMLUtils.isComponentType(container)) 
						return null;


					EList<Component> relationships = UMLUtils.getComponentImplementations((Component) container);
					if (relationships == null || relationships.isEmpty()) 
						return null;

					CompositeCommand cmd = new CompositeCommand("setCommand");
					for (Component comp : relationships) {
						propagateFeature(notification, domain, port, cmd, comp);
					}
					if (!cmd.isEmpty())
						return new GMFtoEMFCommandWrapper(cmd);
				}
			}
			return null;
		}

		private void propagateFeature(Notification notification,
				TransactionalEditingDomain domain, Port port,
				CompositeCommand cmd, Component comp) {
			String opName = port.getName();
			if (notification.getFeature() instanceof EAttribute && ((EAttribute)notification.getFeature()).getName().equals("name"))
				opName = (String) notification.getOldValue();
			Type portType = port.getType();
			if (notification.getFeature() instanceof EAttribute && ((EAttribute)notification.getFeature()).getName().equals("type"))
				portType = (Type) notification.getOldValue();
			Port portComp = comp.getOwnedPort(opName, portType);
			if (portComp == null)
				return;
			SetCommand setC = new SetCommand(domain, portComp, (EStructuralFeature) notification.getFeature(),
					notification.getNewValue());
			cmd.add(new EMFtoGMFCommandWrapper(setC));
		}
	};


	// LB 20150929 for todo#26
	/** The core modification action. */
	public static IAutomatedAction coreModificationAction = new IAutomatedAction() {
		private IStatus operationAborted = new Status(IStatus.ERROR,
				Activator.PLUGIN_ID, Messages.operationAborted);

		@Override
		public Command compile(Notification notification,
				List<Notification> notificationList,
				TransactionalEditingDomain domain) throws RollbackException {
			Object notifier = notification.getNotifier();						

			if (notifier instanceof CH_HwProcessor) {
				CH_HwProcessor chHwProcessor = (CH_HwProcessor) notifier;

				if (chHwProcessor.getBase_Classifier() == null){
					return null;
				}

				String chHwProcessorName = chHwProcessor.getBase_Classifier().getName();				

				if (notification.getEventType() == Notification.SET) {
					if (notification.getFeature() instanceof EAttribute && 
							((EAttribute)notification.getFeature()).getName().equals(Constants.CHHWPROCESSOR_NB_CORES)) {

						Object oldValue = notification.getOldValue();
						Object newValue = notification.getNewValue();

						if (oldValue!=null && newValue!=null &&
								Integer.parseInt(oldValue.toString()) <= Integer.parseInt(newValue.toString())) {
							// if we are increasing the number of cores or not changing it, do nothing
							return null;
						}

						// Ask user if he is sure he wants to modify this attribute, 
						// warning that the associations to the processor will be deleted
						PapyrusMultiDiagramEditor editor = CHESSEditorUtils.getCHESSEditor();																		

						if (editor == null) {							
							return null;
						}

						MessageDialog md = CHESSEditorUtils.showConfirmDialog(editor, "Confirm", "Do you want to propagate the removal of the associations related to this processor "+chHwProcessorName);

						int result = md.open();

						if (result == 0) {
							Model umlModel = ((Element)chHwProcessor.getBase_Classifier()).getModel();	
							Classifier chHwProcClassifier = chHwProcessor.getBase_Classifier();							
							return deleteAssignments(umlModel, chHwProcClassifier, Constants.DEPLOYMENT_VIEW_NAME, domain);
						}
						// CANCEL
						if (result == 2) {
							CHESSProjectSupport.CHESS_CONSOLE.println(operationAborted.getMessage());
							// TODO why?
							//throw new RollbackException(operationAborted);
						}	
					}
					return null;					
				}
			}
			return null;
		}
	};


	/**
	 * Delete all assignments to this processor: this deletes all the comments that are assignments to the 
	 * processor and all the related nfpConstraints (if any)
	 * @param chHwProcClassifier
	 * @param umlModel
	 * @param viewName
	 * @param domain
	 * @return
	 */
	private static Command deleteAssignments(Model umlModel, Classifier chHwProcClassifier, String viewName, 
			TransactionalEditingDomain domain) {
		CompositeCommand cmd = new CompositeCommand("delAssignmentsCommand");

		//Delete all assignments to this Processor
		ArrayList<Comment> assignmentsToDel = new ArrayList<Comment>();
		ArrayList<Constraint> nfpConstraintsToDel = new ArrayList<Constraint>();
		try {
			for (Assign assignment : UMLUtils.getAll2CoreAssignments(umlModel , viewName)) {				
				Element to = assignment.getTo().get(0);					
				Comment assignComment =assignment.getBase_Comment();					

				if (to instanceof InstanceSpecification) {
					InstanceSpecification instSpec = (InstanceSpecification)to;
					Classifier theClassifier = instSpec.getClassifiers().get(0);
					if (theClassifier.equals(chHwProcClassifier)) {						
						assignmentsToDel.add(assignComment);			
						if (assignment.getImpliedConstraint().size() > 0) {
							for (Object c : assignment.getImpliedConstraint().toArray()) {
								if (c instanceof NfpConstraint) {
									NfpConstraint n = (NfpConstraint) c;
									nfpConstraintsToDel.add(n.getBase_Constraint());									
								}
							}
						}
					}
				}				
			}
		} 

		catch (ModelError e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		if (assignmentsToDel.size()>0) {
			for (int i = 0; i < assignmentsToDel.size(); i++) {
				IElementEditService provider = ElementEditServiceUtils
						.getCommandProvider(assignmentsToDel.get(i));
				if (provider == null) {
					continue;					
				}
				// Retrieve delete command from the Element Edit
				// service
				DestroyElementRequest request = new DestroyElementRequest(
						assignmentsToDel.get(i), false);
				ICommand deleteCommand = provider
						.getEditCommand(request);

				cmd.add(deleteCommand);				
			}
		}	

		if(nfpConstraintsToDel.size()>0) {
			for (int i = 0; i < nfpConstraintsToDel.size(); i++) {
				IElementEditService provider = ElementEditServiceUtils
						.getCommandProvider(nfpConstraintsToDel.get(i));
				if (provider == null) {
					continue;					
				}
				// Retrieve delete command from the Element Edit
				// service
				DestroyElementRequest request = new DestroyElementRequest(
						nfpConstraintsToDel.get(i), false);
				ICommand deleteCommand = provider
						.getEditCommand(request);

				cmd.add(deleteCommand);				
			}
		}

		if (!cmd.isEmpty())
			return new GMFtoEMFCommandWrapper(cmd);
		return null;
	};


	/** The partitions modification action. */
	public static IAutomatedAction partitionsModificationAction = new IAutomatedAction() {
		private IStatus operationAborted = new Status(IStatus.ERROR,
				Activator.PLUGIN_ID, Messages.operationAborted);

		@Override
		public Command compile(Notification notification,
				List<Notification> notificationList,
				TransactionalEditingDomain domain) throws RollbackException {
			Object notifier = notification.getNotifier();
			if (!(notifier instanceof Element)) {
				return null;
			}			

			if (notification.getEventType() == Notification.SET) {							
				if (notifier instanceof Property) {					
					Object oldValue = notification.getOldValue();
					if(oldValue == null) {
						return null;
					}					
					Object feature = notification.getFeature();					
					if (feature instanceof EReferenceImpl) {
						EReferenceImpl feat = (EReferenceImpl)feature;			
						if(feat.getName().equals("type")) {
							if (oldValue instanceof Component) {	
								Component oldValueComponent = (Component)oldValue;														
								if(oldValueComponent.getAppliedStereotype(Constants.CH_FunctionalPartition)!=null) {
									Stereotype functionalPartitionStereo = oldValueComponent.getAppliedStereotype(Constants.CH_FunctionalPartition);
									EObject functPartObj = oldValueComponent.getStereotypeApplication(functionalPartitionStereo);

									FunctionalPartition functPart = (FunctionalPartition)functPartObj;
									System.out.println("found a functional partition"+functPart.toString());						

									// Ask user if he is sure he wants to modify this attribute, 
									// warning that the associations to the processor will be deleted
									PapyrusMultiDiagramEditor editor = CHESSEditorUtils.getCHESSEditor();																		

									if (editor == null) {							
										return null;
									}

									MessageDialog md = CHESSEditorUtils.showConfirmDialog(editor, "Confirm", "Do you want to propagate the removal of the associations related to functional partitions?");

									int result = md.open();

									if (result == 0) {
										Model umlModel = functPart.getBase_Component().getModel();

										return deletePartitionAssignments(umlModel, functPart, domain);
									}
									// CANCEL
									if (result == 2) {
										CHESSProjectSupport.CHESS_CONSOLE.println(operationAborted.getMessage());
										// TODO why?
										//throw new RollbackException(operationAborted);
									}	

								}
							}
						}
					}
				}

				return null;					
			}

			//		}
			return null;
		}


		/**
		 * Delete all assignments that have the input functional partition 
		 * either in the To field (Component to Partition Assignment), or
		 * in the From field (Partition to ProcessorAssignment)
		 * and all the related nfpConstraints (if any)
		 * 
		 * @param umlModel
		 * @param functPart
		 * @param viewName
		 * @param domain
		 * @return
		 */
		private Command deletePartitionAssignments(Model umlModel, FunctionalPartition functPart, 
				TransactionalEditingDomain domain) {
			CompositeCommand cmd = new CompositeCommand("delPartitionAssignmentsCommand");

			//Delete all assignments to or from Partitions
			ArrayList<Comment> assignmentsToDel = new ArrayList<Comment>();
			ArrayList<Constraint> nfpConstraintsToDel = new ArrayList<Constraint>();
			try {
				for (Assign assignment : UMLUtils.getPartitionAssignments(umlModel , functPart)) {						
					Comment assignComment =assignment.getBase_Comment();										
					assignmentsToDel.add(assignComment);			
					if (assignment.getImpliedConstraint().size() > 0) {
						for (Object c : assignment.getImpliedConstraint().toArray()) {
							if (c instanceof NfpConstraint) {
								NfpConstraint n = (NfpConstraint) c;
								nfpConstraintsToDel.add(n.getBase_Constraint());									
							}
						}
					}
				}
			}
			catch (ModelError e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

			if (assignmentsToDel.size()>0) {
				for (int i = 0; i < assignmentsToDel.size(); i++) {
					IElementEditService provider = ElementEditServiceUtils
							.getCommandProvider(assignmentsToDel.get(i));
					if (provider == null) {
						continue;					
					}
					// Retrieve delete command from the Element Edit
					// service
					DestroyElementRequest request = new DestroyElementRequest(
							assignmentsToDel.get(i), false);
					ICommand deleteCommand = provider
							.getEditCommand(request);

					cmd.add(deleteCommand);				
				}
			}	

			if(nfpConstraintsToDel.size()>0) {
				for (int i = 0; i < nfpConstraintsToDel.size(); i++) {
					IElementEditService provider = ElementEditServiceUtils
							.getCommandProvider(nfpConstraintsToDel.get(i));
					if (provider == null) {
						continue;					
					}
					// Retrieve delete command from the Element Edit
					// service
					DestroyElementRequest request = new DestroyElementRequest(
							nfpConstraintsToDel.get(i), false);
					ICommand deleteCommand = provider
							.getEditCommand(request);

					cmd.add(deleteCommand);				
				}
			}

			if (!cmd.isEmpty())
				return new GMFtoEMFCommandWrapper(cmd);
			return null;

		}
	};


	// LB 20160517 for deleting automatically the PSM Package related to an saAnalysisContext that is being deleted
	/** The deletion of a saAnalysisContext action. */
	public static IAutomatedAction saAnalysisContextDeletionAction = new IAutomatedAction() {
		private IStatus operationAborted = new Status(IStatus.ERROR,
				Activator.PLUGIN_ID, Messages.operationAborted);

		@Override
		public Command compile(Notification notification,
				List<Notification> notificationList,
				TransactionalEditingDomain domain) throws RollbackException {
			
			PSMPackage psmPackageStereoToDelete = null;
			
			Object notifier = notification.getNotifier();
			
			Package psmPackageToDelete = null;
			org.eclipse.uml2.uml.Class oldAnalysisContextClass = null;
			
			Object feature = notification.getFeature();
			
			if (notifier instanceof SaAnalysisContext && notification.getNewValue()== null &&
						notification.getOldValue() instanceof org.eclipse.uml2.uml.Class && notification.getEventType() == Notification.SET
					&& (feature instanceof EReferenceImpl)	&& ((EReferenceImpl) feature).getName().equals("base_StructuredClassifier")
					
					){
				//check if there is a PSMPackage which refer this SaAnalysisContext 
				oldAnalysisContextClass = (org.eclipse.uml2.uml.Class) notification.getOldValue();
				
				PapyrusMultiDiagramEditor editor = (PapyrusMultiDiagramEditor) PlatformUI.getWorkbench().getActiveWorkbenchWindow()
						.getActivePage().getActiveEditor();
				
				Resource res = null;
				try {
					res = ResourceUtils.getUMLResource(editor.getServicesRegistry());
				} catch (ServiceException e) {
					CHESSProjectSupport.CHESS_CONSOLE.println("Unable to retrieve the UML resource via the Service Registry");
					e.printStackTrace();
					return null;
				}
				Model model =  ResourceUtils.getModel(res);
				
				
				CHESS chess =  (CHESS) model.getStereotypeApplication(model.getAppliedStereotype("CHESS::Core::CHESS"));
				
				PSMView psmView = chess.getPsmView();
				Package psmViewPkg = psmView.getBase_Package();
				
				for (Package p : psmViewPkg.getNestedPackages()){
					if (p.getAppliedStereotype("CHESS::Core::PSMPackage") != null){
						PSMPackage psmPackageStero = (PSMPackage) p.getStereotypeApplication(p.getAppliedStereotype("CHESS::Core::PSMPackage"));
						if (notifier.equals(psmPackageStero.getAnalysisContext())){
							psmPackageStereoToDelete = psmPackageStero;
							psmPackageToDelete = psmPackageStero.getBase_Package();
						}
					}
				}
			}
			
			// If the PSM Package related to this SaAnalysisContext does not exist (e.g. has been purged)
			if (psmPackageStereoToDelete == null) {
				return null;
			}
			
			String saAnalysisContextName = "";
			if(oldAnalysisContextClass.getName() != null) {
				saAnalysisContextName = oldAnalysisContextClass.getName();
			}
			String psmPackageName = "";
			if (psmPackageToDelete!= null && psmPackageToDelete.getName() != null) {
				psmPackageName = psmPackageToDelete.getName();
			}
	
			// Ask user if he is sure he wants to delete this saAnalysisContext
			// warning that the related PSM Package will be deleted
			PapyrusMultiDiagramEditor editor = CHESSEditorUtils.getCHESSEditor();																		

			if (editor == null) {							
				return null;
			}
			
			MessageDialog md = CHESSEditorUtils.showConfirmDialog(editor, "Confirm", 
					"Do you want to remove also the PSM Package: "+psmPackageName+" related to the SaAnalysisContext: "+saAnalysisContextName+" ?");

			int result = md.open();
			
			// OK
			if (result == 0) {
				Model umlModel = oldAnalysisContextClass.getModel();
				if (psmPackageToDelete != null) {
					Command cmd = deletePackage(umlModel, psmPackageToDelete);
					
					return cmd;
				}
				return null;
			}
			// CANCEL
			if (result == 2) {
				CHESSProjectSupport.CHESS_CONSOLE.println(operationAborted.getMessage());
				throw new RollbackException(operationAborted);
			}
			// NO
			if (result == 1) {
				return null;		
			}
			return null;					
		
		}


		/**
		 * Delete the given Package 
		 * (used to delete the PSM package related to a saAnalysisContext that was deleted)
		 * @param umlModel
		 * @param thePackage
		 * @return
		 */
		private Command deletePackage(Model umlModel, Package thePackage) {
			CompositeCommand cmd = new CompositeCommand("delPackageCommand");

			IElementEditService provider = ElementEditServiceUtils
					.getCommandProvider(thePackage);
			if (provider == null) {
				return null;					
			}
			// Retrieve delete command from the Element Edit
			// service
			DestroyElementRequest request = new DestroyElementRequest(
					thePackage, false);
			ICommand deleteCommand = provider
					.getEditCommand(request);

			cmd.add(deleteCommand);				

			if (!cmd.isEmpty())
				return new GMFtoEMFCommandWrapper(cmd);
			return null;

		}
	};


	//	public static IAutomatedAction[] actionList = {portModificationAction,
	//			portRemovalAction, componentInterfaceRealizationAction,
	//			componentRealizationAction, removeRealizationOperationsAction,
	//			propagateOperationModification, propagateInterfaceModification,
	//			propagateParameterRemovalAction, propagateParameterAdditionAction,
	//			commentAction, portAdditionAction, propagatePortModification};

	/** The static list of the actions that will be checked at run-time. */
	public static IAutomatedAction[] actionList = {portModificationAction,
		componentInterfaceRealizationAction, componentRealizationAction,
		commentAction, coreModificationAction, saAnalysisContextDeletionAction, partitionsModificationAction};

}