/*******************************************************************************
 * Copyright (c) 2001, 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
 *     Jens Lukowski/Innoopract - initial renaming/restructuring
 *     
 *******************************************************************************/
package org.eclipse.wst.xml.ui.internal.validation;

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

import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.Position;
import org.eclipse.jface.text.reconciler.DirtyRegion;
import org.eclipse.jface.text.reconciler.IReconcileResult;
import org.eclipse.jface.text.reconciler.IReconcileStep;
import org.eclipse.osgi.util.NLS;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.core.internal.provisional.StructuredModelManager;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion;
import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegion;
import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegionList;
import org.eclipse.wst.sse.ui.internal.reconcile.AbstractStructuredTextReconcilingStrategy;
import org.eclipse.wst.sse.ui.internal.reconcile.ReconcileAnnotationKey;
import org.eclipse.wst.sse.ui.internal.reconcile.StructuredReconcileStep;
import org.eclipse.wst.sse.ui.internal.reconcile.TemporaryAnnotation;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
import org.eclipse.wst.xml.core.internal.regions.DOMRegionContext;
import org.eclipse.wst.xml.ui.internal.XMLUIMessages;
import org.eclipse.wst.xml.ui.internal.correction.ProblemIDsXML;
import org.w3c.dom.Node;

/**
 * Basic XML syntax checking step.
 * 
 * @author pavery
 */
public class ReconcileStepForMarkup extends StructuredReconcileStep {
	private String DQUOTE = "\""; //$NON-NLS-1$

	protected String SEVERITY_ATTR_MISSING_VALUE = TemporaryAnnotation.ANNOT_ERROR;
	protected String SEVERITY_ATTR_NO_VALUE = TemporaryAnnotation.ANNOT_ERROR;
	// severities for the problems discoverable by this reconciler; possibly
	// user configurable later
	protected String SEVERITY_GENERIC_ILLFORMED_SYNTAX = TemporaryAnnotation.ANNOT_WARNING;
	protected String SEVERITY_STRUCTURE = TemporaryAnnotation.ANNOT_ERROR;
	protected String SEVERITY_SYNTAX_ERROR = TemporaryAnnotation.ANNOT_ERROR;
	// used for attribute quote checking
	private String SQUOTE = "'"; //$NON-NLS-1$

	public ReconcileStepForMarkup() {
		super();
	}

	public ReconcileStepForMarkup(IReconcileStep step) {
		super(step);
	}

	private void addAttributeError(String message, String attributeValueText, int start, int length, int problemId, IStructuredDocumentRegion sdRegion, List results) {
        
        if (sdRegion.isDeleted())
            return;
        
        Position p = new Position(start, length);
		ReconcileAnnotationKey key = createKey(sdRegion, getScope());
		TemporaryAnnotation annotation = new TemporaryAnnotation(p, SEVERITY_SYNTAX_ERROR, message, key, problemId);
		annotation.setAdditionalFixInfo(attributeValueText);
		results.add(annotation);
	}

	private void checkAttributesInEndTag(IStructuredDocumentRegion structuredDocumentRegion, List results) {
        
        if(structuredDocumentRegion.isDeleted())
            return;
        
		ITextRegionList textRegions = structuredDocumentRegion.getRegions();
		int errorCount = 0;
		int start = structuredDocumentRegion.getEndOffset();
		int end = structuredDocumentRegion.getEndOffset();
		for (int i = 0; i < textRegions.size() && errorCount < AbstractStructuredTextReconcilingStrategy.ELEMENT_ERROR_LIMIT && !structuredDocumentRegion.isDeleted(); i++) {
			ITextRegion textRegion = textRegions.get(i);
			if (textRegion.getType() == DOMRegionContext.XML_TAG_ATTRIBUTE_NAME || textRegion.getType() == DOMRegionContext.XML_TAG_ATTRIBUTE_EQUALS || textRegion.getType() == DOMRegionContext.XML_TAG_ATTRIBUTE_VALUE) {
				if (start > structuredDocumentRegion.getStartOffset(textRegion))
					start = structuredDocumentRegion.getStartOffset(textRegion);
				end = structuredDocumentRegion.getEndOffset(textRegion);
				errorCount++;
			}
		}
		// create one error for all attributes in the end tag
		if (errorCount > 0) {
			Position p = new Position(start, end - start);
			String message = XMLUIMessages.End_tag_has_attributes;
			results.add(new TemporaryAnnotation(p, SEVERITY_GENERIC_ILLFORMED_SYNTAX, message, createKey(structuredDocumentRegion, getScope()), ProblemIDsXML.AttrsInEndTag));
		}
	}


