/*******************************************************************************
 * Copyright (c) 2000, 2011 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 API and implementation
 *     SAP AG - Changed for initial API, implementation and documentation of Graphiti:
 *     		changed calculateNewSelection to correctly handle HandleBounds
 *     Felix Velasco (mwenz) - Bug 349416 - Support drag&drop operations on FixPointAnchors
 *                                          the same way as for BoxRelativeAnchors
 *     
 *******************************************************************************/
package org.eclipse.graphiti.ui.internal.editor;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

import org.eclipse.draw2d.ColorConstants;
import org.eclipse.draw2d.Connection;
import org.eclipse.draw2d.Figure;
import org.eclipse.draw2d.Graphics;
import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.gef.ConnectionEditPart;
import org.eclipse.gef.EditPart;
import org.eclipse.gef.EditPartViewer;
import org.eclipse.gef.GraphicalEditPart;
import org.eclipse.gef.GraphicalViewer;
import org.eclipse.gef.KeyHandler;
import org.eclipse.gef.Request;
import org.eclipse.gef.RequestConstants;
import org.eclipse.gef.SharedCursors;
import org.eclipse.gef.handles.HandleBounds;
import org.eclipse.gef.tools.AbstractTool;
import org.eclipse.graphiti.ui.internal.parts.AdvancedAnchorEditPart;
import org.eclipse.graphiti.ui.internal.parts.ConnectionDecoratorEditPart;
import org.eclipse.graphiti.ui.internal.services.GraphitiUiInternal;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.widgets.Display;


/**
 * This is a copy of class org.eclipse.gef.tools.MarqueeSelectionTool. In this
 * GEF class there are too many methods declared as private. Hence overriding of
 * this class does not make sense. Only the implementation of
 * calculateNewSelection() has been changed. In this case the insets of the GF
 * figures will be considered.
 * <p>
 * A Tool which selects multiple objects inside a rectangular area of a
 * Graphical Viewer. If the SHIFT key is pressed at the beginning of the drag,
 * the enclosed items will be appended to the current selection. If the MOD1 key
 * is pressed at the beginning of the drag, the enclosed items will have their
 * selection state inverted.
 * <P>
 * By default, only editparts whose figure's are on the primary layer will be
 * considered within the enclosed rectangle.
 * 
 * @noinstantiate This class is not intended to be instantiated by clients.
 * @noextend This class is not intended to be subclassed by clients.
 */
public class GFMarqueeSelectionTool extends AbstractTool {

	/**
	 * The property to be used in
	 * {@link AbstractTool#setProperties(java.util.Map)} for
	 * {@link #setMarqueeBehavior(int)}.
	 */
	public static final Object PROPERTY_MARQUEE_BEHAVIOR = "marqueeBehavior"; //$NON-NLS-1$

	/**
	 * This behaviour selects nodes completely encompassed by the marquee
	 * rectangle. This is the default behaviour for this tool.
	 */
	public static final int BEHAVIOR_NODES_CONTAINED = new Integer(1).intValue();

	/**
	 * This behaviour selects connections that intersect the marquee rectangle.
	 */
	public static final int BEHAVIOR_CONNECTIONS_TOUCHED = new Integer(2).intValue();

	/**
	 * This behaviour selects nodes completely encompassed by the marquee
	 * rectangle, and all connections between those nodes.
	 */
	public static final int BEHAVIOR_NODES_AND_CONNECTIONS = new Integer(3).intValue();

	/**
	 * The Constant DEFAULT_MODE.
	 */
	static final int DEFAULT_MODE = 0;

	/**
	 * The Constant TOGGLE_MODE.
	 */
	static final int TOGGLE_MODE = 1;

	/**
	 * The Constant APPEND_MODE.
	 */
	static final int APPEND_MODE = 2;

	private Figure marqueeRectangleFigure;

	private Set<GraphicalEditPart> allChildren = new HashSet<GraphicalEditPart>();

	private Collection<EditPart> selectedEditParts;

	private Request targetRequest;

	private int marqueeBehavior = BEHAVIOR_NODES_CONTAINED;

	private int mode;

	private static final Request MARQUEE_REQUEST = new Request(RequestConstants.REQ_SELECTION);

	/**
	 * Creates a new MarqueeSelectionTool of default type
	 * {@link #BEHAVIOR_NODES_CONTAINED}.
	 */
	public GFMarqueeSelectionTool() {
		setDefaultCursor(SharedCursors.CROSS);
		setUnloadWhenFinished(false);
	}

