/*******************************************************************************
 * 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.core.internal.contentassist.el;

import org.eclipse.jface.text.Region;
import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContext;
import org.eclipse.jst.jsf.context.symbol.ISymbol;
import org.eclipse.jst.jsp.core.internal.java.jspel.ASTAddExpression;
import org.eclipse.jst.jsp.core.internal.java.jspel.ASTAndExpression;
import org.eclipse.jst.jsp.core.internal.java.jspel.ASTChoiceExpression;
import org.eclipse.jst.jsp.core.internal.java.jspel.ASTEqualityExpression;
import org.eclipse.jst.jsp.core.internal.java.jspel.ASTExpression;
import org.eclipse.jst.jsp.core.internal.java.jspel.ASTFunctionInvocation;
import org.eclipse.jst.jsp.core.internal.java.jspel.ASTLiteral;
import org.eclipse.jst.jsp.core.internal.java.jspel.ASTMultiplyExpression;
import org.eclipse.jst.jsp.core.internal.java.jspel.ASTOrExpression;
import org.eclipse.jst.jsp.core.internal.java.jspel.ASTRelationalExpression;
import org.eclipse.jst.jsp.core.internal.java.jspel.ASTUnaryExpression;
import org.eclipse.jst.jsp.core.internal.java.jspel.ASTValue;
import org.eclipse.jst.jsp.core.internal.java.jspel.ASTValuePrefix;
import org.eclipse.jst.jsp.core.internal.java.jspel.ASTValueSuffix;
import org.eclipse.jst.jsp.core.internal.java.jspel.JSPELParser;
import org.eclipse.jst.jsp.core.internal.java.jspel.JSPELParserConstants;
import org.eclipse.jst.jsp.core.internal.java.jspel.JSPELParserVisitor;
import org.eclipse.jst.jsp.core.internal.java.jspel.ParseException;
import org.eclipse.jst.jsp.core.internal.java.jspel.SimpleNode;
import org.eclipse.jst.jsp.core.internal.java.jspel.Token;

/**
 * Consumes an EL expression and converts into a completion prefix
 * 
 * @author cbateman
 *
 */
public final class ContentAssistParser 
{
    /**
     * @param relativePosition -- 1-based position in elText (first position is 1)
     * @param elText
     * @return a content assist strategy for the given position and el expression
     * or null if one cannot be determined
     */
    public static ContentAssistStrategy getPrefix(final int relativePosition, final String elText)
    {
        if (elText == null)
        {
            return null;
        }
        else if ("".equals(elText.trim())) //$NON-NLS-1$
        {
            return new IdCompletionStrategy("", "");  //$NON-NLS-1$//$NON-NLS-2$
        }
        
        PrefixVisitor visitor = getVisitorForPosition(relativePosition, elText);
        return visitor != null? visitor.getPrefix() : null;
    }
    
    /**
     * Get symbol and symbol region at given position in el string
     * @param context - IStructuredDocumentContext
     * @param relativePosition - position in el string
     * @param elText - el string
     * @return SymbolInfo. May be null.
     */
    public static SymbolInfo getSymbolInfo(IStructuredDocumentContext context, final int relativePosition, final String elText) {
        if (elText == null || "".equals(elText.trim())) //$NON-NLS-1$
        {
            return null;
        }
        PrefixVisitor visitor = getVisitorForPosition(relativePosition, elText);
        if (visitor != null) {
            SymbolInfo symbolInfo = visitor.getSymbolInfo(context);
            if (symbolInfo != null) {
                Region r = symbolInfo.getRelativeRegion();
                if (relativePosition > r.getOffset() && relativePosition <= r.getOffset() + r.getLength()) {
                    return symbolInfo;
                }
            }
        }
        return null;
    }

	private static PrefixVisitor getVisitorForPosition(final int relativePosition,
			final String elText) {
		final java.io.StringReader reader = new java.io.StringReader(elText);
        final JSPELParser  parser = new JSPELParser(reader);
        
        try
        {
            final ASTExpression expr = parser.Expression();
            final PrefixVisitor visitor = new PrefixVisitor(relativePosition, elText);
            expr.jjtAccept(visitor, null);
            return visitor;
        }
        catch (ParseException pe)
        {
            // TODO: handle parser by using current and expected tokens
        	return null;
        }
	}
    