	/**
	 * @param structuredDocumentRegion
	 * @param results
	 */
	private void checkClosingBracket(IStructuredDocumentRegion structuredDocumentRegion, List results) {
        
        if(structuredDocumentRegion.isDeleted())
            return;
        
		ITextRegionList regions = structuredDocumentRegion.getRegions();
		ITextRegion r = null;
		boolean closed = false;
		for (int i = 0; i < regions.size()  && !structuredDocumentRegion.isDeleted(); i++) {
			r = regions.get(i);
			if (r.getType() == DOMRegionContext.XML_TAG_CLOSE || r.getType() == DOMRegionContext.XML_EMPTY_TAG_CLOSE)
				closed = true;
		}
		if (!closed) {

			String message = XMLUIMessages.ReconcileStepForMarkup_6;

			int start = structuredDocumentRegion.getStartOffset();
			int length = structuredDocumentRegion.getText().trim().length();
			Position p = new Position(start, length);
			ReconcileAnnotationKey key = createKey(structuredDocumentRegion, getScope());

			TemporaryAnnotation annotation = new TemporaryAnnotation(p, SEVERITY_SYNTAX_ERROR, message, key, ProblemIDsXML.MissingClosingBracket);
			results.add(annotation);
		}
	}

	private void checkEmptyTag(IStructuredDocumentRegion structuredDocumentRegion, List results) {
        
        if(structuredDocumentRegion.isDeleted())
            return;
        
		// navigate to name
		ITextRegionList regions = structuredDocumentRegion.getRegions();
		if (regions.size() == 2) {
			// missing name region
			if (regions.get(0).getType() == DOMRegionContext.XML_TAG_OPEN && regions.get(1).getType() == DOMRegionContext.XML_TAG_CLOSE) {
				String message = XMLUIMessages.ReconcileStepForMarkup_3;
				int start = structuredDocumentRegion.getStartOffset();
				int length = structuredDocumentRegion.getLength();
				Position p = new Position(start, length);
				ReconcileAnnotationKey key = createKey(structuredDocumentRegion, getScope());

				TemporaryAnnotation annotation = new TemporaryAnnotation(p, SEVERITY_SYNTAX_ERROR, message, key, ProblemIDsXML.EmptyTag);
				results.add(annotation);
			}
		}
	}

	private void checkForAttributeValue(IStructuredDocumentRegion structuredDocumentRegion, List results) {
        
        if(structuredDocumentRegion.isDeleted())
            return;
        
		// check for attributes without a value
		// track the attribute/equals/value sequence using a state of 0, 1 ,2
		// representing the name, =, and value, respectively
		int attrState = 0;
		ITextRegionList textRegions = structuredDocumentRegion.getRegions();
		ReconcileAnnotationKey key = createKey(structuredDocumentRegion, getScope());
		int errorCount = 0;
		for (int i = 0; i < textRegions.size() && errorCount < AbstractStructuredTextReconcilingStrategy.ELEMENT_ERROR_LIMIT; i++) {
			ITextRegion textRegion = textRegions.get(i);
			if (textRegion.getType() == DOMRegionContext.XML_TAG_ATTRIBUTE_NAME || isTagCloseTextRegion(textRegion)) {
				// dangling name and '='
				if (attrState == 2 && i >= 2) {
					// create annotation
					ITextRegion nameRegion = textRegions.get(i - 2);
					Object[] args = {structuredDocumentRegion.getText(nameRegion)};
					String message = NLS.bind(XMLUIMessages.Attribute__is_missing_a_value, args);
					int start = structuredDocumentRegion.getStartOffset(nameRegion);
					int end = structuredDocumentRegion.getTextEndOffset(nameRegion);
					Position p = new Position(start, end - start);
					TemporaryAnnotation annotation = new TemporaryAnnotation(p, SEVERITY_ATTR_MISSING_VALUE, message, key, ProblemIDsXML.MissingAttrValue);

					// quick fix info
					ITextRegion equalsRegion = textRegions.get(i - 2 + 1);
					int insertOffset = structuredDocumentRegion.getTextEndOffset(equalsRegion) - end;
					Object[] additionalFixInfo = {structuredDocumentRegion.getText(nameRegion), new Integer(insertOffset)};
					annotation.setAdditionalFixInfo(additionalFixInfo);

					results.add(annotation);
					errorCount++;
				}
				// name but no '=' (XML only)
				else if (attrState == 1 && i >= 1) {
					// create annotation
					ITextRegion previousRegion = textRegions.get(i - 1);
					Object[] args = {structuredDocumentRegion.getText(previousRegion)};
					String message = NLS.bind(XMLUIMessages.Attribute__has_no_value, args);
					int start = structuredDocumentRegion.getStartOffset(previousRegion);
					int end = structuredDocumentRegion.getTextEndOffset(previousRegion);
					Position p = new Position(start, end - start);
					TemporaryAnnotation annotation = new TemporaryAnnotation(p, SEVERITY_ATTR_NO_VALUE, message, key, ProblemIDsXML.NoAttrValue);

					// quick fix info
					annotation.setAdditionalFixInfo(structuredDocumentRegion.getText(previousRegion));

					results.add(annotation);
					errorCount++;
				}
				attrState = 1;
			} else if (textRegion.getType() == DOMRegionContext.XML_TAG_ATTRIBUTE_EQUALS) {
				attrState = 2;
			} else if (textRegion.getType() == DOMRegionContext.XML_TAG_ATTRIBUTE_VALUE) {
				attrState = 0;
			}
		}

	}

