/*******************************************************************************
 * 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 java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
import org.eclipse.jface.text.contentassist.ICompletionProposal;
import org.eclipse.jst.jsf.common.internal.types.CompositeType;
import org.eclipse.jst.jsf.common.internal.types.IAssignable;
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.resolver.structureddocument.internal.ITextRegionContextResolver;
import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContext;
import org.eclipse.jst.jsf.context.symbol.IInstanceSymbol;
import org.eclipse.jst.jsf.context.symbol.IMethodSymbol;
import org.eclipse.jst.jsf.context.symbol.IObjectSymbol;
import org.eclipse.jst.jsf.context.symbol.ISymbol;
import org.eclipse.jst.jsf.context.symbol.provider.IContentProposalProvider;
import org.eclipse.jst.jsf.context.symbol.provider.ProposalCreationFactoryAdapter;
import org.eclipse.jst.jsf.context.symbol.provider.IContentProposalProvider.IProposalCreationFactory;
import org.eclipse.jst.jsf.designtime.resolver.ISymbolContextResolver;
import org.eclipse.jst.jsf.designtime.resolver.StructuredDocumentSymbolResolverFactory;
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.jsp.core.internal.regions.DOMJSPRegionContexts;
import org.eclipse.swt.graphics.Image;
import org.w3c.dom.Attr;
import org.w3c.dom.Element;
import org.w3c.dom.Node;

/**
 * A completion strategy for function completions like:
 * 
 * v a r .
 *        ^ 
 *
 * @author cbateman
 *
 */
public class FunctionCompletionStrategy extends ContentAssistStrategy 
{
    /**
     * @param value
     * @param proposalStart 
     */
    public FunctionCompletionStrategy(String value, String proposalStart) 
    {
        super(ContentAssistStrategy.PREFIX_TYPE_DOT_COMPLETION, value, proposalStart);
    }

    public List getProposals(IStructuredDocumentContext context) 
    {
        final List completionList = new ArrayList();
        
        String[]  ids = getValue().split("\\.");
        
        // if no suffixes, only one id
        if (ids.length < 1) 
        {
            ids = new String[] {getValue()};
        }

        final ISymbolContextResolver  symbolResolver = 
            StructuredDocumentSymbolResolverFactory.getInstance().
                getSymbolContextResolver(context);
        
        ISymbol symbol = null;
        
        if (symbolResolver != null)
        {
            symbol = symbolResolver.getVariable(ids[0]);
        }
        
        if (symbol instanceof IInstanceSymbol
                && ((IInstanceSymbol)symbol).isTypeResolved())
        {
            int  curSuffixIdx = 1;
            
            while 
                (curSuffixIdx < ids.length
                        && symbol != null) 
            {
                
                final ISymbol[]  properties = 
                    symbolResolver.getProperties(symbol);
                    
                // set symbol to null because hasn't been found yet
                symbol = null;
                
                SEARCH_SYMBOL_NAME:for
                    (int i = 0; i < properties.length; i++)
                {
                    final ISymbol element = properties[i];
                    
                    if (ids[curSuffixIdx].equals(element.getName()))
                    {
                        symbol = element;
                        break SEARCH_SYMBOL_NAME;
                    }
                }
                curSuffixIdx++;
            }
            
            // if we get a completion symbol, get it's proposals
            if (symbol instanceof IObjectSymbol)
            {
                final List expectedMethodBindings = new ArrayList();
                ISymbol[] suffixes = getSymbols((IObjectSymbol) symbol, 
                                                 context, 
                                                 symbolResolver,
                                                 expectedMethodBindings);

                final ComposedAdapterFactory factory =
                    new ComposedAdapterFactory(
                           ComposedAdapterFactory.Descriptor.Registry.INSTANCE);
                final IProposalCreationFactory  creationInfo =
                    new MyProposalFactory(context, getProposalStart().length(), 
                                            expectedMethodBindings);
                
                for (int i = 0; i < suffixes.length; i++)
                {
                    final ISymbol propSymbol = suffixes[i];
                    final Object  provider =  
                      factory.adapt(propSymbol, IContentProposalProvider.class);
                        
                    if (provider instanceof IContentProposalProvider)
                    {
                        final ICompletionProposal[] proposal  = 
                            ((IContentProposalProvider) provider).
                                getProposals(propSymbol, creationInfo);
                        if (proposal != null)
                        {
                        	addProposalsMatchingProposalStart(completionList,
									proposal);
                        }
                    }
                }
            }
        }

        return completionList;
    }

	private ISymbol[] getSymbols(IObjectSymbol symbol, 
                                 IStructuredDocumentContext context, 
                                 ISymbolContextResolver  symbolResolver,
                                 List   expectedMethodBindings)
    {
        List symbols = new ArrayList();

        if (isMethodBindingExpected(context, expectedMethodBindings))
        {
            symbols.addAll(Arrays.asList(
                          symbolResolver.getMethods(symbol)));
        }

        symbols.addAll(Arrays.asList(symbolResolver.getProperties(symbol)));

        return (ISymbol[]) symbols.toArray(ISymbol.EMPTY_SYMBOL_ARRAY);
    }
    
