/**
 * <copyright>
 *
 * Copyright (c) 2008-2010 See4sys, BMW Car IT and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
 *
 * Contributors:
 *     See4sys - Initial API and implementation
 *     BMW Car IT - Added/Updated javadoc
 *
 * </copyright>
 */
package org.eclipse.sphinx.emf.util;

import java.util.HashMap;
import java.util.Map;

import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.operations.IOperationHistory;
import org.eclipse.core.commands.operations.IUndoContext;
import org.eclipse.core.commands.operations.IUndoableOperation;
import org.eclipse.core.commands.operations.OperationHistoryFactory;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Status;
import org.eclipse.emf.common.command.CommandStack;
import org.eclipse.emf.transaction.Transaction;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.emf.transaction.impl.TransactionImpl;
import org.eclipse.emf.workspace.AbstractEMFOperation;
import org.eclipse.emf.workspace.IWorkspaceCommandStack;
import org.eclipse.emf.workspace.impl.WorkspaceCommandStackImpl;
import org.eclipse.osgi.util.NLS;
import org.eclipse.sphinx.emf.internal.messages.Messages;
import org.eclipse.sphinx.platform.operations.ILabeledRunnable;
import org.eclipse.sphinx.platform.operations.ILabeledWorkspaceRunnable;

/**
 * An utility class providing helper methods for handling and executing transactions on an EMF model.
 */
public final class WorkspaceTransactionUtil {

	// Prevent from instantiation
	private WorkspaceTransactionUtil() {
	}

	/**
	 * Returns the IOperationHistory for the given EditingDomain.
	 *
	 * @param editingDomain
	 *            The EditingDomain for which the IOperationHistory is to be retrieved.
	 * @return The IOperationHistory of the given <code>edingDomain</code>.
	 */
	public static IOperationHistory getOperationHistory(TransactionalEditingDomain editingDomain) {
		if (editingDomain != null) {
			CommandStack commandStack = editingDomain.getCommandStack();
			if (commandStack instanceof IWorkspaceCommandStack) {
				return ((IWorkspaceCommandStack) commandStack).getOperationHistory();
			}
		}
		return OperationHistoryFactory.getOperationHistory();
	}

	/**
	 * Returns the IUndoContext for the given EditingDomain.
	 *
	 * @param editingDomain
	 *            The EditingDomain for which the IUndoContext is to be retrieved.
	 * @return The IUndoContext of the given <code>edingDomain</code>.
	 */
	public static IUndoContext getUndoContext(TransactionalEditingDomain editingDomain) {
		if (editingDomain != null) {
			CommandStack commandStack = editingDomain.getCommandStack();
			if (commandStack instanceof WorkspaceCommandStackImpl) {
				return IOperationHistory.GLOBAL_UNDO_CONTEXT;
			}
		}
		return (IUndoContext) ResourcesPlugin.getWorkspace().getAdapter(IUndoContext.class);
	}

	/**
	 * Returns a default set of options which can be used for executing an operation within a transaction.
	 *
	 * @return The default options for executing an operation in a transaction.
	 */
	public static Map<String, Object> getDefaultTransactionOptions() {
		Map<String, Object> options = new HashMap<String, Object>();
		options.put(TransactionImpl.BLOCK_CHANGE_PROPAGATION, Boolean.TRUE);
		options.put(Transaction.OPTION_NO_VALIDATION, Boolean.TRUE);
		return options;
	}

	/**
	 * Returns a default set of options which can be used for executing an operation saving a new model within a write
	 * transaction.
	 *
	 * @return The default options for executing a save new operation in a transaction.
	 */
	public static Map<String, Object> getDefaultSaveNewTransactionOptions() {
		Map<String, Object> options = WorkspaceTransactionUtil.getDefaultTransactionOptions();
		options.put(Transaction.OPTION_NO_UNDO, Boolean.TRUE);
		return options;
	}

	/**
	 * Returns a default set of options which can be used for executing an operation saving an existing model within a
	 * write transaction.
	 *
	 * @return The default options for executing a save operation in a transaction.
	 */
	public static Map<String, Object> getDefaultSaveTransactionOptions() {
		Map<String, Object> options = WorkspaceTransactionUtil.getDefaultTransactionOptions();
		options.put(Transaction.OPTION_NO_UNDO, Boolean.TRUE);
		options.put(Transaction.OPTION_NO_NOTIFICATIONS, Boolean.TRUE);
		options.put(Transaction.OPTION_NO_TRIGGERS, Boolean.TRUE);
		return options;
	}

	/**
	 * Executes given {@linkplain Runnable runnable} in a write transaction.
	 *
	 * @param editingDomain
	 *            The {@linkplain TransactionalEditingDomain editing domain} receiving the transaction.
	 * @param runnable
	 *            The {@linkplain Runnable runnable} to be executed.
	 * @param operationLabel
	 *            The label of the operation to be executed.
	 * @throws OperationCanceledException
	 *             Thrown when the transaction is cancelled by the user.
	 * @throws ExecutionException
	 *             Thrown when the transaction could not be completed to an Exception.
	 **/
	public static void executeInWriteTransaction(TransactionalEditingDomain editingDomain, Runnable runnable, String operationLabel)
			throws OperationCanceledException, ExecutionException {
		executeInWriteTransaction(editingDomain, runnable, operationLabel, getOperationHistory(editingDomain), getDefaultTransactionOptions());
	}

