/*******************************************************************************
 * Copyright (c) 2011, 2012 Formal Mind GmbH and University of Dusseldorf.
 * 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:
 *     Michael Jastram - initial API and implementation
 ******************************************************************************/
package org.eclipse.rmf.reqif10.pror.editor.actions;

import java.util.ArrayList;
import java.util.EventObject;
import java.util.List;

import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.command.CommandStack;
import org.eclipse.emf.common.command.CommandStackListener;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.common.util.Diagnostic;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.util.Diagnostician;
import org.eclipse.emf.edit.command.DeleteCommand;
import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.emf.edit.ui.action.CommandActionHandler;
import org.eclipse.emf.edit.ui.action.EditingDomainActionBarContributor;
import org.eclipse.emf.edit.ui.dnd.EditingDomainViewerDropAdapter;
import org.eclipse.emf.edit.ui.dnd.LocalTransfer;
import org.eclipse.emf.edit.ui.dnd.ViewerDragAdapter;
import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider;
import org.eclipse.jface.action.ActionContributionItem;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.dialogs.TrayDialog;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.jface.viewers.TreeSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.rmf.reqif10.Specification;
import org.eclipse.rmf.reqif10.pror.editor.IReqifEditor;
import org.eclipse.rmf.reqif10.pror.editor.presentation.ProrAdapterFactoryContentProvider;
import org.eclipse.rmf.reqif10.pror.editor.propertiesview.ProrPropertySheetPage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.FormAttachment;
import org.eclipse.swt.layout.FormData;
import org.eclipse.swt.layout.FormLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.swt.widgets.Sash;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.swt.widgets.ToolItem;
import org.eclipse.ui.PlatformUI;

/**
 * This modal dialog shows the tree hanging on a provided {@link EObject}. The
 * idea is to use this to allow the user to configure things selectively (e.g.
 * the columns of a {@link Specification}).
 * 
 * @author jastram
 * 
 */
public class SubtreeDialog extends TrayDialog implements IMenuListener {

	private static final int VALIDATE_ID = 99;
	private final EObject input;
	private final String title;
	private final String helpContext;
	private ISelectionProvider originalSelectionProvider;
	private IAction[] actions = new IAction[] {};
	private boolean presentAsDropdown;
	private TreeViewer viewer;
	private final List<ViewerFilter> filters = new ArrayList<ViewerFilter>();
	private final AdapterFactory adapterFactory;
	private final EditingDomain editingDomain;
	private final IReqifEditor reqifEditor;
	private CommandStackListener commandStackListener;

	protected SubtreeDialog(IReqifEditor reqifEditor, EObject input, String title,
			String helpContext) {
		super(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell());
		this.reqifEditor = reqifEditor;
		this.editingDomain = reqifEditor.getEditingDomain();
		this.adapterFactory = reqifEditor.getAdapterFactory();
		this.input = input;
		this.title = title;
		this.helpContext = helpContext;
		setHelpAvailable(true);
	}

	void addFilter(ViewerFilter filter) {
		filters.add(filter);
	}

	/**
	 * We provide the default "Finish" button, instead of the default OK and
	 * Cancel.
	 */
	@Override
	protected void createButtonsForButtonBar(Composite parent) {
		createButton(parent, IDialogConstants.OK_ID,
				IDialogConstants.FINISH_LABEL, true);

		createButton(parent, VALIDATE_ID, "Validate", false);
	}

	@Override
	protected void buttonPressed(int buttonId) {
		if (buttonId == VALIDATE_ID) {
			IStructuredSelection selection = (IStructuredSelection) viewer
					.getSelection();
			if (selection.getFirstElement() instanceof EObject) {
				EObject element = (EObject) selection.getFirstElement();
				// TODO this is not yet working...
				Diagnostic diagnostic = Diagnostician.INSTANCE
						.validate(element);
				MessageDialog.openInformation(this.getShell(),
						"Validation Report", diagnostic.getMessage());
			}
		} else {
			super.buttonPressed(buttonId);
		}
	}

	@Override
	protected Point getInitialSize() {
		return new Point(500, 600);
	}

	@Override
	protected boolean isResizable() {
		return true;
	}

