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

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

import org.eclipse.gef.EditPart;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.TextSelection;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jst.jsf.core.internal.tld.CMUtil;
import org.eclipse.jst.pagedesigner.dom.DOMPosition;
import org.eclipse.jst.pagedesigner.dom.DOMPositionHelper;
import org.eclipse.jst.pagedesigner.dom.DOMRefPosition;
import org.eclipse.jst.pagedesigner.dom.DOMRefPosition2;
import org.eclipse.jst.pagedesigner.dom.DOMUtil;
import org.eclipse.jst.pagedesigner.dom.EditValidateUtil;
import org.eclipse.jst.pagedesigner.dom.IDOMPosition;
import org.eclipse.jst.pagedesigner.parts.NodeEditPart;
import org.eclipse.jst.pagedesigner.viewer.DesignPosition;
import org.eclipse.jst.pagedesigner.viewer.DesignRange;
import org.eclipse.jst.pagedesigner.viewer.IHTMLGraphicalViewer;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion;
import org.eclipse.wst.xml.core.internal.contentmodel.CMElementDeclaration;
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.w3c.dom.CharacterData;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.Text;

/**
 * @author mengbo
 * @version 1.5
 */
public class SelectionHelper {
	/**
	 * convert the text selection to a Node. Will use the start offset of the
	 * text selection.
	 * 
	 * @param model
	 * @param textSel
	 * @return the node for the text selectin in model or null
	 */
	public static Node toNode(IStructuredModel model, ITextSelection textSel) {
		// FIXME: currently always normalize to a single node. should also
		// consider change into DesignRange
		// on text selection, find the appropriate Node
		Object inode = model.getIndexedRegion(textSel.getOffset());
		if (inode instanceof Node) {
			return (Node) inode;
		}
        return null;
	}

	/**
	 * convert a structured selection of NodeEditPart or Node into the first
	 * node.
	 * 
	 * @param selection
	 * @return the node for the selection or null
	 */
	public static Node toNode(IStructuredSelection selection) {
		if (selection.isEmpty()) {
			return null;
		}
		Object first = selection.getFirstElement();
		if (first instanceof Node) {
			return (Node) first;
		} else if (first instanceof NodeEditPart) {
			return ((NodeEditPart) first).getIDOMNode();
		} else {
			return null;
		}
	}

	/**
	 * convert a DesignRange into a single node.
	 * 
	 * @param range
	 * @return the node for the design range or null
	 */
	public static Node toNode(DesignRange range) {
		if (range.isValid()) {
			Node node1 = range.getStartPosition().getContainerNode();
			Node node2 = range.getEndPosition().getContainerNode();
			return DOMUtil.findCommonAncester(node1, node2);
		}
        return null;
	}

