//------------------------------------------------------------------------------
// Copyright (c) 2005, 2006 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.Iterator;
import java.util.List;

import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.emf.transaction.impl.InternalTransactionalEditingDomain;
import org.eclipse.epf.diagram.core.DiagramCoreResources;
import org.eclipse.epf.diagram.core.commands.ChangeBoundsCommand;
import org.eclipse.epf.diagram.core.commands.ReconnectLinkCommand;
import org.eclipse.epf.diagram.core.util.DiagramCoreUtil;
import org.eclipse.gef.DefaultEditDomain;
import org.eclipse.gef.EditPart;
import org.eclipse.gef.GraphicalViewer;
import org.eclipse.gef.commands.CommandStack;
import org.eclipse.gef.editparts.AbstractGraphicalEditPart;
import org.eclipse.gef.ui.actions.ActionRegistry;
import org.eclipse.gef.ui.actions.GEFActionConstants;
import org.eclipse.gmf.runtime.diagram.core.util.ViewUtil;
import org.eclipse.gmf.runtime.diagram.ui.actions.ActionIds;
import org.eclipse.gmf.runtime.diagram.ui.editparts.ConnectionNodeEditPart;
import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramEditPart;
import org.eclipse.gmf.runtime.diagram.ui.editparts.ShapeNodeEditPart;
import org.eclipse.gmf.runtime.notation.Edge;
import org.eclipse.gmf.runtime.notation.Node;
import org.eclipse.gmf.runtime.notation.NotationPackage;
import org.eclipse.gmf.runtime.notation.View;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;

/**
 * Service class to allow create and register common actions to the action
 * register. Code is migrate from old method of diagramming.
 * 
 * @author Shashidhar Kannoori
 * @since 1.2
 */
public class DiagramActionsService {

	public static final String ALIGN_HORZ_AVERAGE = "align_horizontal_to_average"; //$NON-NLS-1$

	public static final String ALIGN_HORZ_FIRST_SELECTED = "align_horizontal_to_first_selection"; //$NON-NLS-1$

	public static final String ALIGN_VERT_AVERAGE = "align_vertical_to_average"; //$NON-NLS-1$

	public static final String ALIGN_VERT_FIRST_SELECTED = "align_vertical_to_first_selection"; //$NON-NLS-1$

	private DefaultEditDomain editDomain;

	private GraphicalViewer graphicalViewer;

	private ActionRegistry actionRegistry;
	
	private InternalTransactionalEditingDomain transactionDomain;

	/**
	 * Constructor 
	 * @param graphicalViewer {@link GraphicalViewer}
	 * @param editDomain 	{@link DefaultEditDomain}
	 * @param actionRegistry 	{@link ActionRegistry}
	 */
	public DiagramActionsService(InternalTransactionalEditingDomain transactionDomain, GraphicalViewer graphicalViewer,
			DefaultEditDomain editDomain, ActionRegistry actionRegistry) {
		this.transactionDomain = transactionDomain;
		this.graphicalViewer = graphicalViewer;
		this.editDomain = editDomain;
		this.actionRegistry = actionRegistry;
	}

	/**
	 * Sets the GraphicalViewer.
	 */
	public void setGraphicalViewer(GraphicalViewer graphicalViewer) {
		this.graphicalViewer = graphicalViewer;
	}

	/**
	 * returns GraphicalViewer
	 */
	private GraphicalViewer getGraphicalViewer() {
		return graphicalViewer;
	}

	/**
	 * Returns the command stack.
	 * 
	 * @return the command stack
	 */
	protected CommandStack getCommandStack() {
		return getEditDomain().getCommandStack();
	}

	/**
	 * Returns the edit domain.
	 * 
	 * @return the edit domain
	 */
	protected DefaultEditDomain getEditDomain() {
		return editDomain;
	}

	protected ActionRegistry getActionRegistry() {
		return actionRegistry;
	}

	/**
	 * Register HorizontalAlignAverageAction action. 
	 * HorizontalAignAverage Action aligns selected editparts to horizontal average.  
	 */
	public IAction registerHorizontalAlignAverageAction() {
		// align horizontally to average y-value of all nodes
		IAction hAlignAverageAction = new Action(
				DiagramCoreResources.AbstractDiagramEditor_hAlignAverageAction_text) { //$NON-NLS-1$
			public void run() {
				horizAlignToAverageSelected();
			}

			public String getId() {
				return ALIGN_HORZ_AVERAGE;
			}
		};
		getActionRegistry().registerAction(hAlignAverageAction);

		return hAlignAverageAction;
	}
	
