/*******************************************************************************
 * Copyright (c) 2013, 2017 Obeo 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:
 *     Obeo - initial API and implementation
 *     Michael Borkowski - bug 462237
 *     Martin Fleck - bug 483798
 *     Philip Langer - bug 521948
 *******************************************************************************/
package org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.actions;

import static com.google.common.collect.Iterables.addAll;
import static com.google.common.collect.Iterables.any;
import static com.google.common.collect.Iterables.filter;
import static com.google.common.collect.Iterables.transform;
import static com.google.common.collect.Lists.newArrayList;
import static org.eclipse.emf.compare.DifferenceSource.LEFT;
import static org.eclipse.emf.compare.DifferenceSource.RIGHT;
import static org.eclipse.emf.compare.DifferenceState.DISCARDED;
import static org.eclipse.emf.compare.DifferenceState.MERGED;
import static org.eclipse.emf.compare.internal.merge.MergeMode.ACCEPT;
import static org.eclipse.emf.compare.internal.merge.MergeMode.LEFT_TO_RIGHT;
import static org.eclipse.emf.compare.internal.merge.MergeMode.REJECT;
import static org.eclipse.emf.compare.internal.merge.MergeMode.RIGHT_TO_LEFT;

import com.google.common.base.Function;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicate;
import com.google.common.collect.Lists;
import com.google.common.collect.Multimap;
import com.google.common.collect.Streams;

import java.util.Collection;
import java.util.Collections;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.eclipse.compare.INavigatable;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.command.CompoundCommand;
import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.common.notify.Notifier;
import org.eclipse.emf.compare.Diff;
import org.eclipse.emf.compare.DifferenceSource;
import org.eclipse.emf.compare.DifferenceState;
import org.eclipse.emf.compare.command.ICompareCommandStack;
import org.eclipse.emf.compare.command.ICompareCopyCommand;
import org.eclipse.emf.compare.command.impl.AbstractCopyCommand;
import org.eclipse.emf.compare.command.impl.TransactionalDualCompareCommandStack;
import org.eclipse.emf.compare.domain.ICompareEditingDomain;
import org.eclipse.emf.compare.domain.IMergeRunnable;
import org.eclipse.emf.compare.ide.ui.internal.EMFCompareIDEUIMessages;
import org.eclipse.emf.compare.ide.ui.internal.EMFCompareIDEUIPlugin;
import org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.text.EMFCompareTextMergeViewer.EditCommand;
import org.eclipse.emf.compare.ide.ui.internal.preferences.EMFCompareUIPreferences;
import org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.Navigatable;
import org.eclipse.emf.compare.internal.merge.MergeMode;
import org.eclipse.emf.compare.merge.AbstractMerger;
import org.eclipse.emf.compare.merge.IDiffRelationshipComputer;
import org.eclipse.emf.compare.merge.IMerger;
import org.eclipse.emf.compare.merge.IMerger.Registry;
import org.eclipse.emf.compare.provider.ITooltipLabelProvider;
import org.eclipse.emf.compare.rcp.ui.internal.configuration.IEMFCompareConfiguration;
import org.eclipse.emf.compare.rcp.ui.structuremergeviewer.groups.IDifferenceGroup;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.edit.tree.TreeNode;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.BaseSelectionListenerAction;
import org.eclipse.ui.plugin.AbstractUIPlugin;

/**
 * Abstract Action that manages a merge of a difference in case of both sides of the comparison are editable.
 * 
 * @author <a href="mailto:axel.richard@obeo.fr">Axel Richard</a>
 * @since 3.0
 */
public class MergeAction extends BaseSelectionListenerAction {

	private static final Predicate<Diff> IS_IN_TERMINAL_STATE = new Predicate<Diff>() {
		public boolean apply(Diff diff) {
			return AbstractMerger.isInTerminalState(diff);
		}
	};

	private static final Predicate<Diff> IS_NOT_IN_TERMINAL_STATE = new Predicate<Diff>() {
		public boolean apply(Diff diff) {
			return !AbstractMerger.isInTerminalState(diff);
		}
	};