    private static String substring(String s, Region r) {
        return s.substring(r.getOffset(), r.getOffset() + r.getLength());
    }
    
    private static class PrefixVisitor implements JSPELParserVisitor
    {
        private final int       _relativePos;
        private final String    _fullText;
        
        private String          _symbolPrefix; // = null; initialized as tree is visited
        private int             _prefixType;
        private boolean         _prefixResolved;  // = false; set to true when the prefix is resolved
        private int             _symbolStartPos = 1; // first char has position 1
        private int             _symbolEndPos = 0;
        
        PrefixVisitor(final int relativePos, final String fullText)
        {
            _relativePos = relativePos;
            _fullText = fullText;
        }
        
        /**
         * @return the prefix if resolved or null if not resolved
         */
        public ContentAssistStrategy getPrefix()
        {
            if (_prefixResolved)
            {
                switch(_prefixType)
                {
                    case ContentAssistStrategy.PREFIX_TYPE_DOT_COMPLETION:
                        return new FunctionCompletionStrategy(_symbolPrefix, getProposalStart());
                    
                    case ContentAssistStrategy.PREFIX_TYPE_ID_COMPLETION:
                        return new IdCompletionStrategy(_symbolPrefix, getProposalStart());
                    
                    case ContentAssistStrategy.PREFIX_TYPE_EMPTY_EXPRESSION:
                        return new IdCompletionStrategy("", getProposalStart()); //$NON-NLS-1$
                        
                    default:
                        // do nothing; fall-through to return null
                }
            }

            return null;
        }
        
        /**
         * @param context - IStructuredDocumentContext
         * @return symbol and symbol region if resolved, null otherwise
         */
        public SymbolInfo getSymbolInfo(IStructuredDocumentContext context) {
        	if (_prefixResolved && _symbolStartPos < _symbolEndPos) {
        		Region region = new Region(_symbolStartPos - 1, _symbolEndPos - _symbolStartPos + 1);
                ISymbol symbol = null;
                switch (_prefixType) {
                case ContentAssistStrategy.PREFIX_TYPE_ID_COMPLETION:
                    symbol = SymbolResolveUtil.getSymbolForVariable(context, substring(_fullText, region));
                    break;
                case ContentAssistStrategy.PREFIX_TYPE_DOT_COMPLETION:
                    symbol = SymbolResolveUtil.getSymbolForVariableSuffixExpr(context, _symbolPrefix + "." + substring(_fullText, region), _symbolEndPos == _fullText.length()); //$NON-NLS-1$
                    break;
                }
                if (symbol != null) {
                    return new SymbolInfo(symbol, region);
                }
        	}
        	return null;
        }

		private String getProposalStart() {
            if (_symbolStartPos <= _relativePos) {
                return _fullText.substring(_symbolStartPos - 1, _relativePos - 1);
            }
            return ""; //$NON-NLS-1$
		}
        
        public Object visit(ASTAddExpression node, Object data) 
        {
            return node.childrenAccept(this, data);
        }

		public Object visit(ASTAndExpression node, Object data) 
        {
            return node.childrenAccept(this, data);
        }

        public Object visit(ASTChoiceExpression node, Object data) 
        {
            return node.childrenAccept(this, data);
        }

        public Object visit(ASTEqualityExpression node, Object data) 
        {
            return node.childrenAccept(this, data);
        }

        public Object visit(ASTExpression node, Object data) 
        {
            return node.childrenAccept(this, data);
        }

        public Object visit(ASTFunctionInvocation node, Object data) 
        {
            return node.childrenAccept(this, data);
        }

        public Object visit(ASTLiteral node, Object data) 
        {
            return node.childrenAccept(this, data);
        }

        public Object visit(ASTMultiplyExpression node, Object data) 
        {
            return node.childrenAccept(this, data);
        }

        public Object visit(ASTOrExpression node, Object data) 
        {
            return node.childrenAccept(this, data);
        }

        public Object visit(ASTRelationalExpression node, Object data) 
        {
            return node.childrenAccept(this, data);
        }

        public Object visit(ASTUnaryExpression node, Object data) 
        {
            return node.childrenAccept(this, data);
        }

