deprecated_plugins/org.eclipse.epf.diagramming/src/org/eclipse/epf/diagramming/base/actions/RefreshFromBaseAction.java

/**
 * 
 */
package org.eclipse.epf.diagramming.base.actions;

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

import org.eclipse.emf.ecore.EModelElement;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.edit.command.CopyCommand;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.emf.transaction.Transaction;
import org.eclipse.epf.diagram.core.DiagramCoreResources;
import org.eclipse.epf.diagram.core.bridge.ActivityDiagramAdapter;
import org.eclipse.epf.diagram.core.bridge.BridgeHelper;
import org.eclipse.epf.diagram.core.bridge.NodeAdapter;
import org.eclipse.epf.diagram.core.services.DiagramHelper;
import org.eclipse.epf.diagram.core.services.DiagramManager;
import org.eclipse.epf.diagram.model.util.GraphicalDataManager;
import org.eclipse.epf.diagramming.edit.parts.ActivityEditPart;
import org.eclipse.epf.library.edit.util.IDiagramManager;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.BreakdownElement;
import org.eclipse.epf.uma.GraphNode;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.UMASemanticModelBridge;
import org.eclipse.epf.uma.VariabilityElement;
import org.eclipse.epf.uma.VariabilityType;
import org.eclipse.gef.EditPart;
import org.eclipse.gef.GraphicalViewer;
import org.eclipse.gef.commands.Command;
import org.eclipse.gmf.runtime.diagram.ui.services.editpart.EditPartService;
import org.eclipse.gmf.runtime.notation.Diagram;
import org.eclipse.gmf.runtime.notation.Edge;
import org.eclipse.gmf.runtime.notation.Node;
import org.eclipse.gmf.runtime.notation.View;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.IObjectActionDelegate;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.uml2.uml.ActivityNode;
import org.eclipse.uml2.uml.ControlNode;
import org.eclipse.uml2.uml.NamedElement;
import org.eclipse.uml2.uml.ObjectNode;
import org.eclipse.uml2.uml.StructuredActivityNode;

/**
 * @author skannoor
 *
 */
public class RefreshFromBaseAction implements IObjectActionDelegate {

