/*******************************************************************************
 * 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:
 *    Cameron Bateman/Oracle - initial API and implementation
 *    
 ********************************************************************************/

package org.eclipse.jst.jsf.validation.internal.el;

import org.eclipse.emf.common.util.Diagnostic;
import org.eclipse.jst.jsf.common.internal.types.CompositeType;
import org.eclipse.jst.jsf.common.internal.types.SignatureBasedType;
import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContext;
import org.eclipse.jst.jsf.designtime.resolver.IStructuredDocumentSymbolResolverFactory;
import org.eclipse.jst.jsf.validation.internal.IJSFViewValidator.IValidationReporter;
import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory;
import org.eclipse.jst.jsp.core.internal.java.jspel.ASTExpression;
import org.eclipse.jst.jsp.core.internal.java.jspel.JSPELParser;
import org.eclipse.jst.jsp.core.internal.java.jspel.ParseException;
import org.eclipse.jst.jsp.core.internal.java.jspel.Token;
import org.eclipse.jst.jsp.core.internal.java.jspel.TokenMgrError;

/**
 * Validates a single expression string
 * 
 * @author cbateman
 *
 */
public class ELExpressionValidator 
{
    private final IStructuredDocumentContext               _context;
    private final String                                   _elText;
    private final DiagnosticFactory                        _diagnosticFactory;

    private ASTSemanticValidator                           _semanticValidator;
    private final IStructuredDocumentSymbolResolverFactory _symbolResolverFactory;
    private final IValidationReporter                      _reporter;

    /**
     * @param context
     * @param elText
     * @param symbolResolverFactory 
     * @param reporter 
     */
    public ELExpressionValidator(final IStructuredDocumentContext context,
                                 final String elText, 
                                 final IStructuredDocumentSymbolResolverFactory symbolResolverFactory,
                                 final IValidationReporter reporter)
    {
        _context = context;
        _elText = elText;
        _diagnosticFactory = new DiagnosticFactory();
        _symbolResolverFactory = symbolResolverFactory;
        _reporter = reporter;
    }
    
    /**
     * Validates a single EL expression in an XML attribute value
     * @return an ASTExpression for the node
     */
    public ASTExpression validateXMLNode() 
    {
        JSPELParser elParser = JSPELParser.createParser(_elText);
        // = 
        try {
            //final long startParsing = System.currentTimeMillis();
            final ASTExpression expr =  elParser.Expression();
            //final long endParsing = System.currentTimeMillis();
            //final long startSemantics = System.currentTimeMillis();
            validateSemantics(expr, _context);
            //final long endSemantics = System.currentTimeMillis();

            //System.out.println("Time to parse '"+elText+"' = "+(endParsing-startParsing));
            //System.out.println("Time to semantic checking '"+elText+"' = "+(endSemantics-startSemantics));
            
            // if the parser bailed before parsing the whole
            // expression, raise a warning that there is probably
            // some syntatical issue
            if (expr.getLastToken().endColumn < _elText.trim().length()-1)
            {
                final int offset = _context.getDocumentPosition() + expr.getLastToken().endColumn;
                final int length = _elText.trim().length() - expr.getLastToken().endColumn;
                final Diagnostic diagnostic =
                    _diagnosticFactory.create_GENERAL_SYNTAX_ERROR();
                
                _reporter.report(diagnostic, offset, length);
            }
            
            return expr;
        }
        catch (ParseException e) {
            Token curTok = e.currentToken;
            int offset = _context.getDocumentPosition() + curTok.beginColumn;
            int length = curTok.endColumn - curTok.beginColumn + 1;
            final Diagnostic diagnostic = _diagnosticFactory.create_GENERAL_SYNTAX_ERROR();
            _reporter.report(diagnostic, offset, length);
            return null;
        }
        catch (TokenMgrError te) {
            final int offset = _context.getDocumentPosition();
            final int length = _elText.length();
            final Diagnostic diagnostic =
                _diagnosticFactory.create_GENERAL_SYNTAX_ERROR();
            _reporter.report(diagnostic, offset, length);
            return null;
        }
    }

    /**
     * @return the type of the expression or null if 
     * the type could not be evaluated
     */
    public CompositeType getExpressionType()
    {
        if (_semanticValidator != null)
        {
            final SignatureBasedType type = 
                _semanticValidator.getExpressionType();
            
            if (type != null)
            {
                return type.toCompositeType();
            }
        }
        
        return null;
    }
    

    /**
     * @return the EL semantic validator for this expression validitor or
     * null if one has not yet been constructor.  One will only be construct
     * if validate is called and the expression does not have any syntax errors.
     */
    public IExpressionSemanticValidator getSemanticValidator()
    {
        return _semanticValidator;
    }
    
    /**
     * Validates the context-specific data for one EL expressino
     * 
     * @param expr
     * @param file
     * @param reporter
     * @param context
     */
    private void validateSemantics(ASTExpression expr,IStructuredDocumentContext context)
    {
        _semanticValidator = new ASTSemanticValidator(expr, context, _symbolResolverFactory, _reporter);
        _semanticValidator.validate();
    }
}