	/**
	 * Execute given {@linkplain Runnable runnable} in a write transaction.
	 *
	 * @param editingDomain
	 *            The {@linkplain TransactionalEditingDomain editing domain} receiving the transaction.
	 * @param runnable
	 *            The {@linkplain Runnable runnable} to be executed.
	 * @param operationLabel
	 *            The label of the operation to be executed.
	 * @param operationHistory
	 *            The {@linkplain IOperationHistory operation history} to store the executed operation.
	 * @param transactionOptions
	 *            The options to set the transaction.
	 * @throws OperationCanceledException
	 *             Thrown when the transaction is canceled by the user.
	 * @throws ExecutionException
	 *             Thrown when the transaction could not be completed to an Exception.
	 **/
	public static void executeInWriteTransaction(TransactionalEditingDomain editingDomain, final Runnable runnable, final String operationLabel,
			IOperationHistory operationHistory, final Map<String, Object> transactionOptions) throws OperationCanceledException, ExecutionException {
		Assert.isNotNull(editingDomain);
		Assert.isNotNull(runnable);
		Assert.isNotNull(operationHistory);

		final String safeLabel = operationLabel == null ? "Unnamed operation" : operationLabel; //$NON-NLS-1$
		IUndoableOperation operation = new AbstractEMFOperation(editingDomain, safeLabel, transactionOptions) {
			@Override
			protected IStatus doExecute(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
				try {
					runnable.run();
					return Status.OK_STATUS;
				} catch (Exception ex) {
					if (ex instanceof OperationCanceledException) {
						throw (OperationCanceledException) ex;
					} else {
						throw new ExecutionException(NLS.bind(Messages.problem_transactionFailed, safeLabel), ex);
					}
				}
			}

			@Override
			public boolean canUndo() {
				return transactionOptions.get(Transaction.OPTION_NO_UNDO) != Boolean.TRUE;
			}
		};
		// Perform the execution of the transaction.
		IStatus status = operationHistory.execute(operation, null, null);

		if (status.getSeverity() == IStatus.CANCEL) {
			throw new OperationCanceledException();
		}
	}

	/**
	 * Execute given {@linkplain Runnable runnable} in a write transaction.
	 *
	 * @param editingDomain
	 *            The {@linkplain TransactionalEditingDomain editing domain} receiving the transaction.
	 * @param runnable
	 *            The {@linkplain Runnable runnable} to be executed.
	 * @param operationLabel
	 *            The label of the operation to be executed.
	 * @param operationHistory
	 *            The {@linkplain IOperationHistory operation history} to store the executed operation.
	 * @param transactionOptions
	 *            The options to set the transaction.
	 * @param monitor
	 *            The {@linkplain IProgressMonitor progress monitor} to use during operation execution.
	 * @throws OperationCanceledException
	 *             Thrown when the transaction is canceled by the user.
	 * @throws ExecutionException
	 *             Thrown when the transaction could not be completed to an Exception.
	 * @since 0.7.0
	 * @deprecated Use
	 *             {@link #executeInWriteTransaction(TransactionalEditingDomain, Runnable, String, IOperationHistory, Map)}
	 *             or
	 *             {@link #executeInWriteTransaction(TransactionalEditingDomain, ILabeledWorkspaceRunnable, IOperationHistory, Map, IProgressMonitor)}
	 *             instead.
	 **/
	@Deprecated
	public static void executeInWriteTransaction(TransactionalEditingDomain editingDomain, final Runnable runnable, final String operationLabel,
			IOperationHistory operationHistory, final Map<String, Object> transactionOptions, IProgressMonitor monitor)
					throws OperationCanceledException, ExecutionException {
		Assert.isNotNull(editingDomain);
		Assert.isNotNull(runnable);
		Assert.isNotNull(operationHistory);

		final String safeLabel = operationLabel == null ? "Unnamed operation" : operationLabel; //$NON-NLS-1$
		IUndoableOperation operation = new AbstractEMFOperation(editingDomain, safeLabel, transactionOptions) {
			@Override
			protected IStatus doExecute(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
				try {
					runnable.run();
					return Status.OK_STATUS;
				} catch (Exception ex) {
					if (ex instanceof OperationCanceledException) {
						throw (OperationCanceledException) ex;
					} else {
						throw new ExecutionException(NLS.bind(Messages.problem_transactionFailed, safeLabel), ex);
					}
				}
			}

			@Override
			public boolean canUndo() {
				return transactionOptions.get(Transaction.OPTION_NO_UNDO) != Boolean.TRUE;
			}
		};
		// Perform the execution of the transaction.
		IStatus status = operationHistory.execute(operation, monitor, null);

		if (status.getSeverity() == IStatus.CANCEL) {
			throw new OperationCanceledException();
		}
	}

