/*******************************************************************************
 * Copyright (c) 2004, 2006 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.css.ui.internal.contentoutline;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;

import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.views.properties.PropertySheetPage;
import org.eclipse.wst.css.core.internal.provisional.document.ICSSDocument;
import org.eclipse.wst.css.core.internal.provisional.document.ICSSMediaRule;
import org.eclipse.wst.css.core.internal.provisional.document.ICSSModel;
import org.eclipse.wst.css.core.internal.provisional.document.ICSSNode;
import org.eclipse.wst.css.core.internal.provisional.document.ICSSPrimitiveValue;
import org.eclipse.wst.css.core.internal.provisional.document.ICSSStyleDeclItem;
import org.eclipse.wst.css.core.internal.provisional.document.ICSSStyleDeclaration;
import org.eclipse.wst.css.core.internal.provisional.document.ICSSStyleRule;
import org.eclipse.wst.css.core.internal.provisional.document.ICSSStyleSheet;
import org.eclipse.wst.css.ui.internal.image.CSSImageHelper;
import org.eclipse.wst.css.ui.internal.image.CSSImageType;
import org.eclipse.wst.sse.core.internal.provisional.INodeAdapter;
import org.eclipse.wst.sse.core.internal.provisional.INodeAdapterFactory;
import org.eclipse.wst.sse.core.internal.provisional.INodeNotifier;
import org.eclipse.wst.sse.ui.internal.contentoutline.IJFaceNodeAdapter;
import org.eclipse.wst.sse.ui.internal.contentoutline.IJFaceNodeAdapterFactory;
import org.w3c.dom.css.CSSImportRule;
import org.w3c.dom.css.CSSRule;
import org.w3c.dom.stylesheets.MediaList;

/**
 * Adapts the CSS DOM node to a JFace viewer.
 */
class CSSNodeAdapter implements IJFaceNodeAdapter, INodeAdapter, Runnable {
	class NotifyContext {
		NotifyContext(INodeNotifier notifier, int eventType, Object changedFeature, Object oldValue, Object newValue, int pos) {
			this.notifier = notifier;
			this.eventType = eventType;
			this.changedFeature = changedFeature;
			this.oldValue = oldValue;
			this.newValue = newValue;
			this.pos = pos;
		}

		void fire() {
			internalNotifyChanged(notifier, eventType, changedFeature, oldValue, newValue, pos);
		}

		INodeNotifier notifier;
		int eventType;
		Object changedFeature;
		Object oldValue;
		Object newValue;
		int pos;
	}

	class StyleViewUpdater implements Runnable {
		public void run() {
			if (lastUpdater == this) {
				internalActionPerformed();
				lastUpdater = null;
			}
		}
	}

	protected INodeAdapterFactory adapterFactory;
	private Vector notifyQueue;
	StyleViewUpdater lastUpdater;
	protected int delayMSecs = 500;
	final static Class ADAPTER_KEY = IJFaceNodeAdapter.class;

	public CSSNodeAdapter(INodeAdapterFactory adapterFactory) {
		super();
		this.adapterFactory = adapterFactory;
	}

	/**
	 * Insert the method's description here.
	 */
	protected void internalActionPerformed() {
		if (notifyQueue == null) {
			return;
		}
		boolean refresh_all = false;
		boolean refresh_rule = false;
		int pos_all = 0;
		List targets = new ArrayList();
		for (int i = 0; i < notifyQueue.size(); i++) {
			NotifyContext context = (NotifyContext) notifyQueue.get(i);
			if (context.notifier instanceof ICSSStyleSheet) {
				refresh_all = true;
				pos_all = i;
			}
			if (context.notifier instanceof ICSSStyleDeclaration) {
				refresh_rule = true;
				targets.add(context);
				// pos_rule = i;
			}
			// ((NotifyContext) notifyQueue.get(i)).fire();
		}
		if (refresh_all) {
			((NotifyContext) notifyQueue.get(pos_all)).fire();
		}
		else if (refresh_rule) {
			Iterator i = targets.iterator();
			while (i.hasNext()) {
				((NotifyContext) i.next()).fire();
			}
			// else if (refresh_rule) internalRefreshAll();
		}
		else {
			for (int i = 0; i < notifyQueue.size(); i++) {
				((NotifyContext) notifyQueue.get(i)).fire();
			}
		}
		notifyQueue.clear();
	}

	/**
	 * Called by the object being adapter (the notifier) when something has
	 * changed.
	 */
	public void internalNotifyChanged(INodeNotifier notifier, int eventType, Object changedFeature, Object oldValue, Object newValue, int pos) {
		Iterator iterator = ((IJFaceNodeAdapterFactory) adapterFactory).getListeners().iterator();
		while (iterator.hasNext()) {
			Object listener = iterator.next();
			if (listener instanceof StructuredViewer) {
				notifyChangedForStructuredViewer((StructuredViewer) listener, notifier, eventType, changedFeature, oldValue, newValue, pos);
			}
			else if (listener instanceof PropertySheetPage) {
				notifyChangedForPropertySheetPage((PropertySheetPage) listener, notifier, eventType, changedFeature, oldValue, newValue, pos);
			}
		}
	}