	/**
	 * Apply property.
	 * 
	 * @param key
	 *            the key
	 * @param value
	 *            the value
	 * 
	 * @see org.eclipse.gef.tools.AbstractTool#applyProperty(java.lang.Object,
	 *      java.lang.Object)
	 */
	@Override
	protected void applyProperty(Object key, Object value) {
		if (PROPERTY_MARQUEE_BEHAVIOR.equals(key)) {
			if (value instanceof Integer)
				setMarqueeBehavior(((Integer) value).intValue());
			return;
		}
		super.applyProperty(key, value);
	}

	private void calculateConnections(Collection<EditPart> newSelections, Collection<EditPart> deselections) {
		// determine the currently selected nodes minus the ones that are to be
		// deselected
		Collection<EditPart> currentNodes = new HashSet<EditPart>();
		if (getSelectionMode() != DEFAULT_MODE) { // everything is deselected
			// in default mode
			List<EditPart> selectedEditParts2 = GraphitiUiInternal.getGefService().getSelectedEditParts(getCurrentViewer());
			Iterator<EditPart> iter = selectedEditParts2.iterator();
			while (iter.hasNext()) {
				EditPart selected = iter.next();
				if (!(selected instanceof ConnectionEditPart) && !deselections.contains(selected))
					currentNodes.add(selected);
			}
		}
		// add new connections to be selected to newSelections
		Collection<EditPart> connections = new ArrayList<EditPart>();
		for (Iterator<EditPart> nodes = newSelections.iterator(); nodes.hasNext();) {
			GraphicalEditPart node = (GraphicalEditPart) nodes.next();
			for (Iterator<?> itr = node.getSourceConnections().iterator(); itr.hasNext();) {
				ConnectionEditPart sourceConn = (ConnectionEditPart) itr.next();
				if (sourceConn.getSelected() == EditPart.SELECTED_NONE
						&& (newSelections.contains(sourceConn.getTarget()) || currentNodes.contains(sourceConn.getTarget())))
					connections.add(sourceConn);
			}
			for (Iterator<?> itr = node.getTargetConnections().iterator(); itr.hasNext();) {
				ConnectionEditPart targetConn = (ConnectionEditPart) itr.next();
				if (targetConn.getSelected() == EditPart.SELECTED_NONE
						&& (newSelections.contains(targetConn.getSource()) || currentNodes.contains(targetConn.getSource())))
					connections.add(targetConn);
			}
		}
		newSelections.addAll(connections);
		// add currently selected connections that are to be deselected to
		// deselections
		connections = new HashSet<EditPart>();
		for (Iterator<EditPart> nodes = deselections.iterator(); nodes.hasNext();) {
			GraphicalEditPart node = (GraphicalEditPart) nodes.next();
			for (Iterator<?> itr = node.getSourceConnections().iterator(); itr.hasNext();) {
				ConnectionEditPart sourceConn = (ConnectionEditPart) itr.next();
				if (sourceConn.getSelected() != EditPart.SELECTED_NONE)
					connections.add(sourceConn);
			}
			for (Iterator<?> itr = node.getTargetConnections().iterator(); itr.hasNext();) {
				ConnectionEditPart targetConn = (ConnectionEditPart) itr.next();
				if (targetConn.getSelected() != EditPart.SELECTED_NONE)
					connections.add(targetConn);
			}
		}
		deselections.addAll(connections);
	}

	private void calculateNewSelection(Collection<EditPart> newSelections, Collection<EditPart> deselections) {
		Rectangle marqueeRect = getMarqueeSelectionRectangle();
		for (Iterator<GraphicalEditPart> itr = getAllChildren().iterator(); itr.hasNext();) {
			GraphicalEditPart child = itr.next();
			IFigure figure = child.getFigure();
			if (!child.isSelectable() || child.getTargetEditPart(MARQUEE_REQUEST) != child || !isFigureVisible(figure)
					|| !figure.isShowing())
				continue;

			// Graphiti: start change
			Rectangle r;
			if (figure instanceof HandleBounds) {
				r = ((HandleBounds) figure).getHandleBounds().getCopy();
			} else {
				r = figure.getBounds().getCopy();
			}
			// Graphiti: end change
			figure.translateToAbsolute(r);
			boolean included = false;
			if (child instanceof ConnectionEditPart && marqueeRect.intersects(r)) {
				Rectangle relMarqueeRect = Rectangle.SINGLETON;
				figure.translateToRelative(relMarqueeRect.setBounds(marqueeRect));
				included = ((Connection) figure).getPoints().intersects(relMarqueeRect);
			} else
				included = marqueeRect.contains(r);

			if (included) {
				if (child.getSelected() == EditPart.SELECTED_NONE || getSelectionMode() != TOGGLE_MODE)
					newSelections.add(child);
				else
					deselections.add(child);
			}
		}

		if (marqueeBehavior == BEHAVIOR_NODES_AND_CONNECTIONS)
			calculateConnections(newSelections, deselections);
	}

