/*******************************************************************************
 * Copyright (c) 2001, 2005 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
 *     Jens Lukowski/Innoopract - initial renaming/restructuring
 *     
 *******************************************************************************/
package org.eclipse.wst.sse.ui.internal.contentoutline;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.ListenerList;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.jface.action.GroupMarker;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.IContributionManager;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.util.DelegatingDragAdapter;
import org.eclipse.jface.util.DelegatingDropAdapter;
import org.eclipse.jface.util.SafeRunnable;
import org.eclipse.jface.util.TransferDragSourceListener;
import org.eclipse.jface.util.TransferDropTargetListener;
import org.eclipse.jface.viewers.DoubleClickEvent;
import org.eclipse.jface.viewers.IContentProvider;
import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.IPostSelectionProvider;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.DragSource;
import org.eclipse.swt.dnd.DropTarget;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.events.KeyListener;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.ISelectionListener;
import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.part.IPageSite;
import org.eclipse.ui.part.IShowInSource;
import org.eclipse.ui.part.IShowInTarget;
import org.eclipse.ui.part.IShowInTargetList;
import org.eclipse.ui.part.ShowInContext;
import org.eclipse.ui.views.contentoutline.ContentOutlinePage;
import org.eclipse.ui.views.contentoutline.IContentOutlinePage;
import org.eclipse.wst.sse.ui.views.contentoutline.ContentOutlineConfiguration;


public class ConfigurableContentOutlinePage extends ContentOutlinePage implements IAdaptable {
	/*
	 * Menu listener to create the additions group and add any menu items
	 * contributed by the configuration; required since the context menu is
	 * cleared every time it is shown
	 */
	class AdditionGroupAdder implements IMenuListener {
		public void menuAboutToShow(IMenuManager manager) {
			IContributionItem[] items = manager.getItems();
			if (items.length > 0 && items[items.length - 1].getId() != null) {
				manager.insertAfter(items[items.length - 1].getId(), new GroupMarker(IWorkbenchActionConstants.MB_ADDITIONS));
			}
			else {
				manager.add(new GroupMarker(IWorkbenchActionConstants.MB_ADDITIONS));
			}

			// add configuration's menu items
			IMenuListener listener = getConfiguration().getMenuListener(getTreeViewer());
			if (listener != null) {
				listener.menuAboutToShow(manager);
			}
		}
	}

	/**
	 * Provides double-click registration so it can be done before the Control
	 * is created.
	 */
	private class DoubleClickProvider implements IDoubleClickListener {
		private IDoubleClickListener[] listeners = null;

		void addDoubleClickListener(IDoubleClickListener newListener) {
			if (listeners == null) {
				listeners = new IDoubleClickListener[]{newListener};
			}
			else {
				IDoubleClickListener[] newListeners = new IDoubleClickListener[listeners.length + 1];
				System.arraycopy(listeners, 0, newListeners, 0, listeners.length);
				newListeners[listeners.length] = newListener;
				listeners = newListeners;
			}
		}

		public void doubleClick(DoubleClickEvent event) {
			fireDoubleClickEvent(event);
		}

		private void fireDoubleClickEvent(final DoubleClickEvent event) {
			IDoubleClickListener[] firingListeners = listeners;
			for (int i = 0; i < firingListeners.length; ++i) {
				final IDoubleClickListener l = firingListeners[i];
				SafeRunner.run(new SafeRunnable() {
					public void run() {
						l.doubleClick(event);
					}
				});
			}
		}

		void removeDoubleClickListener(IDoubleClickListener oldListener) {
			if (listeners != null) {
				if (listeners.length == 1 && listeners[0].equals(oldListener)) {
					listeners = null;
				}
				else {
					List newListeners = new ArrayList(Arrays.asList(listeners));
					newListeners.remove(oldListener);
					listeners = (IDoubleClickListener[]) newListeners.toArray(new IDoubleClickListener[listeners.length - 1]);
				}
			}
		}
	}

