/*******************************************************************************
 * 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.properties;

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

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectNature;
import org.eclipse.gef.editparts.AbstractEditPart;
import org.eclipse.gef.ui.parts.GraphicalEditor;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jst.pagedesigner.IHTMLConstants;
import org.eclipse.jst.pagedesigner.PDPlugin;
import org.eclipse.jst.pagedesigner.css2.property.ICSSPropertyID;
import org.eclipse.jst.pagedesigner.dom.DOMUtil;
import org.eclipse.jst.pagedesigner.editors.HTMLEditor;
import org.eclipse.jst.pagedesigner.utils.SelectionHelper;
import org.eclipse.jst.pagedesigner.viewer.DesignRange;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.editors.text.TextEditor;
import org.eclipse.ui.views.contentoutline.ContentOutline;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.xml.core.internal.contentmodel.CMElementDeclaration;
import org.eclipse.wst.xml.core.internal.contentmodel.CMNamedNodeMap;
import org.eclipse.wst.xml.core.internal.contentmodel.CMNode;
import org.eclipse.wst.xml.core.internal.contentmodel.modelquery.ModelQuery;
import org.eclipse.wst.xml.core.internal.modelquery.ModelQueryUtil;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
import org.w3c.dom.Attr;
import org.w3c.dom.CDATASection;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.Text;

/**
 * This is util class most used by Property related operation.
 * 
 * @author mengbo
 */
public class DesignerPropertyTool {
	
	/**
	 * @param fNode
	 * @param attributeDesc
	 * @return attribute value
	 */
	public static String getAttributeValue(Element fNode, CMNode attributeDesc) {
		if (attributeDesc == null) {
			return ""; //$NON-NLS-1$
		}
		String returnedValue = ""; //$NON-NLS-1$
		NamedNodeMap attrMap = fNode.getAttributes();
		if (attrMap != null) {
			Node attribute = attrMap.getNamedItem(attributeDesc.getNodeName());
			if (attribute != null) {
				if (attribute instanceof IDOMNode) {
					returnedValue = ((IDOMNode) attribute).getValueSource();
				} else {
					returnedValue = attribute.getNodeValue();
				}
			}
		}
		return returnedValue;
	}

//	/**
//	 * @param fNode
//	 * @param filter
//	 * @return array of attributes as objects
//   * (unused)	
//	 */
//	public static Object[] getElementReferedAttributes(Element fNode,
//			String[] filter) {
//		List result = new ArrayList();
//		CMNamedNodeMap cmnnm = getElementDeclaredAttributes(fNode);
//		for (int i = 0, n = cmnnm.getLength(); i < n; i++) {
//			String name = cmnnm.item(i).getNodeName();
//			if (Arrays.asList(filter).contains(name)) {
//				result.add(cmnnm.item(i));
//			}
//		}
//		return result.toArray(new CMNode[result.size()]);
//	}

	/**
	 * @param fNode
	 * @return CMNamedNodeMap
	 */
	public static CMNamedNodeMap getElementDeclaredAttributes(Node fNode) {
		IStructuredModel structModel = null;
		if (fNode instanceof IDOMNode) {
			structModel = ((IDOMNode) fNode).getModel();
		}
		if (null == structModel) {
			return null;
		}
		CMElementDeclaration cmde = null;
		CMNamedNodeMap cmnnm = null;
		if (fNode == null || fNode.getNodeType() != Node.ELEMENT_NODE) {
			cmde = null;
		}
		ModelQuery modelQuery = ModelQueryUtil.getModelQuery(fNode
				.getOwnerDocument());
		if (modelQuery != null) {
			cmde = modelQuery.getCMElementDeclaration((Element) fNode);
		}
		if (cmde != null) {
			cmnnm = cmde.getAttributes();
		}
		return cmnnm;
	}

	/**
	 * the selection could be different kinds of selection, including: 1.
	 * ITextSelection 2. IStructuredSelection (Node) 3. IStructuredSelection
	 * (EditPart) 4. DesignRange we want to normalize it to only #2. If the node
	 * is ATTR or TEXT/CDATA_SECTION, will use it's parent node.
	 * 
	 * @param selectingPart
	 * @param selection
	 * @param htmlEditor
	 * @return null if can't normalize.
	 */
	public static Node normalizeSelectionToElement(
			IWorkbenchPart selectingPart, ISelection selection,
			HTMLEditor htmlEditor) {
		
		Node node = null;
		if (selectingPart instanceof HTMLEditor) {
			IEditorPart part = ((HTMLEditor) selectingPart).getActiveEditor();
			if (part instanceof TextEditor) {
				if (selection instanceof ITextSelection) {
					IStructuredModel model = ((HTMLEditor) selectingPart)
							.getModel();
					node = SelectionHelper.toNode(model,
							(ITextSelection) selection);
				}
			} else if (part instanceof GraphicalEditor) {
				if (selection instanceof IStructuredSelection) {
					node = SelectionHelper
							.toNode((IStructuredSelection) selection);
				} else if (selection instanceof DesignRange) {
					node = SelectionHelper.toNode((DesignRange) selection);
				}
			}
			if (node instanceof Attr) {
				node = ((Attr) node).getOwnerElement();
			} else if (node instanceof Text || node instanceof CDATASection) {
				node = node.getParentNode();
			}
		} else if (selectingPart instanceof ContentOutline) {
			if (selection instanceof IStructuredSelection
					&& ((ContentOutline) selectingPart).getCurrentPage() != null
					&& ((ContentOutline) selectingPart).getCurrentPage()
							.getControl().isFocusControl()) {
				node = SelectionHelper.toNode((IStructuredSelection) selection);
				if (node == null) {
					node = htmlEditor.getDOMDocument();
				}
			}
		}

		return node;
	}