	private Request createTargetRequest() {
		return MARQUEE_REQUEST;
	}

	/**
	 * Erases feedback if necessary and puts the tool into the terminal state.
	 */
	@Override
	public void deactivate() {
		if (isInState(STATE_DRAG_IN_PROGRESS)) {
			eraseMarqueeFeedback();
			eraseTargetFeedback();
		}
		super.deactivate();
		allChildren.clear();
		setState(STATE_TERMINAL);
	}

	private void eraseMarqueeFeedback() {
		if (marqueeRectangleFigure != null) {
			removeFeedback(marqueeRectangleFigure);
			marqueeRectangleFigure = null;
		}
	}

	private void eraseTargetFeedback() {
		if (selectedEditParts == null)
			return;
		Iterator<EditPart> oldEditParts = selectedEditParts.iterator();
		while (oldEditParts.hasNext()) {
			EditPart editPart = oldEditParts.next();
			editPart.eraseTargetFeedback(getTargetRequest());
		}
	}

	private Set<GraphicalEditPart> getAllChildren() {
		if (allChildren.isEmpty())
			getAllChildren(getCurrentViewer().getRootEditPart(), allChildren);
		return allChildren;
	}

	private void getAllChildren(EditPart editPart, Set<GraphicalEditPart> allChildren) {
		List<EditPart> children = GraphitiUiInternal.getGefService().getEditPartChildren(editPart);
		for (int i = 0; i < children.size(); i++) {
			GraphicalEditPart child = (GraphicalEditPart) children.get(i);
			if (marqueeBehavior == BEHAVIOR_NODES_CONTAINED || marqueeBehavior == BEHAVIOR_NODES_AND_CONNECTIONS)
				allChildren.add(child);
			if (marqueeBehavior == BEHAVIOR_CONNECTIONS_TOUCHED) {
				allChildren.addAll(GraphitiUiInternal.getGefService().getSourceConnections(child));
				allChildren.addAll(GraphitiUiInternal.getGefService().getTargetConnections(child));
			}
			getAllChildren(child, allChildren);
		}
	}

	/**
	 * Gets the command name.
	 * 
	 * @return the command name
	 * 
	 * @see org.eclipse.gef.tools.AbstractTool#getCommandName()
	 */
	@Override
	protected String getCommandName() {
		return REQ_SELECTION;
	}

	/**
	 * Gets the debug name.
	 * 
	 * @return the debug name
	 * 
	 * @see org.eclipse.gef.tools.AbstractTool#getDebugName()
	 */
	@Override
	protected String getDebugName() {
		return "Marquee Tool: " + marqueeBehavior;//$NON-NLS-1$
	}

	private IFigure getMarqueeFeedbackFigure() {
		if (marqueeRectangleFigure == null) {
			marqueeRectangleFigure = new MarqueeRectangleFigure();
			addFeedback(marqueeRectangleFigure);
		}
		return marqueeRectangleFigure;
	}

	private Rectangle getMarqueeSelectionRectangle() {
		return new Rectangle(getStartLocation(), getLocation());
	}

	private int getSelectionMode() {
		return mode;
	}

	private Request getTargetRequest() {
		if (targetRequest == null)
			targetRequest = createTargetRequest();
		return targetRequest;
	}

	/**
	 * Handle button down.
	 * 
	 * @param button
	 *            the button
	 * 
	 * @return true, if handle button down
	 * 
	 * @see org.eclipse.gef.tools.AbstractTool#handleButtonDown(int)
	 */
	@Override
	protected boolean handleButtonDown(int button) {
		if (!isGraphicalViewer())
			return true;
		// if ((button == 3 || button == 1) && isInState(STATE_INITIAL))
		// performMarqueeSelect();

		if (button != 1 && button != 3) {
			setState(STATE_INVALID);
			handleInvalidInput();
		}
		if (stateTransition(STATE_INITIAL, STATE_DRAG_IN_PROGRESS)) {
			if (getCurrentInput().isModKeyDown(SWT.MOD1))
				setSelectionMode(TOGGLE_MODE);
			else if (getCurrentInput().isShiftKeyDown())
				setSelectionMode(APPEND_MODE);
			else
				setSelectionMode(DEFAULT_MODE);
		}
		return true;
	}

