/*******************************************************************************
 * Copyright (c) 2006 Oracle Corporation.
 * 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:
 *    Gerry Kessler/Oracle - initial API and implementation
 *    
 ********************************************************************************/
package org.eclipse.jst.jsf.validation.internal;

import java.io.IOException;
import java.text.MessageFormat;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.common.util.Diagnostic;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jst.jsf.common.dom.TagIdentifier;
import org.eclipse.jst.jsf.common.internal.JSPUtil;
import org.eclipse.jst.jsf.common.internal.types.CompositeType;
import org.eclipse.jst.jsf.common.internal.types.TypeComparator;
import org.eclipse.jst.jsf.common.metadata.Entity;
import org.eclipse.jst.jsf.common.metadata.Trait;
import org.eclipse.jst.jsf.common.metadata.query.ITaglibDomainMetaDataModelContext;
import org.eclipse.jst.jsf.common.metadata.query.TaglibDomainMetaDataQueryHelper;
import org.eclipse.jst.jsf.common.sets.AxiomaticSet;
import org.eclipse.jst.jsf.common.sets.ConcreteAxiomaticSet;
import org.eclipse.jst.jsf.context.resolver.structureddocument.IDOMContextResolver;
import org.eclipse.jst.jsf.context.resolver.structureddocument.IStructuredDocumentContextResolverFactory;
import org.eclipse.jst.jsf.context.resolver.structureddocument.ITaglibContextResolver;
import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContext;
import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContextFactory;
import org.eclipse.jst.jsf.core.internal.JSFCorePlugin;
import org.eclipse.jst.jsf.core.internal.tld.TagIdentifierFactory;
import org.eclipse.jst.jsf.core.set.constraint.MemberConstraint;
import org.eclipse.jst.jsf.core.set.mapping.ElementToTagIdentifierMapping;
import org.eclipse.jst.jsf.core.tagmatcher.EvaluationException;
import org.eclipse.jst.jsf.core.tagmatcher.InvalidExpressionException;
import org.eclipse.jst.jsf.core.tagmatcher.XPathMatchingAlgorithm;
import org.eclipse.jst.jsf.metadataprocessors.MetaDataEnabledProcessingFactory;
import org.eclipse.jst.jsf.metadataprocessors.features.ELIsNotValidException;
import org.eclipse.jst.jsf.metadataprocessors.features.IValidELValues;
import org.eclipse.jst.jsf.metadataprocessors.features.IValidValues;
import org.eclipse.jst.jsf.metadataprocessors.features.IValidationMessage;
import org.eclipse.jst.jsf.validation.internal.constraints.ContainsTagConstraint;
import org.eclipse.jst.jsf.validation.internal.constraints.TagId;
import org.eclipse.jst.jsf.validation.internal.constraints.TagSet;
import org.eclipse.jst.jsf.validation.internal.el.ELExpressionValidator;
import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory;
import org.eclipse.jst.jsf.validation.internal.el.diagnostics.ValidationMessageFactory;
import org.eclipse.jst.jsp.core.internal.domdocument.DOMModelForJSP;
import org.eclipse.jst.jsp.core.internal.regions.DOMJSPRegionContexts;
import org.eclipse.jst.jsp.core.internal.validation.JSPValidator;
import org.eclipse.wst.sse.core.StructuredModelManager;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
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.ITextRegionCollection;
import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegionList;
import org.eclipse.wst.sse.ui.internal.reconcile.validator.ISourceValidator;
import org.eclipse.wst.validation.internal.provisional.core.IMessage;
import org.eclipse.wst.validation.internal.provisional.core.IReporter;
import org.eclipse.wst.validation.internal.provisional.core.IValidationContext;
import org.eclipse.wst.xml.core.internal.regions.DOMRegionContext;
import org.w3c.dom.Element;
import org.w3c.dom.Node;

/**
 * A JSP page validator that makes use of the JSF metadata processing framework so that JSP page
 * semantics can be validated.
 * 
 * This implementation currently only validates attribute values. 
 * @author Gerry Kessler - Oracle
 */
public class JSPSemanticsValidator extends JSPValidator implements ISourceValidator
{
    // TODO: should the source validator be a separate class in jsp.ui?
    // problem with simple split off is that preference must also be split off
	static final boolean DEBUG;
	static {
		String value = Platform.getDebugOption("org.eclipse.jst.jsf.validation.internal.el/debug/jspsemanticsvalidator"); //$NON-NLS-1$
		DEBUG = value != null && value.equalsIgnoreCase("true"); //$NON-NLS-1$
	}
    private final static ElementToTagIdentifierMapping elem2TagIdMapper = new ElementToTagIdentifierMapping();
	private IDocument fDocument;
	private int		  containmentValidationCount;  // = 0; 