	protected static final Function<? super Adapter, ? extends Notifier> ADAPTER__TARGET = new Function<Adapter, Notifier>() {
		public Notifier apply(Adapter adapter) {
			return adapter.getTarget();
		}
	};

	protected final Registry mergerRegistry;

	protected ICompareEditingDomain editingDomain;

	private final List<Diff> selectedDifferences;

	private final INavigatable navigatable;

	/**
	 * The merge mode used for the comparison.
	 */
	private final MergeMode selectedMode;

	/**
	 * The adapter factory for the comparison.
	 */
	private AdapterFactory adapterFactory;

	private IDiffRelationshipComputer diffRelationshipComputer;

	private IEMFCompareConfiguration compareConfiguration;

	private boolean isMirrored;

	/**
	 * Constructor.
	 * 
	 * @param configuration
	 *            The compare configuration object.
	 */
	public MergeAction(IEMFCompareConfiguration compareConfiguration, IMerger.Registry mergerRegistry,
			MergeMode mode, INavigatable navigatable) {
		super(""); //$NON-NLS-1$

		this.compareConfiguration = compareConfiguration;
		adapterFactory = compareConfiguration.getAdapterFactory();
		diffRelationshipComputer = compareConfiguration.getDiffRelationshipComputer();
		boolean isLeftEditable = compareConfiguration.isLeftEditable();
		boolean isRightEditable = compareConfiguration.isRightEditable();

		this.navigatable = navigatable;
		Preconditions.checkNotNull(mode);
		// at least should be editable
		Preconditions.checkState(isLeftEditable || isRightEditable);
		// if left and right editable, the only accepted mode are LtR or RtL
		if (isLeftEditable && isRightEditable) {
			Preconditions.checkState(mode == LEFT_TO_RIGHT || mode == RIGHT_TO_LEFT);
		}
		// if mode is accept or reject, left and right can't be both read only (no action should be created in
		// this case) and can't be both editable.
		if (isLeftEditable != isRightEditable) {
			Preconditions.checkState(mode == ACCEPT || mode == REJECT);
		}

		this.editingDomain = compareConfiguration.getEditingDomain();
		this.mergerRegistry = mergerRegistry;
		this.selectedDifferences = newArrayList();
		this.selectedMode = mode;

		initToolTipAndImage(mode);
	}

	public MergeAction(IEMFCompareConfiguration compareConfiguration, IMerger.Registry mergerRegistry,
			MergeMode mode, INavigatable navigatable, IStructuredSelection selection) {
		this(compareConfiguration, mergerRegistry, mode, navigatable);
		setEnabled(updateSelection(selection));
	}

	protected IMergeRunnable createMergeRunnable(MergeMode mode, boolean leftEditable, boolean rightEditable,
			IDiffRelationshipComputer relationshipComputer) {
		return new MergeRunnableImpl(leftEditable, rightEditable, mode, relationshipComputer);
	}

