/*******************************************************************************
 * Copyright (c) 2004 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.jst.jsp.core.internal.parser;


import java.util.Iterator;

import org.eclipse.jst.jsp.core.JSP12Namespace;
import org.eclipse.jst.jsp.core.internal.contentmodel.tld.provisional.JSP11TLDNames;
import org.eclipse.jst.jsp.core.internal.regions.DOMJSPRegionContexts;
import org.eclipse.wst.sse.core.events.StructuredDocumentEvent;
import org.eclipse.wst.sse.core.exceptions.SourceEditingRuntimeException;
import org.eclipse.wst.sse.core.internal.text.CoreNodeList;
import org.eclipse.wst.sse.core.parser.RegionParser;
import org.eclipse.wst.sse.core.parser.StructuredDocumentRegionParser;
import org.eclipse.wst.sse.core.text.IStructuredDocumentRegion;
import org.eclipse.wst.sse.core.text.IStructuredDocumentRegionList;
import org.eclipse.wst.sse.core.text.IStructuredTextReParser;
import org.eclipse.wst.sse.core.text.ITextRegion;
import org.eclipse.wst.sse.core.text.ITextRegionContainer;
import org.eclipse.wst.sse.core.text.ITextRegionList;
import org.eclipse.wst.sse.core.util.Debug;
import org.eclipse.wst.xml.core.internal.parser.XMLStructuredDocumentReParser;
import org.eclipse.wst.xml.core.internal.regions.DOMRegionContext;

public class JSPReParser extends XMLStructuredDocumentReParser {

	/**
	 * Allow a reparser to check for extra syntactic cases that require
	 * parsing beyond the flatNode boundary.
	 * 
	 * This implementation adds JSP language markers (comments are handled
	 * elsewhere).
	 */
	protected StructuredDocumentEvent checkForCrossStructuredDocumentRegionSyntax() {
		StructuredDocumentEvent result = super.checkForCrossStructuredDocumentRegionSyntax();
		// None of the superclass' cases were valid, so check for JSP cases
		if (result == null) {
			result = checkForJSP();
		}
		return result;
	}

	/**
	 * A change to a JSP tag can result in all being reparsed.
	 */
	private StructuredDocumentEvent checkForJSP() {
		StructuredDocumentEvent result = null;
		result = checkForCriticalKey("<%"); //$NON-NLS-1$
		if (result == null)
			result = checkForCriticalKey("<%="); //$NON-NLS-1$
		if (result == null)
			result = checkForCriticalKey("<%!"); //$NON-NLS-1$
		if (result == null)
			result = checkForCriticalKey("%>"); //$NON-NLS-1$

		return result;
	}

	/**
	 * If a comment start or end tag is being added or deleted, we'll rescan
	 * the whole document. The reason is that content that is revealed or
	 * commented out can effect the interpretation of the rest of the
	 * document. Note: for now this is very XML/JSP specific, can
	 * refactor/improve later.
	 */
	protected StructuredDocumentEvent checkForComments() {

		StructuredDocumentEvent result = super.checkForComments();

		if (result == null)
			result = checkForCriticalKey("<%--"); //$NON-NLS-1$
		if (result == null)
			result = checkForCriticalKey("--%>"); //$NON-NLS-1$
		// we'll also check for these degenerate cases
		if (result == null)
			result = checkForCriticalKey("<%---%>"); //$NON-NLS-1$

		return result;
	}

	/**
	 * The core reparsing method ... after the dirty start and dirty end have
	 * been calculated elsewhere. - this method overrides, does not extend
	 * super's method. changes/fixes to super may have to be made here as
	 * well.
	 */
	protected StructuredDocumentEvent reparse(IStructuredDocumentRegion dirtyStart, IStructuredDocumentRegion dirtyEnd) {
		StructuredDocumentEvent result = null;
		int rescanStart = -1;
		int rescanEnd = -1;
		boolean firstTime = false;
		boolean detectedBreakingChange = false;

		//
		// "save" the oldNodes (that may be replaced) in a list
		CoreNodeList oldNodes = formOldNodes(dirtyStart, dirtyEnd);

		if (containsBreakingChange(oldNodes) || isBreakingWithNestedTag(dirtyStart, dirtyEnd)) {
			if (Debug.debugTaglibs)
				System.out.println("reparse: is taglib or include"); //$NON-NLS-1$
			detectedBreakingChange = true;
			rescanStart = 0;
			rescanEnd = fStructuredDocument.getLength() + fLengthDifference;
			oldNodes = formOldNodes(fStructuredDocument.getFirstStructuredDocumentRegion(), fStructuredDocument.getLastStructuredDocumentRegion());
			clearTaglibInfo();
		}
		else if (dirtyStart == null || dirtyEnd == null) {
			// dirtyStart or dirty end are null, then that means we didn't
			// have a
			// cached node, which means we have an empty document, so we
			// just need to rescan the changes
			rescanStart = 0;
			rescanEnd = fChanges.length();
			firstTime = true;
		}
		else {
			// set the start of the text to rescan
			rescanStart = dirtyStart.getStart();
			//
			// set the end of the text to rescan
			// notice we use the same rationale as for the rescanStart,
			// with the added caveat that length has to be added to it,
			// to compensate for the new text which has been added or deleted.
			// If changes has zero length, then "length" will be negative,
			// since
			// we are deleting text. Otherwise, use the difference between
			// what's selected to be replaced and the length of the new text.
			rescanEnd = dirtyEnd.getEnd() + fLengthDifference;
		}

		// now that we have the old stuff "saved" away, update the document
		// with the changes.
		fStructuredDocument.updateDocumentData(fStart, fLengthToReplace, fChanges);
		// ------------------ now the real work
		result = core_reparse(rescanStart, rescanEnd, oldNodes, firstTime);
		//

		// if we did not detect a breaking type of change at the beginning,
		// but
		// do now, then reparse all! If we did detect them, then we may or may
		// not detect again, but presumably we've already set up to re-parsed
		// everthing, so no need to do again.
		if ((!detectedBreakingChange) && (containsBreakingChange(oldNodes))) {
			clearTaglibInfo();
			// reparse all
			oldNodes = formOldNodes(fStructuredDocument.getFirstStructuredDocumentRegion(), fStructuredDocument.getLastStructuredDocumentRegion());
			result = core_reparse(0, fStructuredDocument.getLength(), oldNodes, firstTime);
		}

		// event is returned to the caller, incase there is
		// some optimization they can do
		return result;
	}

	/**
	 * Verifies that the regions given, representing the contents of a
	 * IStructuredDocumentRegion, contain regions that could alter the
	 * behavior of the parser or the parsing of areas outside of the regions
	 * given.
	 */
	private boolean isBreakingChange(IStructuredDocumentRegion node, ITextRegionList regions) {
		return isTaglibOrInclude(node, regions) || isJspRoot(regions);
	}

	/**
	 * Verifies that the regions given, representing the regions touched by a
	 * text change have: 1) ...an insertion at the textEndOffset of an
	 * XML_TAG_OPEN that's in it's own IStructuredDocumentRegion and preceded
	 * by an unended IStructuredDocumentRegion 2) ...a deletion happening in
	 * an XML_EMPTY_TAG_CLOSE that ends a ITextRegionContainer 3) ...an
	 * insertion happening with a ' <' character somewhere in an XML attribute
	 * name or value 4) ...a deletion of a normal XML_TAG_CLOSE since
	 * subsequent tags become attribute values
	 */

	private boolean isBreakingWithNestedTag(boolean changesIncludeA_lt, boolean delsIncludeA_gt, IStructuredDocumentRegion parent, ITextRegion region) {
		boolean result = false;

		IStructuredDocumentRegion previous = parent.getPrevious();
		// case 1 test
		if (parent.getRegions().size() == 1 && region.getType() == DOMRegionContext.XML_TAG_OPEN && (previous == null || (!previous.isEnded() || previous.getType() == DOMRegionContext.XML_CONTENT))) {
			result = true;
		}
		//case 2 test
		if (region instanceof ITextRegionContainer) {
			ITextRegionContainer container = (ITextRegionContainer) region;
			ITextRegion internal = container.getRegions().get(container.getRegions().size() - 1);
			if (internal.getType() == DOMRegionContext.WHITE_SPACE && container.getRegions().size() >= 2)
				internal = container.getRegions().get(container.getRegions().size() - 2);
			if (internal.getType() == DOMRegionContext.XML_EMPTY_TAG_CLOSE) {
				result = true;
			}
		}
		//case 3 test
		if (changesIncludeA_lt && (region.getType() == DOMRegionContext.XML_TAG_ATTRIBUTE_NAME || region.getType() == DOMRegionContext.XML_TAG_ATTRIBUTE_VALUE)) {
			result = true;
		}
		//case 4 test
		if (delsIncludeA_gt && region.getType() == DOMRegionContext.XML_TAG_CLOSE) {
			result = true;
		}
		return result;
	}

	/**
	 * Verifies that the regions given, representing the contents of a
	 * IStructuredDocumentRegion, includes a jsp:root tag
	 */
	private boolean isJspRoot(ITextRegionList regions) {
		return regions.size() > 1 && regions.get(0).getType() == DOMRegionContext.XML_TAG_OPEN && regions.get(1).getType() == DOMJSPRegionContexts.JSP_ROOT_TAG_NAME;
	}

	/**
	 * Verifies that the regions given, representing the contents of a
	 * IStructuredDocumentRegion, includes a valid taglib directive or include
	 * directive
	 */
	private boolean isTaglibOrInclude(IStructuredDocumentRegion node, ITextRegionList regions) {
		boolean sizeAndTypesMatch = (regions.size() > 1) && (regions.get(1).getType() == DOMJSPRegionContexts.JSP_DIRECTIVE_NAME)
					&& (regions.get(0).getType() == DOMJSPRegionContexts.JSP_DIRECTIVE_OPEN || regions.get(0).getType() == DOMRegionContext.XML_TAG_OPEN);
		if (!sizeAndTypesMatch)
			return false;
		ITextRegion region = regions.get(1);
		String directiveName = node.getText(region);
		return sizeAndTypesMatch
					&& (directiveName.equals(JSP11TLDNames.TAGLIB) || directiveName.equals(JSP11TLDNames.INCLUDE) || directiveName.equals(JSP12Namespace.ElementName.DIRECTIVE_TAGLIB) || directiveName
								.equals(JSP12Namespace.ElementName.DIRECTIVE_INCLUDE));
	}

	private void clearTaglibInfo() {
		if (Debug.debugTaglibs)
			System.out.println("clearing taglib info"); //$NON-NLS-1$
		RegionParser parser = fStructuredDocument.getParser();
		if (parser instanceof StructuredDocumentRegionParser)
			((StructuredDocumentRegionParser) parser).resetHandlers();
	}

	private boolean containsBreakingChange(IStructuredDocumentRegionList list) {
		boolean contains = false;
		for (int i = 0; i < list.getLength(); i++) {
			IStructuredDocumentRegion node = list.item(i);
			if (isBreakingChange(node, node.getRegions())) {
				contains = true;
				break;
			}
		}
		return contains;
	}

	protected IStructuredDocumentRegion findDirtyEnd(int end) {

		IStructuredDocumentRegion result = super.findDirtyEnd(end);

		// if not well formed, get one past, if its not null

		// now, if any of to-be-scanned flatnodes are the start of a jsp
		// region, we'll
		// reparse all the way to the end, to be sure we detect embedded
		// regions (or not-embedded regions) correctly.
		// notice we don't need to do if we're only processing one node.
		// notice too we have a strong assumption here that dirtyStart has
		// already been found!
		//
		// note that dirtyEnd is not checked in the do-block below, so we'll
		// check it first.
		if (isJSPEmbeddedStartOrEnd(result)) {
			result = fStructuredDocument.getLastStructuredDocumentRegion();
		}
		else {
			// when end node and start node are the same, we only need the
			// above
			// check, otherwise, there's a few cases that we'll search the
			// rest of the
			// flatnodes needlessly.
			if (result != dirtyStart) {
				IStructuredDocumentRegion searchNode = dirtyStart;
				do {
					if (isJSPEmbeddedStartOrEnd(searchNode)) {
						result = fStructuredDocument.getLastStructuredDocumentRegion();
						break;
					}
					else {
						searchNode = searchNode.getNext();
					}
					// if we get to the current dirty end, or end of
					// flatnodes, without finding JSP region then we
					// don't need to check further
				}
				while ((searchNode != result) && (searchNode != null));
			}
		}
		// result should never be null, but cachedNode needs to be protected
		// from being changed to null
		if (result != null)
			fStructuredDocument.setCachedDocumentRegion(result);
		dirtyEnd = result;
		return dirtyEnd;
	}

	private boolean isBreakingWithNestedTag(IStructuredDocumentRegion start, IStructuredDocumentRegion end) {
		boolean result = false;
		boolean changesIncludeA_lt = fChanges != null && fChanges.indexOf('<') >= 0;
		boolean delsIncludeA_gt = fDeletedText != null && fDeletedText.indexOf('>') >= 0;

		//List regions = new ArrayList();
		IStructuredDocumentRegion node = start;
		int endReplace = fStart + fLengthToReplace;
		while (end != null && node != end.getNext()) {
			Iterator i = node.getRegions().iterator();
			while (i.hasNext()) {
				ITextRegion region = (ITextRegion) i.next();
				if (intersects(node, region, fStart, endReplace)) {

					result = isBreakingWithNestedTag(changesIncludeA_lt, delsIncludeA_gt, node, region);

					if (result)
						break;
				}
			}
			node = node.getNext();
			if (result)
				break;
		}
		return result;
	}

	private boolean intersects(IStructuredDocumentRegion node, ITextRegion region, int low, int high) {
		int start = node.getStartOffset(region);
		int end = node.getEndOffset(region);
		return (end >= low && start <= high) || (start <= low && end >= low) || (start <= high && end >= high);
	}

	/**
	 * Returns true if potentially could be a jsp embedded region. Things like
	 * JSP Declaration can't be embedded.
	 */
	private boolean isJSPEmbeddedStartOrEnd(IStructuredDocumentRegion flatNode) {
		boolean result = false;
		String type = flatNode.getType();
		result = ((type == DOMJSPRegionContexts.JSP_SCRIPTLET_OPEN) || (type == DOMJSPRegionContexts.JSP_EXPRESSION_OPEN) || (type == DOMJSPRegionContexts.JSP_DECLARATION_OPEN));
		return result;
	}

	/**
	 * extends super class behavior
	 */
	protected boolean isPartOfBlockRegion(IStructuredDocumentRegion flatNode) {
		boolean result = false;
		String type = flatNode.getType();
		result = ((type == DOMJSPRegionContexts.JSP_CLOSE) || (type == DOMJSPRegionContexts.JSP_CONTENT) || super.isPartOfBlockRegion(flatNode));
		return result;
	}

	public IStructuredTextReParser newInstance() {
		return new JSPReParser();
	}

	public StructuredDocumentEvent quickCheck() {
		if (containsBreakingChange(new CoreNodeList(dirtyStart, dirtyEnd)))
			return null;
		return super.quickCheck();
	}

	public Object clone() {
		try {
			return super.clone();
		}
		catch (CloneNotSupportedException e) {
			// could only happen if some changes
			// superclass someday
			throw new SourceEditingRuntimeException(e);
		}
	}

}