	@Override
	protected Control createDialogArea(Composite parent) {
		this.getShell().setText(title);

		Composite composite = (Composite) super.createDialogArea(parent);
		composite.setLayout(new FormLayout());

		ToolBar toolbar = presentAsDropdown ? buildDropdownToolbar(composite)
				: buildRowToolbar(composite);

		// Enable help
		PlatformUI.getWorkbench().getHelpSystem().setHelp(parent, helpContext);

		final Sash sash = new Sash(composite, SWT.HORIZONTAL | SWT.BORDER);
		FormData data = new FormData();
		data.bottom = new FormAttachment(50, 0);
		data.left = new FormAttachment(0, 0);
		data.right = new FormAttachment(100, 0);
		sash.setLayoutData(data);

		// Without this, the sash wouldn't hold its new position
		sash.addListener(SWT.Selection, new Listener() {
			public void handleEvent(Event e) {
				sash.setBounds(e.x, e.y, e.width, e.height);
				((FormData) sash.getLayoutData()).bottom = new FormAttachment(
						0, e.y);
				sash.getParent().layout();
			}
		});

		viewer = new TreeViewer(composite, SWT.BORDER);
		viewer.setContentProvider(new ProrAdapterFactoryContentProvider(
				getAdapterFactory()));
		viewer.setLabelProvider(new AdapterFactoryLabelProvider(
				getAdapterFactory()));
		viewer.setInput(input);
		viewer.setFilters(filters.toArray(new ViewerFilter[] {}));
		createContextMenuFor(viewer);

		viewer.getTree().addKeyListener(new KeyAdapter() {
			@Override
			public void keyPressed(KeyEvent e) {
				if (e.keyCode == SWT.DEL) {
					ISelection selection = viewer.getSelection();
					TreeSelection treeSelection = (TreeSelection) selection;
					Object firstElement = treeSelection.getFirstElement();
					Command create = DeleteCommand.create(editingDomain,
							firstElement);
					editingDomain.getCommandStack().execute(create);
				}
			}
		});

		data = new FormData();
		data.top = new FormAttachment(toolbar, 0);
		data.bottom = new FormAttachment(sash, 0);
		data.left = new FormAttachment(0, 0);
		data.right = new FormAttachment(100, 0);
		viewer.getControl().setLayoutData(data);

		// Now that we have the TreeViewer, let's attach the Toolbar
		data = new FormData();
		data.bottom = new FormAttachment(viewer.getControl(), 0);
		data.left = new FormAttachment(0, 0);
		data.right = new FormAttachment(100, 0);
		toolbar.setLayoutData(data);

		final ProrPropertySheetPage propertySheet = new ProrPropertySheetPage(
				(AdapterFactoryEditingDomain) editingDomain, adapterFactory);
		propertySheet.createControl(composite);

		data = new FormData();
		data.top = new FormAttachment(sash, 0);
		data.bottom = new FormAttachment(100, 0);
		data.left = new FormAttachment(0, 0);
		data.right = new FormAttachment(100, 0);
		propertySheet.getControl().setLayoutData(data);

		// The and Property Sheet Editor must know about changes, so that the context
		// menu contains the correct child creation actions.
		originalSelectionProvider = getActionBarContributor().getActiveEditor()
				.getSite().getSelectionProvider();
		getActionBarContributor().getActiveEditor().getSite()
				.setSelectionProvider(viewer);
		viewer.addSelectionChangedListener(new ISelectionChangedListener() {
			public void selectionChanged(SelectionChangedEvent event) {
				((ISelectionChangedListener)getActionBarContributor()).selectionChanged(event);
				propertySheet.selectionChanged(null, event.getSelection());
				((ISelectionProvider) getActionBarContributor()
						.getActiveEditor()).setSelection(event.getSelection());
			}
		});
		
		commandStackListener = new CommandStackListener() {
			public void commandStackChanged(final EventObject event) {
				Display.getCurrent().asyncExec(new Runnable() {
					public void run() {
						Command mostRecentCommand = ((CommandStack) event
								.getSource()).getMostRecentCommand();
						if (mostRecentCommand != null) {
							StructuredSelection selection = new StructuredSelection(
									new ArrayList<Object>(mostRecentCommand
											.getAffectedObjects()));
							viewer.setSelection(selection);
						}
					}
				});

			}
		};
		editingDomain.getCommandStack().addCommandStackListener(
				commandStackListener);
		
		return composite;
	}

