//------------------------------------------------------------------------------
// Copyright (c) 2005, 2007 IBM Corporation and others.
// 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-v10.html
//
// Contributors:
// IBM Corporation - initial implementation
//------------------------------------------------------------------------------
/**
 * 
 */
package org.eclipse.epf.diagram.core.actions;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
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.ecore.resource.ResourceSet;
import org.eclipse.emf.edit.command.CopyCommand;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.emf.transaction.util.TransactionUtil;
import org.eclipse.epf.diagram.core.DiagramCorePlugin;
import org.eclipse.epf.diagram.core.DiagramCoreResources;
import org.eclipse.epf.diagram.core.bridge.BridgeHelper;
import org.eclipse.epf.diagram.core.bridge.DiagramAdapter;
import org.eclipse.epf.diagram.core.bridge.NodeAdapter;
import org.eclipse.epf.diagram.core.part.AbstractDiagramEditor;
import org.eclipse.epf.diagram.core.part.util.DiagramEditorUtil;
import org.eclipse.epf.diagram.core.services.DiagramHelper;
import org.eclipse.epf.diagram.core.services.DiagramService;
import org.eclipse.epf.diagram.model.impl.NodeImpl;
import org.eclipse.epf.diagram.model.util.TxUtil;
import org.eclipse.epf.library.edit.util.IDiagramManager;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.MethodElement;
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.editparts.DiagramEditPart;
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.ActivityEdge;
import org.eclipse.uml2.uml.ActivityNode;
import org.eclipse.uml2.uml.ObjectNode;
import org.eclipse.uml2.uml.StructuredActivityNode;

/**
 * Action to refresh the latest changes from base activity diagram into 
 * extend's Activity diagram. Action will keep the existing immediate children's 
 * information of extend diagram, only refresh the base diagram's related information.
 *  
 * @author Shashidhar Kannoori
 * @author Phong Nguyen Le
 */
public class RefreshFromBaseAction implements IObjectActionDelegate {