	/**
	 * @param model
	 * @param region
	 *            if null, then will calculate it using offset.
	 * @param offset
	 *            offset in source.
	 * @return a dom position for the region and offset
	 */
	public static IDOMPosition toDOMPosition(IDOMModel model,
			IndexedRegion region, int offset) {
		if (region == null) {
			region = model.getIndexedRegion(offset);
		}
		if (region == null && offset > 0) {
			// in case this is at end of file.
			offset = offset - 1;
			region = model.getIndexedRegion(offset);
			if (region != null) {
				if (region.getEndOffset() >= offset + 1) {
					offset += 1; // restore offset.
				}
			}
		}
		if (region == null) {
			return new DOMPosition(model.getDocument(), 0);
		}
		IDOMNode node = (IDOMNode) region;
		int start = node.getStartOffset();
		if (offset <= start) {
			return new DOMRefPosition(node, false);
		}
		int end = node.getEndOffset();
		if (offset >= end) {
			return new DOMRefPosition(node, true);
		}
		if (node instanceof CharacterData) {
			String data = ((CharacterData) node).getData();
			String source = node.getSource();
			if (data.equals(source)) {
				return new DOMPosition(node, offset - start);
			}
			IStructuredDocumentRegion r = node
					.getFirstStructuredDocumentRegion();
			int countedData = 0;
			// TODO: dead? int offsetInNode = offset - start;
			while (r != null) {
				if (DOMRegionContext.XML_CHAR_REFERENCE.equals(r.getType())
						|| DOMRegionContext.XML_ENTITY_REFERENCE.equals(r
								.getType())) {
					countedData += 1; // FIXME: what if the entity reference's
					// corresponding data is more than 1
					// char?
					// where can we get that information?
					if (r.getEnd() >= offset) {
						return new DOMPosition(node, countedData);
					}
				} else {
					if (r.getEnd() >= offset) {
						return new DOMPosition(node, countedData + offset
								- r.getStart());
					}
					countedData += r.getLength();
				}
				r = r.getNext();
			}
			return new DOMRefPosition(node, true);
		} else if (node instanceof Element) {
			CMElementDeclaration cm = CMUtil
					.getElementDeclaration((Element) node);
			if (cm != null && cm.getContentType() == CMElementDeclaration.EMPTY) {
				// this node can't have children.
				return new DOMRefPosition(node, true);
			}
			IStructuredDocumentRegion startRegion = node
					.getStartStructuredDocumentRegion();
			if (startRegion == null) {
				return new DOMRefPosition(node, true);
			}
            int startRegionEnd = node.getStartStructuredDocumentRegion()
            		.getEnd();
            if (offset <= startRegionEnd) {
            	// it is in the start tag region. So put position at first
            	// child position.
            	return new DOMRefPosition2(node, false);
            }
            return new DOMRefPosition2(node, true);
		} else {
			return new DOMRefPosition(node, true);
		}
		// XXX: the implementation in EditModelQuery seemed to be very complex.
		// Need revisit that
		// and refactor the implementation to this class later. (lium)
	}

	/**
	 * Give a text selection with offset and length, convert it into a Designer
	 * selection (IStrucuturedSelection of editpart or DesignerRange). If the
	 * text selection include just a single element node, we'll create a
	 * IStructuredSelection, otherwise we'll create a DesignerRange.
	 * 
	 * @param graphicViewer
	 * @param offset
	 * @param length
	 * @return a selection
	 */
	public static ISelection convertToDesignerSelection(
			IHTMLGraphicalViewer graphicViewer, int offset, int length) {
		IDOMModel model = graphicViewer.getModel();
		IndexedRegion region1 = model.getIndexedRegion(offset);
		IndexedRegion region2 = model.getIndexedRegion(offset + length);
		IDOMNode node1 = (IDOMNode) region1;

		if (node1 == null) {
			IDOMPosition endOfDoc = new DOMRefPosition2(model.getDocument(),
					true);
			DesignPosition p = DOMPositionHelper.toDesignPosition(endOfDoc);
			return new DesignRange(p, p);
		}

		if ((region1 == region2 || node1.getEndOffset() == offset + length)
				&& !(node1 instanceof Text)) {
			// ok, we selected a single node.
			EditPart part = (EditPart) node1.getAdapterFor(EditPart.class);
			if (part != null) {
				return new StructuredSelection(part);
			}
		}

		// when we reach here, we'll create a DesignerRange
		IDOMPosition position1 = toDOMPosition(model, region1, offset);
		IDOMPosition position2 = (length == 0 ? position1 : toDOMPosition(
				model, region2, offset + length));

		if (position1 == null || position2 == null) {
			return new DesignRange(null, null);
		}
		DesignPosition p1 = DOMPositionHelper.toDesignPosition(position1);
		DesignPosition p2 = (length == 0 ? p1 : DOMPositionHelper
				.toDesignPosition(position2));
		if (p1 == null || p2 == null) {
			return new DesignRange(null, null);
		}

		return new DesignRange(p1, p2);

	}