    private boolean isMethodBindingExpected(IStructuredDocumentContext context,
                                            List            expectedBindings)
    {
        boolean  isMBExpected = false;  // assume false until we find it true
        
        final IDOMContextResolver  domResolver = 
            IStructuredDocumentContextResolverFactory.INSTANCE.
                getDOMContextResolver(context);
        
        final Node curNode = domResolver.getNode();
        
        if (curNode instanceof Attr)
        {
            final Attr attr = (Attr) curNode;
            final Element element = attr.getOwnerElement();

            final ITaglibContextResolver taglibResolver =
                IStructuredDocumentContextResolverFactory.INSTANCE.
                    getTaglibContextResolver(context);

            final String uri = taglibResolver.getTagURIForNodeName(element);
            
            final List elVals = 
                MetaDataEnabledProcessingFactory.getInstance()
                    .getAttributeValueRuntimeTypeFeatureProcessors
                        (IValidELValues.class, context, uri, 
                                element.getLocalName(), attr.getLocalName());
            
            for (final Iterator it = elVals.iterator(); it.hasNext();)
            {
                final IValidELValues validValues = (IValidELValues) it.next();
                
                try
                {
                    CompositeType type = validValues.getExpectedRuntimeType();
                    if (type != null
                            && type.getAssignmentTypeMask()
                                    == IAssignable.ASSIGNMENT_TYPE_NONE)
                    {
                        isMBExpected = true;
                        expectedBindings.addAll(
                                Arrays.asList(
                                        validValues.
                                            getExpectedRuntimeType().
                                            getSignatures()));
                    }
                }
                catch (ELIsNotValidException e)
                {
                    // do nothing
                }
            }
        }

        // default condition is no method binding
        return isMBExpected;
    }
    
    private static class MyProposalFactory extends ProposalCreationFactoryAdapter
    {
        private final static int   DEFAULT_RELEVANCE = 1;
        
        private final static int   HIGH_RELEVANCE = 2;
        private final static int   NORMAL_RELEVANCE = 1;
        private final static int   LOW_RELEVANCE = 0;
        
        private final List                         _expectedMethodBindings;
        private final IStructuredDocumentContext   _context;
        
        /**
         * @param context 
         * @param replacementLength
         * @param expectedMethodBindings 
         */
        public MyProposalFactory(IStructuredDocumentContext context, int replacementLength,
                                    List expectedMethodBindings) {
        	/*TODO I changed the meaning of "replacementLength" from "number of chars AFTER cursor to be
        	 * replaced" to "number of chars BEFORE cursor to be replaced. Since "replacementLength"
        	 * has always been 0 (constructor is only called by FunctionCompletionStrategy.getProposals()),
        	 * this should not change anything, but I don't know if there have been different plans
        	 * for "replacementLength".
        	 * TODO Maybe this change should be done in the super class instead?
        	 */
            super(context.getDocumentPosition() - replacementLength, replacementLength);
            _context = context;
            _expectedMethodBindings = expectedMethodBindings;
        }

        public ICompletionProposal createProposal(String replacementText, 
                                                  String displayText, 
                                                  String additionalText, 
                                                  Image displayImage,
                                                  Object target) 
        {
            int replacementOffset = _replacementOffset;
            int replacementLength = _replacementLength;
            
            // TODO: I regard this as a bit of hack, but until we write our 
            // proposal implementation, it's basically the only way I can
            // see to do this
            // if it's an array, we must check if we need to replace a
            // preceding '.'
            if (replacementText.startsWith("["))
            {
                ITextRegionContextResolver textResolver = 
                    IStructuredDocumentContextResolverFactory.INSTANCE.getTextRegionResolver(_context);
                
                if (textResolver.getRegionType().equals(DOMJSPRegionContexts.JSP_VBL_CLOSE))
                {
                    textResolver = 
                        IStructuredDocumentContextResolverFactory.
                            INSTANCE.getTextRegionResolver(textResolver.getPreviousContext());
                }
                
                String regionText = textResolver.getRegionText();
                int regionStart = textResolver.getStartOffset();
                
                if (DOMJSPRegionContexts.JSP_VBL_CONTENT.equals(textResolver.getRegionType())
                        && regionText != null
                        && regionStart != -1
                        && regionStart < _context.getDocumentPosition())
                {
                    int  relativeOffset = _context.getDocumentPosition() - regionStart - 1;
                    
                    if (regionText.charAt(relativeOffset) == '.')
                    {
                        // we must replace a length of 1 (the dot)
                        // at an offset on prior
                        replacementOffset--;
                        replacementLength = 1;
                    }
                }
            }
            
            return createDefaultProposal(replacementText, 
                                         replacementOffset, 
                                         replacementLength, 
                                         replacementText.length(), 
                                         displayImage, 
                                         displayText, 
                                         null, 
                                         additionalText, 
                                         getRelevance(target, DEFAULT_RELEVANCE));
        }

        private int getRelevance(final Object target, final int defaultRelevance)
        {
            // if method bindings are expected, then list exact signature 
            // matches top most.  Still list non-matching methods, but put 
            // them at the bottom
            if (_expectedMethodBindings.size() > 0)
            {
                if (target instanceof IMethodSymbol)
                {
                    final IMethodSymbol methodSymbol = (IMethodSymbol) target;
                    
                    for (final Iterator it = _expectedMethodBindings.iterator();
                            it.hasNext();)
                    {
                        final String methodType = (String) it.next();
                        
                        // we have a match, so push to the top
                        if (methodType.equals(methodSymbol.getSignature()))
                        {
                            return HIGH_RELEVANCE;
                        }
                    }
                    
                    // if we get out of the loop, then this method doesn't
                    // match the expected signature
                    return LOW_RELEVANCE;
                }

                // non-method targets have normal relevance when mb expected
                return NORMAL_RELEVANCE;
            }
 
            // otherwise, simply return the default for all
            return defaultRelevance;
        }
    }
}