	/**
	 * Handle button up.
	 * 
	 * @param button
	 *            the button
	 * 
	 * @return true, if handle button up
	 * 
	 * @see org.eclipse.gef.tools.AbstractTool#handleButtonUp(int)
	 */
	@Override
	protected boolean handleButtonUp(int button) {
		if (stateTransition(STATE_DRAG_IN_PROGRESS, STATE_TERMINAL)) {
			eraseTargetFeedback();
			eraseMarqueeFeedback();
			performMarqueeSelect();
		}
		handleFinished();
		return true;
	}

	/**
	 * Handle drag in progress.
	 * 
	 * @return true, if handle drag in progress
	 * 
	 * @see org.eclipse.gef.tools.AbstractTool#handleDragInProgress()
	 */
	@Override
	protected boolean handleDragInProgress() {
		if (isInState(STATE_DRAG | STATE_DRAG_IN_PROGRESS)) {
			showMarqueeFeedback();
			eraseTargetFeedback();
			calculateNewSelection(selectedEditParts = new ArrayList<EditPart>(), new ArrayList<EditPart>());
			showTargetFeedback();
		}
		return true;
	}

	/**
	 * Handle focus lost.
	 * 
	 * @return true, if handle focus lost
	 * 
	 * @see org.eclipse.gef.tools.AbstractTool#handleFocusLost()
	 */
	@Override
	protected boolean handleFocusLost() {
		if (isInState(STATE_DRAG | STATE_DRAG_IN_PROGRESS)) {
			handleFinished();
			return true;
		}
		return false;
	}

	/**
	 * This method is called when mouse or keyboard input is invalid and erases
	 * the feedback.
	 * 
	 * @return <code>true</code>
	 */
	@Override
	protected boolean handleInvalidInput() {
		eraseTargetFeedback();
		eraseMarqueeFeedback();
		return true;
	}

	/**
	 * Handles high-level processing of a key down event. KeyEvents are
	 * forwarded to the current viewer's {@link KeyHandler}, via
	 * {@link KeyHandler#keyPressed(KeyEvent)}.
	 * 
	 * @param e
	 *            the e
	 * 
	 * @return true, if handle key down
	 * 
	 * @see AbstractTool#handleKeyDown(KeyEvent)
	 */
	@Override
	protected boolean handleKeyDown(KeyEvent e) {
		if (super.handleKeyDown(e))
			return true;
		if (getCurrentViewer().getKeyHandler() != null)
			return getCurrentViewer().getKeyHandler().keyPressed(e);
		return false;
	}

	private boolean isFigureVisible(IFigure fig) {
		Rectangle figBounds = fig.getBounds().getCopy();
		IFigure walker = fig.getParent();
		while (!figBounds.isEmpty() && walker != null) {
			walker.translateToParent(figBounds);
			figBounds.intersect(walker.getBounds());
			walker = walker.getParent();
		}
		return !figBounds.isEmpty();
	}

	private boolean isGraphicalViewer() {
		return getCurrentViewer() instanceof GraphicalViewer;
	}

	/**
	 * MarqueeSelectionTool is only interested in GraphicalViewers, not
	 * TreeViewers.
	 * 
	 * @param viewer
	 *            the viewer
	 * 
	 * @return true, if checks if is viewer important
	 * 
	 * @see org.eclipse.gef.tools.AbstractTool#isViewerImportant(org.eclipse.gef.EditPartViewer)
	 */
	@Override
	protected boolean isViewerImportant(EditPartViewer viewer) {
		return viewer instanceof GraphicalViewer;
	}