	/**
	 * Executes given {@linkplain ILabeledRunnable runnable} in a write transaction.
	 *
	 * @param editingDomain
	 *            The {@linkplain TransactionalEditingDomain editing domain} receiving the transaction.
	 * @param runnable
	 *            The {@linkplain ILabeledRunnable runnable} to be executed.
	 * @throws OperationCanceledException
	 *             Thrown when the transaction is cancelled by the user.
	 * @throws ExecutionException
	 *             Thrown when the transaction could not be completed to an Exception.
	 **/
	public static void executeInWriteTransaction(TransactionalEditingDomain editingDomain, ILabeledRunnable runnable)
			throws OperationCanceledException, ExecutionException {
		executeInWriteTransaction(editingDomain, runnable, runnable.getLabel(), getOperationHistory(editingDomain), getDefaultTransactionOptions());
	}

	/**
	 * Execute given {@linkplain ILabeledRunnable runnable} in a write transaction.
	 *
	 * @param editingDomain
	 *            The {@linkplain TransactionalEditingDomain editing domain} receiving the transaction.
	 * @param runnable
	 *            The {@linkplain ILabeledRunnable runnable} to be executed.
	 * @param operationHistory
	 *            The {@linkplain IOperationHistory operation history} to store the executed operation.
	 * @param transactionOptions
	 *            The options to set the transaction.
	 * @throws OperationCanceledException
	 *             Thrown when the transaction is canceled by the user.
	 * @throws ExecutionException
	 *             Thrown when the transaction could not be completed to an Exception.
	 **/
	public static void executeInWriteTransaction(TransactionalEditingDomain editingDomain, ILabeledRunnable runnable,
			IOperationHistory operationHistory, Map<String, Object> transactionOptions) throws OperationCanceledException, ExecutionException {
		executeInWriteTransaction(editingDomain, runnable, runnable.getLabel(), operationHistory, transactionOptions);
	}

	/**
	 * Executes given {@linkplain ILabeledWorkspaceRunnable runnable} in a write transaction.
	 *
	 * @param editingDomain
	 *            The {@linkplain TransactionalEditingDomain editing domain} receiving the transaction.
	 * @param runnable
	 *            The {@linkplain ILabeledWorkspaceRunnable runnable} to be executed.
	 * @param monitor
	 *            The {@linkplain IProgressMonitor progress monitor} to use during operation execution.
	 * @throws OperationCanceledException
	 *             Thrown when the transaction is cancelled by the user.
	 * @throws ExecutionException
	 *             Thrown when the transaction could not be completed to an Exception.
	 **/
	public static void executeInWriteTransaction(TransactionalEditingDomain editingDomain, ILabeledWorkspaceRunnable runnable,
			IProgressMonitor monitor) throws OperationCanceledException, ExecutionException {
		executeInWriteTransaction(editingDomain, runnable, getOperationHistory(editingDomain), getDefaultTransactionOptions(), monitor);
	}

	/**
	 * Execute given {@linkplain ILabeledWorkspaceRunnable runnable} in a write transaction.
	 *
	 * @param editingDomain
	 *            The {@linkplain TransactionalEditingDomain editing domain} receiving the transaction.
	 * @param runnable
	 *            The {@linkplain ILabeledWorkspaceRunnable runnable} to be executed.
	 * @param operationHistory
	 *            The {@linkplain IOperationHistory operation history} to store the executed operation.
	 * @param transactionOptions
	 *            The options to set the transaction.
	 * @param monitor
	 *            The {@linkplain IProgressMonitor progress monitor} to use during operation execution.
	 * @throws OperationCanceledException
	 *             Thrown when the transaction is canceled by the user.
	 * @throws ExecutionException
	 *             Thrown when the transaction could not be completed to an Exception.
	 **/
	public static void executeInWriteTransaction(TransactionalEditingDomain editingDomain, final ILabeledWorkspaceRunnable runnable,
			IOperationHistory operationHistory, final Map<String, Object> transactionOptions, IProgressMonitor monitor)
					throws OperationCanceledException, ExecutionException {
		Assert.isNotNull(editingDomain);
		Assert.isNotNull(runnable);
		Assert.isNotNull(operationHistory);

		String label = runnable.getLabel();
		final String safeLabel = label == null ? "Unnamed operation" : label; //$NON-NLS-1$
		IUndoableOperation operation = new AbstractEMFOperation(editingDomain, safeLabel, transactionOptions) {
			@Override
			protected IStatus doExecute(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
				try {
					runnable.run(monitor);
					return Status.OK_STATUS;
				} catch (Exception ex) {
					if (ex instanceof OperationCanceledException) {
						throw (OperationCanceledException) ex;
					} else {
						throw new ExecutionException(NLS.bind(Messages.problem_transactionFailed, safeLabel), ex);
					}
				}
			}

			@Override
			public boolean canUndo() {
				return transactionOptions.get(Transaction.OPTION_NO_UNDO) != Boolean.TRUE;
			}
		};
		// Perform the execution of the transaction.
		IStatus status = operationHistory.execute(operation, monitor, null);

		if (status.getSeverity() == IStatus.CANCEL) {
			throw new OperationCanceledException();
		}
	}
}