	private void checkForSpaceBeforeName(IStructuredDocumentRegion structuredDocumentRegion, List results) {
        
        if(structuredDocumentRegion.isDeleted())
            return;
        
		String sdRegionText = structuredDocumentRegion.getFullText();
		if (sdRegionText.startsWith(" ")) { //$NON-NLS-1$
			IStructuredDocumentRegion prev = structuredDocumentRegion.getPrevious();
			if (prev != null) {
				// this is possibly the case of "< tag"
				if (prev.getRegions().size() == 1 && isStartTag(prev)) {
					// add the error for preceding space in tag name
					String message = XMLUIMessages.ReconcileStepForMarkup_2;
					int start = structuredDocumentRegion.getStartOffset();
					// find length of whitespace
					int length = sdRegionText.trim().equals("") ? sdRegionText.length() : sdRegionText.indexOf(sdRegionText.trim()); //$NON-NLS-1$

					Position p = new Position(start, length);
					ReconcileAnnotationKey key = createKey(structuredDocumentRegion, getScope());

					TemporaryAnnotation annotation = new TemporaryAnnotation(p, SEVERITY_SYNTAX_ERROR, message, key, ProblemIDsXML.SpacesBeforeTagName);
					results.add(annotation);
				}
			}
		}
	}

	private void checkNoNamespaceInPI(IStructuredDocumentRegion structuredDocumentRegion, List results) {
        
        if(structuredDocumentRegion.isDeleted())
            return;
        
		// navigate to name
		ITextRegionList regions = structuredDocumentRegion.getRegions();
		ITextRegion r = null;
		int errorCount = 0;
		for (int i = 0; i < regions.size() && errorCount < AbstractStructuredTextReconcilingStrategy.ELEMENT_ERROR_LIMIT && !structuredDocumentRegion.isDeleted(); i++) {
			r = regions.get(i);
			if (r.getType() == DOMRegionContext.XML_TAG_NAME) {
				String piText = structuredDocumentRegion.getText(r);
				int index = piText.indexOf(":"); //$NON-NLS-1$
				if (index != -1) {
					String message = XMLUIMessages.ReconcileStepForMarkup_4;
					int start = structuredDocumentRegion.getStartOffset(r) + index;
					int length = piText.trim().length() - index;
					Position p = new Position(start, length);
					ReconcileAnnotationKey key = createKey(structuredDocumentRegion, getScope());

					TemporaryAnnotation annotation = new TemporaryAnnotation(p, SEVERITY_SYNTAX_ERROR, message, key, ProblemIDsXML.NamespaceInPI);
					results.add(annotation);
					errorCount++;
				}
			}
		}
	}