	protected void initToolTipAndImage(MergeMode mode) {
		switch (mode) {
			case LEFT_TO_RIGHT:
				setText(EMFCompareIDEUIMessages.getString("merged.to.right.tooltip")); //$NON-NLS-1$
				setToolTipText(EMFCompareIDEUIMessages.getString("merged.to.right.tooltip")); //$NON-NLS-1$
				setImageDescriptor(AbstractUIPlugin.imageDescriptorFromPlugin(EMFCompareIDEUIPlugin.PLUGIN_ID,
						"icons/full/toolb16/merge_to_right.gif")); //$NON-NLS-1$
				break;
			case RIGHT_TO_LEFT:
				setText(EMFCompareIDEUIMessages.getString("merged.to.left.tooltip")); //$NON-NLS-1$
				setToolTipText(EMFCompareIDEUIMessages.getString("merged.to.left.tooltip")); //$NON-NLS-1$
				setImageDescriptor(AbstractUIPlugin.imageDescriptorFromPlugin(EMFCompareIDEUIPlugin.PLUGIN_ID,
						"icons/full/toolb16/merge_to_left.gif")); //$NON-NLS-1$
				break;
			case ACCEPT:
				setText(EMFCompareIDEUIMessages.getString("accept.change.tooltip")); //$NON-NLS-1$
				setToolTipText(EMFCompareIDEUIMessages.getString("accept.change.tooltip")); //$NON-NLS-1$
				setImageDescriptor(AbstractUIPlugin.imageDescriptorFromPlugin(EMFCompareIDEUIPlugin.PLUGIN_ID,
						"icons/full/toolb16/accept_change.gif")); //$NON-NLS-1$
				break;
			case REJECT:
				setText(EMFCompareIDEUIMessages.getString("reject.change.tooltip")); //$NON-NLS-1$
				setToolTipText(EMFCompareIDEUIMessages.getString("reject.change.tooltip")); //$NON-NLS-1$
				setImageDescriptor(AbstractUIPlugin.imageDescriptorFromPlugin(EMFCompareIDEUIPlugin.PLUGIN_ID,
						"icons/full/toolb16/reject_change.gif")); //$NON-NLS-1$
				break;
			default:
				throw new IllegalStateException();
		}
	}

	/**
	 * This method is used to created contextual tooltips.
	 */
	protected void contextualizeTooltip() {
		if (this.selectedDifferences.size() > 1) {
			// multiple selection
			setMultipleTooltip(this.selectedMode);
		} else if (this.selectedDifferences.isEmpty()) {
			// no selection
			initToolTipAndImage(this.selectedMode);
		} else {
			Diff diff = this.selectedDifferences.get(0);
			Object adapter = adapterFactory.adapt(diff, ITooltipLabelProvider.class);
			if (adapter instanceof ITooltipLabelProvider) {
				String tooltip = ((ITooltipLabelProvider)adapter).getTooltip(this.selectedMode);
				setToolTipText(tooltip);
			} else {
				initToolTipAndImage(this.selectedMode);
			}
		}
	}

	/**
	 * Set the tooltips for multiple selection.
	 *
	 * @param mode
	 *            The comparison mode
	 */
	private void setMultipleTooltip(MergeMode mode) {
		switch (mode) {
			case LEFT_TO_RIGHT:
				setToolTipText(EMFCompareIDEUIMessages.getString("merged.multiple.to.right.tooltip")); //$NON-NLS-1$
				break;
			case RIGHT_TO_LEFT:
				setToolTipText(EMFCompareIDEUIMessages.getString("merged.multiple.to.left.tooltip")); //$NON-NLS-1$
				break;
			case ACCEPT:
				setToolTipText(EMFCompareIDEUIMessages.getString("accept.multiple.changes.tooltip")); //$NON-NLS-1$
				break;
			case REJECT:
				setToolTipText(EMFCompareIDEUIMessages.getString("reject.multiple.changes.tooltip")); //$NON-NLS-1$
				break;
			default:
				throw new IllegalStateException();
		}
	}