	private void notifyChangedForPropertySheetPage(PropertySheetPage page, INodeNotifier notifier, int eventType, Object changedFeature, Object oldValue, Object newValue, int pos) {
		if (page.getControl() == null || page.getControl().isDisposed()) {
			return;
		}
		if (eventType == INodeNotifier.CHANGE || eventType == INodeNotifier.ADD || eventType == INodeNotifier.REMOVE) {
			page.refresh();
		}
	}

	private void notifyChangedForStructuredViewer(StructuredViewer viewer, INodeNotifier notifier, int eventType, Object changedFeature, Object oldValue, Object newValue, int pos) {
		if (viewer.getControl() == null || viewer.getControl().isDisposed()) {
			return;
		}
		if (eventType == INodeNotifier.CHANGE) {
			if (notifier instanceof ICSSStyleSheet) {
				ICSSNode temp = (changedFeature != null) ? (ICSSNode) changedFeature : (ICSSNode) newValue;
				if (temp instanceof ICSSStyleRule) {
					viewer.refresh();
				}
				else {
					for (;;) {
						if (temp instanceof ICSSStyleRule) {
							break;
						}
						temp = temp.getParentNode();
						if (temp == null) {
							break;
						}
					}
					if (temp == null || temp instanceof ICSSStyleSheet) {
						viewer.refresh();
					}
					else {
						viewer.refresh(temp);
					}
				}
			}
			else {
				ICSSNode temp = (ICSSNode) notifier;
				if (temp != null) {
					temp = temp.getParentNode();
				}
				if (temp == null || temp instanceof ICSSStyleSheet) {
					viewer.refresh();
				}
				else {
					viewer.refresh(temp);
				}
			}
		}
		if (eventType == INodeNotifier.ADD) {
			if (notifier instanceof ICSSStyleSheet) {
				ICSSNode temp = (changedFeature != null) ? (ICSSNode) changedFeature : (ICSSNode) newValue;
				if (temp instanceof ICSSStyleRule) {
					viewer.refresh();
				}
				else {
					for (;;) {
						if (temp instanceof ICSSStyleRule) {
							break;
						}
						temp = temp.getParentNode();
						if (temp == null) {
							break;
						}
					}
				}
				if (temp == null || (temp instanceof ICSSStyleSheet)) {
					viewer.refresh();
				}
				else {
					viewer.refresh(temp);
				}
			}
			else {
				if (newValue != null && (newValue instanceof ICSSStyleDeclItem)) {
					viewer.refresh(((ICSSNode) newValue).getParentNode());
				}
				else {
					ICSSNode temp = (ICSSNode) notifier;
					if (temp != null) {
						temp = temp.getParentNode();
					}
					if (temp == null || (temp instanceof ICSSStyleSheet)) {
						viewer.refresh();
					}
					else {
						viewer.refresh(temp);
					}
				}
			}
		}
		else if (eventType == INodeNotifier.REMOVE) {
			if (notifier instanceof ICSSStyleSheet) {
				ICSSNode temp = (changedFeature != null) ? (ICSSNode) changedFeature : (ICSSNode) newValue;
				if (temp instanceof ICSSStyleRule) {
					viewer.refresh();
				}
				else {
					for (;;) {
						if (temp instanceof ICSSStyleRule) {
							break;
						}
						temp = temp.getParentNode();
						if (temp == null) {
							break;
						}
					}
					if (temp == null || (temp instanceof ICSSStyleSheet)) {
						viewer.refresh();
					}
					else {
						viewer.refresh(temp);
					}
				}
			}
			else {
				// viewer.refresh(notifier);
				ICSSNode temp = (ICSSNode) notifier;
				if (temp != null) {
					temp = temp.getParentNode();
				}
				if (temp == null || (temp instanceof ICSSStyleSheet)) {
					viewer.refresh();
				}
				else {
					viewer.refresh(temp);
				}
			}
		}
		// }
	}

	/**
	 * 
	 */
	public void internalRefreshAll() {
		Collection listeners = ((JFaceNodeAdapterFactoryCSS) adapterFactory).getListeners();
		Iterator iterator = listeners.iterator();
		while (iterator.hasNext()) {
			Object listener = iterator.next();
			if (listener instanceof StructuredViewer) {
				StructuredViewer viewer = (StructuredViewer) listener;
				if (viewer.getControl() != null && !viewer.getControl().isDisposed()) {
					viewer.refresh();
				}
			}
			else if (listener instanceof PropertySheetPage) {
				PropertySheetPage page = (PropertySheetPage) listener;
				if (page.getControl() != null && !page.getControl().isDisposed()) {
					page.refresh();
				}
			}
		}
	}

