/*******************************************************************************
 * Copyright (c) 2005, 2008 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
 *******************************************************************************/

package org.eclipse.ui.internal.handlers;

import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.IHandler;
import org.eclipse.core.commands.IHandler2;
import org.eclipse.core.commands.IHandlerListener;
import org.eclipse.core.commands.IObjectWithState;
import org.eclipse.core.commands.ParameterizedCommand;
import org.eclipse.core.commands.State;
import org.eclipse.core.expressions.EvaluationResult;
import org.eclipse.core.expressions.Expression;
import org.eclipse.core.expressions.IEvaluationContext;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.InvalidRegistryObjectException;
import org.eclipse.core.runtime.ListenerList;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.swt.widgets.Event;
import org.eclipse.ui.IActionDelegate;
import org.eclipse.ui.IActionDelegate2;
import org.eclipse.ui.IActionDelegateWithEvent;
import org.eclipse.ui.IEditorActionDelegate;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.INullSelectionListener;
import org.eclipse.ui.IObjectActionDelegate;
import org.eclipse.ui.IPartListener2;
import org.eclipse.ui.ISelectionListener;
import org.eclipse.ui.ISources;
import org.eclipse.ui.IViewActionDelegate;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchPartReference;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkbenchWindowActionDelegate;
import org.eclipse.ui.internal.WorkbenchPlugin;

/**
 * <p>
 * This proxies an {@link IActionDelegate} so that it can impersonate an
 * {@link IHandler}.
 * </p>
 * <p>
 * This class is not intended for use outside of the
 * <code>org.eclipse.ui.workbench</code> plug-in.
 * </p>
 * 
 * @since 3.2
 */