	/**
	 * It's unbelievable that there is no better way for doing this! I
	 * couldn't even use {@link MenuManager} to add the action, as that created
	 * an additional menu hierarchy that I couldn't get rid of!
	 * 
	 * @param composite
	 * @return
	 */
	private ToolBar buildDropdownToolbar(Composite composite) {
		final ToolBar toolbar = new ToolBar(composite, SWT.PUSH);

		final Menu menu = new Menu(getShell(), SWT.POP_UP);
		for (final IAction action : actions) {
			MenuItem newItem = new MenuItem(menu, SWT.PUSH);
			newItem.setText(action.getText());
			newItem.addSelectionListener(new SelectionAdapter() {
				@Override
				public void widgetSelected(SelectionEvent e) {
					action.run();
				}
			});

		}

		final ToolItem item = new ToolItem(toolbar, SWT.DROP_DOWN);
		item.setText("Select Action...");
		item.addListener(SWT.Selection, new Listener() {
			public void handleEvent(Event event) {
				// The following code would allow to distinguish arrow and
				// button, something we don't need right now.
				// if (event.detail == SWT.ARROW) {
				Rectangle rect = item.getBounds();
				Point pt = new Point(rect.x, rect.y + rect.height);
				pt = toolbar.toDisplay(pt);
				menu.setLocation(pt.x, pt.y);
				menu.setVisible(true);
			}
			// }
		});
		return toolbar;
	}

	private ToolBar buildRowToolbar(Composite composite) {
		ToolBar toolbar = new ToolBar(composite, SWT.PUSH);
		ToolBarManager toolbarManager = new ToolBarManager(toolbar);
		for (IAction action : actions) {
			toolbarManager.add(action);
		}

		toolbarManager.update(true);
		return toolbar;
	}

	private AdapterFactory getAdapterFactory() {
		return adapterFactory;
	}

	public void createContextMenuFor(StructuredViewer viewer) {
		MenuManager contextMenu = new MenuManager("#PopUp");
		contextMenu.add(new Separator("additions"));
		contextMenu.setRemoveAllWhenShown(true);
		contextMenu.addMenuListener(this);
		Menu menu = contextMenu.createContextMenu(viewer.getControl());
		viewer.getControl().setMenu(menu);

		int dndOperations = DND.DROP_COPY | DND.DROP_MOVE | DND.DROP_LINK;
		Transfer[] transfers = new Transfer[] { LocalTransfer.getInstance() };
		viewer.addDragSupport(dndOperations, transfers, new ViewerDragAdapter(
				viewer));
		viewer.addDropSupport(dndOperations, transfers,
				new EditingDomainViewerDropAdapter(editingDomain, viewer));
	}

	public void menuAboutToShow(IMenuManager menuManager) {
		getActionBarContributor().menuAboutToShow(menuManager);

		// Some actions may have the wrong selection, because the
		// ActionBarContributor grabs it from the associated editor.
		for (IContributionItem item : menuManager.getItems()) {
			if (item instanceof ActionContributionItem) {
				IAction action = ((ActionContributionItem) item).getAction();
				if (action instanceof CommandActionHandler) {
					CommandActionHandler handler = (CommandActionHandler) action;
					handler.updateSelection((IStructuredSelection) viewer.getSelection());
				}
			}
		}
		
	}

	private EditingDomainActionBarContributor getActionBarContributor() {
		return reqifEditor.getActionBarContributor();
	}

	@Override
	public boolean close() {
		getActionBarContributor().getActiveEditor().getSite()
				.setSelectionProvider(originalSelectionProvider);
		if (commandStackListener != null) {
			editingDomain.getCommandStack().removeCommandStackListener(commandStackListener);
		}
		return super.close();
	}

	/**
	 * If Actions are set before opening the Dialog, then these are presented in
	 * a row or in a dropdown.
	 * <p>
	 * 
	 * When shown in a row, the text is omitted and only the icon shown. This
	 * makes sense for a small number of well-defined actions.
	 * <p>
	 * 
	 * When shown in a dropdown, both icon and text are shown. This makes sense
	 * when the text is important and/or the number of items is unknown.
	 * 
	 * @param actions
	 * @param presentAsDropdown
	 */
	public void setActions(IAction[] actions, boolean presentAsDropdown) {
		this.actions = actions;
		this.presentAsDropdown = presentAsDropdown;
	}
}