/*******************************************************************************
 * Copyright (c) 2006 Sybase, Inc. 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:
 *     Sybase, Inc. - initial API and implementation
 *******************************************************************************/
package org.eclipse.jst.pagedesigner.viewer;

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

import org.eclipse.draw2d.FigureCanvas;
import org.eclipse.draw2d.Viewport;
import org.eclipse.gef.EditPart;
import org.eclipse.gef.ui.parts.ScrollingGraphicalViewer;
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jst.pagedesigner.commands.nav.CaretPositionTracker;
import org.eclipse.jst.pagedesigner.dom.DOMPositionHelper;
import org.eclipse.jst.pagedesigner.dom.DOMRefPosition;
import org.eclipse.jst.pagedesigner.dom.IDOMPosition;
import org.eclipse.jst.pagedesigner.parts.DocumentEditPart;
import org.eclipse.jst.pagedesigner.parts.ElementEditPart;
import org.eclipse.jst.pagedesigner.tools.ExposeHelper;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Caret;
import org.eclipse.ui.IEditorPart;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
import org.w3c.dom.Node;

/**
 * For the GraphicalViewer selection management, we have two different selection
 * mode: Range mode and object mode.
 * 
 * Range mode is to support inline text editing, it selects a range. Object mode
 * selects a list of edit parts.
 * 
 * We let the super class of HTMLGraphicalViewer to handle object selection, and
 * add range selection support in this class. Need to override certain selection
 * related methods of super class to handle selection mode switching.
 * 
 * @author mengbo
 */