	/**
	 * {@inheritDoc}
	 * 
	 * @see org.eclipse.jface.action.Action#run()
	 */
	@Override
	public void run() {
		MergeMode mode = getSelectedMode();
		ICompareCommandStack commandStack = editingDomain.getCommandStack();
		if (commandStack instanceof TransactionalDualCompareCommandStack) {
			TransactionalDualCompareCommandStack transactionalDualCompareCommandStack = (TransactionalDualCompareCommandStack)commandStack;
			boolean oldDeliver = transactionalDualCompareCommandStack.isDeliver();

			try {
				// Disable notifications during all the processing
				transactionalDualCompareCommandStack.setDeliver(false);

				ManagedCommandStack managedCmdStack = new ManagedCommandStack(commandStack);
				managedCmdStack.undoUntilDiffsAreInTerminalState(selectedDifferences);

				// If selected diffs are still in the terminal state we seem to be unable to process them.
				// This should really never happen, but if some command doesn't support undo, it's possible to
				// get in this situation.
				if (any(selectedDifferences, IS_IN_TERMINAL_STATE)) {
					managedCmdStack.restoreCommandStack();
					return;
				}

				// There might be commands that can't be repeated, so they would be lost when we redo all
				// undone commands. We should better ask the user if that's what she wants.
				if (managedCmdStack.hasUnrepeatableCommands()) {
					if (!MessageDialog.openQuestion(
							PlatformUI.getWorkbench().getModalDialogShellProvider().getShell(),
							EMFCompareIDEUIMessages.getString("MergeAction.redoProblem.title"), //$NON-NLS-1$
							EMFCompareIDEUIMessages.getString("MergeAction.redoProblem.message", //$NON-NLS-1$
									Integer.valueOf(managedCmdStack.getNonRepeatableCommandsCount())))) {
						managedCmdStack.restoreCommandStack();
						return;
					}
				}

				// Execute the command to process the selected diffs using the selected mode.
				execute(commandStack, mode, selectedDifferences);

				boolean haveUndoneSelectedDifferences = managedCmdStack.redoExcept(selectedDifferences, mode);

				// If we have undone the command...
				if (haveUndoneSelectedDifferences) {
					// Process the selected diffs again, but now at the top of the stack.
					execute(commandStack, mode, selectedDifferences);
				}
			} finally {
				// Restore old delivery state. This will send notifications to the command stack listeners.
				if (oldDeliver) {
					transactionalDualCompareCommandStack.setDeliver(true);
				}
			}
		} else {
			// Execute the command to process using the selected mode the selected diffs.
			execute(commandStack, mode, selectedDifferences);
		}

		if (navigatable != null && EMFCompareIDEUIPlugin.getDefault().getPreferenceStore()
				.getBoolean(EMFCompareUIPreferences.SELECT_NEXT_UNRESOLVED_DIFF)) {
			// navigator is null in MergeAllNonConflictingAction
			navigatable.selectChange(Navigatable.NEXT_UNRESOLVED_CHANGE);
		}
	}

	protected void execute(ICompareCommandStack commandStack, MergeMode mode, List<Diff> diffs) {
		IMergeRunnable runnable = createMergeRunnable(mode, isLeftEditable(), isRightEditable(),
				diffRelationshipComputer);
		ICompareCopyCommand command = editingDomain.createCopyCommand(diffs,
				mode.isLeftToRight(isLeftEditable(), isRightEditable()), mergerRegistry, runnable);
		commandStack.execute(command);
	}

	/**
	 * A facade to get a more manageable command stack when undoing and redoing certain diffs.
	 * <p>
	 * Maintains a list of diff changes and a map from each of those to a possible associated edit command.
	 * This allows to properly detect cases that we can't support and redo undone diffs.
	 * </p>
	 * 
	 * @author Philip Langer <planger@eclipsesource.com>
	 */
	private class ManagedCommandStack {

		private List<Multimap<DifferenceState, Diff>> diffChangesList = Lists.newArrayList();

		private Map<Multimap<DifferenceState, Diff>, EditCommand> editCommands = new IdentityHashMap<Multimap<DifferenceState, Diff>, EditCommand>();

		private int nonRepeatableCommandCount = 0;

		private ICompareCommandStack commandStack;

		private boolean isChangeUndoneYet;

		public ManagedCommandStack(ICompareCommandStack commandStack) {
			this.commandStack = commandStack;
		}

		private void addChangedDiffs(Multimap<DifferenceState, Diff> changedDiffs) {
			diffChangesList.add(changedDiffs);
		}

		private void addChangedDiffs(Multimap<DifferenceState, Diff> changedDiffs, EditCommand editCommand) {
			addChangedDiffs(changedDiffs);
			editCommands.put(changedDiffs, editCommand);
		}

		private int getChangedDiffsSize() {
			return diffChangesList.size();
		}

		private void reverseDiffChanges() {
			Collections.reverse(diffChangesList);
		}

		private List<Multimap<DifferenceState, Diff>> getDiffChanges() {
			return diffChangesList;
		}