	/**
	 * Listens to post selection from the selection service, applying it to
	 * the tree viewer.
	 */
	private class PostSelectionServiceListener implements ISelectionListener {
		public void selectionChanged(IWorkbenchPart part, ISelection selection) {
			// from selection service
			if (_DEBUG) {
				_DEBUG_TIME = System.currentTimeMillis();
			} /*
				 * Bug 136310, unless this page is that part's
				 * IContentOutlinePage, ignore the selection change
				 */
			if (part == null || part.getAdapter(IContentOutlinePage.class) == ConfigurableContentOutlinePage.this) {
				ISelection validContentSelection = getConfiguration().getSelection(getTreeViewer(), selection);

				boolean isLinked = getConfiguration().isLinkedWithEditor(getTreeViewer());
				if (isLinked) {
					getTreeViewer().setSelection(validContentSelection, true);
				}
			}
			if (_DEBUG) {
				System.out.println("(O:" + (System.currentTimeMillis() - _DEBUG_TIME) + "ms) " + part + " : " + selection); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
			}
		}
	}

	/**
	 * Forwards post-selection from the tree viewer to the listeners while
	 * acting as this page's selection provider.
	 */
	private class SelectionProvider implements IPostSelectionProvider {
		private class PostSelectionChangedListener implements ISelectionChangedListener {
			public void selectionChanged(SelectionChangedEvent event) {
				if (!isFiringSelection()) {
					fireSelectionChanged(event, postListeners);
				}
			}
		}

		private class SelectionChangedListener implements ISelectionChangedListener {
			public void selectionChanged(SelectionChangedEvent event) {
				if (!isFiringSelection()) {
					fireSelectionChanged(event, listeners);
				}
			}
		}

		private boolean isFiringSelection = false;
		private ListenerList listeners = new ListenerList();
		private ListenerList postListeners = new ListenerList();
		private ISelectionChangedListener postSelectionChangedListener = new PostSelectionChangedListener();
		private ISelectionChangedListener selectionChangedListener = new SelectionChangedListener();

		public void addPostSelectionChangedListener(ISelectionChangedListener listener) {
			postListeners.add(listener);
		}

		public void addSelectionChangedListener(ISelectionChangedListener listener) {
			listeners.add(listener);
		}

		public void fireSelectionChanged(final SelectionChangedEvent event, ListenerList listenerList) {
			isFiringSelection = true;
			Object[] listeners = listenerList.getListeners();
			for (int i = 0; i < listeners.length; ++i) {
				final ISelectionChangedListener l = (ISelectionChangedListener) listeners[i];
				SafeRunner.run(new SafeRunnable() {
					public void run() {
						l.selectionChanged(event);
					}
				});
			}
			isFiringSelection = false;
		}

		public ISelectionChangedListener getPostSelectionChangedListener() {
			return postSelectionChangedListener;
		}

		public ISelection getSelection() {
			if (getTreeViewer() != null) {
				return getTreeViewer().getSelection();
			}
			return StructuredSelection.EMPTY;
		}

		public ISelectionChangedListener getSelectionChangedListener() {
			return selectionChangedListener;
		}

		public boolean isFiringSelection() {
			return isFiringSelection;
		}

		public void removePostSelectionChangedListener(ISelectionChangedListener listener) {
			postListeners.remove(listener);
		}

		public void removeSelectionChangedListener(ISelectionChangedListener listener) {
			listeners.remove(listener);
		}

		public void setSelection(ISelection selection) {
			if (!isFiringSelection) {
				getTreeViewer().setSelection(selection);
			}
		}
	}

	private class ShowInTarget implements IShowInTarget {
		/*
		 * @see org.eclipse.ui.part.IShowInTarget#show(org.eclipse.ui.part.ShowInContext)
		 */
		public boolean show(ShowInContext context) {
			setSelection(context.getSelection());
			return getTreeViewer().getSelection().equals(context.getSelection());
		}
	}