	/**
	 * Allowing the INodeAdapter to compare itself against the type allows it
	 * to return true in more than one case.
	 */
	public boolean isAdapterForType(Object type) {
		return type.equals(ADAPTER_KEY);
	}

	/**
	 * Called by the object being adapter (the notifier) when something has
	 * changed.
	 */
	public void notifyChanged(INodeNotifier notifier, int eventType, Object changedFeature, Object oldValue, Object newValue, int pos) {
		if (notifyQueue == null)
			notifyQueue = new Vector();
		notifyQueue.add(new NotifyContext(notifier, eventType, changedFeature, oldValue, newValue, pos));
		// TODO-future: there's probably a better way than relying on async
		// exec
		if (Thread.currentThread() == getDisplay().getThread())
			getDisplay().timerExec(delayMSecs, this);
		else
			getDisplay().asyncExec(new Runnable() {
				public void run() {
					if (getDisplay() != null) {
						getDisplay().timerExec(delayMSecs, this);
					}
				}
			});
	}

	Display getDisplay() {
		return PlatformUI.getWorkbench().getDisplay();
	}

	/**
	 * this method is intended only for timerExec()
	 */
	public void run() {
		lastUpdater = new StyleViewUpdater();
		getDisplay().asyncExec(lastUpdater);
	}

	/**
	 * Returns an enumeration containing all child nodes of the given element,
	 * which represents a node in a tree. The difference to
	 * <code>IStructuredContentProvider.getElements(Object)</code> is as
	 * follows: <code>getElements</code> is called to obtain the tree
	 * viewer's root elements. Method <code>getChildren</code> is used to
	 * obtain the children of a given node in the tree, which can can be a
	 * root node, too.
	 */
	public Object[] getChildren(Object object) {
		if (object instanceof ICSSNode) {
			ICSSNode node = (ICSSNode) object;

			short nodeType = node.getNodeType();
			if (nodeType == ICSSNode.STYLERULE_NODE || nodeType == ICSSNode.PAGERULE_NODE || nodeType == ICSSNode.FONTFACERULE_NODE) {
				for (node = node.getFirstChild(); node != null && !(node instanceof ICSSStyleDeclaration); node.getNextSibling()) {
					// nop
				}
			}
			List children = new ArrayList();
			ICSSNode child = (node != null) ? node.getFirstChild() : null;
			while (child != null) {
				if (!(child instanceof ICSSPrimitiveValue) && !(child instanceof MediaList)) {
					children.add(child);
				}
				/*
				 * Required to correctly connect the refreshing behavior to
				 * the tree
				 */
				if (child instanceof INodeNotifier) {
					((INodeNotifier) child).getAdapterFor(IJFaceNodeAdapter.class);
				}
				child = child.getNextSibling();
			}
			return children.toArray();
		}
		return new Object[0];
	}

	/**
	 * Returns an enumeration with the elements belonging to the passed
	 * element. These elements can be presented as rows in a table, items in a
	 * list etc.
	 */
	public Object[] getElements(Object object) {
		// The root is usually an instance of an XMLStructuredModel in
		// which case we want to extract the document.

		if (object instanceof ICSSModel) {
			ArrayList v = new ArrayList();
			// internalGetElements(object, v);
			addElements(object, v);
			Object[] elements = v.toArray();

			for (int i = 0; i < elements.length; i++) {
				/*
				 * Required to correctly connect the refreshing behavior to
				 * the tree
				 */
				if (elements[i] instanceof INodeNotifier) {
					((INodeNotifier) elements[i]).getAdapterFor(IJFaceNodeAdapter.class);
				}
			}

			return elements;
		}
		return new Object[0];

	}

	/**
	 * Returns the image for the label of the given element, for use in the
	 * given viewer.
	 * 
	 * @param viewer
	 *            The viewer that displays the element.
	 * @param element
	 *            The element for which to provide the label image. Element
	 *            can be <code>null</code> indicating no input object is set
	 *            to the viewer.
	 */
	public Image getLabelImage(Object element) {
		if (element instanceof ICSSNode) {
			CSSImageHelper helper = CSSImageHelper.getInstance();
			return helper.getImage(CSSImageType.getImageType((ICSSNode) element));
			// Image image = getCSSNodeImage(element);
			// return image;
			// return getAdapter(element).getLabelImage((ICSSNode) element);
		}
		return null;
	}