		private EditCommand getEditCommand(Multimap<DifferenceState, Diff> diffChanges) {
			return editCommands.get(diffChanges);
		}

		private void increaseNonRepeatableCommandCount() {
			nonRepeatableCommandCount = nonRepeatableCommandCount + 1;
		}

		public int getNonRepeatableCommandsCount() {
			return nonRepeatableCommandCount;
		}

		public int getUndoneCommandsCount() {
			return getNonRepeatableCommandsCount() + getChangedDiffsSize();
		}

		public boolean hasUnrepeatableCommands() {
			return getNonRepeatableCommandsCount() > 0;
		}

		public void undoUntilDiffsAreInTerminalState(List<Diff> diffs) {
			while (commandStack.canUndo() && any(diffs, IS_IN_TERMINAL_STATE)) {
				Command undoCommand = commandStack.getUndoCommand();

				// Keep track of undone changes
				if (undoCommand instanceof AbstractCopyCommand) {
					AbstractCopyCommand copyCommand = (AbstractCopyCommand)undoCommand;
					addChangedDiffs(copyCommand.getChangedDiffs());
				} else if (undoCommand instanceof EditCommand) {
					EditCommand editCommand = (EditCommand)undoCommand;
					addChangedDiffs(editCommand.getChangedDiffs(), editCommand);
				} else if (isCompoundCommandContainingAbstractCopyCommand(undoCommand)) {
					Command firstCommand = getFirstCommandFromCompoundCommand(undoCommand);
					AbstractCopyCommand copyCmd = (AbstractCopyCommand)firstCommand;
					addChangedDiffs(copyCmd.getChangedDiffs());
				} else {
					increaseNonRepeatableCommandCount();
				}

				commandStack.undo();
			}
		}

		public void restoreCommandStack() {
			for (int i = getUndoneCommandsCount(); i > 0; --i) {
				commandStack.redo();
			}
		}

		/**
		 * Performs a redo of all commands that have previously been undone with this managed command stack,
		 * except for the specified <code>diffsToExclude</code>.
		 * 
		 * @param diffsToExclude
		 *            Diffs to exclude from redoing.
		 * @param mode
		 *            The merge mode.
		 * @return whether we've needed to undo any of the <code>diffsToExclude</code>.
		 */
		public boolean redoExcept(List<Diff> diffsToExclude, MergeMode mode) {
			isChangeUndoneYet = false;
			reverseDiffChanges();

			for (Multimap<DifferenceState, Diff> diffsToBeRestored : getDiffChanges()) {
				redoExcept(diffsToBeRestored, diffsToExclude, mode);
			}

			return isChangeUndoneYet;
		}

		private void redoExcept(Multimap<DifferenceState, Diff> diffsToRestore, List<Diff> diffsToExclude,
				MergeMode mode) {
			// If there is an edit command associated with these diff changes...
			EditCommand editCommand = getEditCommand(diffsToRestore);
			if (editCommand != null) {
				// If any of the diffs changed by this edit command is the diff we are currently
				// processing, then ignore this edit command and its associated diff.
				Collection<Diff> discardedDiffs = diffsToRestore.get(DISCARDED);
				for (Diff diff : discardedDiffs) {
					if (diffsToExclude.contains(diff)) {
						return;
					}
				}

				undoIfNotUndoneYet();
				commandStack.execute(editCommand.recreate());
				return;
			}

			// Remove any diffs that have changed state because of other command execution.
			removeTerminalStateDiffs(diffsToRestore.values().iterator());

			// If there are diff changes that need to be restored...
			if (!diffsToRestore.values().isEmpty()) {
				undoIfNotUndoneYet();

				List<Diff> diffsToMerge = Lists.newArrayList(diffsToRestore.get(MERGED));
				List<Diff> diffsToDiscard = Lists.newArrayList(diffsToRestore.get(DISCARDED));

				if (mode == ACCEPT || mode == REJECT) {
					redoDiffs(diffsToMerge, diffsToDiscard, ACCEPT, REJECT);
				} else {
					List<Diff> diffsToBeCopiedLTR = Streams
							.concat(diffsToMerge.stream().filter(fromSource(LEFT)),
									diffsToDiscard.stream().filter(fromSource(RIGHT)))
							.collect(Collectors.toList());
					List<Diff> diffsToBeCopiedRTL = Stream
							.concat(diffsToMerge.stream().filter(fromSource(RIGHT)),
									diffsToDiscard.stream().filter(fromSource(LEFT)))
							.collect(Collectors.toList());
					redoDiffs(diffsToBeCopiedLTR, diffsToBeCopiedRTL, LEFT_TO_RIGHT, RIGHT_TO_LEFT);
				}
			}
		}