	/**
	 * Register HorizontalAlignFirstSelectedAction action. 
	 * HorizontalAlignFirstSelectedAction aligns selected editparts with 
	 * respect to first selected editpart. 
	 */

	public IAction registerHorizontalAlignFirstSelectedAction() {
		// align horizontally to y-value of first selected node
		IAction hAlignFirstSelectedAction = new Action(
				DiagramCoreResources.AbstractDiagramEditor_hAlignFirstSelectedAction_text) { //$NON-NLS-1$
			public void run() {
				horzAlignToFirstSelected();
			}

			public String getId() {
				return ALIGN_HORZ_FIRST_SELECTED;
			}
		};
		getActionRegistry().registerAction(hAlignFirstSelectedAction);

		return hAlignFirstSelectedAction;
	}
	
	/**
	 * Register vertialAlignAverageAction action. 
	 * vertialAlignAverageAction aligns selected editparts vertically w.r.t average.
	 * 
	 */
	
	public IAction registerVerticalAlignAverageAction() {
		// align vertically to average x-value of all selected nodes
		IAction vAlignAverageAction = new Action(
				DiagramCoreResources.AbstractDiagramEditor_vAlignAverageAction_text) { //$NON-NLS-1$
			public void run() {
				verticalAlignToAverageSelected();
			}

			public String getId() {
				return ALIGN_VERT_AVERAGE;
			}
		};
		getActionRegistry().registerAction(vAlignAverageAction);

		return vAlignAverageAction;
	}

	/**
	 * Register vertialAlignFirstSelectedAction action. 
	 * vertialAlignFirstSelectedAction aligns selected editparts vertically w.r.t first selected.
	 * 
	 */

	public IAction registerVerticalAlignFirstSelectedAction() {
		// align vertically to x-value of first selected node
		IAction vAlignFirstSelectedAction = new Action(
				DiagramCoreResources.AbstractDiagramEditor_vAlignFirstSelectedAction_text) { //$NON-NLS-1$
			public void run() {
				verticalAlignToFirstSelected();
			}

			public String getId() {
				return ALIGN_VERT_FIRST_SELECTED;
			}
		};
		getActionRegistry().registerAction(vAlignFirstSelectedAction);

		return vAlignFirstSelectedAction;
	}

	// /////////////////////////////////////////////////////////////////////////////////////////////////
	// action methods
	// /////////////////////////////////////////////////////////////////////////////////////////////////
	
	/** 
	 * Action implementation method for horizontalAlignFirsteSElectedAction.
	 * 
	 */
	public void horzAlignToFirstSelected() {
		List editParts = getGraphicalViewer().getSelectedEditParts();
		AbstractGraphicalEditPart firstPart = null;
		// loop through all selected items, remember the y-value of the
		// first node,
		// set the following nodes to the same y-value
		for (int a = 0; a < editParts.size(); a++) {
			if (editParts.get(a) instanceof ShapeNodeEditPart) {
				AbstractGraphicalEditPart ep = (AbstractGraphicalEditPart) editParts
						.get(a);
				// remember the first part we move
				if (firstPart == null) {
					firstPart = ep;
				} else {
					// calculate the offset for centerline alignment
					Rectangle bounds = ep.getFigure().getBounds();
					int offset = (int) ((double) (bounds.height - firstPart
							.getFigure().getBounds().height) / 2.0);
					// is this node in a container?
					if (!(ep.getParent() instanceof DiagramEditPart)) {
						// need to move the container, adjust the offset
						ep = (AbstractGraphicalEditPart) ep.getParent();
						Rectangle parentBounds = ep.getFigure().getBounds();
						offset += bounds.y - parentBounds.y;
						bounds = parentBounds;
					}
					// send the command to move the node
					org.eclipse.gef.commands.Command c = new ChangeBoundsCommand(transactionDomain,
							(Node) ep.getModel(), new Point(bounds.x, firstPart
									.getFigure().getBounds().y
									- offset), bounds.width, -1);
					getCommandStack().execute(c);
				}
			}
		}
	}
	