public class HTMLGraphicalViewer extends ScrollingGraphicalViewer implements
		IHTMLGraphicalViewer, CaretPositionTracker {
	private IEditorPart _parentPart;
	private Caret _caret;
	// initially nothing selected, treat as object selectin mode.
	private boolean _rangeMode = false;
	private DesignRange _selectionRange = null;
	private int _inBatch = 0;
	private final CaretUpdater _caretUpdater;
	private int _xOffset;
	private final List<IHTMLGraphicalViewerListener>  _htmlViewerListeners;
	// private ListenerList _postSelectionChangedListeners = new
	// ListenerList(1);

	/**
	 * @param parent 
	 * 
	 */
	public HTMLGraphicalViewer(IEditorPart parent) {
		_parentPart = parent;
		// CaretUpdater is not fully initialized yet, since this time the
		// viewport is not
		// initialized yet, and we need add listener to range model change.
        _htmlViewerListeners = new ArrayList<IHTMLGraphicalViewerListener>();
		_caretUpdater = new CaretUpdater(this);
	}

	/**
	 * Adds listener both as a selection changed listener and as an
	 * {@link IHTMLGraphicalViewerListener}.  Callers of this method
	 * need not call addSelectionChangedListener.
	 * @param listener
	 */
	public void addHTMLViewerListener(IHTMLGraphicalViewerListener listener)
	{
	    addSelectionChangedListener(listener);
	    
	    if (!_htmlViewerListeners.contains(listener))
	    {
	        _htmlViewerListeners.add(listener);
	    }
	}
	
	/**
	 * Removes listener both as a selection changed listener and as an
     * {@link IHTMLGraphicalViewerListener}.  Callers of this method
     * need not call removeSelectionChangedListener.
	 * @param listener
	 */
	public void removeHTMLViewerListener(IHTMLGraphicalViewerListener listener)
	{
	    removeSelectionChangedListener(listener);
	    _htmlViewerListeners.remove(listener);
	}

	public Viewport getViewport() {
		FigureCanvas canvas = this.getFigureCanvas();
		if (canvas != null) {
			return canvas.getViewport();
		}
        return null;
	}

	public IDOMModel getModel() {
		// XXX: temp implementation.
		EditPart part = this.getContents();
		if (part != null) {
			return ((IDOMNode) part.getModel()).getModel();
		}
        return null;
	}

	/**
	 * @return the status line manager
	 */
	public IStatusLineManager getStatusLineManager() {
		if (_parentPart == null) {
			return null;
		}
        return _parentPart.getEditorSite().getActionBars()
        		.getStatusLineManager();
	}

	public Caret getCaret() {
		if (_caret == null) {
			Canvas parentCanvas = (Canvas) getControl();
			if (parentCanvas == null || parentCanvas.isDisposed()) {
				return null;
			}

			_caret = new Caret(parentCanvas, 0);
			_caretUpdater.connectViewer();
		}
		return _caret;

	}

	/**
	 * this method normally should only be called when in object selection mode.
	 * 
	 * @return the edit part that has primary selection or null if none
	 */
	public EditPart getPrimarySelectedNode() {
		List list = this.getSelectedEditParts();
		if (list.isEmpty()) {
			return null;
		}
		for (int i = 0, n = list.size(); i < n; i++) {
			EditPart part = (EditPart) list.get(i);
			if (part.getSelected() == EditPart.SELECTED_PRIMARY) {
				return part;
			}
		}
		return (EditPart) list.get(0);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jst.pagedesigner.parts.IHTMLGraphicalViewer#ensureRangeSelectionMode()
	 */
	public void ensureRangeSelectionMode() {
		if (!_rangeMode) {
			EditPart primary = getPrimarySelectedNode();
			this.deselectAll();
			DesignPosition begin = primary == null ? DesignPosition.INVALID
					: DesignPosition.createPositionBeforePart(primary);
			DesignPosition after = primary == null ? DesignPosition.INVALID
					: DesignPosition.createPositionAfterPart(primary);
			internalSetRange(begin, after);
			fireSelectionChanged();
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jst.pagedesigner.parts.IHTMLGraphicalViewer#ensureObjectSelectionMode()
	 */
	public void ensureObjectSelectionMode() {
		if (_rangeMode) {
			// switch to object selection mode with no selection.
			internalToObjectMode();
			fireSelectionChanged();
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jst.pagedesigner.parts.IHTMLGraphicalViewer#isInRangeMode()
	 */
	public boolean isInRangeMode() {
		return _rangeMode;
	}

	public ISelection getSelection() {
		if (isInRangeMode()) {
			return getRangeSelection();
		}
        return super.getSelection();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jst.pagedesigner.parts.IHTMLGraphicalViewer#startSelectionChange()
	 */
	public void startSelectionChange() {
		if (_inBatch == 0) {
			fireSelectionAboutToChange();
		}
		_inBatch++;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jst.pagedesigner.parts.IHTMLGraphicalViewer#selectionChanged()
	 */
	public void selectionChanged() {
		if (--_inBatch == 0) {
			fireSelectionChanged();
			fireSelectionChangeFinished();
		}
	}

	/**
	 * 
	 */
	private void fireSelectionAboutToChange() {
		IHTMLGraphicalViewerListener listeners[] = 
		    _htmlViewerListeners.toArray(new IHTMLGraphicalViewerListener[0]);

		for (int i = 0; i < listeners.length; i++) 
		{
			listeners[i].selectionAboutToChange();
		}
	}

	/**
	 * 
	 */
	private void fireSelectionChangeFinished()
	{
        IHTMLGraphicalViewerListener listeners[] = 
            _htmlViewerListeners.toArray(new IHTMLGraphicalViewerListener[0]);
        for (int i = 0; i < listeners.length; i++) 
        {
            listeners[i].selectionChangeFinished();
        }
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.gef.ui.parts.AbstractEditPartViewer#fireSelectionChanged()
	 */
	protected void fireSelectionChanged() {
		if (_inBatch == 0)// && this.getControl().isFocusControl())
		{
			super.fireSelectionChanged();
			// firePostSelectionChanged(new SelectionChangedEvent(this,
			// getSelection()));
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.gef.ui.parts.AbstractEditPartViewer#setSelection(org.eclipse.jface.viewers.ISelection)
	 */
	public void setSelection(ISelection newSelection) {
		if (newSelection instanceof IStructuredSelection) {
			internalToObjectMode();
			ExposeHelper.expose(newSelection, this);
			updateRangeSelection(newSelection);
			super.setSelection(newSelection);
		} else if (newSelection instanceof DesignRange) {
			DesignRange range = (DesignRange) newSelection;
			internalSetRange(range.getStartPosition(), range.getEndPosition());
			fireSelectionChanged();
		}
		// else we don't support, ignore
	}


	/**
	 * @param newSelection
	 */
	public void updateRangeSelection(ISelection newSelection) {
		if (newSelection instanceof IStructuredSelection && //
				!(((IStructuredSelection) newSelection).getFirstElement() instanceof DocumentEditPart)) {
			Object element = ((IStructuredSelection) newSelection)
					.getFirstElement();
			if (element instanceof ElementEditPart) {
				updateRangeSelection(new DesignRefPosition((EditPart) element,
						false), new DesignRefPosition((EditPart) element, true));
			} else if (element instanceof Node) {
				IDOMPosition start = new DOMRefPosition((Node) element, false);
				IDOMPosition end = new DOMRefPosition((Node) element, true);
				updateRangeSelection(DOMPositionHelper.toDesignPosition(start),
						DOMPositionHelper.toDesignPosition(end));
			}
		}
	}

	/**
	 * This method is used to synchronize range mode selection when node
	 * selection is changed.
	 * 
	 * @param position
	 * @param position2
	 */
	private void updateRangeSelection(DesignPosition position,
			DesignPosition position2) {
		// if only one position is invalid, we will make a collapsed range using
		// the valid position
		if (position == null) {
			position = DesignPosition.INVALID;
		}
		if (position2 == null || !position2.isValid()) {
			position2 = position;
		}
		if (!position.isValid()) {
			position = position2;
		}

		_selectionRange = new DesignRange(position, position2);
	}

	// -------------------------------------------------------------------------------------------------
	// override super class methods for selection handling.
	// operations that handles object selection
	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.gef.ui.parts.AbstractEditPartViewer#appendSelection(org.eclipse.gef.EditPart)
	 */
	public void appendSelection(EditPart editpart) {
		internalToObjectMode();
		super.appendSelection(editpart); // super will fireSelectionChanged.
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.gef.ui.parts.AbstractEditPartViewer#deselectAll()
	 */
	public void deselectAll() {
		internalToObjectMode();
		super.deselectAll(); // super.deselectAll() will fireSelectionChanged
	}

	/**
	 * Clear the selection to null. When the model is modified, the selection is
	 * invalid, so we need to clear the selection. We change the selection
	 * directly, it won't need to fire selectionchange event to other part.
	 * 
	 */
	public void clearSelectionRange() {
		internalToObjectMode();
		_selectionRange = null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.gef.ui.parts.AbstractEditPartViewer#deselect(org.eclipse.gef.EditPart)
	 */
	public void deselect(EditPart editpart) {
		if (!_rangeMode) {
			super.deselect(editpart); // super will fireSelectionChanged.
		}
		// else just ignore.
	}

	// ---------------------------------------------------------------------------------------------
	// range selection handling methods.
	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jst.pagedesigner.parts.IHTMLGraphicalViewer#getRangeSelection()
	 */
	public DesignRange getRangeSelection() {
		return _selectionRange;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jst.pagedesigner.parts.IHTMLGraphicalViewer#setRange(org.eclipse.jst.pagedesigner.selection.EditPartPosition,
	 *      org.eclipse.jst.pagedesigner.selection.EditPartPosition)
	 */
	public void setRange(DesignPosition position, DesignPosition position2) {
		internalSetRange(position, position2);
		fireSelectionChanged();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jst.pagedesigner.parts.IHTMLGraphicalViewer#setRangeEndPosition(org.eclipse.jst.pagedesigner.selection.EditPartPosition)
	 */
	public void setRangeEndPosition(DesignPosition position) {
		DesignRange range = getRangeSelection();
		DesignPosition begin = null;
		if (range != null) {
			begin = range.getStartPosition();
		}
		internalSetRange(begin, position);
		fireSelectionChanged();
	}

	// --------------------------------------------------------------------------------------
	/**
	 * internall switch to object mode, no selection change event is fired. the
	 * caller must call some other methods that will result in selection change
	 * event after calling this method.
	 */
	private void internalToObjectMode() {
		_rangeMode = false;
	}

	/**
	 * this method will not fire selection changed event. caller should do that.
	 * 
	 * @param position
	 * @param position2
	 */
	private void internalSetRange(DesignPosition position,
			DesignPosition position2) {
		if (!_rangeMode) {
			// XXX: deselectAll() will result in fireSelectionChange, so here is
			// one unnecessary
			// event fire. But should be ok.
			deselectAll();
			_rangeMode = true;
		}
		// if only one position is invalid, we will make a collapsed range using
		// the valid position
		if (position == null) {
			position = DesignPosition.INVALID;
		}
		if (position2 == null || !position2.isValid()) {
			position2 = position;
		}
		if (!position.isValid()) {
			position = position2;
		}

		_selectionRange = new DesignRange(position, position2);
	}

	/**
	 * debug method, dump some debug information to the console
	 */
	public void dumpStatus() {
		if (isInRangeMode()) {
			// System.out.println("Range start: " +
			// this.getRangeSelection().getStartPosition());
			// System.out.println("Range end: " +
			// this.getRangeSelection().getEndPosition());
		} else {
			// System.out.println("Object selection mode");
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jst.pagedesigner.commands.nav.CaretPositionTracker#getXoffset()
	 */
	public int getXoffset() {
		return _xOffset;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jst.pagedesigner.commands.nav.CaretPositionTracker#setXoffset(int)
	 */
	public void setXoffset(int xoffset) {
		this._xOffset = xoffset;
	}

	/**
	 * 
	 */
	public void updateHorizontalPos() {
		Caret caret = getCaret();
		if (caret != null && !caret.isDisposed() && isInRangeMode()) {
			org.eclipse.swt.graphics.Rectangle rect = caret.getBounds();
			setXoffset(rect.x);
		}
	}

	/**
	 * Gets parent editor part.
	 * @return Parent editor part.
	 */
	public IEditorPart getParent() {
		return _parentPart;
	}

	// public void addPostSelectionChangedListener(ISelectionChangedListener
	// listener)
	// {
	// _postSelectionChangedListeners.add(listener);
	//
	// }
	//
	// public void removePostSelectionChangedListener(ISelectionChangedListener
	// listener)
	// {
	// _postSelectionChangedListeners.remove(listener);
	// }

	/**
	 * Notifies any post selection listeners that a post selection event has
	 * been received. Only listeners registered at the time this method is
	 * called are notified.
	 * 
	 * @param event
	 *            a selection changed event
	 * 
	 * @see #addPostSelectionChangedListener(ISelectionChangedListener)
	 */
	// public void firePostSelectionChanged(final SelectionChangedEvent event)
	// {
	// Object[] listeners = _postSelectionChangedListeners.getListeners();
	// for (int i = 0; i < listeners.length; ++i)
	// {
	// final ISelectionChangedListener l = (ISelectionChangedListener)
	// listeners[i];
	// SafeRunnable.run(new SafeRunnable()
	// {
	// public void run()
	// {
	// l.selectionChanged(event);
	// }
	// });
	// }
	// }
}