	private EditPart editPart;
	private IWorkbenchPart targetPart;
	/**
	 * 
	 */
	public RefreshFromBaseAction() {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IObjectActionDelegate#setActivePart(org.eclipse.jface.action.IAction, org.eclipse.ui.IWorkbenchPart)
	 */
	public void setActivePart(IAction action, IWorkbenchPart targetPart) {
		this.targetPart = targetPart;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IActionDelegate#run(org.eclipse.jface.action.IAction)
	 */
	public void run(IAction action) {
		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 EditPart) {
				editPart = (EditPart) structuredSelection
						.getFirstElement();
			}
		}
		if(editPart != null){
			action.setChecked(false);
			// Check if diagram readonly.
			if(editPart instanceof DiagramEditPart){
				if(!((DiagramEditPart)editPart).isEditModeEnabled()){
					action.setEnabled(false);
					return;
				}
			}

			// Checked variability 
			Diagram diagram = (Diagram)editPart.getModel();
			EObject model = diagram.getElement();
			Activity e = null;
			if(model instanceof org.eclipse.uml2.uml.Activity){
				e = (Activity)BridgeHelper.getMethodElement((EModelElement)model);
			}else if(model instanceof org.eclipse.epf.diagram.model.Diagram){
				e = (Activity)((org.eclipse.epf.diagram.model.Diagram)model).getLinkedElement();
			}
			if(e != null){
				if(e instanceof Activity){
					if(((Activity)e).getVariabilityBasedOnElement() == null
							|| (((Activity)e).getVariabilityBasedOnElement() != null
							&& ((Activity)e).getVariabilityType() != VariabilityType.EXTENDS)){
						action.setEnabled(false);
						return;
					}
				}

			}
		}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 = (EditPart)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 = (EditPart)EditPartService.getInstance().createGraphicEditPart(diagram);
			getGraphicalViewer().setContents(editPart);
			editPart.activate();
		}
	};
	
	private GraphicalViewer getGraphicalViewer(){
		return (GraphicalViewer)editPart.getRoot().getViewer();
	}
	
	public boolean refreshFromBase(final Diagram diagram) {
		final boolean[] resultHolder = new boolean[1];
		try {
			TxUtil.runInTransaction(diagram, new Runnable() {

				public void run() {
					resultHolder[0] = doRefreshFromBase(diagram);
				}
				
			});			
		} catch (Exception e) {
			DiagramCorePlugin.getDefault().getLogger().logError(e);
		}
		return resultHolder[0];
	}
	
	public boolean refreshFromBase(final Diagram diagram, final Activity activity) {
		final boolean[] resultHolder = new boolean[1];
		try {
			TxUtil.runInTransaction(diagram, new Runnable() {

				public void run() {
					resultHolder[0] = doRefreshFromBase(diagram, activity);
				}
				
			});			
		} catch (Exception e) {
			DiagramCorePlugin.getDefault().getLogger().logError(e);
		}
		return resultHolder[0];
	}

	private static interface IDiagramAssociationHelper {
		/**
		 * Gets the {@link MethodElement} that the given {@link Node} represents.
		 * 
		 * @param node
		 * @param resourceSet the resource set of the library
		 * @return
		 */
		MethodElement getMethodElement(Node node, ResourceSet resourceSet);
		
		/**
		 * Finds in the given diagram the node that represents the given {@link MethodElement}.
		 *  
		 * @param diagram
		 * @param e
		 * @return
		 */
		Node findNode(Diagram diagram, MethodElement e);
				
		/**
		 * Re-associates activity nodes in the base diagram copy with corresponding
		 * locally contributors or replacers if there is any.
		 * 
		 * @param activity
		 * @param copyOfBaseDiagram
		 */
		void reassociate(Activity activity, Diagram copyOfBaseDiagram);
		
		void addNodeModels(EObject diagramModel, Collection<?> nodeModels);
		
		void addEdgeModels(EObject diagramModel, Collection<?> edgeModels);
		
		void removeNodeModel(EObject diagramModel, EObject nodeModel);
		
		void removeEdgeModel(EObject diagramModel, EObject edgeModel);

		Collection<?> getNodeModels(EObject element);

		Collection<?> getEdgeModels(EObject element);
	}
	
	private static final IDiagramAssociationHelper ADAssociationHelper = new IDiagramAssociationHelper() {

		public Node findNode(Diagram diagram, MethodElement e) {
			return DiagramHelper.findNode(diagram, e);
		}

		public MethodElement getMethodElement(Node node, ResourceSet resourceSet) {
			EObject umlObject = node.getElement();
			if (umlObject instanceof StructuredActivityNode
					|| umlObject instanceof ObjectNode) {
				MethodElement e = BridgeHelper
						.getMethodElement((ActivityNode) umlObject);
				if (e == null && resourceSet != null) {
					// base diagram is not open, try to get from
					// annotation
					//
					e = BridgeHelper
							.getMethodElementFromAnnotation(
									(EModelElement) umlObject, resourceSet);
				}
				return e;
			}
			return null;
		}

		public void reassociate(Activity activity, Diagram copyOfBaseDiagram) {
			DiagramHelper.reassociate(activity, copyOfBaseDiagram);
		}

		public void addEdgeModels(EObject diagramModel, Collection<?> edgeModels) {
			if(!(diagramModel instanceof org.eclipse.uml2.uml.Activity)) {
				return;
			}
			DiagramAdapter diagramAdapter = BridgeHelper.getDiagramAdapter(diagramModel);
			boolean oldNotify = false;
			if(diagramAdapter != null) {
				oldNotify = diagramAdapter.isNotificationEnabled();
				diagramAdapter.setNotificationEnabled(false);
			}
			try {
				((org.eclipse.uml2.uml.Activity) diagramModel).getEdges().addAll((Collection<? extends ActivityEdge>) edgeModels);
			}
			finally {
				if(diagramAdapter != null) {
					diagramAdapter.setNotificationEnabled(oldNotify);
				}
			}
		}

		public void addNodeModels(EObject diagramModel, Collection<?> nodeModels) {
			if(!(diagramModel instanceof org.eclipse.uml2.uml.Activity)) {
				return;
			}
			DiagramAdapter diagramAdapter = BridgeHelper.getDiagramAdapter(diagramModel);
			boolean oldNotify = false;
			if(diagramAdapter != null) {
				oldNotify = diagramAdapter.isNotificationEnabled();
				diagramAdapter.setNotificationEnabled(false);
			}
			try {
				((org.eclipse.uml2.uml.Activity) diagramModel).getNodes().addAll((Collection<? extends ActivityNode>) nodeModels);
			}
			finally {
				if(diagramAdapter != null) {
					diagramAdapter.setNotificationEnabled(oldNotify);
				}
			}
		}

		public void removeEdgeModel(EObject diagramModel, EObject edgeModel) {
			if(!(diagramModel instanceof org.eclipse.uml2.uml.Activity)) {
				return;
			}
			DiagramAdapter diagramAdapter = BridgeHelper.getDiagramAdapter(diagramModel);
			boolean oldNotify = false;
			if(diagramAdapter != null) {
				oldNotify = diagramAdapter.isNotificationEnabled();
				diagramAdapter.setNotificationEnabled(false);
			}
			try {
				((org.eclipse.uml2.uml.Activity) diagramModel).getEdges().remove(edgeModel);
			}
			finally {
				if(diagramAdapter != null) {
					diagramAdapter.setNotificationEnabled(oldNotify);
				}
			}
		}

		public void removeNodeModel(EObject diagramModel, EObject nodeModel) {
			if(!(diagramModel instanceof org.eclipse.uml2.uml.Activity)) {
				return;
			}
			DiagramAdapter diagramAdapter = BridgeHelper.getDiagramAdapter(diagramModel);
			boolean oldNotify = false;
			if(diagramAdapter != null) {
				oldNotify = diagramAdapter.isNotificationEnabled();
				diagramAdapter.setNotificationEnabled(false);
			}
			try {
				((org.eclipse.uml2.uml.Activity) diagramModel).getNodes().remove(nodeModel);
			}
			finally {
				if(diagramAdapter != null) {
					diagramAdapter.setNotificationEnabled(oldNotify);
				}
			}
		}

		public Collection<?> getEdgeModels(EObject element) {
			if(element instanceof org.eclipse.uml2.uml.Activity) {
				return ((org.eclipse.uml2.uml.Activity) element).getEdges();
			}
			return Collections.EMPTY_LIST;
		}

		public Collection<?> getNodeModels(EObject element) {
			if(element instanceof org.eclipse.uml2.uml.Activity) {
				return ((org.eclipse.uml2.uml.Activity) element).getNodes();
			}
			return Collections.EMPTY_LIST;
		}

	};
	
	private static final IDiagramAssociationHelper diagramAssociationHelper = new IDiagramAssociationHelper() {

		public Node findNode(Diagram diagram, MethodElement e) {
			return DiagramHelper.findNodeInModelDiagram(diagram, e);
		}

		public MethodElement getMethodElement(Node node, ResourceSet resourceSet) {
			EObject element = node.getElement();
			return element instanceof org.eclipse.epf.diagram.model.Node? 
					((org.eclipse.epf.diagram.model.Node) element).getLinkedElement() : null;
		}

		public void reassociate(Activity activity, Diagram copyOfBaseDiagram) {
			// TODO Auto-generated method stub
			
		}
		
		public void addNodeModels(EObject diagramModel, Collection<?> nodeModels) {
			if(!(diagramModel instanceof org.eclipse.epf.diagram.model.Diagram)) {
				return;
			}
			org.eclipse.epf.diagram.model.Diagram diagram = (org.eclipse.epf.diagram.model.Diagram) diagramModel;
			boolean oldNotify = ((NodeImpl)diagram).isNotificationEnabled();
			try {
				((NodeImpl)diagram).setNotificationEnabled(false);
				diagram.getNodes().addAll((Collection<? extends org.eclipse.epf.diagram.model.Node>) nodeModels);
			}
			finally {
				((NodeImpl)diagram).setNotificationEnabled(oldNotify);
			}
		}

		public void addEdgeModels(EObject diagramModel, Collection<?> edgeModels) {
			//
		}

		public void removeEdgeModel(EObject diagramModel, EObject edgeModel) {
		}

		public void removeNodeModel(EObject diagramModel, EObject nodeModel) {
			if(!(diagramModel instanceof org.eclipse.epf.diagram.model.Diagram)) {
				return;
			}
			org.eclipse.epf.diagram.model.Diagram diagram = (org.eclipse.epf.diagram.model.Diagram) diagramModel;
			boolean oldNotify = ((NodeImpl)diagram).isNotificationEnabled();
			try {
				((NodeImpl)diagram).setNotificationEnabled(false);
				diagram.getNodes().remove(nodeModel);
			}
			finally {
				((NodeImpl)diagram).setNotificationEnabled(oldNotify);
			}
		}

		public Collection<?> getEdgeModels(EObject element) {
			return Collections.EMPTY_LIST;
		}

		public Collection<?> getNodeModels(EObject element) {
			if(element instanceof org.eclipse.epf.diagram.model.Diagram) {
				return ((org.eclipse.epf.diagram.model.Diagram) element).getNodes();
			}
			return Collections.EMPTY_LIST;
		}
		
	};
	
	/**
	 * Checks if the given node is one of the specified nodes or their children.
	 * 
	 * @param nodes
	 * @param node
	 */
	private static boolean contains(Collection<?> nodes, View node) {
		if(nodes.contains(node)) {
			return true;
		}
		for (Object child : nodes) {
			if(child instanceof Node && contains(((Node) child).getChildren(), node)) {
				return true;
			}
		}
		return false;
	}
	
	private boolean doRefreshFromBase(Diagram diagram) {
		Activity act = null;
		EObject model = diagram.getElement();
		if (model instanceof org.eclipse.uml2.uml.Activity) {
			act = (Activity) BridgeHelper
					.getMethodElement((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;
		
		return doRefreshFromBase(diagram, act);
		
	}
	
	private boolean doRefreshFromBase(Diagram diagram, Activity act) {
		EObject model = diagram.getElement();
		Activity base = (Activity) act.getVariabilityBasedOnElement();
		if (base == null
				|| act.getVariabilityType() == VariabilityType.LOCAL_REPLACEMENT) {
			return false;
		}
		int type = DiagramHelper.getDiagramType(diagram);
		DiagramService diagramSvc = new DiagramService();
		try {
			Diagram baseDiagram = diagramSvc.getBaseDiagram(act, type);
			if (baseDiagram == null)
				return false;

			Collection<Node> oldNodes = new HashSet<Node>();
			Collection<Edge> oldEdges = new HashSet<Edge>();
			Diagram baseCopy = DiagramHelper.copyDiagram(TransactionUtil
					.getEditingDomain(diagram), baseDiagram);
			
			IDiagramAssociationHelper helper = type == IDiagramManager.ACTIVITY_DIAGRAM ? ADAssociationHelper
					: diagramAssociationHelper; 
			
			boolean notification = model.eDeliver();
			try {
//				model.eSetDeliver(false);
				ResourceSet resourceSet = base.eResource().getResourceSet();
				// Collect the base nodes that exist in extend diagram
				for (Iterator<?> iter = baseDiagram.getChildren().iterator(); iter
						.hasNext();) {
					Node baseNode = (Node) iter.next();
					MethodElement e = helper.getMethodElement(baseNode, resourceSet);
					if (e != null) {
						Node node = helper.findNode(diagram, e);
						if (node != null) {
							oldNodes.add(node);
						}
					}
				}

				// Collect old inherited UI nodes && nodes of
				// contributor/replacer
				List<?> children = diagram.getChildren();
				for (Iterator<?> iter = children.iterator(); iter.hasNext();) {
					Node node = (Node) iter.next();
					if (BridgeHelper.isInherited(node)) {
						oldNodes.add(node);
					} else {
						MethodElement e = helper.getMethodElement(node, resourceSet);
						if (e instanceof Activity
								&& ((Activity) e).getVariabilityBasedOnElement() != null) {
							// node is of contributor or replacer
							//
							oldNodes.add(node);
						}
					}
				}
				
				Map<MethodElement, Edge> targetToCustomLinkMap = new HashMap<MethodElement, Edge>();
				// Collect the edges thats exists in extend diagram
				for (Iterator<?> iter = diagram.getEdges().iterator(); iter
						.hasNext();) {
					Edge edge = (Edge) iter.next();
					if (contains(oldNodes, edge.getTarget())) {
						if(contains(oldNodes, edge.getSource())) {
							oldEdges.add(edge);
						} else { // must be custom connection
							MethodElement e = helper.getMethodElement((Node) edge.getTarget(), resourceSet);
							targetToCustomLinkMap.put(e, edge);
						}
					}
				}

				// remove the old base nodes and edges that exists in the
				// extend diagram.
				for (Node node : oldNodes) {
					diagram.removeChild(node);
					helper.removeNodeModel(model, node.getElement());
				}
				for (Edge edge : oldEdges) {
					diagram.removeEdge(edge);
					helper.removeEdgeModel(model, edge.getElement());
					edge.setSource(null);
					edge.setTarget(null);
				}

				// replace associated base element with
				// contributing/replacing
				// element
				//
				helper.reassociate(act, baseCopy);

				// Mark inherited
				for (Object obj : baseCopy.getChildren()) {
					View child = (View) obj;
					BridgeHelper.markInherited(child);
					if(child instanceof Node) {
						MethodElement e = helper.getMethodElement((Node) child, resourceSet);
						if(e != null) {
							Edge edge = targetToCustomLinkMap.get(e);
							if(edge != null) {
								// update custom edge with new copy of target from base
								edge.setTarget(child);
								Object edgeModel = edge.getElement();
								if(edgeModel instanceof ActivityEdge && child.getElement() instanceof ActivityNode) {
									ActivityEdge actEdge = (ActivityEdge) edgeModel;
									// disable notification for node adapter of
									// the old target so associated work order
									// will not be removed
									ActivityNode oldTarget = actEdge.getTarget();
									NodeAdapter nodeAdapter = BridgeHelper.getNodeAdapter(oldTarget);
									boolean notify = false;
									if(nodeAdapter != null) {
										notify = nodeAdapter.isNotificationEnabled();
										nodeAdapter.setNotificationEnabled(false);
									}
									try {
										((ActivityEdge) edgeModel).setTarget((ActivityNode) child.getElement());
									} finally {
										if(nodeAdapter != null) {
											nodeAdapter.setNotificationEnabled(notify);
										}
									}
								}
							}
						}
					}
				}
				for (Object obj : baseCopy.getEdges()) {
					BridgeHelper.markInherited((View) obj);
				}
				
				// Add all new nodes and edges from base copy to extend diagram.
				//
				diagram.getPersistedChildren().addAll(
						baseCopy.getChildren());
				diagram.getPersistedEdges().addAll(
						baseCopy.getEdges());
				Collection<?> baseNodeModels = helper.getNodeModels(baseCopy.getElement());
				if(baseNodeModels != null && !baseNodeModels.isEmpty()) {
					helper.addNodeModels(model, baseNodeModels);
				}					
				Collection<?> baseEdgeModels = helper.getEdgeModels(baseCopy
						.getElement());
				if (baseEdgeModels != null && !baseEdgeModels.isEmpty()) {
					helper.addEdgeModels(model, baseEdgeModels);
				}
				
				// TODO: handle the missed links.

				// ActivityDiagramAdapter adapter =
				// (ActivityDiagramAdapter)BridgeHelper.getNodeAdapter(umlActivity);
				// adapter.populateDiagram();
				// if(targetPart instanceof AbstractDiagramEditor){
				// DiagramEditorUtil.resetEditor((AbstractDiagramEditor)targetPart);
				// }
			} finally {
				// reset the notification.
				model.eSetDeliver(notification);
			}

			try {
				if (targetPart instanceof AbstractDiagramEditor) {
					DiagramEditorUtil
							.resetEditor((AbstractDiagramEditor) targetPart);
				}
				// diagram.eResource().save(null);
			} catch (Exception e) {

			}
		} finally {
			diagramSvc.dispose();
		}
		return true;
	}
	
	public void initialize(){
		if(targetPart instanceof AbstractDiagramEditor){
			AbstractDiagramEditor editor = (AbstractDiagramEditor)targetPart;
			DiagramEditPart part = editor.getDiagramEditPart();
			
		}
		
	}
}