	/** 
	 * Action implementation method for horizontalAlignAverageAction.
	 * 
	 */
	public void horizAlignToAverageSelected() {
		List editParts = getGraphicalViewer().getSelectedEditParts();
		AbstractGraphicalEditPart firstPart = null;
		int total = 0;
		int ysum = 0;
		for (int a = 0; a < editParts.size(); a++) {
			if (editParts.get(a) instanceof ShapeNodeEditPart) {
				AbstractGraphicalEditPart ep = (AbstractGraphicalEditPart) editParts
						.get(a);
				// remember the first part we move
				if (firstPart == null) {
					firstPart = ep;
				}
				ysum += ep.getFigure().getBounds().y;
				total++;
			}
		}
		// calculate the average y-value for all nodes
		int yave = (int) ((double) ysum / (double) total);
		// loop through all the nodes again and set them
		for (int a = 0; a < editParts.size(); a++) {
			if (editParts.get(a) instanceof ShapeNodeEditPart) {
				AbstractGraphicalEditPart ep = (AbstractGraphicalEditPart) editParts
						.get(a);
				// calculate the height difference, so that elements are aligned
				// through the centerline
				Rectangle bounds = ep.getFigure().getBounds();
				int offset = (int) ((double) (bounds.height - firstPart
						.getFigure().getBounds().height) / 2.0);
				// is this node inside a container?
				if (!(ep.getParent() instanceof DiagramEditPart)) {
					// we need to move the container, adjust the offset
					ep = (AbstractGraphicalEditPart) ep.getParent();
					Rectangle parentBounds = ep.getFigure().getBounds();
					offset += bounds.y - parentBounds.y;
					bounds = parentBounds;
				}
				// send the command to move the node
				org.eclipse.gef.commands.Command c = new ChangeBoundsCommand(transactionDomain,
						(Node) ep.getModel(),
						new Point(bounds.x, yave - offset), bounds.width, -1);
				getCommandStack().execute(c);
			}
		}

	}
	/** 
	 * Action implementation method for verticalAlignToAverageAction.
	 * 
	 */

	public void verticalAlignToAverageSelected() {
		List editParts = getGraphicalViewer().getSelectedEditParts();
		AbstractGraphicalEditPart firstPart = null;
		int total = 0;
		int xsum = 0;
		// loop through the selected parts
		for (int a = 0; a < editParts.size(); a++) {
			// we are only interested in nodes and containers
			if (editParts.get(a) instanceof ShapeNodeEditPart) {
				AbstractGraphicalEditPart ep = (AbstractGraphicalEditPart) editParts
						.get(a);
				if (firstPart == null) {
					firstPart = ep;
				}
				// sum the x coordinates of each element
				xsum += ep.getFigure().getBounds().x;
				// remember how many selected elements applied to this operation
				total++;
			}
		}
		// calculate the average x-value for all nodes
		int xave = (int) ((double) xsum / (double) total);
		// loop through all the nodes again and set them
		for (int a = 0; a < editParts.size(); a++) {
			if (editParts.get(a) instanceof ShapeNodeEditPart) {
				AbstractGraphicalEditPart ep = (AbstractGraphicalEditPart) editParts
						.get(a);
				// calculate the offset for centerline alignment
				Rectangle bounds = ep.getFigure().getBounds();
				int offset = (int) ((double) (bounds.width - firstPart
						.getFigure().getBounds().width) / 2.0);
				// are we inside a container?
				if (!(ep.getParent() instanceof DiagramEditPart)) {
					// adjust the offset since we have to move the container
					ep = (AbstractGraphicalEditPart) ep.getParent();
					Rectangle parentBounds = ep.getFigure().getBounds();
					offset += bounds.x - parentBounds.x;
					bounds = parentBounds;
				}
				// send the command to move the element
				org.eclipse.gef.commands.Command c = new ChangeBoundsCommand(transactionDomain,
						(Node) ep.getModel(),
						new Point(xave - offset, bounds.y), bounds.width, -1);
				getCommandStack().execute(c);
			}
		}

	}
	/** 
	 * Action implementation method for verticalAlignToFirstSelectedAction.
	 * 
	 */