	/**
	 * @param structuredDocumentRegion
	 * @param results
	 */
	private void checkQuotesForAttributeValues(IStructuredDocumentRegion structuredDocumentRegion, List results) {
		ITextRegionList regions = structuredDocumentRegion.getRegions();
		ITextRegion r = null;
		String attrValueText = ""; //$NON-NLS-1$
		int errorCount = 0;
		for (int i = 0; i < regions.size() && errorCount < AbstractStructuredTextReconcilingStrategy.ELEMENT_ERROR_LIMIT; i++) {
			r = regions.get(i);
			if (r.getType() != DOMRegionContext.XML_TAG_ATTRIBUTE_VALUE)
				continue;

			attrValueText = structuredDocumentRegion.getText(r);
			// attribute value includes quotes in the string
			// split up attribute value on quotes
			StringTokenizer st = new StringTokenizer(attrValueText, "\"'", true); //$NON-NLS-1$
			int size = st.countTokens();
			// get the pieces of the attribute value
			String one = "", two = ""; //$NON-NLS-1$ //$NON-NLS-2$
			if (size > 0)
				one = st.nextToken();
			if (size > 1)
				two = st.nextToken();
			if (size > 2) {
				// should be handled by parsing...
				// as in we can't have an attribute value like: <element
				// attr="a"b"c"/>
				// and <element attr='a"b"c' /> is legal
				continue;
			}


			if (size == 1) {
				if (one.equals(DQUOTE) || one.equals(SQUOTE)) {
					// missing closing quote
					String message = XMLUIMessages.ReconcileStepForMarkup_0;
					addAttributeError(message, attrValueText, structuredDocumentRegion.getStartOffset(r), attrValueText.trim().length(), ProblemIDsXML.Unclassified, structuredDocumentRegion, results);
					errorCount++;
				} else {
					// missing both
					String message = XMLUIMessages.ReconcileStepForMarkup_1;
					addAttributeError(message, attrValueText, structuredDocumentRegion.getStartOffset(r), attrValueText.trim().length(), ProblemIDsXML.AttrValueNotQuoted, structuredDocumentRegion, results);
					errorCount++;
				}
			} else if (size == 2) {
				if (one.equals(SQUOTE) && !two.equals(SQUOTE) || one.equals(DQUOTE) && !two.equals(DQUOTE)) {
					// missing closing quote
					String message = XMLUIMessages.ReconcileStepForMarkup_0;
					addAttributeError(message, attrValueText, structuredDocumentRegion.getStartOffset(r), attrValueText.trim().length(), ProblemIDsXML.Unclassified, structuredDocumentRegion, results);
					errorCount++;
				}
			}
		}
		// end of region for loop
	}

	private void checkStartEndTagPairs(IStructuredDocumentRegion sdRegion, List results) {
        
        if(sdRegion.isDeleted())
            return;
        
		// check start/end tag pairs
		IDOMNode xmlNode = getXMLNode(sdRegion);
        
        if(xmlNode == null)
            return;
        
		boolean selfClosed = false;
		String tagName = null;
		int length = 0;

		if (xmlNode.isContainer()) {
			IStructuredDocumentRegion endRegion = xmlNode.getEndStructuredDocumentRegion();
			if (endRegion == null) {
                IStructuredDocumentRegion startRegion = xmlNode.getStartStructuredDocumentRegion();
                if(!startRegion.isDeleted()) {
    				// analyze the tag (check self closing)
    				ITextRegionList regions = startRegion.getRegions();
    				ITextRegion r = null;
    				for (int i = 0; i < regions.size(); i++) {
    					r = regions.get(i);
    					if (r.getType() == DOMRegionContext.XML_TAG_OPEN || r.getType() == DOMRegionContext.XML_TAG_CLOSE) {
    						length++;
    					} else if (r.getType() == DOMRegionContext.XML_TAG_NAME) {
    						tagName = sdRegion.getText(r);
    						length += tagName.length();
    					} else if (r.getType() == DOMRegionContext.XML_EMPTY_TAG_CLOSE) {
    						selfClosed = true;
    					}
    				}
    
    				if (!selfClosed && tagName != null) {
    					Object[] args = {tagName};
    					String message = NLS.bind(XMLUIMessages.Missing_end_tag_, args);
    
    					int start = sdRegion.getStart();
    					Position p = new Position(start, length);
    					TemporaryAnnotation annotation = new TemporaryAnnotation(p, SEVERITY_STRUCTURE, message, createKey(sdRegion, getScope()), ProblemIDsXML.MissingEndTag);
    
    					// quick fix info
    					String tagClose = "/>"; //$NON-NLS-1$
    					int tagCloseOffset = xmlNode.getFirstStructuredDocumentRegion().getEndOffset();
    					if (r != null && r.getType() == DOMRegionContext.XML_TAG_CLOSE) {
    						tagClose = "/"; //$NON-NLS-1$
    						tagCloseOffset--;
    					}
    					IDOMNode firstChild = (IDOMNode) xmlNode.getFirstChild();
    					while (firstChild != null && firstChild.getNodeType() == Node.TEXT_NODE) {
    						firstChild = (IDOMNode) firstChild.getNextSibling();
    					}
    					int endOffset = xmlNode.getEndOffset();
    					int firstChildStartOffset = firstChild == null ? endOffset : firstChild.getStartOffset();
    					Object[] additionalFixInfo = {tagName, tagClose, new Integer(tagCloseOffset), new Integer(xmlNode.getFirstStructuredDocumentRegion().getEndOffset()), // startTagEndOffset
    								new Integer(firstChildStartOffset), // firstChildStartOffset
    								new Integer(endOffset)}; // endOffset
    					annotation.setAdditionalFixInfo(additionalFixInfo);
    
    					results.add(annotation);
    				}
    			}
            }

		}
	}