        public Object visit(ASTValue node, Object data) 
        {
            // we're only in this value expr if it contains the cursor
            if (testContainsCursor(node))
            {
                return node.childrenAccept(this, data);
            }
            
            return null;
        }

        public Object visit(ASTValuePrefix node, Object data) 
        {
            // for now, only concern ourselves with simple (identifier) prefixes
            if (!_prefixResolved
                    && node.jjtGetNumChildren() == 0
                    && node.getFirstToken().kind == JSPELParserConstants.IDENTIFIER)
            {
                _symbolPrefix = node.getFirstToken().image;
                
                if (testContainsCursor(node))
                {
                    // if the cursor is on this id, we don't need to visit
                    // further since we know both the prefix -- the id -- and
                    // the type -- it's an id completion
                    _prefixType = ContentAssistStrategy.PREFIX_TYPE_ID_COMPLETION;
                    _symbolStartPos = node.getFirstToken().beginColumn;
                    _symbolEndPos = node.getFirstToken().endColumn;
                    _prefixResolved = true;
                }
            }
            return node.childrenAccept(this, data);
        }

        public Object visit(ASTValueSuffix node, Object data) 
        {
            // for now, only deal with the simple .id suffix
            Token lastToken = node.getLastToken();
			if (node.jjtGetNumChildren() == 0)
            {
                if (!_prefixResolved
                      && node.getFirstToken().kind == JSPELParserConstants.DOT)
                {
                    if (lastToken.kind == JSPELParserConstants.IDENTIFIER)
                    {
                        if (testContainsCursor(node))
                        {
                            _prefixType = ContentAssistStrategy.PREFIX_TYPE_DOT_COMPLETION;
                            int proposalStartLength = _relativePos - lastToken.beginColumn;
                            if (proposalStartLength < 0) { // Cursor after firstToken start but before lastToken start?
                            	proposalStartLength = 0;
                            }
                            _symbolStartPos = lastToken.beginColumn;
                            _symbolEndPos = lastToken.endColumn;
                            _prefixResolved = true;
                        }
                        // only include this suffix on the path if the cursor is 
                        // further to the right.  Thus for x.^y we get a prefix "x"
                        // and for x.y.^z we get "x.y" since this the part we must
                        // resolve the prefix for
                        else
                        {
                            _symbolPrefix += node.getFirstToken().image + lastToken.image;
                        }
                    }
                    else if (lastToken == node.getFirstToken())
                    {
                        if (testCursorImmediatelyAfter(node))
                        {
                            _prefixType = ContentAssistStrategy.PREFIX_TYPE_DOT_COMPLETION;
                            _symbolStartPos = lastToken.endColumn + 1;
                            _symbolEndPos = lastToken.endColumn;
                            _prefixResolved = true;
                        }
                    }
                }

                return null;                
            }
            
            if (node.getFirstToken().kind == JSPELParserConstants.LBRACKET)
            {
                // try to support ca inside the brackets
                node.childrenAccept(this, data);
            }

            Object retValue =  node.childrenAccept(this, data);
                
            if (!_prefixResolved)
            {
                // if we haven't resolved the prefix yet, then we need
                // to append this suffix value
                _symbolPrefix += _fullText.substring(node.getFirstToken().beginColumn-1, node.getLastToken().endColumn);
            }
            
            return retValue;
        }

        public Object visit(SimpleNode node, Object data) 
        {
            return node.childrenAccept(this, data);
        }
        
        private boolean testCursorImmediatelyAfter(SimpleNode node)
        {
            return node.getLastToken().endColumn == _relativePos-1;
        }
        
        /**
         * "Containing a cursor" here is deemed to mean that current cursor
         * position as indicated by _relativePos, is either directly before, on or
         * directly after an expression.  For example, in a Value expression like
         * 
         *          x x x . y y y . z z z
         *         ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^
         *         1 2 3 4 5 6 7 8 9 0 1 2
         *         
         * Position's 1-4 are on xxx, 5-8 are on yyy and 9-12 are on zzz
         * 
         * @param node
         * @return true if the node "contains the cursor" (see above)
         */
        private boolean testContainsCursor(SimpleNode node)
        {
            return (node.getFirstToken().beginColumn <= _relativePos
                    && node.getLastToken().endColumn+1 >= _relativePos);
                
        }
    }
    
    private ContentAssistParser()
    {
        // utility class; not instantiable
    }
}