	public void verticalAlignToFirstSelected() {
		// get the selected items
		List editParts = getGraphicalViewer().getSelectedEditParts();
		AbstractGraphicalEditPart alignToPart = null;
		// find the first diagram part we can align to
		for (int a = 0; a < editParts.size(); a++) {
			if (editParts.get(a) instanceof ShapeNodeEditPart) {
				AbstractGraphicalEditPart ep = (AbstractGraphicalEditPart) editParts
						.get(a);
				if (alignToPart == null) {
					// remember it and stop
					alignToPart = ep;
					break;
				}
			}
		}
		// loop through the elements and set their new position
		for (int a = 0; a < editParts.size(); a++) {
			if (editParts.get(a) instanceof ShapeNodeEditPart) {
				AbstractGraphicalEditPart ep = (AbstractGraphicalEditPart) editParts
						.get(a);
				// we can skip the first one since this is an align-to
				if (ep != alignToPart
						&& !(DiagramCoreUtil.isSyncBar(alignToPart))) {
					// calculate the offset for centerline alignment
					if (!(DiagramCoreUtil.isSyncBar(ep))) {
						Rectangle bounds = ep.getFigure().getBounds();
						int offset = (int) ((double) (bounds.width - alignToPart
								.getFigure().getBounds().width) / 2.0);
						// is this inside a container?
						if (!(ep.getParent() instanceof DiagramEditPart)) {
							// adjust the offset since we are moving the
							// container
							ep = (AbstractGraphicalEditPart) ep.getParent();
							Rectangle parentBounds = ep.getFigure().getBounds();
							offset += bounds.x - parentBounds.x;
							bounds = parentBounds;
						}
						// send the command to move the element
						org.eclipse.gef.commands.Command c = new ChangeBoundsCommand(transactionDomain,
								(Node) ep.getModel(), new Point(alignToPart
										.getFigure().getBounds().x
										- offset, bounds.y), bounds.width, -1);
						getCommandStack().execute(c);
						ep.getFigure().setLocation(
								new Point(alignToPart.getFigure().getBounds().x
										- offset, bounds.y));
					} else {
						Point tp = ep.getFigure().getBounds().getCenter();
						boolean connected = false;
						boolean source = false;
						Point endPoint = null;
						ConnectionNodeEditPart lp = null;
						// check target connections
						List list = ((ShapeNodeEditPart) ep).getTargetConnections();
						for (Iterator itor = list.iterator(); itor.hasNext();) {
							lp = (ConnectionNodeEditPart) itor.next();
							if (lp.getSource().equals(alignToPart)) {
								connected = true;
								break;
							}
						}
						// check source connections if not found in target connections
						if (!connected) {
							list = ((ShapeNodeEditPart) ep).getSourceConnections();
							for (Iterator itor = list.iterator(); itor
									.hasNext();) {
								lp = (ConnectionNodeEditPart) itor.next();
								if (lp.getTarget().equals(alignToPart)) {
									connected = true;
									source = true;
									break;
								}
							}
						}
						if (connected && (alignToPart instanceof ShapeNodeEditPart)) {
									Point centerPoint = alignToPart.getFigure()
											.getBounds().getCenter();
									int delta = centerPoint.x - tp.x;
							endPoint.x += delta;
									ReconnectLinkCommand c = new ReconnectLinkCommand(transactionDomain,
									(Edge) lp.getModel(), (Node) ep.getModel(),
									source);
							c.setEndPoint(endPoint);
									getCommandStack().execute(c);
						}

					}
				}
				// If first selected edit part is syncbarnodeeditpart, need to
				// handle differently
				if (ep != alignToPart
						&& !(DiagramCoreUtil.isSyncBar(alignToPart))) {

					Point sp = alignToPart.getFigure().getBounds()
							.getCenter();
					boolean connected = false;
					// check if the part is connected via source connections
					List list = ((ShapeNodeEditPart) alignToPart)
							.getSourceConnections();
					for (Iterator itor = list.iterator(); itor.hasNext();) {
						ConnectionNodeEditPart lp = (ConnectionNodeEditPart) itor.next();
						if (lp.getTarget().equals(ep)) {
							connected = true;
							break;
						}
					}
					// if not found above, check if it is connected via target connections
					if (!connected) {
						list = ((ShapeNodeEditPart) alignToPart)
								.getTargetConnections();
						for (Iterator itor = list.iterator(); itor.hasNext();) {
							ConnectionNodeEditPart lp = (ConnectionNodeEditPart) itor.next();
							if (lp.getSource().equals(ep)) {
								connected = true;
								break;
							}
						}
					}
					if (DiagramCoreUtil.isSyncBar(ep)) {
						Point p = new Point();
						p.x = ((Integer) ViewUtil.getStructuralFeatureValue((View)ep.getModel(),
								NotationPackage.eINSTANCE.getLocation_X())).intValue();
						p.y = ((Integer) ViewUtil.getStructuralFeatureValue((View)ep.getModel(),
								NotationPackage.eINSTANCE.getLocation_Y())).intValue();
						Point tp = p.getCopy();
						Point alignToCenter = alignToPart.getFigure().getBounds().getCenter();
						Point centerPoint = ep.getFigure().getBounds().getCenter();
						int delta = alignToCenter.x - centerPoint.x;
						tp.x = tp.x + delta;
						org.eclipse.gef.commands.Command c = new ChangeBoundsCommand(transactionDomain,
								(Node) ep.getModel(), tp, ep.getFigure()
										.getBounds().width, -1);
						getCommandStack().execute(c);
						ep.getFigure().setLocation(new Point(tp.x, tp.y));
					} else if (ep instanceof ShapeNodeEditPart) {
						Point p = new Point();
						p.x = ((Integer) ViewUtil.getStructuralFeatureValue((View)ep.getModel(),
								NotationPackage.eINSTANCE.getLocation_X())).intValue();
						p.y = ((Integer) ViewUtil.getStructuralFeatureValue((View)ep.getModel(),
								NotationPackage.eINSTANCE.getLocation_Y())).intValue();
						Point tp = p.getCopy();
						Point centerPoint = ep.getFigure().getBounds()
								.getCenter();
						int delta = sp.x - centerPoint.x;
						tp.x = tp.x + delta;
						org.eclipse.gef.commands.Command c = new ChangeBoundsCommand(transactionDomain,
								(Node) ep.getModel(), tp, ep.getFigure()
										.getBounds().width, -1);
						getCommandStack().execute(c);
						ep.getFigure().setLocation(new Point(tp.x, tp.y));
					}
				}
			}
		}
	}
	