	private void checkStartingSpaceForPI(IStructuredDocumentRegion structuredDocumentRegion, List results) {
        
        if(structuredDocumentRegion.isDeleted())
            return;
        
		IStructuredDocumentRegion prev = structuredDocumentRegion.getPrevious();
		if (prev != null && !prev.isDeleted()) {
			String prevText = prev.getFullText();
			if (prev.getType() == DOMRegionContext.XML_CONTENT && prevText.endsWith(" ")) { //$NON-NLS-1$
				String message = XMLUIMessages.ReconcileStepForMarkup_5;
				int start = prev.getStartOffset();
				int length = prev.getLength();
				Position p = new Position(start, length);
				ReconcileAnnotationKey key = createKey(structuredDocumentRegion, getScope());

				TemporaryAnnotation annotation = new TemporaryAnnotation(p, SEVERITY_SYNTAX_ERROR, message, key, ProblemIDsXML.SpacesBeforePI);
				results.add(annotation);
			}
		}
	}

	public int getScope() {
		return ReconcileAnnotationKey.PARTIAL;
	}

	/**
	 * A DirtyRegion can span multiple StructuredDocumentRegions. This method
	 * returns the StructuredDocumentRegions in a given dirty region.
	 * 
	 * @param dirtyRegion
	 */
	private IStructuredDocumentRegion[] getStructuredDocumentRegions(DirtyRegion dirtyRegion) {
		List regions = new ArrayList();
        
        if(getStructuredDocument() == null)
            return new IStructuredDocumentRegion[0];
        
		IStructuredDocumentRegion sdRegion = getStructuredDocument().getRegionAtCharacterOffset(dirtyRegion.getOffset());
		if (sdRegion != null) {
            
			if (!sdRegion.isDeleted())
				regions.add(sdRegion);
            
            IDOMNode xmlNode = getXMLNode(sdRegion);
            
			while (sdRegion != null 
                    && !sdRegion.isDeleted() 
                    && xmlNode != null
                    && sdRegion.getEndOffset() <= xmlNode.getEndOffset()) {
				if (!sdRegion.isDeleted())
					regions.add(sdRegion);
                sdRegion = sdRegion.getNext();
                xmlNode = getXMLNode(sdRegion);
			}
		}
		return (IStructuredDocumentRegion[]) regions.toArray(new IStructuredDocumentRegion[regions.size()]);
	}

	private IDOMNode getXMLNode(IStructuredDocumentRegion sdRegion) {
        
        if(sdRegion == null)
            return null;
        
		IStructuredModel xModel = null;
		IDOMNode xmlNode = null;
		// get/release models should always be in a try/finally block
		try {
			xModel = StructuredModelManager.getModelManager().getExistingModelForRead(getDocument());
			// xModel is sometime null, when closing editor, for example
			if (xModel != null) {
				xmlNode = (IDOMNode) xModel.getIndexedRegion(sdRegion.getStart());
			}
		} finally {
			if (xModel != null) {
				xModel.releaseFromRead();
			}
		}
		return xmlNode;
	}

	/**
	 * Determines whether the IStructuredDocumentRegion is a XML "end tag"
	 * since they're not allowed to have attribute ITextRegions
	 * 
	 * @param structuredDocumentRegion
	 */
	private boolean isEndTag(IStructuredDocumentRegion structuredDocumentRegion) {
		if (structuredDocumentRegion == null || structuredDocumentRegion.isDeleted())
			return false;
		return structuredDocumentRegion.getFirstRegion().getType() == DOMRegionContext.XML_END_TAG_OPEN;
	}

	/**
	 * Determines if the IStructuredDocumentRegion is an XML Processing
	 * Instruction
	 * 
	 * @param structuredDocumentRegion
	 * 
	 */
	private boolean isPI(IStructuredDocumentRegion structuredDocumentRegion) {
        if (structuredDocumentRegion == null || structuredDocumentRegion.isDeleted())
            return false;
		return structuredDocumentRegion.getFirstRegion().getType() == DOMRegionContext.XML_PI_OPEN;
	}