	/**
	 * convert a IDOMPosition into index in the source.
	 * 
	 * @param p
	 * @return
	 */
	private static int getIndexedRegionLocation(IDOMPosition p) {
		if (!EditValidateUtil.validPosition(p)) {
			return 0;
		}

		IDOMNode parent = (IDOMNode) p.getContainerNode();
		if (p.isText()) {
			String text = ((CharacterData) parent).getData();
			String source = parent.getSource();
			if (text.length() == source.length()) {
				// no entity reference.
				return parent.getStartOffset() + p.getOffset();
			}
			// CR404708. Need to handle entity reference in the text.
			int offset = p.getOffset();
			int counted = 0;
			IStructuredDocumentRegion r = parent
					.getFirstStructuredDocumentRegion();
			while (r != null && counted < offset) {
				if (DOMRegionContext.XML_CHAR_REFERENCE.equals(r.getType())
						|| DOMRegionContext.XML_ENTITY_REFERENCE.equals(r
								.getType())) {
					counted++;
					if (counted >= offset) {
						return r.getEndOffset();
					}
				} else {
					int length = r.getLength();
					if (counted + length >= offset) {
						return r.getStartOffset() + offset - counted;
					}
					counted += length;
				}
				r = r.getNext();
			}
			return parent.getStartOffset() + p.getOffset();
		}
        IDOMNode previous = (IDOMNode) p.getPreviousSiblingNode();
        if (previous != null) {
        	return previous.getEndOffset();
        }
        IDOMNode next = (IDOMNode) p.getNextSiblingNode();
        if (next != null) {
        	return next.getStartOffset();
        }
        IStructuredDocumentRegion r = parent
        		.getStartStructuredDocumentRegion();
        if (r != null) {
        	return r.getEnd();
        }
        // r == null normally means the parent is the document node.
        return parent.getEndOffset();
	}

	/**
	 * convert design selection of structured selection of NodeEditPart into
	 * structured selection of Node
	 * 
	 * @param sel
	 * @return a structured selectino
	 */
	public static IStructuredSelection convertFromDesignSelection(
			IStructuredSelection sel) {
		List list = sel.toList();
		if (list != null) {
			List result = new ArrayList(list.size());
			for (int i = 0, size = list.size(); i < size; i++) {
				NodeEditPart part = (NodeEditPart) list.get(i);
				result.add(part.getIDOMNode());
			}
			return new StructuredSelection(result);
		}
        return new StructuredSelection();
	}

	/**
	 * 
	 * @param range
	 *            selection from designer, could be IStructuredSelection of
	 *            NodeEditPart, or DesignRange.
	 * @return a text selection
	 */
	public static ITextSelection convertFromDesignSelection(DesignRange range) {
		if (range.isValid()) {
			IDOMPosition start = DOMPositionHelper.toDOMPosition(range
					.getStartPosition());
			IDOMPosition end = DOMPositionHelper.toDOMPosition(range
					.getEndPosition());
			// We should not encounter invalid position.
			if (EditValidateUtil.validPosition(start)
					&& EditValidateUtil.validPosition(end)) {
				int offset = getIndexedRegionLocation(start);
				int endoffset = getIndexedRegionLocation(end);
				if (offset > endoffset) {
					int temp = offset;
					offset = endoffset;
					endoffset = temp;
				}
				return new TextSelection(offset, endoffset - offset);
			} 
		}
        return new TextSelection(0, 0);
	}

	/**
	 * @param selection
	 * @return a text selection for the selection or TextSelection(0,0)
	 * if nothing can be determined
	 */
	public static ITextSelection convertFromDesignSelectionToTextSelection(
			ISelection selection) {
		if (selection instanceof IStructuredSelection) {
			IStructuredSelection nodes = convertFromDesignSelection((IStructuredSelection) selection);
			IDOMNode node = (IDOMNode) nodes.getFirstElement();
			if (node != null && node.getNodeType() != Node.DOCUMENT_NODE) {
				return new TextSelection(node.getStartOffset(), node
						.getEndOffset()
						- node.getStartOffset());
			}
		} else if (selection instanceof DesignRange) {
			return convertFromDesignSelection((DesignRange) selection);
		}
        return new TextSelection(0, 0);
	}
}