	private ActivityEditPart editPart;
	/**
	 * 
	 */
	public RefreshFromBaseAction() {
		// TODO Auto-generated constructor stub
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IObjectActionDelegate#setActivePart(org.eclipse.jface.action.IAction, org.eclipse.ui.IWorkbenchPart)
	 */
	public void setActivePart(IAction action, IWorkbenchPart targetPart) {
		// TODO Auto-generated method stub

	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IActionDelegate#run(org.eclipse.jface.action.IAction)
	 */
	public void run(IAction action) {
		// TODO Auto-generated method stub
		refreshFromBaseCommand.execute();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IActionDelegate#selectionChanged(org.eclipse.jface.action.IAction, org.eclipse.jface.viewers.ISelection)
	 */
	public void selectionChanged(IAction action, ISelection selection) {
		editPart = null;
		if (selection instanceof IStructuredSelection) {
			IStructuredSelection structuredSelection = (IStructuredSelection) selection;
			if (structuredSelection.size() == 1
					&& structuredSelection.getFirstElement() instanceof ActivityEditPart) {
				editPart = (ActivityEditPart) structuredSelection
						.getFirstElement();
			}
		}
		if(editPart != null){
			Diagram diagram = (Diagram)editPart.getModel();
			if(diagram != null){
				NodeAdapter adapter= BridgeHelper.getNodeAdapter(diagram.getElement());
				if(((VariabilityElement)adapter.getElement()).getVariabilityBasedOnElement() == null)
					action.setEnabled(false);

			}
		}else{
			action.setEnabled(false);
		}
	}
	
	/**
	 * Refresh base from previous graphical editor code.
	 * TODO: handle consumer (set)
	 * 
	 */
	private Command refreshFromBaseCommand = new Command(DiagramCoreResources.AbstractDiagramEditorrefreshfrombase) { //$NON-NLS-1$
		private ArrayList oldContent = new ArrayList();

		public void execute() {
			Diagram diagram = (Diagram) editPart.getModel();
			
			EditPart parent = editPart.getParent();
			// back up old diagram content
			//
			oldContent.clear();
			oldContent.addAll(diagram.getPersistedChildren());

			boolean refreshed = //DiagramHelper.refreshFromBase(diagram);
				refreshFromBase(diagram);
			if(!refreshed) return;
			
			if (editPart.isActive()) {
				editPart.deactivate();
			}
			//diagram.removeConsumer(this);
			//createEditPart();
			editPart = (ActivityEditPart)EditPartService.getInstance().createGraphicEditPart(diagram);
			editPart.setParent(parent);
			parent.getViewer().setContents(editPart);
		}

		public void undo() {
			Diagram diagram = (Diagram) editPart.getModel();
			diagram.getChildren().clear();
			diagram.getChildren().addAll(oldContent);
			if (editPart.isActive()) {
				editPart.deactivate();
			}
			//diagram.removeConsumer(this);
			editPart = (ActivityEditPart)EditPartService.getInstance().createGraphicEditPart(diagram);
			getGraphicalViewer().setContents(editPart);
			editPart.activate();
		}
	};
	
	private GraphicalViewer getGraphicalViewer(){
		return (GraphicalViewer)editPart.getRoot().getViewer();
	}
	
	public boolean refreshFromBase(Diagram diagram){
		
			Activity act = null;
			EObject model = diagram.getElement();
			if(model instanceof org.eclipse.uml2.uml.Activity){
				act = (Activity)BridgeHelper.getMethodElementFromAnnotation((EModelElement)model);
			}else if(model instanceof org.eclipse.epf.diagram.model.Diagram){
				act = (Activity)((org.eclipse.epf.diagram.model.Diagram)model).getLinkedElement();
			}
			if(act == null) return false;
			
			Activity base = (Activity)act.getVariabilityBasedOnElement();
			if(base == null 
					|| act.getVariabilityType() == 
						VariabilityType.LOCAL_REPLACEMENT_LITERAL ){
				return false;
			}
			int type = DiagramHelper.getDiagramType(diagram);
			
			Diagram baseDiagram = DiagramHelper.getBaseDiagram(act, type);
			if(baseDiagram == null) return false;
			
			List<EObject> oldNodes = new ArrayList<EObject>();
			Map<EObject, EObject> map = new HashMap<EObject, EObject>();
			
			Diagram baseCopy = DiagramHelper.copyDiagram(DiagramHelper.getEditingDomain(), baseDiagram);
//			Diagram baseCopy = null;
//			org.eclipse.emf.common.command.Command copyCommand = copyDiagram(DiagramHelper.getEditingDomain(), baseDiagram);
//			for (Iterator iter = copyCommand.getResult().iterator(); iter.hasNext();) {
//				Object element = (Object) iter.next();
//				if(element instanceof Diagram) {
//					baseCopy = (Diagram) element;
//				}
//			}
//			
//			if(baseCopy == null) return false;
			
			Transaction tx = DiagramHelper.getTransaction(diagram);
			
			switch(type){
			case IDiagramManager.ACTIVITY_DIAGRAM:{
				
				org.eclipse.uml2.uml.Activity umlActivity = (org.eclipse.uml2.uml.Activity)model;
				
				boolean notification = umlActivity.eDeliver();
				umlActivity.eSetDeliver(false);
				EObject umlObject;
				// Collect the base nodes that exists in extend diagram 
				for (Iterator iter = baseDiagram.getChildren().iterator(); iter.hasNext();) {
					Node baseNode = (Node) iter.next();
					umlObject = baseNode.getElement();
					if(umlObject instanceof StructuredActivityNode ||
							umlObject instanceof ObjectNode){
						MethodElement e = BridgeHelper.getMethodElementFromAnnotation((ActivityNode)umlObject);
						Node node =  DiagramHelper.findNode(diagram, e);
						if(node !=null){
							oldNodes.add(node);
							map.put(node, baseNode);
						}
					}
				}
				
				// Collect old UI nodes && nodes of contributor/replacer
				List children = diagram.getChildren();
				for (Iterator iter = children.iterator(); iter
						.hasNext();) {
					Node node = (Node) iter.next();
					EObject uml = node.getElement();
					if (uml instanceof ControlNode){
						if(BridgeHelper.isInherited(node)){
							oldNodes.add(node);
						}
					} else {
						if (uml instanceof ActivityNode) {
							MethodElement e = BridgeHelper.getMethodElement((NamedElement)uml);
							if (e instanceof Activity
									&& ((Activity) e)
											.getVariabilityBasedOnElement() != null) {
								oldNodes.add(node);
							}
						}
					}
				}
				
				//Collect the edges thats exists in extend diagram
				for (Iterator iter = diagram.getEdges().iterator(); iter.hasNext();) {
					Edge edge = (Edge) iter.next();
					if(oldNodes.contains(edge.getSource()) && 
							oldNodes.contains(edge.getTarget())){
						oldNodes.add(edge);
					}
				}
				
				// remove the old base nodes and edges that exists in the extend diagram.
				if(tx != null){
					for (Iterator iter = oldNodes.iterator(); iter.hasNext();) {
						View view = (View) iter.next();
						if(view instanceof Node){
							diagram.removeChild(view);
							umlActivity.getNodes().remove(view.getElement());
						}
						else if(view instanceof Edge){
							diagram.removeEdge((Edge)view);
							umlActivity.getEdges().remove(view.getElement());
						}
					}
				}
				
				// replace associated base element with contributing/replacing
				// element
				//
				for (Iterator iter = act.getBreakdownElements().iterator(); iter
						.hasNext();) {
					Object element = iter.next();
					if (element instanceof Activity) {
						VariabilityElement baseElement = ((Activity) element)
								.getVariabilityBasedOnElement();
						if(baseElement != null){
							Node node = DiagramHelper.findNode(baseCopy, baseElement);
							if (node != null) {
								EObject umlObj = node.getElement();
								BridgeHelper.addEAnnotation((EModelElement)umlObj, (MethodElement)element);
							}
						}
					}
				}
				// Mark inherited 
				List copyChildren = baseCopy.getChildren();
				int size = copyChildren.size();		
				for (int i = 0; i < size; i++) {
					Object obj = copyChildren.get(i);
					if(obj instanceof View){
						View view = (View) obj;
						BridgeHelper.markInherited(view);
					}
				}
				// 	Add all news from base copy to extend diagram.
				org.eclipse.uml2.uml.Activity umlBaseCopy = (org.eclipse.uml2.uml.Activity)baseCopy.getElement();
				diagram.getPersistedChildren().addAll(baseCopy.getPersistedChildren());
				diagram.getPersistedEdges().addAll(baseCopy.getPersistedEdges());
				umlActivity.getNodes().addAll(umlBaseCopy.getNodes());
				umlActivity.getEdges().addAll(umlBaseCopy.getEdges());
				
				// TODO: handle the missed links.
				
				ActivityDiagramAdapter adapter = (ActivityDiagramAdapter)BridgeHelper.getNodeAdapter(umlActivity);
				adapter.populateDiagram();
				
				// reset the notification.
				umlActivity.eSetDeliver(notification);
				
				break;
			}
			default: {


				for (Iterator iter = baseDiagram.getChildren().iterator(); iter
						.hasNext();) {
					Node baseNode = (Node)iter.next();
					EObject element = baseNode.getElement();
					if(element instanceof org.eclipse.epf.diagram.model.NamedNode){
						MethodElement e = ((org.eclipse.epf.diagram.model.Node)element).getLinkedElement();
						Node node = DiagramHelper.findNodeInADD(diagram, e);
						if(node != null){
							oldNodes.add(node);
						}
					}
				}

				// remove old nodes
				//
				for (Iterator iter = oldNodes.iterator(); iter.hasNext();) {
					View view = (View) iter.next();
					if(view instanceof Node){
						diagram.removeChild(view);
					}
					else if(view instanceof Edge){
						diagram.removeEdge((Edge)view);
					}
				}
				
				// add new nodes
				//
				diagram.getPersistedChildren().addAll(baseCopy.getPersistedChildren());
				diagram.getPersistedEdges().addAll(baseCopy.getPersistedEdges());


				break;

				
			}
			
			}
			try{
				//diagram.eResource().save(null);
				}catch(Exception e){
					
				}
			if(tx != null){
				DiagramHelper.commitTransaction(tx);
			}
			
		return true;
	}
	
	public static org.eclipse.emf.common.command.Command copyDiagram(EditingDomain domain, Diagram diagram) {
		ArrayList list = new ArrayList();
		list.add(diagram.getElement());
		list.add(diagram);
		org.eclipse.emf.common.command.Command cmd = CopyCommand.create(domain, list);
		cmd.execute();
//		for (Iterator iter = cmd.getResult().iterator(); iter.hasNext();) {
//			Object element = (Object) iter.next();
//			if(element instanceof Diagram) {
//				return (Diagram) element;
//			}
//		}
		return cmd;
		//return null;
	}
}