	/* (non-Javadoc)
	 * @see org.eclipse.jst.jsp.core.internal.validation.JSPValidator#validateFile(org.eclipse.core.resources.IFile, org.eclipse.wst.validation.internal.provisional.core.IReporter)
	 */
	protected void validateFile(IFile file, IReporter reporter) {	
		IStructuredModel model = null;		
		if (DEBUG)
			System.out.println("executing JSPSemanticsValidator.validateFile");
		try {
			model = StructuredModelManager.getModelManager().getModelForRead(file);

			if (model instanceof DOMModelForJSP)
			{
			    ValidationPreferences prefs= new ValidationPreferences(JSFCorePlugin.getDefault().getPreferenceStore());
			    prefs.load();
			    DiagnosticFactory diagnosticFactory = new DiagnosticFactory();

				// zero the containment validation count for each mondel
				containmentValidationCount = 0;
    			DOMModelForJSP jspModel = (DOMModelForJSP) model;
    			IStructuredDocument structuredDoc = jspModel.getStructuredDocument();
    			IStructuredDocumentRegion curNode = structuredDoc.getFirstStructuredDocumentRegion();
    			while (null != curNode && !reporter.isCancelled()) {
    				if (curNode.getFirstRegion().getType() == DOMRegionContext.XML_TAG_OPEN ) 
                    {
    					validateTag(curNode, reporter, file, false, prefs, diagnosticFactory);
    				}				
    				curNode = curNode.getNext();
    			}
			}
		}
        catch (CoreException e)
        {
            JSFCorePlugin.log("Error validating JSF", e);
        }
		catch (IOException e) 
        {
            JSFCorePlugin.log("Error validating JSF", e);
		}
		finally 
        {
			if (null != model)
				model.releaseFromRead();
			
			// zero the containment count before exit
			containmentValidationCount = 0;
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.wst.sse.ui.internal.reconcile.validator.ISourceValidator#validate(org.eclipse.jface.text.IRegion, org.eclipse.wst.validation.internal.provisional.core.IValidationContext, org.eclipse.wst.validation.internal.provisional.core.IReporter)
	 */
	public void validate(IRegion dirtyRegion, IValidationContext helper, IReporter reporter) {
		if (DEBUG)
			System.out.println("exec JSPSemanticsValidator.validateRegion");

		ValidationPreferences prefs = new ValidationPreferences(JSFCorePlugin.getDefault().getPreferenceStore());
		prefs.load();
		DiagnosticFactory diagnosticFactory = new DiagnosticFactory();
		if (fDocument instanceof IStructuredDocument) {
			IStructuredDocument sDoc = (IStructuredDocument) fDocument;
			IStructuredDocumentRegion[] regions = sDoc.getStructuredDocumentRegions(dirtyRegion.getOffset(), dirtyRegion.getLength());
			if (regions != null){
					validateTag(regions[0], reporter, getFile(helper), true, prefs, diagnosticFactory);
			}
		}		
	}

	private IFile getFile(IValidationContext helper) {
		String[] uris = helper.getURIs();
		IWorkspaceRoot wsRoot = ResourcesPlugin.getWorkspace().getRoot();
		if (uris.length > 0) 
			return wsRoot.getFile(new Path(uris[0]));

		return null;
	}


	/**
	 * Validates a JSP tag.
	 * 
	 * Currently only attribute values with supplied annotation meta-data is being validated.
	 * Also, only JSF EL is being validated and not JSP EL.
	 * 
	 * This method may be extended in the future to validate tag semantics an other cross attribute
	 * validations.
     * 
	 * @param container 
	 * @param reporter 
	 * @param file 
	 * @param isIncremental -- true if this validation is "as you type"
	 *  
	 */
	private void validateTag(ITextRegionCollection container, IReporter reporter, IFile file, boolean isIncremental, ValidationPreferences prefs, DiagnosticFactory diagnosticFactory) 
	{
		ITextRegionCollection containerRegion = container;
		Iterator regions = containerRegion.getRegions().iterator();
		ITextRegion region = null;
		String uri = null;
		String tagName = null;
		String attrName = null;		
		while (regions.hasNext() && !reporter.isCancelled()) 
		{
			region = (ITextRegion) regions.next();
			String type = region.getType();
			IDOMContextResolver resolver = null;
			ITaglibContextResolver tagLibResolver = null; 
			if (type != null  && (type == DOMRegionContext.XML_TAG_NAME || type == DOMRegionContext.XML_TAG_ATTRIBUTE_NAME || type == DOMRegionContext.XML_TAG_ATTRIBUTE_VALUE))
			{											
				IStructuredDocumentContext context = IStructuredDocumentContextFactory.INSTANCE.getContext(((IStructuredDocumentRegion)containerRegion).getParentDocument(), containerRegion.getStartOffset() + region.getStart());
				resolver = IStructuredDocumentContextResolverFactory.INSTANCE.getDOMContextResolver(context);
				if	(type == DOMRegionContext.XML_TAG_NAME) 
				{					
					tagLibResolver = IStructuredDocumentContextResolverFactory.INSTANCE.getTaglibContextResolver(context);
                    Node node = resolver.getNode();
					tagName = resolver.getNode().getLocalName();
					uri = tagLibResolver.getTagURIForNodeName(resolver.getNode());
                    
                    if (node instanceof Element && uri != null)
                    {
                        validateContainment((Element)node, uri, tagName, reporter, file, context);
                    }
                    
					if (DEBUG)
						System.out.println(addDebugSpacer(1)+"tagName= "+ (tagName!= null ? tagName : "null") +": uri= "+(uri != null ? uri : "null") );
				} 
				else if (type == DOMRegionContext.XML_TAG_ATTRIBUTE_NAME)
				{
					attrName = resolver.getNode().getNodeName();
					if (DEBUG)
						System.out.println(addDebugSpacer(2)+"attrName= "+(attrName != null ? attrName : "null" ));
					if (uri != null && tagName != null)
                    {
						// TODO: validateAttribute(context, region, uri, resolver.getNode(), file);
                    }
				}
				else if (type == DOMRegionContext.XML_TAG_ATTRIBUTE_VALUE)
				{
                    final String attributeVal = 
                        resolver.getNode().getNodeValue();    

                    // if there's  elText then validate it
                    // TODO: this approach will fail with mixed expressions
                    if (!checkIfELAndValidate(region, 
                                              context,
                                              uri,
                                              tagName,
                                              attrName,
                                              attributeVal,
                                              isIncremental,
                                              reporter,
                                              file,
                                              prefs,
                                              diagnosticFactory)
                                              )
                    {
                        // else validate as static attribute value 
                        if (DEBUG)
                            System.out.println(addDebugSpacer(3)+"attrVal= "+(attributeVal != null ? attributeVal : "null") );

                        if (uri != null && tagName != null && attrName != null)
                            validateAttributeValue(context, uri, tagName, attrName, attributeVal, reporter, file);
                    }
				}
			}
		}
	}

    /**
     * Checks the region to see if it contains an EL attribute value.  If it
     * does, validates it
     * @return true if validated EL, false otherwise
     */
    private boolean checkIfELAndValidate(ITextRegion region, 
                                         IStructuredDocumentContext context,
                                         String uri,
                                         String tagName,
                                         String attrName,
                                         String attrValue,
                                         boolean isIncremental,
                                         IReporter reporter,
                                         IFile  file,
                                         ValidationPreferences validationPrefs,
                                         DiagnosticFactory  diagnosticFactory)
    {
        if (region instanceof ITextRegionCollection) {
            ITextRegionCollection parentRegion = ((ITextRegionCollection) region);
            if (parentRegion.getType() == DOMRegionContext.XML_TAG_ATTRIBUTE_VALUE)
            {
                // look for attribute pattern "#{}"
                // TODO: need to generalize this for RValue concatenation
                final ITextRegionList  regionList = parentRegion.getRegions();
                if (regionList.size() >= 4)
                {
                    ITextRegion  openQuote = regionList.get(0);
                    ITextRegion  openVBLQuote = regionList.get(1);

                    if (    (openQuote.getType() == DOMJSPRegionContexts.XML_TAG_ATTRIBUTE_VALUE_DQUOTE
                                || openQuote.getType() == DOMJSPRegionContexts.XML_TAG_ATTRIBUTE_VALUE_SQUOTE)
                                && (openVBLQuote.getType() == DOMJSPRegionContexts.JSP_VBL_OPEN))
                    {
                        // we appear to be inside "#{", so next should be a VBL_CONTENT if there's anything
                        // here to validate
                        final ITextRegion content = regionList.get(2);
                        if (content.getType() == DOMJSPRegionContexts.JSP_VBL_CONTENT)
                        {
                            final int contentStart = 
                                parentRegion.getStartOffset(content);
                            final IStructuredDocumentContext elContext =
                                IStructuredDocumentContextFactory.INSTANCE.
                                    getContext(context.getStructuredDocument(), 
                                            contentStart);

                            final String elText = parentRegion.getText(content);
                            
                            if (DEBUG)
                                System.out.println(addDebugSpacer(3)+"EL attrVal= "+elText);

                            // EL validation is user configurable because
                            // it can be computationally costly.
                            if (checkShouldValidateEL(validationPrefs, isIncremental))
                            {
                                List elVals = MetaDataEnabledProcessingFactory.getInstance().getAttributeValueRuntimeTypeFeatureProcessors(IValidELValues.class, elContext, uri, tagName, attrName);
                                validateELExpression(context, 
                                                     elContext, 
                                                     elVals, 
                                                     attrValue,
                                                     elText, 
                                                     reporter, 
                                                     file,
                                                     validationPrefs.getElPrefs());
                            }
                        }
                        else if (content.getType() == DOMJSPRegionContexts.JSP_VBL_CLOSE)
                        {
                            final int offset = parentRegion.getStartOffset(openVBLQuote)+1;
                            final int length = 2;
                            
                            // detected empty EL expression
                            IMessage message = ValidationMessageFactory.createFromDiagnostic(
                                    diagnosticFactory.create_EMPTY_EL_EXPRESSION(),
                                     offset, length, file, validationPrefs.getElPrefs());
                            
                            reportFinding(reporter, message);
                        }
                        
                        boolean foundClosingQuote = false;
                        for (int i = 2; !foundClosingQuote && i < regionList.size(); i++)
                        {
                            ITextRegion  searchRegion = regionList.get(i);
                            if (searchRegion.getType() == DOMJSPRegionContexts.JSP_VBL_CLOSE)
                            {
                                foundClosingQuote = true;
                            }
                        }
                          
                        if (!foundClosingQuote)
                        {
                            int offset = context.getDocumentPosition()+1;
                            int length = parentRegion.getText().length();

                            reportFinding(reporter, 
                               ValidationMessageFactory.
                                  createFromDiagnostic(
                                          diagnosticFactory.create_MISSING_CLOSING_EXPR_BRACKET(), 
                                              offset, length, file, validationPrefs.getElPrefs()));
                        }
                        
                        return true;
                    }
                }
            }
        }
        return false;
    }
            
	private void validateELExpression(IStructuredDocumentContext context,
                                     IStructuredDocumentContext elContext, 
                                     List elVals, 
                                     String attributeVal,
                                     String elText, 
                                     IReporter reporter, 
                                     IFile file,
                                     ELValidationPreferences prefs) 
    {
        //Call EL validator which will perform at least the syntactical validation
        final ELExpressionValidator elValidator = 
            new ELExpressionValidator(elContext, elText,file,prefs);
        elValidator.validateXMLNode();
        elValidator.reportFindings(this, reporter);
        
		CompositeType exprType = elValidator.getExpressionType();
		if (exprType != null)
        {
			for (Iterator it=elVals.iterator();it.hasNext();){
				IValidELValues elval = (IValidELValues)it.next();
				CompositeType expectedType;
				IMessage message = null;
				try {
					expectedType = elval.getExpectedRuntimeType();
                    
                    if (expectedType != null)
                    {
    					Diagnostic status = TypeComparator.calculateTypeCompatibility
                            (expectedType, exprType);
    					if (status.getSeverity() != Diagnostic.OK){
    						message = createValidationMessage(context, attributeVal, getSeverity(status.getSeverity()), status.getMessage(), file);						
    					}
                    }
				} catch (ELIsNotValidException e) {
					message = createValidationMessage(context, attributeVal, IMessage.NORMAL_SEVERITY, e.getMessage(), file);						
				}
				if (message != null) {
					reportFinding(reporter, message);
				}
			}
        }
	}

//    private void validateAttribute(IStructuredDocumentContext context, ITextRegion region, String uri, Node attr, IFile file) {
		//Not doing anything until the resolver can help me
		
		//validate that attribute can be part of the tag
//		ITaglibContextResolver tagLibResolver = IStructuredDocumentContextResolverFactory.INSTANCE.getTaglibContextResolver(context);
//		if (tagLibResolver.getTagURIForNodeName(attr) == null){
//			System.out.println("not ok: "+attr.getNodeName());
//		}
//		else
//			System.out.println("ok");
		
//	}

	/**
	 * Validates an attribute value in context using the JSF metadata processing framework
	 * 
	 * @param context
	 * @param region
	 * @param uri
	 * @param tagName
	 * @param attrName
	 * @param attributeVal
	 * @param reporter
	 * @param file
	 */
	private void validateAttributeValue(IStructuredDocumentContext context, String uri, String tagName, String attrName, String attributeVal, IReporter reporter, IFile file) {						
		List vv = MetaDataEnabledProcessingFactory.getInstance().getAttributeValueRuntimeTypeFeatureProcessors(IValidValues.class, context, uri, tagName, attrName);
		if (!vv.isEmpty()){
			for (Iterator it = vv.iterator();it.hasNext();){
				IValidValues v = (IValidValues)it.next();
				if (attributeVal == null) attributeVal = "";//ensure to be non-null
				if (!v.isValidValue(attributeVal.trim())){	
					if (DEBUG)
						System.out.println(addDebugSpacer(4)+"NOT VALID ");
					
					for (Iterator msgs = v.getValidationMessages().iterator();msgs.hasNext();){
						IValidationMessage msg = (IValidationMessage)msgs.next();
						IMessage message = createValidationMessage(context, attributeVal, getSeverity(msg.getSeverity()), msg.getMessage(), file);						
						if (message != null) {
							reportFinding(reporter, message);
						}
					}
				}
				else
					if (DEBUG)
						System.out.println(addDebugSpacer(5) + "VALID ");
			}			
		}
		else if (DEBUG)
			System.out.println(addDebugSpacer(4)+"NO META DATA ");
	}
	
	private IMessage createValidationMessage(IStructuredDocumentContext context, String attributeValue, int severity, String msg, IFile file){
		IMessage message = new LocalizedMessage(severity, msg, file);						
		if (message != null) {
			final int start = context.getDocumentPosition() + 1;
			final int length = attributeValue.length();
			
			int lineNo = 0;
			try {
				lineNo = context.getStructuredDocument().getLineOfOffset(start);
			} catch (BadLocationException e) {
                //  TODO: C.B why need line number? Length and offset should be
			    //  sufficient
			}
			
			message.setLineNo(lineNo);
			message.setOffset(start);
			message.setLength(length);
		}
		return message;
	}
	/**
	 * Maps IStatus codes to IMessage severity
	 * @param IStatus codesseverity
	 * @return IMessage severity
	 */
	private int getSeverity(int severity) {

		switch (severity){
			case IStatus.ERROR:
				return IMessage.HIGH_SEVERITY;
			case IStatus.WARNING:
				return IMessage.NORMAL_SEVERITY;
			case IStatus.INFO:
				return IMessage.LOW_SEVERITY;
		}
		return IMessage.NORMAL_SEVERITY;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.wst.sse.ui.internal.reconcile.validator.ISourceValidator#connect(org.eclipse.jface.text.IDocument)
	 */
	public void connect(IDocument document) {
		fDocument = document;
		containmentValidationCount = 0; // ensure is zeroed before we start
	}

	/* (non-Javadoc)
	 * @see org.eclipse.wst.sse.ui.internal.reconcile.validator.ISourceValidator#disconnect(org.eclipse.jface.text.IDocument)
	 */
	public void disconnect(IDocument document) {
		containmentValidationCount = 0; // ensure is zeroed when we are finished
	}
	
	private String addDebugSpacer(int count){
		String TAB = "\t";
		StringBuffer ret = new StringBuffer("");
		for(int i=0;i<=count;i++){
			ret.append(TAB);
		}
		return ret.toString();
	}

    /**
     * @param isIncremental -- true if this is "as-you-type" validation, false
     * if this is "Build" or "Run Validation" validation
     * @return true if user preferences say we should do EL validation,
     * false otherwise
     */
    private boolean checkShouldValidateEL(ValidationPreferences prefs, boolean isIncremental)
    {
        prefs.load();
        if (isIncremental)
        {
            return prefs.getElPrefs().isEnableIncrementalValidation();
        }

        return prefs.getElPrefs().isEnableBuildValidation();
    }
    
    private void validateContainment(Element node, String uri, String tagName, IReporter reporter, IFile file, IStructuredDocumentContext context)
    {
    	// don't validate JSP fragments since the necessary containment may existing
    	// in the JSP files that include them
    	// also only validate the first instance of containment violation in a file
    	if (JSPUtil.isJSPFragment(file) || containmentValidationCount > 0)
    	{
    		return;
    	}
    	
        final ITaglibDomainMetaDataModelContext modelContext = 
            TaglibDomainMetaDataQueryHelper.createMetaDataModelContext(file.getProject(), uri);
        final Entity entity = 
        	TaglibDomainMetaDataQueryHelper.getEntity(modelContext, tagName);
        if (entity != null)
        {
            final Trait trait = 
            	TaglibDomainMetaDataQueryHelper.getTrait
                    (entity, "containment-constraint");
            
            if (trait != null)
            {
                final ContainsTagConstraint tagConstraint = 
                    (ContainsTagConstraint) trait.getValue();

                final String algorithm = tagConstraint.getSetGenerator().getAlgorithm();
                
                // TODO: need generalized factory mechanism for registering and constructing
                // algorithms.
                if (!"xpath".equals(algorithm))
                {
                    return;
                }
                
                final String expr = tagConstraint.getSetGenerator().getExpression();
                
                // TODO: optimize on the expression and cache for reuse
                final XPathMatchingAlgorithm  xpathAlg = 
                    new XPathMatchingAlgorithm(expr);
                
                AxiomaticSet set = null;
                
                try
                {
                    set = xpathAlg.evaluate(node);
                    // map dom nodes to tag identifiers
                    set = elem2TagIdMapper.map(set);
                }
                catch(InvalidExpressionException  e)
                {
                    JSFCorePlugin.log(e, "Problem with expression: "+expr+" on node "+node);
                    return;
                }
                catch (EvaluationException  e)
                {
                    JSFCorePlugin.log(e, "Problem evaluating expression: "+expr+" on node "+node);
                    return;
                }

                final TagSet constraintData = tagConstraint.getSatisfiesSet();
                final AxiomaticSet constraintSet = new ConcreteAxiomaticSet();
                for (final Iterator it = constraintData.getTags().iterator(); it.hasNext();)
                {
                    final TagId tagId = (TagId) it.next();
                    constraintSet.add(TagIdentifierFactory.createJSPTagWrapper(tagId.getUri(), tagId.getName()));
                }
                final MemberConstraint memberConstraint = new MemberConstraint(constraintSet);
                final Diagnostic diag = memberConstraint.isSatisfied(set);

                if (diag.getSeverity() != Diagnostic.OK)
                {
                	containmentValidationCount++; // found a violation
                	
                    final String messagePattern = "Tag {0} is missing required parent tag \"{1}\" ({2})";

                    List data = diag.getData();

                    for (Iterator it = data.iterator(); it.hasNext();)
                    {
                        TagIdentifier missingParent = (TagIdentifier) it.next();

                        IMessage message =
                            createTagValidationMessage(context, node.getNodeName(), 
                                IMessage.NORMAL_SEVERITY, 
                                MessageFormat.format(messagePattern, new Object[]{node.getNodeName(), missingParent.getTagName(), missingParent.getUri()})
                                , file);
                        reportFinding(reporter, message);
                    }
                }
            }
        }
    }
    
    /**
     * @return the test interface
     */
    public IJSPSemanticValidatorTest getTestInterface()
    {
    	return new IJSPSemanticValidatorTest()
    	{
			public void validateContainment(Element node, String uri,
					String tagName, IReporter reporter, IFile file,
					IStructuredDocumentContext context) {
				
				JSPSemanticsValidator.this.validateContainment(node, uri, tagName, reporter, file, context);
			}
    	};
    }
    
    // TODO: need a diagnostic factory
    private IMessage createTagValidationMessage(IStructuredDocumentContext context, String attributeValue, int severity, String msg, IFile file)
    {
        IMessage message = new LocalizedMessage(severity, msg, file);                       
        final int start = context.getDocumentPosition();
        final int length = attributeValue.length();
        
        message.setOffset(start);
        message.setLength(length);
        return message;
    }
    
    private void reportFinding(IReporter reporter, IMessage message)
    {
        if ((message.getSeverity() & IMessage.ALL_MESSAGES) != 0)
        {
            reporter.addMessage(this, message);
        }
    }
}