public final class ActionDelegateHandlerProxy implements ISelectionListener,
		ISelectionChangedListener, INullSelectionListener, IHandler2,
		IObjectWithState, IPartListener2 {

	/**
	 * The fake action that proxies all of the command-based services. This
	 * value is never <code>null</code>.
	 */
	private CommandLegacyActionWrapper action;

	/**
	 * The identifier of the actions to create as a wrapper to the command
	 * architecture. This value may be <code>null</code>.
	 */
	private String actionId;

	/**
	 * The command that will back the dummy actions exposed to this delegate.
	 * This value is never <code>null</code>.
	 */
	private ParameterizedCommand command;

	/**
	 * This is the current selection, as seen by this proxy.
	 */
	private ISelection currentSelection;

	/**
	 * The delegate, if it has been created yet.
	 */
	private IActionDelegate delegate;

	//
	// instead of casting, which is unreliable, pick
	// a delegate type based on the IConfigurationElement
	//
	private IEditorActionDelegate editorDelegate = null;
	private IViewActionDelegate viewDelegate = null;
	private IObjectActionDelegate objectDelegate = null;
	private IWorkbenchWindowActionDelegate windowDelegate = null;
	
	private IWorkbenchPart currentPart = null;

	/**
	 * The name of the configuration element attribute which contains the
	 * information necessary to instantiate the real handler.
	 */
	private String delegateAttributeName;

	/**
	 * The configuration element from which the handler can be created. This
	 * value will exist until the element is converted into a real class -- at
	 * which point this value will be set to <code>null</code>.
	 */
	private IConfigurationElement element;

	/**
	 * The <code>enabledWhen</code> expression for the handler. Only if this
	 * expression evaluates to <code>true</code> (or the value is
	 * <code>null</code>) should we consult the handler.
	 */
	private final Expression enabledWhenExpression;

	/**
	 * A collection of objects listening to changes to this manager. This
	 * collection is <code>null</code> if there are no listeners.
	 */
	private transient ListenerList listenerList = null;

	/**
	 * The image style to use when selecting the images to display for this
	 * delegate. This value may be <code>null</code>, if the default style
	 * should be used.
	 */
	private final String style;

	/**
	 * The identifier of the view with which this delegate must be associated.
	 * This value is not <code>null</code> iff the delegate is an
	 * {@link IViewActionDelegate}.
	 */
	private final String viewId;

	/**
	 * The workbench window in which this delegate is active. This value is
	 * never <code>null</code>.
	 */
	private final IWorkbenchWindow window;

	/**
	 * Constructs a new instance of <code>ActionDelegateHandlerProxy</code>
	 * with all the information it needs to try to avoid loading until it is
	 * needed.
	 * 
	 * @param element
	 *            The configuration element from which the real class can be
	 *            loaded at run-time; must not be <code>null</code>.
	 * @param delegateAttributeName
	 *            The name of the attibute or element containing the action
	 *            delegate; must not be <code>null</code>.
	 * @param actionId
	 *            The identifier of the underlying action; may be
	 *            <code>null</code>.
	 * @param command
	 *            The command with which the action delegate will be associated;
	 *            must not be <code>null</code>.
	 * @param window
	 *            The workbench window in which this delegate will be active;
	 *            must not be <code>null</code>.
	 * @param style
	 *            The image style with which the icons are associated; may be
	 *            <code>null</code>.
	 * @param enabledWhenExpression
	 *            The name of the element containing the enabledWhen expression.
	 *            This should be a child of the
	 *            <code>configurationElement</code>. If this value is
	 *            <code>null</code>, then there is no enablement expression
	 *            (i.e., enablement will be delegated to the handler when
	 *            possible).
	 * @param viewId
	 *            The identifier of the view to which this proxy is bound; may
	 *            be <code>null</code> if this proxy is not for an
	 *            {@link IViewActionDelegate}.
	 */
	public ActionDelegateHandlerProxy(final IConfigurationElement element,
			final String delegateAttributeName, final String actionId,
			final ParameterizedCommand command, final IWorkbenchWindow window,
			final String style, final Expression enabledWhenExpression,
			final String viewId) {
		if (element == null) {
			throw new NullPointerException(
					"The configuration element backing a handler proxy cannot be null"); //$NON-NLS-1$
		}

		if (delegateAttributeName == null) {
			throw new NullPointerException(
					"The attribute containing the action delegate must be known"); //$NON-NLS-1$
		}

		if (window == null) {
			throw new NullPointerException(
					"The workbench window for a delegate must not be null"); //$NON-NLS-1$
		}

		this.element = element;
		this.enabledWhenExpression = enabledWhenExpression;
		this.delegateAttributeName = delegateAttributeName;
		this.window = window;
		this.command = command;
		this.actionId = actionId;
		this.style = style;
		this.viewId = viewId;
	}

	public final void addHandlerListener(final IHandlerListener handlerListener) {
		if (listenerList == null) {
			listenerList = new ListenerList(ListenerList.IDENTITY);
		}

		listenerList.add(handlerListener);
	}

	public void addState(String id, State state) {
		// TODO Auto-generated method stub

	}

	
	public final void dispose() {
		disposeDelegate();
	}

	/**
	 * 
	 */
	private void disposeDelegate() {
		final IActionDelegate actDel = getDelegate();
		if (actDel instanceof IWorkbenchWindowActionDelegate) {
			final IWorkbenchWindowActionDelegate workbenchWindowDelegate = (IWorkbenchWindowActionDelegate) actDel;
			workbenchWindowDelegate.dispose();
		} else if (actDel instanceof IActionDelegate2) {
			final IActionDelegate2 delegate2 = (IActionDelegate2) actDel;
			delegate2.dispose();
		}
		delegate = null;
		editorDelegate = null;
		objectDelegate = null;
		viewDelegate = null;
		windowDelegate = null;
		currentSelection = null;
	}

	public final Object execute(final ExecutionEvent event) {
		final IAction action = getAction();
		if (loadDelegate() && (action != null)) {
			final Object trigger = event.getTrigger();

			// Attempt to update the selection.
			final Object applicationContext = event.getApplicationContext();
			if (applicationContext instanceof IEvaluationContext) {
				final IEvaluationContext context = (IEvaluationContext) applicationContext;
				updateDelegate(action, context);
			}

			// Decide what type of delegate we have.
			if ((delegate instanceof IActionDelegate2)
					&& (trigger instanceof Event)) {
				// This supports Eclipse 2.1 to Eclipse 3.1.
				final IActionDelegate2 delegate2 = (IActionDelegate2) delegate;
				final Event triggeringEvent = (Event) trigger;
				delegate2.runWithEvent(action, triggeringEvent);
			} else if ((delegate instanceof IActionDelegateWithEvent)
					&& (trigger instanceof Event)) {
				// This supports Eclipse 2.0
				final IActionDelegateWithEvent delegateWithEvent = (IActionDelegateWithEvent) delegate;
				final Event triggeringEvent = (Event) trigger;
				delegateWithEvent.runWithEvent(action, triggeringEvent);
			} else {
				delegate.run(action);
			}
		}

		return null;
	}

	/**
	 * @param action
	 * @param context
	 */
	private void updateDelegate(final IAction action,
			final IEvaluationContext context) {
		if (action == null || delegate == null) {
			return;
		}

		if (editorDelegate != null) {
			final Object activeEditor = context
					.getVariable(ISources.ACTIVE_EDITOR_NAME);
			if (activeEditor != IEvaluationContext.UNDEFINED_VARIABLE) {
				editorDelegate.setActiveEditor(action,
						(IEditorPart) activeEditor);
			}
			updateActivePart(activeEditor==IEvaluationContext.UNDEFINED_VARIABLE
					?null:(IWorkbenchPart)activeEditor);
		} else if (objectDelegate != null) {
			final Object activePart = context
					.getVariable(ISources.ACTIVE_PART_NAME);
			if (activePart != IEvaluationContext.UNDEFINED_VARIABLE) {
				objectDelegate.setActivePart(action,
						(IWorkbenchPart) activePart);
			}
			updateActivePart(activePart==IEvaluationContext.UNDEFINED_VARIABLE
					?null:(IWorkbenchPart) activePart);
		}

		final Object selectionObject = getCurrentSelection(context);
		if (selectionObject instanceof ISelection) {
			currentSelection = (ISelection) selectionObject;
		} else {
			currentSelection = null;
		}
		if (delegate != null) {
			delegate.selectionChanged(action, currentSelection);
		}
	}

	/**
	 * @param activePart
	 */
	private void updateActivePart(IWorkbenchPart activePart) {
		if (currentPart == activePart) {
			return;
		}
		if (currentPart != null) {
			currentPart.getSite().getPage().removePartListener(this);
		}
		if (activePart != null) {
			activePart.getSite().getPage().addPartListener(this);
		} else {
			selectionChanged(StructuredSelection.EMPTY);
			disposeDelegate();
			if (action!=null) {
				action.setEnabled(true);
			}
		}
		currentPart = activePart;
	}

	/**
	 * @param context
	 * @return
	 */
	private Object getCurrentSelection(final IEvaluationContext context) {
		Object obj = context
				.getVariable(ISources.ACTIVE_MENU_EDITOR_INPUT_NAME);
		if (obj == null || obj == IEvaluationContext.UNDEFINED_VARIABLE) {
			obj = context.getVariable(ISources.ACTIVE_MENU_SELECTION_NAME);
			if (obj == null || obj == IEvaluationContext.UNDEFINED_VARIABLE) {
				obj = context
						.getVariable(ISources.ACTIVE_CURRENT_SELECTION_NAME);
			}
		}
		return obj;
	}

	/**
	 * Retrieves the action corresponding to the currently active workbench
	 * window, if any.
	 * 
	 * @return The current action; <code>null</code> if there is no currently
	 *         active workbench window.
	 */
	private final CommandLegacyActionWrapper getAction() {
		if (action == null) {
			action = new CommandLegacyActionWrapper(actionId, command, style,
					window);
			action.addPropertyChangeListener(new IPropertyChangeListener() {
				public final void propertyChange(final PropertyChangeEvent event) {
					// TODO Update the state somehow.
				}
			});
		}
		return action;
	}

	/**
	 * Retrieves the delegate corresponding to the currently active workbench
	 * window, if any. This does not trigger loading of the delegate.
	 * 
	 * @return The current delegate; or <code>null</code> if none.
	 */
	private final IActionDelegate getDelegate() {
		return delegate;
	}

	public State getState(String stateId) {
		// TODO Auto-generated method stub
		return null;
	}

	public String[] getStateIds() {
		// TODO Auto-generated method stub
		return null;
	}

	public final void handleStateChange(final State state, final Object oldValue) {
		// TODO What should we do here?
	}

	/**
	 * Initialize the action delegate by calling its lifecycle method.
	 */
	private final boolean initDelegate() {
		final IWorkbenchPage page = window.getActivePage();
		final IWorkbenchPart activePart;
		final IEditorPart activeEditor;
		if (page == null) {
			activePart = null;
			activeEditor = null;
		} else {
			activePart = page.getActivePart();
			activeEditor = page.getActiveEditor();
		}
		final IActionDelegate delegate = getDelegate();
		final IAction action = getAction();

		// Check to see if the view delegate should be initialized.
		if ((viewId != null) && (page != null) && (viewDelegate != null)) {
			final IViewPart viewPart = page.findView(viewId);
			if (viewPart == null) {
				return false;
			}
		}

		// Initialize the delegate.
		final ISafeRunnable runnable = new ISafeRunnable() {
			public final void handleException(final Throwable exception) {
				// Do nothing.
			}

			public final void run() {
				// Handle IActionDelegate2
				if (delegate instanceof IActionDelegate2) {
					final IActionDelegate2 delegate2 = (IActionDelegate2) delegate;
					delegate2.init(action);
				}

				// Handle IObjectActionDelegates
				if ((objectDelegate != null) && (activePart != null)) {
					objectDelegate.setActivePart(action, activePart);
					updateActivePart(activePart);
				} else if (editorDelegate != null) {
					editorDelegate.setActiveEditor(action, activeEditor);
					updateActivePart(activeEditor);
				} else if ((viewId != null) && (page != null)
						&& (viewDelegate != null)) {
					final IViewPart viewPart = page.findView(viewId);
					viewDelegate.init(viewPart);
				} else if (windowDelegate != null) {
					windowDelegate.init(window);
				}
			}
		};
		SafeRunner.run(runnable);
		return true;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.core.commands.IHandler2#setEnabled(java.lang.Object)
	 */
	public void setEnabled(Object evaluationContext) {
		if (!(evaluationContext instanceof IEvaluationContext)) {
			return;
		}

		IEvaluationContext context = (IEvaluationContext) evaluationContext;
		final CommandLegacyActionWrapper action = getAction();
		if (enabledWhenExpression != null) {
			try {
				final EvaluationResult result = enabledWhenExpression
						.evaluate(context);
				if (action != null) {
					action.setEnabled(result != EvaluationResult.FALSE);
				}
			} catch (final CoreException e) {
				// We will just fall through an let it return false.
				final StringBuffer message = new StringBuffer(
						"An exception occurred while evaluating the enabledWhen expression for "); //$NON-NLS-1$
				if (delegate != null) {
					message.append(delegate);
				} else {
					message.append(element.getAttribute(delegateAttributeName));
				}
				message.append("' could not be loaded"); //$NON-NLS-1$
				final IStatus status = new Status(IStatus.WARNING,
						WorkbenchPlugin.PI_WORKBENCH, 0, e.getMessage(), e);
				WorkbenchPlugin.log(message.toString(), status);
				return;
			}
		}
		updateDelegate(action, context);
	}

	public final boolean isEnabled() {
		return (action == null) || action.isEnabledDisregardingCommand();
	}

	public final boolean isHandled() {
		return true;
	}

	/**
	 * Checks if the declaring plugin has been loaded. This means that there
	 * will be no need to delay creating the delegate.
	 * 
	 * @return <code>true</code> if the bundle containing the delegate is
	 *         already loaded -- making it safe to load the delegate.
	 */
	private final boolean isSafeToLoadDelegate() {
		return false;
		// TODO This causes problem because some people expect their selections
		// to be a particular class.
		// final String bundleId = element.getNamespace();
		// return BundleUtility.isActive(bundleId);
	}

	/**
	 * Loads the delegate, if possible. If the delegate is loaded, then the
	 * member variables are updated accordingly.
	 * 
	 * @return <code>true</code> if the delegate is now non-null;
	 *         <code>false</code> otherwise.
	 */
	private final boolean loadDelegate() {
		// Try to load the delegate, if it hasn't been loaded already.
		if (delegate == null) {
			/*
			 * If this is an IViewActionDelegate, then check to see if we have a
			 * view ready yet. If not, then we'll have to wait.
			 */
			if (viewId != null) {
				final IWorkbenchPage activePage = window.getActivePage();
				if (activePage != null) {
					final IViewPart part = activePage.findView(viewId);
					if (part == null) {
						return false;
					}
				} else {
					return false;
				}
			}

			// Load the delegate.
			try {
				delegate = (IActionDelegate) element
						.createExecutableExtension(delegateAttributeName);
				String name = element.getDeclaringExtension()
						.getExtensionPointUniqueIdentifier();
				if ("org.eclipse.ui.actionSets".equals(name) //$NON-NLS-1$
						&& delegate instanceof IWorkbenchWindowActionDelegate) {
					windowDelegate = (IWorkbenchWindowActionDelegate) delegate;
				} else if ("org.eclipse.ui.editorActions".equals(name) //$NON-NLS-1$
						&& delegate instanceof IEditorActionDelegate) {
					editorDelegate = (IEditorActionDelegate) delegate;
				} else if ("org.eclipse.ui.viewActions".equals(name) //$NON-NLS-1$
						&& delegate instanceof IViewActionDelegate) {
					viewDelegate = (IViewActionDelegate) delegate;
				} else if ("org.eclipse.ui.popupMenus".equals(name)) { //$NON-NLS-1$
					IConfigurationElement parent = (IConfigurationElement) element
							.getParent();
					if ("objectContribution".equals(parent.getName()) //$NON-NLS-1$
							&& delegate instanceof IObjectActionDelegate) {
						objectDelegate = (IObjectActionDelegate) delegate;
					} else if (viewId == null
							&& delegate instanceof IEditorActionDelegate) {
						editorDelegate = (IEditorActionDelegate) delegate;
					} else if (viewId != null
							&& delegate instanceof IViewActionDelegate) {
						viewDelegate = (IViewActionDelegate) delegate;
					}
				}
				if (initDelegate()) {
					return true;
				}

				delegate = null;
				objectDelegate = null;
				viewDelegate = null;
				editorDelegate = null;
				windowDelegate = null;
				return false;

			} catch (final ClassCastException e) {
				final String message = "The proxied delegate was the wrong class"; //$NON-NLS-1$
				final IStatus status = new Status(IStatus.ERROR,
						WorkbenchPlugin.PI_WORKBENCH, 0, message, e);
				WorkbenchPlugin.log(message, status);
				return false;

			} catch (final CoreException e) {
				final String message = "The proxied delegate for '" //$NON-NLS-1$
						+ element.getAttribute(delegateAttributeName)
						+ "' could not be loaded"; //$NON-NLS-1$
				IStatus status = new Status(IStatus.ERROR,
						WorkbenchPlugin.PI_WORKBENCH, 0, message, e);
				WorkbenchPlugin.log(message, status);
				return false;
			}
		}

		return true;
	}

	/**
	 * Refresh the action enablement.
	 */
	private final void refreshEnablement() {
		final IActionDelegate delegate = getDelegate();
		final IAction action = getAction();
		if ((delegate != null) && (action != null)) {
			delegate.selectionChanged(action, currentSelection);
		}
	}

	public void removeHandlerListener(IHandlerListener handlerListener) {
		if (listenerList != null) {
			listenerList.remove(handlerListener);

			if (listenerList.isEmpty()) {
				listenerList = null;
			}
		}
	}

	public void removeState(String stateId) {
		// TODO Auto-generated method stub

	}

	private final void selectionChanged(final ISelection selection) {
		// Update selection.
		currentSelection = selection;
		if (currentSelection == null) {
			currentSelection = StructuredSelection.EMPTY;
		}

		// The selection is passed to the delegate as-is without
		// modification. If the selection needs to be modified
		// the action contributors should do so.

		// If the delegate can be loaded, do so.
		// Otherwise, just update the enablement.
		final IActionDelegate delegate = getDelegate();
		if (delegate == null && isSafeToLoadDelegate()) {
			loadDelegate();
		}
		refreshEnablement();
	}

	public final void selectionChanged(final IWorkbenchPart part,
			final ISelection selection) {
		selectionChanged(selection);

	}

	public final void selectionChanged(final SelectionChangedEvent event) {
		final ISelection selection = event.getSelection();
		selectionChanged(selection);
	}

	public final String toString() {
		final StringBuffer buffer = new StringBuffer();
		buffer.append("ActionDelegateHandlerProxy("); //$NON-NLS-1$
		buffer.append(getDelegate());
		if (element != null) {
			buffer.append(',');
			try {
				final String className = element
						.getAttribute(delegateAttributeName);
				buffer.append(className);
			} catch (InvalidRegistryObjectException e) {
				buffer.append(actionId);
			}
		}
		buffer.append(')');
		return buffer.toString();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IPartListener2#partActivated(org.eclipse.ui.IWorkbenchPartReference)
	 */
	public void partActivated(IWorkbenchPartReference partRef) {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IPartListener2#partBroughtToTop(org.eclipse.ui.IWorkbenchPartReference)
	 */
	public void partBroughtToTop(IWorkbenchPartReference partRef) {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IPartListener2#partClosed(org.eclipse.ui.IWorkbenchPartReference)
	 */
	public void partClosed(IWorkbenchPartReference partRef) {
		if (currentPart != null && partRef.getPart(false) == currentPart) {
			updateActivePart(null);
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IPartListener2#partDeactivated(org.eclipse.ui.IWorkbenchPartReference)
	 */
	public void partDeactivated(IWorkbenchPartReference partRef) {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IPartListener2#partHidden(org.eclipse.ui.IWorkbenchPartReference)
	 */
	public void partHidden(IWorkbenchPartReference partRef) {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IPartListener2#partInputChanged(org.eclipse.ui.IWorkbenchPartReference)
	 */
	public void partInputChanged(IWorkbenchPartReference partRef) {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IPartListener2#partOpened(org.eclipse.ui.IWorkbenchPartReference)
	 */
	public void partOpened(IWorkbenchPartReference partRef) {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IPartListener2#partVisible(org.eclipse.ui.IWorkbenchPartReference)
	 */
	public void partVisible(IWorkbenchPartReference partRef) {
	}
}