		private void redoDiffs(List<Diff> diffsToMerge, List<Diff> diffsToDiscarded, MergeMode modeForMerged,
				MergeMode modeForDiscarded) {
			// If there are any diffs that need to be in the merged state...
			if (!diffsToMerge.isEmpty()) {
				// Processed those diffs.
				executeCompareCopyCommand(commandStack, modeForMerged, diffsToMerge);
				// Clean up any discarded diffs that are already in the terminal state.
				removeTerminalStateDiffs(diffsToDiscarded.iterator());
			}

			// If there are any diffs that need to be in the discarded state...
			if (!diffsToDiscarded.isEmpty()) {
				// Process those diffs.
				executeCompareCopyCommand(commandStack, modeForDiscarded, diffsToDiscarded);
			}
		}

		private void undoIfNotUndoneYet() {
			if (!isChangeUndoneYet) {
				commandStack.undo();
				isChangeUndoneYet = true;
			}
		}

		private java.util.function.Predicate<? super Diff> fromSource(DifferenceSource source) {
			return (diff) -> diff.getSource() == source;
		}

		private boolean isCompoundCommandContainingAbstractCopyCommand(Command command) {
			Command firstCommand = getFirstCommandFromCompoundCommand(command);
			return firstCommand instanceof AbstractCopyCommand;
		}

		private Command getFirstCommandFromCompoundCommand(Command possiblyCompoundCommand) {
			Command command = null;
			if (possiblyCompoundCommand instanceof CompoundCommand) {
				final CompoundCommand compoundCommand = (CompoundCommand)possiblyCompoundCommand;
				if (!compoundCommand.getCommandList().isEmpty()) {
					command = compoundCommand.getCommandList().get(0);
				}
			}
			return command;
		}

		private void removeTerminalStateDiffs(Iterator<Diff> diffs) {
			while (diffs.hasNext()) {
				if (AbstractMerger.isInTerminalState(diffs.next())) {
					diffs.remove();
				}
			}
		}

	}

	protected void executeCompareCopyCommand(ICompareCommandStack commandStack, MergeMode mode,
			List<Diff> diffs) {
		IMergeRunnable runnable = new MergeRunnableImpl(isLeftEditable(), isRightEditable(), mode,
				diffRelationshipComputer);
		ICompareCopyCommand command = editingDomain.createCopyCommand(diffs,
				mode.isLeftToRight(isLeftEditable(), isRightEditable()), mergerRegistry, runnable);
		commandStack.execute(command);
	}

	/**
	 * {@inheritDoc}
	 * 
	 * @see org.eclipse.ui.actions.BaseSelectionListenerAction#updateSelection(org.eclipse.jface.viewers.IStructuredSelection)
	 */
	@Override
	protected boolean updateSelection(IStructuredSelection selection) {
		addAll(selectedDifferences, getSelectedDifferences(selection));
		if (this.adapterFactory != null) {
			contextualizeTooltip();
		}
		// The action is enabled only if all the elements in the selection are diffs that will change state
		// when this action is applied.
		return !selectedDifferences.isEmpty() && selection.toList().size() == selectedDifferences.size();
	}

	/**
	 * {@inheritDoc}
	 * 
	 * @see org.eclipse.ui.actions.BaseSelectionListenerAction#clearCache()
	 */
	@Override
	protected void clearCache() {
		selectedDifferences.clear();
	}