	private void performMarqueeSelect() {
		EditPartViewer viewer = getCurrentViewer();
		Collection<EditPart> newSelections = new LinkedHashSet<EditPart>(), deselections = new HashSet<EditPart>();
		calculateNewSelection(newSelections, deselections);
		if (getSelectionMode() != DEFAULT_MODE) {
			List<EditPart> selectedEditParts2 = GraphitiUiInternal.getGefService().getSelectedEditParts(viewer);
			newSelections.addAll(selectedEditParts2);
			newSelections.removeAll(deselections);
		}

		/*
		 * Filter the current selection of editParts. Remove those editParts
		 * where the parentEditPart is already in the current selection. Anchors
		 * and ConnectionDecorators are always excluded from the selection.
		 */
		Collection<EditPart> filteredSelections = new ArrayList<EditPart>();
		for (Object object : newSelections) {
			if (object instanceof EditPart) {
				EditPart ep = (EditPart) object;
				if (newSelections.contains(ep.getParent())) {
					continue;
				}
				if (ep instanceof AdvancedAnchorEditPart || ep instanceof ConnectionDecoratorEditPart) {
					continue;
				}
				filteredSelections.add(ep);
			}
		}

		viewer.setSelection(new StructuredSelection(filteredSelections.toArray()));
	}

	/**
	 * Sets the type of parts that this tool will select. This method should
	 * only be invoked once: when the tool is being initialized.
	 * 
	 * @param type
	 *            {@link #BEHAVIOR_CONNECTIONS_TOUCHED} or
	 *            {@link #BEHAVIOR_NODES_CONTAINED} or
	 *            {@link #BEHAVIOR_NODES_AND_CONNECTIONS}
	 * 
	 * @since 3.1
	 */
	public void setMarqueeBehavior(int type) {
		if (type != BEHAVIOR_CONNECTIONS_TOUCHED && type != BEHAVIOR_NODES_CONTAINED && type != BEHAVIOR_NODES_AND_CONNECTIONS)
			throw new IllegalArgumentException("Invalid marquee behaviour specified."); //$NON-NLS-1$
		marqueeBehavior = type;
	}

	private void setSelectionMode(int mode) {
		this.mode = mode;
	}

	/**
	 * Sets the viewer.
	 * 
	 * @param viewer
	 *            the viewer
	 * 
	 * @see org.eclipse.gef.Tool#setViewer(org.eclipse.gef.EditPartViewer)
	 */
	@Override
	public void setViewer(EditPartViewer viewer) {
		if (viewer == getCurrentViewer())
			return;
		super.setViewer(viewer);
		if (viewer instanceof GraphicalViewer)
			setDefaultCursor(SharedCursors.CROSS);
		else
			setDefaultCursor(SharedCursors.NO);
	}

	private void showMarqueeFeedback() {
		Rectangle rect = getMarqueeSelectionRectangle().getCopy();
		getMarqueeFeedbackFigure().translateToRelative(rect);
		getMarqueeFeedbackFigure().setBounds(rect);
	}

	private void showTargetFeedback() {
		for (Iterator<EditPart> itr = selectedEditParts.iterator(); itr.hasNext();) {
			EditPart editPart = itr.next();
			editPart.showTargetFeedback(getTargetRequest());
		}
	}

	/**
	 * The Class MarqueeRectangleFigure.
	 */
	class MarqueeRectangleFigure extends Figure {

		private static final int DELAY = 110; // animation delay in
		// millisecond

		private int offset = 0;

		private boolean schedulePaint = true;

		/**
		 * Paint figure.
		 * 
		 * @param graphics
		 *            the graphics
		 * 
		 * @see org.eclipse.draw2d.Figure#paintFigure(org.eclipse.draw2d.Graphics)
		 */
		@Override
		protected void paintFigure(Graphics graphics) {
			Rectangle bounds = getBounds().getCopy();
			graphics.translate(getLocation());

			graphics.setXORMode(true);
			graphics.setForegroundColor(ColorConstants.white);
			graphics.setBackgroundColor(ColorConstants.black);

			graphics.setLineStyle(Graphics.LINE_DOT);

			int[] points = new int[6];

			points[0] = 0 + offset;
			points[1] = 0;
			points[2] = bounds.width - 1;
			points[3] = 0;
			points[4] = bounds.width - 1;
			points[5] = bounds.height - 1;

			graphics.drawPolyline(points);

			points[0] = 0;
			points[1] = 0 + offset;
			points[2] = 0;
			points[3] = bounds.height - 1;
			points[4] = bounds.width - 1;
			points[5] = bounds.height - 1;

			graphics.drawPolyline(points);

			graphics.translate(getLocation().getNegated());

			if (schedulePaint) {
				Display.getCurrent().timerExec(DELAY, new Runnable() {
					public void run() {
						offset++;
						if (offset > 5)
							offset = 0;

						schedulePaint = true;
						repaint();
					}
				});
			}

			schedulePaint = false;
		}

	}

}