/*
    * This file is a part of CAST project.
    * (c) Copyright 2007, AGH University of Science & Technology
    * https://caribou.iisg.agh.edu.pl/trac/cast
    *
    * Licensed under the Eclipse Public License, Version 1.0 (the "License").
    * You may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    * http://www.eclipse.org/legal/epl-v10.html
   */
  /*
   * File: DeleteModelElementsCommand.java
   * Created: 2007-00-00
   * Author: awos
   * $Id: DeleteModelElementsCommand.java 3217 2009-08-19 12:00:08Z kpietak $
   */
  
  package pl.edu.agh.cast.backward.command;
  
  
  import java.lang.reflect.InvocationTargetException;
  import java.util.HashSet;
  import java.util.Set;
  
  import org.eclipse.core.runtime.IProgressMonitor;
  import org.eclipse.gef.commands.Command;
  import org.eclipse.jface.operation.IRunnableWithProgress;
  
  import pl.edu.agh.cast.Activator;
  import pl.edu.agh.cast.backward.editor.EditorUtilBackward;
  import pl.edu.agh.cast.model.visual.backward.Connection;
  import pl.edu.agh.cast.model.visual.backward.ConnectionGroup;
  import pl.edu.agh.cast.model.visual.backward.IDiagram;
  import pl.edu.agh.cast.model.visual.backward.Node;
  import pl.edu.agh.cast.util.IExceptionHandler;
  import pl.edu.agh.cast.util.Messages;
  
  /**
   * This command will be created multiple times because of the way delete requests work on edit parts. The exact same
   * command is returned for all requests - GEF fires a single request for each model element to delete, and they're all
   * aggregated into a single command.
   *
   * It should execute only once, deleting all elements at once, and undo only once, restoring them at once as well.
   * That's what the _executed and _undone flags are for. GEF calls execute for a command created for each model element
   * to be deleted - that's why this command's {@link #execute()} will be called multiple times, and we have to guard
   * against that.
   *
   * @author AGH CAST Team
   */
  public class DeleteModelElementsCommand extends Command {
  
  	/**
  	 * Id of the command.
  	 */
  	public static final Object ID = "pl.edu.agh.cast.schema.command.DeleteModelElementsCommand"; //$NON-NLS-1$
  
  	private Set<Connection> connections;
  
  	private Set<Node> nodes;
  
  	private IDiagram diagram;
  
  	private boolean executed = false;
  
  	private boolean undone = false;
  
  	/**
  	 * Creates new instance of command to delete model elements.
  	 *
  	 * @param diagram
  	 *            the diagram to operate on
  	 */
  	public DeleteModelElementsCommand(IDiagram diagram) {
  		this.diagram = diagram;
  		connections = new HashSet<Connection>();
  		nodes = new HashSet<Node>();
  	}
  
  	/**
  	 * Adds {@link Connection} to remove.
  	 *
  	 * @param connection
  	 *            connection to remove
  	 */
  	public void add(Connection connection) {
  		connections.add(connection);
  	}
  
  	/**
  	 * Adds {@link ConnectionGroup} to remove.
  	 *
  	 * @param group
  	 *            connection group to remove
  	 */
  	public void add(ConnectionGroup group) {
  		connections.addAll(group.getAllConnections());
  	}
  
  	/**
 	 * Adds {@link Node} to remove.
 	 *
 	 * @param node
 	 *            node to remove
 	 */
 	public void add(Node node) {
 		nodes.add(node);
 		for (ConnectionGroup cg : node.getConnectionGroups()) {
 			connections.addAll(cg.getAllConnections());
 		}
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see org.eclipse.gef.commands.Command#execute()
 	 */
 	@Override
 	public void execute() {
 		if (executed) {
 			return;
 		}
 
 		diagram.setSuppressEvents(true);
 		EditorUtilBackward.runWithProgressMonitorInUIThread(new IRunnableWithProgress() {
 			public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
 				doDeleteElements(monitor);
 				monitor.subTask(Messages.DeleteModelElementsCommand_6);
 				diagram.setSuppressEvents(false);
 				monitor.done();
 			}
 		}, new IExceptionHandler() {
 			public void handleException(Exception e) {
 				Activator.getLogger().warn("Error removing model elements", e); //$NON-NLS-1$
 				diagram.setSuppressEvents(false);
 			}
 		});
 
 		executed = true;
 	}
 
 	private void doDeleteElements(IProgressMonitor progress) {
 		int count = 110 * (nodes.size() + connections.size()) / 100;
 		progress.beginTask(Messages.DeleteModelElementsCommand_0, count);
 		progress.subTask(Messages.DeleteModelElementsCommand_1);
 		for (Connection c : connections) {
 			Connection foundConnection = diagram.findConnection(c.getSourceNode().getId(), c.getTargetNode().getId(), c
 			        .getStartDate());
 			diagram.removeConnection(foundConnection);
 			progress.worked(1);
 		}
 		progress.subTask(Messages.DeleteModelElementsCommand_2);
 		for (Node node : nodes) {
 			diagram.removeNode(diagram.findNode(node.getId()));
 			progress.worked(1);
 		}
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see org.eclipse.gef.commands.Command#undo()
 	 */
 	@Override
 	public void undo() {
 		if (undone) {
 			return;
 		}
 
 		diagram.setSuppressEvents(true);
 		EditorUtilBackward.runWithProgressMonitorInUIThread(new IRunnableWithProgress() {
 			public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
 				doRestoreElements(monitor);
 				monitor.subTask(Messages.DeleteModelElementsCommand_6);
 				diagram.setSuppressEvents(false);
 				monitor.done();
 			}
 		}, new IExceptionHandler() {
 			public void handleException(Exception e) {
 				Activator.getLogger().warn("Error undoing model element removal", e); //$NON-NLS-1$
 				diagram.setSuppressEvents(false);
 			}
 		});
 
 		undone = true;
 	}
 
 	private void doRestoreElements(IProgressMonitor progress) {
 		int count = 110 * (nodes.size() + connections.size()) / 100;
 		progress.beginTask(Messages.DeleteModelElementsCommand_3, count);
 		progress.subTask(Messages.DeleteModelElementsCommand_4);
 		for (Node node : nodes) {
 			diagram.addNode(node);
 			progress.worked(1);
 		}
 		progress.subTask(Messages.DeleteModelElementsCommand_5);
 		for (Connection c : connections) {
 			c.setSourceNode(diagram.findNode(c.getSourceNode().getId()));
 			c.setTargetNode(diagram.findNode(c.getTargetNode().getId()));
 			diagram.addConnection(c);
 			progress.worked(1);
 		}
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see org.eclipse.gef.commands.Command#redo()
 	 */
 	@Override
 	public void redo() {
 		executed = false;
 		undone = false;
 		execute();
 	}
 
 }