	/**
	 * @param node as Object
	 * @return element 
	 */
	public static Element getElementNode(Object node) {
		Object model;
		Element element = null;
		if (node == null) {
			return null;
		}

		if (node instanceof Element) {
			element = (Element) node;
		} else if (node instanceof AbstractEditPart) {
			model = ((AbstractEditPart) node).getModel();
			if (model instanceof Element) {
				element = (Element) model;
			}
		} else if (node instanceof ISelection) {
			element = getElement(null, (ISelection) node);
		}
		return element;
	}

	/**
	 * @param element
	 * @param filter
	 * @return list of attribute names
	 */
	public static List getNameList(Element element, String[] filter) {
		List result = new ArrayList();
		CMNamedNodeMap attributes = getElementDeclaredAttributes(element);
		if (attributes != null) {
			for (int i = 0, n = attributes.getLength(); i < n; i++) {
				String name = attributes.item(i).getNodeName();
				if (Arrays.asList(filter).contains(name))
					result.add(name);
			}
		}
		return result;
	}

	/**
	 * @param selection
	 *            should be a normalized selection
	 * @return node
	 */
	public static Node getCommonParent(ISelection selection) {
		if (selection instanceof IStructuredSelection) {
			Object obj = ((IStructuredSelection) selection).getFirstElement();
			return (Node) obj;
		} else if (selection instanceof DesignRange) {
			DesignRange range = (DesignRange) selection;
			Node node1 = range.getStartPosition().getContainerNode();
			Node node2 = range.getEndPosition().getContainerNode();
			return DOMUtil.findCommonAncester(node1, node2);
		} else {
			// should not happen
			return null;
		}
	}

	/**
	 * The passed in selection should be normalized selection.
	 * 
	 * @param selectingPart
	 * @param selection
	 * @return element
	 */
	public static Element getElement(IWorkbenchPart selectingPart,
			ISelection selection) {
		Node node = getCommonParent(selection);
		if (node instanceof Element) {
			return (Element) node;
		} else if (node != null) {
			node = node.getParentNode();
			if (node instanceof Element) {
				return (Element) node;
			}
		}
		return null;
	}

	// reserved for future native use.
	// public static void dumpChildren(Element element)
	// {
	// // In this function we are using logger to dump message out.
	// Logger logger = PDPlugin.getLogger(DesignerPropertyTool.class);
	// if (element == null || !DEBUG)
	// return;
	// NodeList nl = element.getChildNodes();
	// // It's our pattern for dumping message
	// logger.debug("\n----------------------------"); //$NON-NLS-1$
	// logger.debug("Element:" + element.getNodeName()); //$NON-NLS-1$
	// for (int i = 0; i < nl.getLength(); i++)
	// {
	// Node node = nl.item(i);
	// logger.debug("child[" + i + "]:" + node.getNodeName()); //$NON-NLS-1$
	// //$NON-NLS-2$
	// }
	// logger.debug("----------------------------\n"); //$NON-NLS-1$
	// }

	/**
	 * @param element
	 * @return bool
	 *  (unused)
	 */
	public static boolean isMultiSelection(Element element) {
		if (element.getNodeName().equalsIgnoreCase(IHTMLConstants.TAG_OPTION)) {
			return element.getAttribute(ICSSPropertyID.ATTR_MULTIPLE) != null;
		}
		return false;
	}

//	/**
//	 * @param element
//	 * @return if elementImpl, return source, else null
//	 * (unused)
//	 */
//	public static String getElementTextSource(Element element) {
//		if (element == null) {
//			return null;
//		}
//		if (element instanceof ElementImpl) {
//			return ((ElementImpl) element).getSource();
//		}
//		return null;
//	}

	/**
	 * @param project
	 * @return IJavaProject
	 */
	public static IJavaProject getJavaProject(Object project) {
		if (project == null) {
			return null;
		}
		if (project instanceof IJavaProject) {
			return (IJavaProject) project;
		} else if (project instanceof IProject) {
			try {
				IProjectNature nature = ((IProject) project)
						.getNature(JavaCore.NATURE_ID);
				if (nature == null) {
					return null;
				}
                return (IJavaProject) nature;
			} catch (Exception e) {
				// Error.DesignerPropertyTool.NatureQuerying = Error in project
				// java nature querying
				PDPlugin.getLogger(DesignerPropertyTool.class).error(
						"Error.DesignerPropertyTool.NatureQuerying", e); //$NON-NLS-1$
				// Should be error tolerable?
				return null;
			}
		}
		return null;
	}
//
//	/**
//	 * @param project as Object
//	 * @return IProject or null
//	 */
//	public static IProject getProject(Object project) {
//		if (project instanceof IProject) {
//			return (IProject) project;
//		} else if (project instanceof IJavaProject) {
//			return ((IJavaProject) project).getProject();
//		}
//		return null;
//	}

}