	/**
	 * Returns the text for the label of the given element, for use in the
	 * given viewer.
	 * 
	 * @param viewer
	 *            The viewer that displays the element.
	 * @param element
	 *            The element for which to provide the label text. Element can
	 *            be <code>null</code> indicating no input object is set to
	 *            the viewer.
	 */
	public String getLabelText(Object element) {
		// This was returning null, on occasion ... probably should not be,
		// but
		// took the quick and easy way out for now. (dmw 3/8/01)

		String result = "";//$NON-NLS-1$
		String mediaText;
		if (element instanceof ICSSNode) {
			switch (((ICSSNode) element).getNodeType()) {
				case ICSSNode.STYLERULE_NODE :
					result = ((ICSSStyleRule) element).getSelectors().getString();
					break;
				case ICSSNode.FONTFACERULE_NODE :
					result = "@font-face";//$NON-NLS-1$
					break;
				case ICSSNode.IMPORTRULE_NODE :
					result = ((CSSImportRule) element).getHref();
					mediaText = getMediaText((CSSImportRule) element);
					if (mediaText != null && 0 < mediaText.length()) {
						result += " (" + mediaText + ")"; //$NON-NLS-1$ //$NON-NLS-2$
					}
					break;
				case ICSSNode.PAGERULE_NODE :
					result = "@page";//$NON-NLS-1$
					break;
				case ICSSNode.STYLEDECLARATION_NODE :
					result = "properties";//$NON-NLS-1$
					break;
				case ICSSNode.STYLEDECLITEM_NODE :
					result = ((ICSSStyleDeclItem) element).getPropertyName();
					break;
				case ICSSNode.PRIMITIVEVALUE_NODE :
					result = ((ICSSPrimitiveValue) element).getStringValue();
					break;
				case ICSSNode.MEDIARULE_NODE :
					result = "@media";//$NON-NLS-1$
					mediaText = getMediaText((ICSSMediaRule) element);
					if (mediaText != null && 0 < mediaText.length()) {
						result += " (" + mediaText + ")"; //$NON-NLS-1$ //$NON-NLS-2$
					}
					break;
				case ICSSNode.CHARSETRULE_NODE :
					result = "@charset";//$NON-NLS-1$
					break;
				case ICSSNode.MEDIALIST_NODE :
					result = ((MediaList) element).getMediaText();
					break;
				default :
					break;
			}
		}

		// if (element instanceof ICSSNode) {
		// ICSSNode node = ((ICSSNode)element);
		// result = getAdapter(element).getLabelText((ICSSNode) element);
		// }
		return result;
	}

	/**
	 * Returns the parent for the given element. This method can return
	 * <code>null</code> indicating that the parent can't be computed. In
	 * this case the tree viewer can't expand a given node correctly if
	 * requested.
	 */
	public Object getParent(Object object) {
		if (object instanceof ICSSNode) {
			ICSSNode node = ((ICSSNode) object).getParentNode();
			if (node != null && node.getNodeType() == ICSSNode.STYLEDECLARATION_NODE) {
				/*
				 * Required to also correctly connect style declaration to the
				 * refreshing behavior in the tree
				 */
				if (node instanceof INodeNotifier) {
					((INodeNotifier) node).getAdapterFor(IJFaceNodeAdapter.class);
				}
				node = node.getParentNode();
			}
			return node;
		}
		return null;
	}

	/**
	 * Returns <code>true</code> if the given element has children.
	 * Otherwise <code>false</code> is returned.
	 */
	public boolean hasChildren(Object object) {
		// return getAdapter(object).hasChildren((ICSSNode) object);
		if (object instanceof ICSSNode) {
			/*
			 * Required to correctly connect the refreshing behavior to the
			 * tree
			 */
			if (object instanceof INodeNotifier) {
				((INodeNotifier) object).getAdapterFor(IJFaceNodeAdapter.class);
			}

			if (object instanceof ICSSStyleDeclItem)
				return false;
			else
				return ((ICSSNode) object).hasChildNodes();
		}
		return false;
	}

	private void addElements(Object element, ArrayList v) {

		ICSSNode node;

		if (element instanceof ICSSModel) {
			ICSSModel model = (ICSSModel) element;
			ICSSDocument doc = model.getDocument();
			node = doc.getFirstChild();
		}
		else if (element instanceof ICSSNode) {
			node = ((ICSSNode) element).getFirstChild();
		}
		else
			return;

		while (node != null) {
			if (node instanceof CSSRule) {
				v.add(node);
			}

			node = node.getNextSibling();
		}

	}

	private String getMediaText(CSSRule rule) {
		String result = ""; //$NON-NLS-1$
		ICSSNode child = (rule != null) ? ((ICSSNode) rule).getFirstChild() : null;
		while (child != null) {
			if (child.getNodeType() == ICSSNode.MEDIALIST_NODE) {
				result = ((MediaList) child).getMediaText();
				break;
			}
			child = child.getNextSibling();
		}
		return result;
	}
}