	/**
	 * Determines whether the IStructuredDocumentRegion is a XML "start tag"
	 * since they need to be checked for proper XML attribute region sequences
	 * 
	 * @param structuredDocumentRegion
	 * 
	 */
	private boolean isStartTag(IStructuredDocumentRegion structuredDocumentRegion) {
		if (structuredDocumentRegion == null || structuredDocumentRegion.isDeleted())
			return false;
		return structuredDocumentRegion.getFirstRegion().getType() == DOMRegionContext.XML_TAG_OPEN;
	}

	// Because we check the "proper" closing separately from attribute
	// sequencing, we need to know what's
	// an appropriate close.
	private boolean isTagCloseTextRegion(ITextRegion textRegion) {
		return textRegion.getType() == DOMRegionContext.XML_TAG_CLOSE || textRegion.getType() == DOMRegionContext.XML_EMPTY_TAG_CLOSE;
	}

	/**
	 * Determines if the IStructuredDocumentRegion is XML Content
	 * 
	 * @param structuredDocumentRegion
	 * 
	 */
	private boolean isXMLContent(IStructuredDocumentRegion structuredDocumentRegion) {
        if(structuredDocumentRegion == null || structuredDocumentRegion.isDeleted())
            return false;
		return structuredDocumentRegion.getFirstRegion().getType() == DOMRegionContext.XML_CONTENT;
	}

	/*
	 * check syntax of dirty region
	 */
	protected IReconcileResult[] reconcile(IStructuredDocumentRegion structuredDocumentRegion) {
		List results = new ArrayList();

		if (structuredDocumentRegion == null)
			return EMPTY_RECONCILE_RESULT_SET;

		if (isStartTag(structuredDocumentRegion)) {
			// check for attributes without a value
			checkForAttributeValue(structuredDocumentRegion, results);
			// check if started tag is ended
			checkStartEndTagPairs(structuredDocumentRegion, results);
			// check empty tag <>
			checkEmptyTag(structuredDocumentRegion, results);
			// check that each attribute has quotes
			checkQuotesForAttributeValues(structuredDocumentRegion, results);
			// check that the closing '>' is there
			checkClosingBracket(structuredDocumentRegion, results);
		} else if (isEndTag(structuredDocumentRegion)) {
			checkAttributesInEndTag(structuredDocumentRegion, results);
			// check that the closing '>' is there
			checkClosingBracket(structuredDocumentRegion, results);
		} else if (isPI(structuredDocumentRegion)) {
			// check validity of processing instruction
			checkStartingSpaceForPI(structuredDocumentRegion, results);
			checkNoNamespaceInPI(structuredDocumentRegion, results);
		} else if (isXMLContent(structuredDocumentRegion)) {
			checkForSpaceBeforeName(structuredDocumentRegion, results);
		}

		return (IReconcileResult[]) results.toArray(new IReconcileResult[results.size()]);
	}

	/*
	 * @see org.eclipse.text.reconcilerpipe.AbstractReconcilePipeParticipant#reconcileModel(org.eclipse.jface.text.reconciler.DirtyRegion,
	 *      org.eclipse.jface.text.IRegion)
	 */
	protected IReconcileResult[] reconcileModel(DirtyRegion dirtyRegion, IRegion subRegion) {
		if (dirtyRegion == null)
			return EMPTY_RECONCILE_RESULT_SET;

        if(DEBUG)
            System.out.println("[trace reconciler] > reconcile model in MARKUP step w/ dirty region: [" + dirtyRegion.getOffset() + ":" + dirtyRegion.getLength() + "]" + (dirtyRegion == null ? "null" : dirtyRegion.getText())); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$

		IReconcileResult[] results = EMPTY_RECONCILE_RESULT_SET;

		// TODO: may need to add back some synch(doc) and/or synch(region[i])
		// to be thread safe
		IStructuredDocumentRegion[] regions = getStructuredDocumentRegions(dirtyRegion);
		for (int i = 0; i < regions.length; i++) {
			// the region may be irrelevant at this point
			// if the user has deleted it
			if (!regions[i].isDeleted()) {
				results = merge(results, reconcile(regions[i]));
			}
		}

        if(DEBUG)
            System.out.println("[trace reconciler] > MARKUP step done"); //$NON-NLS-1$
		return results;
	}
}