	public void createAlignMenu(IMenuManager menu, boolean canModify) {
		// create a new menu manager for the cascading menu
		
		IContributionItem formatMenu = menu.find(ActionIds.MENU_FORMAT);
		
		MenuManager alignMenuManager = null;
		if (alignMenuManager == null) {
			alignMenuManager = new MenuManager(
					DiagramCoreResources.AbstractDiagramEditor_alignMenu_text) { //$NON-NLS-1$

				public boolean isEnabled() {
					int total = 0;
					// enable the menu only if 2 or more nodes or node
					// containers
					// are selected
					List editParts = graphicalViewer.getSelectedEditParts();
					// need at least two things selected to align
					if (editParts.size() > 1) {
						for (int a = 0; a < editParts.size(); a++) {
							EditPart editPart = (EditPart) editParts.get(a);
							// we can align nodes and containers
							if (editPart instanceof ShapeNodeEditPart) {
								// add up the elements we need, there may be
								// more
								// elements selected (links, etc.)
								total++;
								if (total > 1) {
									// we only need to know there is more than
									// 1, so
									// we can stop here
									break;
								}
							}
						}
					}
					return total > 1;
				}
			};
		}
		if (formatMenu != null && formatMenu instanceof IMenuManager 
				&& alignMenuManager.isEnabled() && canModify) {
			IContributionItem item =  ((IMenuManager)formatMenu).find(ActionIds.MENU_ALIGN);
			if(item != null && item instanceof IMenuManager){
				IMenuManager alignMenu = (IMenuManager)item;
				alignMenu.add(getActionRegistry().getAction(
						DiagramActionsService.ALIGN_HORZ_AVERAGE));
				alignMenu.add(getActionRegistry().getAction(
						DiagramActionsService.ALIGN_HORZ_FIRST_SELECTED));
				alignMenu.add(getActionRegistry().getAction(
						DiagramActionsService.ALIGN_VERT_AVERAGE));
				alignMenu.add(getActionRegistry().getAction(
						DiagramActionsService.ALIGN_VERT_FIRST_SELECTED));
			}
		}else{
			alignMenuManager.add(getActionRegistry().getAction(
					DiagramActionsService.ALIGN_HORZ_AVERAGE));
			alignMenuManager.add(getActionRegistry().getAction(
					DiagramActionsService.ALIGN_HORZ_FIRST_SELECTED));
			alignMenuManager.add(getActionRegistry().getAction(
					DiagramActionsService.ALIGN_VERT_AVERAGE));
			alignMenuManager.add(getActionRegistry().getAction(
					DiagramActionsService.ALIGN_VERT_FIRST_SELECTED));
			if (alignMenuManager.isEnabled() && canModify) {
				menu.appendToGroup(GEFActionConstants.MB_ADDITIONS,
								new Separator());
				menu.appendToGroup(GEFActionConstants.MB_ADDITIONS, alignMenuManager);
				menu.appendToGroup(GEFActionConstants.MB_ADDITIONS,
								new Separator());
			}
		}
	}
	
}