	protected static final ContentOutlineConfiguration NULL_CONFIGURATION = new ContentOutlineConfiguration() {
		public IContentProvider getContentProvider(TreeViewer viewer) {
			return new ITreeContentProvider() {
				public void dispose() {
				}

				public Object[] getChildren(Object parentElement) {
					return null;
				}

				public Object[] getElements(Object inputElement) {
					return null;
				}

				public Object getParent(Object element) {
					return null;
				}

				public boolean hasChildren(Object element) {
					return false;
				}

				public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
				}
			};
		}
	};

	private static final String OUTLINE_CONTEXT_MENU_ID = "org.eclipse.wst.sse.ui.StructuredTextEditor.OutlineContext"; //$NON-NLS-1$

	private static final String OUTLINE_CONTEXT_MENU_SUFFIX = ".source.OutlineContext"; //$NON-NLS-1$
	private static final boolean _DEBUG = "true".equalsIgnoreCase(Platform.getDebugOption("org.eclipse.wst.sse.ui/contentOutline")); //$NON-NLS-1$  //$NON-NLS-2$;

	private long _DEBUG_TIME = 0;

	private TransferDragSourceListener[] fActiveDragListeners;
	private TransferDropTargetListener[] fActiveDropListeners;
	private ContentOutlineConfiguration fConfiguration;

	private Menu fContextMenu;
	private String fContextMenuId;

	private MenuManager fContextMenuManager;
	private DoubleClickProvider fDoubleClickProvider = null;

	private DelegatingDragAdapter fDragAdapter;
	private DragSource fDragSource;
	private DelegatingDropAdapter fDropAdapter;
	private DropTarget fDropTarget;
	private IEditorPart fEditor;
	private IMenuListener fGroupAdder = null;
	private Object fInput = null;

	private String fInputContentTypeIdentifier = null;
	private ISelectionListener fSelectionListener = null;

	SelectionProvider fSelectionProvider = null;

	/**
	 * A ContentOutlinePage that abstract as much behavior as possible away
	 * from the Controls and varies it by content type.
	 */
	public ConfigurableContentOutlinePage() {
		super();
		fGroupAdder = new AdditionGroupAdder();
		fSelectionProvider = new SelectionProvider();
	}

	/**
	 * Adds a listener to a list of those notified when someone double-clicks
	 * in the page.
	 * 
	 * @param newListener -
	 *            the listener to add
	 */
	public void addDoubleClickListener(IDoubleClickListener newListener) {
		if (fDoubleClickProvider == null) {
			fDoubleClickProvider = new DoubleClickProvider();
		}
		fDoubleClickProvider.addDoubleClickListener(newListener);
	}

	private String computeContextMenuID() {
		String id = null;
		if (fInputContentTypeIdentifier != null) {
			id = fInputContentTypeIdentifier + OUTLINE_CONTEXT_MENU_SUFFIX;
		}
		return id;
	}

	/**
	 * @see ContentOutlinePage#createControl
	 */
	public void createControl(Composite parent) {
		super.createControl(parent);

		IWorkbenchPage page = getSite().getWorkbenchWindow().getActivePage();
		if (page != null) {
			fEditor = page.getActiveEditor();
		}

		fDragAdapter = new DelegatingDragAdapter();
		fDragSource = new DragSource(getControl(), DND.DROP_COPY | DND.DROP_MOVE | DND.DROP_LINK);
		fDropAdapter = new DelegatingDropAdapter();
		fDropTarget = new DropTarget(getControl(), DND.DROP_COPY | DND.DROP_MOVE | DND.DROP_LINK);

		setConfiguration(getConfiguration());

		/*
		 * ContentOutlinePage only implements ISelectionProvider while the
		 * tree viewer implements both ISelectionProvider and
		 * IPostSelectionProvider. Use an ISelectionProvider that listens to
		 * post selection from the tree viewer and forward only post selection
		 * to the selection service.
		 */
		getTreeViewer().addPostSelectionChangedListener(fSelectionProvider.getPostSelectionChangedListener());
		getTreeViewer().addSelectionChangedListener(fSelectionProvider.getSelectionChangedListener());
		if (fDoubleClickProvider == null) {
			fDoubleClickProvider = new DoubleClickProvider();
		}
		getTreeViewer().addDoubleClickListener(fDoubleClickProvider);
		getSite().setSelectionProvider(fSelectionProvider);
	}

	public void dispose() {
		getSite().getWorkbenchWindow().getSelectionService().removePostSelectionListener(getSelectionServiceListener());
		if (fDoubleClickProvider != null) {
			getTreeViewer().removeDoubleClickListener(fDoubleClickProvider);
		}

		// dispose menu controls
		if (fContextMenu != null) {
			fContextMenu.dispose();
		}
		if (fContextMenuManager != null) {
			fContextMenuManager.removeMenuListener(fGroupAdder);
			fContextMenuManager.removeAll();
			fContextMenuManager.dispose();
		}
		setConfiguration(NULL_CONFIGURATION);
		super.dispose();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class)
	 */
	public Object getAdapter(Class key) {
		Object adapter = null;
		if (key.equals(IShowInTarget.class)) {
			adapter = new ShowInTarget();
		}
		final IEditorPart editor = fEditor;

		if (key.equals(IShowInSource.class) && editor != null) {
			adapter = new IShowInSource() {
				public ShowInContext getShowInContext() {
					return new ShowInContext(editor.getEditorInput(), editor.getEditorSite().getSelectionProvider().getSelection());
				}
			};
		}
		else if (key.equals(IShowInTargetList.class) && editor != null) {
			adapter = editor.getAdapter(key);
		}
		return adapter;
	}

	/**
	 * @return the currently used ContentOutlineConfiguration
	 */
	public ContentOutlineConfiguration getConfiguration() {
		if (fConfiguration == null) {
			fConfiguration = NULL_CONFIGURATION;
		}
		return fConfiguration;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.ISelectionProvider#getSelection()
	 */
	public ISelection getSelection() {
		return fSelectionProvider.getSelection();
	}

	private ISelectionListener getSelectionServiceListener() {
		if (fSelectionListener == null) {
			fSelectionListener = new PostSelectionServiceListener();
		}
		return fSelectionListener;
	}


	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.part.IPageBookViewPage#init(org.eclipse.ui.part.IPageSite)
	 */
	public void init(IPageSite pageSite) {
		super.init(pageSite);
		pageSite.getWorkbenchWindow().getSelectionService().addPostSelectionListener(getSelectionServiceListener());
	}

	/**
	 * Removes a listener to a list of those notified when someone
	 * double-clicks in the page.
	 * 
	 * @param oldListener -
	 *            the listener to remove
	 */
	public void removeDoubleClickListener(IDoubleClickListener oldListener) {
		if (fDoubleClickProvider != null) {
			fDoubleClickProvider.removeDoubleClickListener(oldListener);
		}
	}

	/**
	 * Configures (or reconfigures) the page according to the given
	 * configuration.
	 * 
	 * @param configuration
	 */
	public void setConfiguration(ContentOutlineConfiguration configuration) {
		// intentionally do not check to see if the new configuration != old
		// configuration
		if (getTreeViewer() != null) {
			// remove the key listeners
			if (getControl() != null && !getControl().isDisposed()) {
				KeyListener[] listeners = getConfiguration().getKeyListeners(getTreeViewer());
				if (listeners != null) {
					for (int i = 0; i < listeners.length; i++) {
						getControl().removeKeyListener(listeners[i]);
					}
				}
			}

			IContributionManager toolbar = getSite().getActionBars().getToolBarManager();
			if (toolbar != null) {
				IContributionItem[] toolbarItems = getConfiguration().getToolbarContributions(getTreeViewer());
				if (toolbarItems != null && toolbarItems.length > 0) {
					for (int i = 0; i < toolbarItems.length; i++) {
						toolbar.remove(toolbarItems[i]);
					}
					toolbar.update(false);
				}
			}

			IContributionManager menubar = getSite().getActionBars().getMenuManager();
			if (menubar != null) {
				IContributionItem[] menuItems = getConfiguration().getMenuContributions(getTreeViewer());
				if (menuItems != null && menuItems.length > 0) {
					for (int i = 0; i < menuItems.length; i++) {
						menubar.remove(menuItems[i]);
					}
					menubar.remove(IWorkbenchActionConstants.MB_ADDITIONS);
					menubar.update(false);
				}
			}
			// clear the DnD listeners and transfer types
			if (fDragAdapter != null && !fDragAdapter.isEmpty() && fDragSource != null && !fDragSource.isDisposed() && fDragSource.getTransfer().length > 0) {
				if (fActiveDragListeners != null) {
					for (int i = 0; i < fActiveDragListeners.length; i++) {
						fDragAdapter.removeDragSourceListener(fActiveDragListeners[i]);
					}
				}
				fActiveDragListeners = null;
				fDragSource.removeDragListener(fDragAdapter);
				fDragSource.setTransfer(new Transfer[0]);
			}
			if (fDropAdapter != null && !fDropAdapter.isEmpty() && fDropTarget != null && !fDropTarget.isDisposed() && fDropTarget.getTransfer().length > 0) {
				if (fActiveDropListeners != null) {
					for (int i = 0; i < fActiveDropListeners.length; i++) {
						fDropAdapter.removeDropTargetListener(fActiveDropListeners[i]);
					}
				}
				fActiveDropListeners = null;
				fDropTarget.removeDropListener(fDropAdapter);
				fDropTarget.setTransfer(new Transfer[0]);
			}
			getConfiguration().getContentProvider(getTreeViewer()).inputChanged(getTreeViewer(), fInput, null);
			// release any ties to this tree viewer
			getConfiguration().unconfigure(getTreeViewer());
		}

		fConfiguration = configuration;

		if (getTreeViewer() != null && getControl() != null && !getControl().isDisposed()) {
			// (re)set the providers
			getTreeViewer().setLabelProvider(getConfiguration().getLabelProvider(getTreeViewer()));
			getTreeViewer().setContentProvider(getConfiguration().getContentProvider(getTreeViewer()));

			// view toolbar
			IContributionManager toolbar = getSite().getActionBars().getToolBarManager();
			if (toolbar != null) {
				IContributionItem[] toolbarItems = getConfiguration().getToolbarContributions(getTreeViewer());
				if (toolbarItems != null) {
					for (int i = 0; i < toolbarItems.length; i++) {
						toolbar.add(toolbarItems[i]);
					}
					toolbar.update(true);
				}
			}
			// view menu
			IContributionManager menu = getSite().getActionBars().getMenuManager();
			if (menu != null) {
				IContributionItem[] menuItems = getConfiguration().getMenuContributions(getTreeViewer());
				if (menuItems != null) {
					for (int i = 0; i < menuItems.length; i++) {
						menuItems[i].setVisible(true);
						menu.add(menuItems[i]);
						menuItems[i].update();
					}
					menu.update(true);
				}
			}
			// add the allowed DnD listeners and types
			TransferDragSourceListener[] dragListeners = getConfiguration().getTransferDragSourceListeners(getTreeViewer());
			if (fDragAdapter != null && dragListeners.length > 0) {
				for (int i = 0; i < dragListeners.length; i++) {
					fDragAdapter.addDragSourceListener(dragListeners[i]);
				}
				fActiveDragListeners = dragListeners;
				fDragSource.addDragListener(fDragAdapter);
				fDragSource.setTransfer(fDragAdapter.getTransfers());
			}
			TransferDropTargetListener[] dropListeners = getConfiguration().getTransferDropTargetListeners(getTreeViewer());
			if (fDropAdapter != null && dropListeners.length > 0) {
				for (int i = 0; i < dropListeners.length; i++) {
					fDropAdapter.addDropTargetListener(dropListeners[i]);
				}
				fActiveDropListeners = dropListeners;
				fDropTarget.addDropListener(fDropAdapter);
				fDropTarget.setTransfer(fDropAdapter.getTransfers());
			}
			// add the key listeners
			KeyListener[] listeners = getConfiguration().getKeyListeners(getTreeViewer());
			if (listeners != null) {
				for (int i = 0; i < listeners.length; i++) {
					getControl().addKeyListener(listeners[i]);
				}
			}
		}

		if (fInput != null) {
			setInput(fInput);
		}
	}

	/**
	 * @param editor
	 *            The IEditorPart that "owns" this page. Used to support the
	 *            "Show In..." menu.
	 */
	public void setEditorPart(IEditorPart editor) {
		fEditor = editor;
	}

	/**
	 * @param newInput
	 *            The input for the page's viewer. Should only be set after a
	 *            configuration has been applied.
	 */
	public void setInput(Object newInput) {
		fInput = newInput;
		/*
		 * Intentionally not optimized for checking new input vs. old input so
		 * that any existing content providers can be updated
		 */
		if (getControl() != null && !getControl().isDisposed()) {
			getTreeViewer().setInput(fInput);
			updateContextMenuId();
		}
	}

	/**
	 * @param id -
	 *            the content type identifier to use for further extension
	 */
	public void setInputContentTypeIdentifier(String id) {
		fInputContentTypeIdentifier = id;
	}

	/**
	 * Updates the outline page's context menu for the current input
	 */
	private void updateContextMenuId() {
		String computedContextMenuId = null;
		// update outline view's context menu control and ID

		if (fEditor == null) {
			IWorkbenchPage page = getSite().getWorkbenchWindow().getActivePage();
			if (page != null) {
				fEditor = page.getActiveEditor();
			}
		}

		computedContextMenuId = computeContextMenuID();

		if (computedContextMenuId == null) {
			computedContextMenuId = OUTLINE_CONTEXT_MENU_ID;
		}

		/*
		 * Update outline context menu id if updating to a new id or if
		 * context menu is not already set up
		 */
		if (!computedContextMenuId.equals(fContextMenuId) || (fContextMenu == null)) {
			fContextMenuId = computedContextMenuId;

			if (getControl() != null && !getControl().isDisposed()) {
				// dispose of previous context menu
				if (fContextMenu != null) {
					fContextMenu.dispose();
				}
				if (fContextMenuManager != null) {
					fContextMenuManager.removeMenuListener(fGroupAdder);
					fContextMenuManager.removeAll();
					fContextMenuManager.dispose();
				}

				fContextMenuManager = new MenuManager(fContextMenuId, fContextMenuId);
				fContextMenuManager.setRemoveAllWhenShown(true);

				fContextMenuManager.addMenuListener(fGroupAdder);

				fContextMenu = fContextMenuManager.createContextMenu(getControl());
				getControl().setMenu(fContextMenu);

				getSite().registerContextMenu(fContextMenuId, fContextMenuManager, this);

				/*
				 * also register this menu for source page part and structured
				 * text outline view ids
				 */
				if (fEditor != null) {
					String partId = fEditor.getSite().getId();
					if (partId != null) {
						getSite().registerContextMenu(partId + OUTLINE_CONTEXT_MENU_SUFFIX, fContextMenuManager, this);
					}
				}
				getSite().registerContextMenu(OUTLINE_CONTEXT_MENU_ID, fContextMenuManager, this);
			}
		}
	}

}