/*****************************************************************************
 * Copyright (c) 2004, 2011 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.wst.xml.ui.internal.tabletree;

import java.util.Iterator;

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.text.IDocument;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.util.LocalSelectionTransfer;
import org.eclipse.jface.util.SafeRunnable;
import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.jface.viewers.ColumnViewerEditorActivationEvent;
import org.eclipse.jface.viewers.ColumnViewerEditorActivationListener;
import org.eclipse.jface.viewers.ColumnViewerEditorDeactivationEvent;
import org.eclipse.jface.viewers.ICellEditorListener;
import org.eclipse.jface.viewers.ICellModifier;
import org.eclipse.jface.viewers.IPostSelectionProvider;
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.StructuredSelection;
import org.eclipse.jface.viewers.TextCellEditor;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.accessibility.ACC;
import org.eclipse.swt.accessibility.AccessibleAdapter;
import org.eclipse.swt.accessibility.AccessibleEvent;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.DragSource;
import org.eclipse.swt.dnd.DragSourceEvent;
import org.eclipse.swt.dnd.DragSourceListener;
import org.eclipse.swt.dnd.DropTarget;
import org.eclipse.swt.dnd.DropTargetEvent;
import org.eclipse.swt.dnd.DropTargetListener;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.events.ControlAdapter;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Item;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swt.widgets.TreeColumn;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.ui.views.properties.IPropertyDescriptor;
import org.eclipse.wst.sse.core.StructuredModelManager;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion;
import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegion;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMDocument;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
import org.eclipse.wst.xml.core.internal.regions.DOMRegionContext;
import org.eclipse.wst.xml.ui.internal.actions.NodeAction;
import org.eclipse.wst.xml.ui.internal.contentoutline.XMLNodeActionManager;
import org.eclipse.wst.xml.ui.internal.dnd.DragNodeCommand;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;

public class XMLTableTreeViewer extends TreeViewer implements IDesignViewer {

	class NodeActionMenuListener implements IMenuListener {
		public void menuAboutToShow(IMenuManager menuManager) {
			// used to disable NodeSelection listening while running
			// NodeAction
			XMLNodeActionManager nodeActionManager = new XMLNodeActionManager(((IDOMDocument) getInput()).getModel(), XMLTableTreeViewer.this) {
				public void beginNodeAction(NodeAction action) {
					super.beginNodeAction(action);
				}

				public void endNodeAction(NodeAction action) {
					super.endNodeAction(action);
				}
			};
			nodeActionManager.fillContextMenu(menuManager, getSelection());
		}
	}
	
	private class SelectionProvider implements IPostSelectionProvider {

		public void addPostSelectionChangedListener(ISelectionChangedListener listener) {
			XMLTableTreeViewer.this.addPostSelectionChangedListener(listener);
		}

		public void removePostSelectionChangedListener(ISelectionChangedListener listener) {
			XMLTableTreeViewer.this.removePostSelectionChangedListener(listener);
		}

		public void addSelectionChangedListener(ISelectionChangedListener listener) {
			XMLTableTreeViewer.this.addSelectionChangedListener(listener);
		}

		public ISelection getSelection() {
			return XMLTableTreeViewer.this.getSelection();
		}

		public void removeSelectionChangedListener(ISelectionChangedListener listener) {
			XMLTableTreeViewer.this.removeSelectionChangedListener(listener);
		}

		public void setSelection(ISelection selection) {
			boolean selectionSet = false;
			if (!selection.isEmpty() && selection instanceof IStructuredSelection) {
				IStructuredSelection structuredSelection = (IStructuredSelection) selection;
				if (selection instanceof ITextSelection) {
					ITextSelection textSelection = (ITextSelection) selection;
					
					if (structuredSelection.size() == 1) {
						if (structuredSelection.getFirstElement() instanceof IDOMNode) {
							IDOMNode domNode = (IDOMNode) structuredSelection.getFirstElement();
							IStructuredDocumentRegion startStructuredDocumentRegion = domNode.getStartStructuredDocumentRegion();
							if (startStructuredDocumentRegion != null) {
								ITextRegion matchingRegion = startStructuredDocumentRegion.getRegionAtCharacterOffset(textSelection.getOffset());
								int allowedIterations = 40;
								while (matchingRegion != null && !matchingRegion.getType().equals(DOMRegionContext.XML_TAG_ATTRIBUTE_NAME) && allowedIterations > 0) {
									matchingRegion = startStructuredDocumentRegion.getRegionAtCharacterOffset(startStructuredDocumentRegion.getStartOffset(matchingRegion) - 1);
									allowedIterations--;
								}
								if (matchingRegion != null && matchingRegion.getType().equals(DOMRegionContext.XML_TAG_ATTRIBUTE_NAME)) {
									String attrName = startStructuredDocumentRegion.getText(matchingRegion);
									NamedNodeMap attributes = domNode.getAttributes();
									if (attributes != null && attrName.length() > 0) {
										Node attr = attributes.getNamedItem(attrName);
										if (attr != null) {
											selectionSet = true;
											XMLTableTreeViewer.this.setSelection(new StructuredSelection(attr));
										}
									}
								}
							}
						}
					}
				}
			}
			if (!selectionSet) {
				XMLTableTreeViewer.this.setSelection(selection);
			}
		}
	}

	private PaintListener fContentPaintListener = new PaintListener() {

		public void paintControl(PaintEvent e) {
			GC gc = e.gc;
			if (getTree().getItemCount() == 0) {
				gc.setForeground(getTree().getDisplay().getSystemColor(SWT.COLOR_LIST_FOREGROUND));
				gc.setBackground(getTree().getDisplay().getSystemColor(SWT.COLOR_LIST_BACKGROUND));
				gc.drawString(XMLEditorMessages.XMLTreeExtension_3, 10, 10);
				gc.drawString(XMLEditorMessages.XMLTreeExtension_4, 10, 10 + gc.getFontMetrics().getHeight());
			}
		}
		
	};

	private ISelectionProvider fSelectionProvider = new SelectionProvider();
	// node: 40%, content: 60%
	static final double[] WEIGHTS = { .4, .6 };

	private ControlAdapter fResizeAdapter = new ControlAdapter() {
		public void controlResized(ControlEvent e) {
			sizeColumns(getTree().getSize().x, WEIGHTS);
		}

		private void sizeColumns(int width, double[] weights) {
			TreeColumn[] columns = getTree().getColumns();
			int size = columns.length;
			for (int i = 0; i < size; i++) {
				columns[i].setWidth((int)(weights[i] * width));
			}
		}
	};

	public XMLTableTreeViewer(Composite parent) {
		super(parent, SWT.FULL_SELECTION | SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
		
		TreeColumn column = new TreeColumn(this.getTree(), SWT.LEFT);
		column.setText(XMLEditorMessages.XMLTableTreeViewer_1);

		column = new TreeColumn(this.getTree(), SWT.LEFT);
		column.setText(XMLEditorMessages.XMLTableTreeViewer_2);

		this.getTree().setHeaderVisible(true);
		this.getTree().setLinesVisible(true);
		getTree().addControlListener(fResizeAdapter);
		getTree().getAccessible().addAccessibleListener(new AccessibleAdapter() {
			public void getDescription(AccessibleEvent e) {
				if (e.childID == ACC.CHILDID_SELF && getTree().getItemCount() == 0) {
					e.result = XMLEditorMessages.XMLTreeExtension_3 + "\n" + XMLEditorMessages.XMLTreeExtension_4;
				}
			}
		});
		// set up providers
		propertyDescriptorFactory = new XMLTableTreePropertyDescriptorFactory();

		XMLTableTreeContentProvider provider = new XMLTableTreeContentProvider();
		setContentProvider(provider);
		setLabelProvider(provider);

		setColumnProperties(new String[] {STRUCTURE_PROPERTY, VALUE_PROPERTY});
		setCellEditors(new CellEditor[] {null, new TextCellEditor(this.getTree())});

		setCellModifier(new XMLCMCellModifier());
		createContextMenu();

		DragSource dragSource = new DragSource(getControl(), DND.DROP_COPY | DND.DROP_MOVE);
		dragSource.addDragListener(createDragSourceListener());
		dragSource.setTransfer(new Transfer[] {LocalSelectionTransfer.getTransfer()});
		DropTarget dropTarget = new DropTarget(getControl(), DND.DROP_COPY | DND.DROP_MOVE);
		dropTarget.addDropListener(createDropTargetListener());
		dropTarget.setTransfer(new Transfer[] {LocalSelectionTransfer.getTransfer()});

		this.getTree().addPaintListener(fContentPaintListener);
	}

	/**
	 * This creates a context menu for the viewer and adds a listener as well
	 * registering the menu for extension.
	 */
	protected void createContextMenu() {
		MenuManager contextMenu = new MenuManager("#PopUp"); //$NON-NLS-1$
		contextMenu.add(new Separator("additions")); //$NON-NLS-1$
		contextMenu.setRemoveAllWhenShown(true);
		contextMenu.addMenuListener(new NodeActionMenuListener());
		Menu menu = contextMenu.createContextMenu(getControl());
		getControl().setMenu(menu);
	}

	private DragSourceListener createDragSourceListener() {
		return new DragSourceListener() {
			public void dragFinished(DragSourceEvent event) {
				LocalSelectionTransfer.getTransfer().setSelection(null);
			}

			public void dragSetData(DragSourceEvent event) {
			}

			public void dragStart(DragSourceEvent event) {
				LocalSelectionTransfer.getTransfer().setSelection(getSelection());
			}
		};
	}

	private DropTargetListener createDropTargetListener() {
		return new DropTargetListener() {
			public void dragEnter(DropTargetEvent event) {
			}

			public void dragLeave(DropTargetEvent event) {
			}

			public void dragOperationChanged(DropTargetEvent event) {
			}

			public void drop(DropTargetEvent event) {
				if (event.operations != DND.DROP_NONE && LocalSelectionTransfer.getTransfer().getSelection() instanceof IStructuredSelection) {
					dragOver(event);
					IStructuredSelection selection = (IStructuredSelection) LocalSelectionTransfer.getTransfer().getSelection();
					if (selection != null && !selection.isEmpty() && event.item != null && event.item.getData() != null) {
						/*
						 * the command uses these numbers instead of the
						 * feedback constants (even though it converts in
						 * the other direction as well)
						 */
						float feedbackFloat = getHeightInItem(event);

						final DragNodeCommand command = new DragNodeCommand(event.item.getData(), feedbackFloat, event.operations, event.detail, selection.toList(), XMLTableTreeViewer.this);
						if (command != null && command.canExecute()) {
							SafeRunnable.run(new SafeRunnable() {
								public void run() throws Exception {
									command.execute();
								}
							});
						}
					}
				}
			}

			public void dropAccept(DropTargetEvent event) {
			}

			public void dragOver(DropTargetEvent event) {
				event.feedback = DND.FEEDBACK_SELECT;
				float feedbackFloat = getHeightInItem(event);
				if (feedbackFloat > 0.75) {
					event.feedback = DND.FEEDBACK_INSERT_AFTER;
				}
				else if (feedbackFloat < 0.25) {
					event.feedback = DND.FEEDBACK_INSERT_BEFORE;
				}
				event.feedback |= DND.FEEDBACK_EXPAND | DND.FEEDBACK_SCROLL;
				if ( getLocalNodeSelection(event) == null){
					event.detail = DND.DROP_NONE;
				}
			}

			private IStructuredSelection getLocalNodeSelection(DropTargetEvent event){
				IStructuredSelection selection = (IStructuredSelection) LocalSelectionTransfer.getTransfer().getSelection();
				if (selection != null && !selection.isEmpty() ) {
					for (Iterator i = selection.iterator(); i.hasNext();) {
						Object node = i.next();
						if (node instanceof Node){
							return selection;
						}
					}
				}
				return null;
			}
			private float getHeightInItem(DropTargetEvent event) {
				if(event.item == null) return .5f;
				if (event.item instanceof TreeItem) {
					TreeItem treeItem = (TreeItem) event.item;
					Control control = treeItem.getParent();
					Point point = control.toControl(new Point(event.x, event.y));
					Rectangle bounds = treeItem.getBounds();
					return (float) (point.y - bounds.y) / (float) bounds.height;
				}
				else if (event.item instanceof TableItem) {
					TableItem tableItem = (TableItem) event.item;
					Control control = tableItem.getParent();
					Point point = control.toControl(new Point(event.x, event.y));
					Rectangle bounds = tableItem.getBounds(0);
					return (float) (point.y - bounds.y) / (float) bounds.height;
				}
				else {
					return 0.0F;
				}
			}
		};
	}
	
	protected void doRefresh(Object o, boolean fromDelayed) {
		super.refresh(o);
	}

	public ISelectionProvider getSelectionProvider() {
		return fSelectionProvider;
	}

	public String getTitle() {
		return XMLEditorMessages.XMLTableTreeViewer_0;
	}

	protected void handleDispose(DisposeEvent event) {
		super.handleDispose(event);
		this.getTree().removePaintListener(fContentPaintListener);
		getTree().removeControlListener(fResizeAdapter);
		setDocument(null);
	}

	public void setDocument(IDocument document) {
		/*
		 * let the text editor to be the one that manages the model's lifetime
		 */
		IStructuredModel model = null;
		try {
			model = StructuredModelManager.getModelManager().getExistingModelForRead(document);

			if ((model != null) && (model instanceof IDOMModel)) {
				Document domDoc = null;
				domDoc = ((IDOMModel) model).getDocument();
				setInput(domDoc);
			}
		}
		finally {
			if (model != null) {
				model.releaseFromRead();
			}
		}

	}
	
	protected TreeContentHelper treeContentHelper = new TreeContentHelper();
	protected XMLTableTreePropertyDescriptorFactory propertyDescriptorFactory;
	
	private final static String STRUCTURE_PROPERTY = XMLEditorMessages.XMLTreeExtension_0;
	private final static String VALUE_PROPERTY = XMLEditorMessages.XMLTreeExtension_1;
	
	private class CellListener extends ColumnViewerEditorActivationListener implements ICellEditorListener {

		private Node node;
		private CellEditor editor;
		private String originalValue;

		CellListener(Node data, CellEditor editor) {
			this.node = data;
			this.editor = editor;
			
			originalValue = treeContentHelper.getNodeValue(node);
			((IDOMNode) node).getModel().aboutToChangeModel();
		}

		public void applyEditorValue() {
			editor.removeListener(this);
		}

		public void cancelEditor() {
			final Object value = editor.getValue();
			if (value != null && !value.equals(originalValue)) {
				treeContentHelper.setNodeValue(node, originalValue);
			}
			editor.removeListener(this);
		}

		public void editorValueChanged(boolean oldValidState, boolean newValidState) {
			if (newValidState) {
				treeContentHelper.setNodeValue(node, editor.getValue().toString(), getControl().getShell());
			}
		}

		public void beforeEditorActivated(ColumnViewerEditorActivationEvent event) {
		}

		public void afterEditorActivated(ColumnViewerEditorActivationEvent event) {
		}

		public void beforeEditorDeactivated(ColumnViewerEditorDeactivationEvent event) {
		}

		public void afterEditorDeactivated(ColumnViewerEditorDeactivationEvent event) {
			((IDOMNode) node).getModel().changedModel();
			getColumnViewerEditor().removeEditorActivationListener(this);
		}
		
	}

	public class XMLCMCellModifier implements ICellModifier, TreeExtension.ICellEditorProvider {
		public boolean canModify(Object element, String property) {
			boolean result = false;
			if (element instanceof Node) {
				Node node = (Node) element;
				if (property == VALUE_PROPERTY) {
					result = treeContentHelper.isEditable(node);
					if (result) {
						/* Set up the cell editor based on the element */
						CellEditor[] editors = getCellEditors();
						if (editors.length > 0) {
							if (editors[1] != null)
								editors[1].dispose();
							editors[1] = getCellEditor(element, 1);
							if (editors[1] instanceof TextCellEditor) {
								final CellListener listener = new CellListener(node, editors[1]);
								getColumnViewerEditor().addEditorActivationListener(listener);
								editors[1].addListener(listener);
							}
						}
					}
					
				}
			}
			return result;
		}

		public Object getValue(Object object, String property) {
			String result = null;
			if (object instanceof Node) {
				result = treeContentHelper.getNodeValue((Node) object);
			}
			return (result != null) ? result : ""; //$NON-NLS-1$
		}

		public void modify(Object element, String property, Object value) {
			Item item = (Item) element;
			String oldValue = treeContentHelper.getNodeValue((Node) item.getData());
			String newValue = value.toString();
			if ((newValue != null) && !newValue.equals(oldValue)) {
				treeContentHelper.setNodeValue((Node) item.getData(), value.toString(), getControl().getShell());
			}
		}

		public CellEditor getCellEditor(Object o, int col) {
			IPropertyDescriptor pd = propertyDescriptorFactory.createPropertyDescriptor(o);
			return pd != null ? pd.createPropertyEditor(XMLTableTreeViewer.this.getTree()) : null;
		}
	}

}