	protected Iterable<Diff> getSelectedDifferences(IStructuredSelection selection) {
		List<?> selectedObjects = selection.toList();
		Iterable<Adapter> selectedAdapters = filter(selectedObjects, Adapter.class);
		Iterable<Notifier> selectedNotifiers = transform(selectedAdapters, ADAPTER__TARGET);
		Iterable<TreeNode> selectedTreeNode = filter(selectedNotifiers, TreeNode.class);
		Iterable<EObject> selectedEObjects = transform(selectedTreeNode, IDifferenceGroup.TREE_NODE_DATA);
		Iterable<Diff> diffs = filter(selectedEObjects, Diff.class);
		return getSelectedDifferences(diffs);
	}

	protected Predicate<Diff> getStatePredicate() {
		return new Predicate<Diff>() {
			public boolean apply(Diff diff) {
				switch (diff.getState()) {
					case DISCARDED:
						switch (getSelectedMode()) {
							case ACCEPT:
								return true;
							case LEFT_TO_RIGHT:
								return diff.getSource() == LEFT;
							case RIGHT_TO_LEFT:
								return diff.getSource() == RIGHT;
							default:
								return false;
						}

					case MERGED:
						switch (getSelectedMode()) {
							case REJECT:
								return true;
							case RIGHT_TO_LEFT:
								return diff.getSource() == LEFT;
							case LEFT_TO_RIGHT:
								return diff.getSource() == RIGHT;
							default:
								return false;
						}
					default:
						return true;
				}
			}
		};
	}

	protected Iterable<Diff> getSelectedDifferences(Iterable<Diff> diffs) {
		ICompareCommandStack commandStack = editingDomain.getCommandStack();

		// We can only re-process diffs in the terminal state if we have a command stack that supports
		// suspending the delivery of notifications. So filter out diffs that are already in the terminal
		// state.
		if (!(commandStack instanceof TransactionalDualCompareCommandStack)) {
			return filter(diffs, IS_NOT_IN_TERMINAL_STATE);
		}

		// Filter out diffs whose state would not be changed by this actions's selected mode.
		return filter(diffs, getStatePredicate());
	}

	/**
	 * @param newValue
	 */
	public final void setEditingDomain(ICompareEditingDomain editingDomain) {
		this.editingDomain = editingDomain;
		clearCache();
		setEnabled(editingDomain != null && updateSelection(getStructuredSelection()));
	}

	/**
	 * Set the adapter factory used by this action.
	 * 
	 * @param adapterFactory
	 *            adapter factory
	 */
	public final void setAdapterFactory(AdapterFactory adapterFactory) {
		this.adapterFactory = adapterFactory;
		if (adapterFactory != null) {
			contextualizeTooltip();
		}
	}

	/**
	 * Refreshes the merge action by re-creating the necessary elements based on the current compare
	 * configuration.
	 */
	public void setMirrored(boolean mirrored) {
		if (selectedMode == ACCEPT || selectedMode == REJECT) {
			return;
		}

		this.isMirrored = mirrored;
	}

	/**
	 * @return the leftToRight
	 */
	protected final boolean isLeftToRight() {
		return getSelectedMode().isLeftToRight(isLeftEditable(), isRightEditable());
	}

	/**
	 * Returns the cached selected differences.
	 * 
	 * @return The cached selected differences.
	 */
	public List<Diff> getSelectedDifferences() {
		return selectedDifferences;
	}

	protected IDiffRelationshipComputer getDiffRelationshipComputer() {
		return diffRelationshipComputer;
	}

	protected MergeMode getSelectedMode() {
		if (isMirrored() && (selectedMode == LEFT_TO_RIGHT || selectedMode == RIGHT_TO_LEFT)) {
			return selectedMode.inverse();
		} else {
			return selectedMode;
		}
	}

	protected boolean isLeftEditable() {
		return compareConfiguration.isLeftEditable();
	}

	protected boolean isRightEditable() {
		return compareConfiguration.isRightEditable();
	}

	protected boolean isMirrored() {
		return isMirrored;
	}
}