* Copyright (c) 2008 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:

*    Matthias Fuessel -- extracted from https://bugs.eclipse.org/bugs/show_bug.cgi?id=215461

*    Cameron Bateman/Oracle - integrated and moved data table code here.

*

********************************************************************************/

* Factory for creating symbols for variables/message bundles that are

* contributed by components/tags. This Factory can be used by descendants of

* {@link org.eclipse.jst.jsf.context.symbol.source.AbstractContextSymbolFactory} in order to create the symbols they want

* to contribute.

*

* It provides also methods for getting the resulting {@link ValueType} from an

* EL expression and the "row" type signature from an DataModel/Array/List

* {@link ValueType}.

*

* NOTE: C.B March 26, 2008 -- commented out portions are left for the future

* because the rely on enhancements to the symbol model that could not be made

* in the current release.  Other portions of the original ComponentSymbolFactory

* have been moved to {@link org.eclipse.jst.jsf.context.symbol.InitializedSymbolFactory}

* This reflects the split between things deemed to be generic EL (put in common

* plugin) and things deemed to be JSF-specific (put here).

*

*/

    /**

     * @param elText The EL expression text. Must not be null

     * @param elContext The document context pointing to elText in the source document. Must not be null

     * @param file The workspace resource that contains elText. Must not be null.

     * @param symbolResolverFactory

    * @return the value expression resolved from elText or null if it cannot

     * be resolved or elText doesn't resolve to value expression (i.e. is a method expression)

      */

    public ValueType getValueTypeFromEL(final String elText,

            final IStructuredDocumentContext elContext, final IFile file, IStructuredDocumentSymbolResolverFactory symbolResolverFactory)

    {

        assert elText != null;

        assert elContext != null;

        assert file != null;

        // TODO investigate if infinite recursion; use ASTResolver instead??

        final IValidationReporter  reporter = new ReporterAdapter();

        final ELExpressionValidator validator =

            new ELExpressionValidator(

                elContext, elText, symbolResolverFactory, reporter);

        validator.validateXMLNode();

        final IExpressionSemanticValidator semValidator = validator

                .getSemanticValidator();

        if (semValidator != null

                && semValidator.getExpressionType() instanceof ValueType)

        {

            return (ValueType) semValidator.getExpressionType();

        }

        return null;

    }

    /**

     * Convenience for {@link JSFSymbolFactory#getValueTypeFromEL(String, IStructuredDocumentContext, IFile, IStructuredDocumentSymbolResolverFactory)}

     * using StructuredDocumentSymbolResolverFactory.getInstance().

     *

     * @param elText

     * @param elContext

     * @param file

     * @return a ValueType or null

     */

    public ValueType getValueTypeFromEL(final String elText,

            final IStructuredDocumentContext elContext, final IFile file)

    {

        return getValueTypeFromEL(elText, elContext, file, StructuredDocumentSymbolResolverFactory.getInstance());

    }

    /**

     * @param type

     * @return <code>true</code>, if the given {@link ValueType} represents

     *         an instance of <code>javax.faces.model.DataModel</code>

     */

    private boolean isFacesDataModel(ValueType type)

    {

        return type.isInstanceOf(TypeConstants.TYPE_DATA_MODEL);

    }

    /**

     * Tries to guess the row type of a <code>javax.faces.DataModel</code>

     * instance. This will only work if <code>type</code> is a descendant that

     * narrows down the return type of "getRowData()".

     *

     * @param type

     * @return the row type of the given DataModel. Will return

     *         <code>null</code> if <code>type</code> is no DataModel or if

     *         nothing more specific than <code>Object</code> can be

     *         determined

     */

    public String getRowSignatureFromDataModel(ValueType type)

    {

        if (type instanceof IObjectSymbolBasedValueType)

        {

            ISymbol resSymbol = ((IObjectSymbolBasedValueType) type)

                    .getSymbol().call(

                            "getRowData", ECollections.emptyEList(), "res"); //$NON-NLS-1$ //$NON-NLS-2$

            if (resSymbol != null && resSymbol instanceof IObjectSymbol)

            {

                // TODO full signature

                final String signature = ((IObjectSymbol) resSymbol)

                        .getTypeDescriptor().getTypeSignature();

                if (!TypeConstants.TYPE_JAVAOBJECT.equals(signature))

                {

                    return signature;

                }

            }

        }

        return null;

    }

    /**

     * @param type

     * @return <code>true</code>, if <code>type</code> is a collection or

     *         array

     */

    public boolean isContainerType(ValueType type)

    {

        return type.isArray()

                || type.isInstanceOf(TypeConstants.TYPE_COLLECTION);

    }

    /**

     * @param type -

     *            the type of the <code>value</code> property

     * @return the type signature of the row variable for every type that

     *         <code>UIData</code> takes as <code>value</code> property.

     *         Will return <code>null</code> if no type or nothing more

     *         specific than <code>Object</code> can be determined

     */

    public String getRowSignatureFromValueType(ValueType type)

    {

        if (isContainerType(type))

        {

            return getElementSignatureFromContainerType(type);

        }

        if (isFacesDataModel(type))

        {

            return getRowSignatureFromDataModel(type);

        }

        // Otherwise, according to jsf spec, treat value as single row:

        // TODO full signature

        return type.getSignature();

    }

    /**

     * @param symbolName The name of the symbol to be created. Must not be null

     * @param signature The type signature of the array type. Must not be null

     * @param source the runtime source

     * @param javaProject must not be null

     * @return a symbol based approximating an implicit DataModel wrapper for an array

     */

    public final ISymbol createArraySymbol(final String symbolName, final String signature, final ERuntimeSource source, final IJavaProject javaProject)

    {

        assert symbolName != null;

        assert signature != null;

        assert javaProject != null;

       

        final String arrayElementType = Signature.getElementType(signature);

        final int arrayCount = Signature.getArrayCount(signature);

        String  adjustedSignature = null;

       

        // if it is a single array nesting, then it will just be the element type,

        // but if it is a multi-dim array, then the scalar element will be an array

        // with one less nesting level.  It's a strange corner case to have an implicit

        // array of something as a row type, but it is a valid case.  I suppose

        // it may be happen if you want to have tables of tables in which the nested tables

        // in turn use nested variables as their type...

        if (arrayCount > 0)

        {

            adjustedSignature = Signature.createArraySignature(arrayElementType, arrayCount-1);

        }

        else

        {

            adjustedSignature = arrayElementType;

        }

       

        return createScalarSymbol(symbolName, adjustedSignature, source, javaProject);

    }

    /**

     * @param symbolName The name of the symbol to create. Must not be null.

     * @param signature The fully resolved type signature of the scalar.  Must not be null.

     * @param source

     * @param javaProject The JavaProject whose classpath is to be used to resolve type information for signture. Must not be null.

     * @return a symbol approximating a scalar object DataModel wrapper.  The row variable for the

     * data model becomes of type signature

     */

    public final ISymbol createScalarSymbol(final String symbolName, final String signature, final ERuntimeSource source, final IJavaProject javaProject)

    {

        assert symbolName != null;

        assert signature != null;

        assert javaProject != null;

        final String elementType = Signature.getElementType(signature);

       

        IJavaTypeDescriptor2 desc =

            SymbolFactory.eINSTANCE.createIJavaTypeDescriptor2();

        final int arrayCount = Signature.getArrayCount(signature);

        if (arrayCount > 0)

        {

            desc.setArrayCount(arrayCount);

        }

       

        IType type = TypeUtil.resolveType(javaProject, elementType);

        if (type != null)

        {

            desc.setType(type);

        }

        else

        {

            desc.setTypeSignatureDelegate(Signature.getTypeErasure(signature));

        }

        desc.getTypeParameterSignatures().addAll(Arrays.asList(Signature.getTypeArguments(signature)));

        IComponentSymbol symbol = SymbolFactory.eINSTANCE.createIComponentSymbol();

        symbol.setName(symbolName);

        symbol.setTypeDescriptor(desc);

        symbol.setRuntimeSource(ERuntimeSource.TAG_INSTANTIATED_SYMBOL_LITERAL);

        return symbol;

    }

    /**

     * @param symbolName The name of the symbol to create. Must not be null.

     * @param valueType The value expression representing the implicit list.  The signature

     * on the valueType must be a list. Must not be null.

     * @param source

     * @param description

     * @param javaProject The JavaProject whose classpath will be used to resolve types.  Must not be null.

     *

     * @return a symbol that approximates as best as possible an implicit DataModel for java.util.List value expressions.  If the List has

     * resolvable Java 5 type arguments, then a scalar symbol will be created

     * using this type information.  If it is a raw type, then

     * createDefaultSymbol() is called

     */

    public final ISymbol createFromList(String symbolName, ValueType valueType, ERuntimeSource source, String description, IJavaProject javaProject)

    {

        assert symbolName != null;

        assert valueType != null;

        assert javaProject != null;

        assert TypeConstants.TYPE_LIST.equals(valueType.getSignature());

       

        final String[] typeArguments = valueType.getTypeArguments();

       

        if (typeArguments != null && typeArguments.length > 0)

        {

            // a list has a single type argument

            final String typeArg = typeArguments[0];

            if (Signature.getTypeSignatureKind(typeArg) == Signature.CLASS_TYPE_SIGNATURE)

            {

                return createScalarSymbol(symbolName, typeArg, source, javaProject);

            }

        }

       

        // if no resolvable type signatures, do the default thing

        return createDefaultSymbol(symbolName, ERuntimeSource.TAG_INSTANTIATED_SYMBOL_LITERAL, description);

    }

    /**

     * @param symbolName The name of the symbol to create.  Must not be null

     * @param source

     * @param description

     * @return a default symbol that eliminates bogus warnings for this dataTable's

     * row variable in cases where something better is resolvable.  Note that this is

     * not ideal, since will result in any property being accepted on the variable with

     * this name.

     */

    public final ISymbol createDefaultSymbol(final String symbolName, final ERuntimeSource source, final String description)

    {

        assert symbolName != null;

       

        final IMapTypeDescriptor typeDesc =

            SymbolFactory.eINSTANCE.createIBoundedMapTypeDescriptor();

        // empty map source

        typeDesc.setMapSource(new HashMap());

        final IComponentSymbol symbol =

            SymbolFactory.eINSTANCE.createIComponentSymbol();

        symbol.setName(symbolName);

        symbol.setTypeDescriptor(typeDesc);

        symbol.setDetailedDescription(description);

        symbol.setRuntimeSource(source);

        return symbol;

    }

    /**

     * FUTURE use: added to support future API feature.  Should not be used.

     * @param symbolName

     * @param bundleName

     * @param project

     * @return an instance symbol for the message bundle

     */

    public IInstanceSymbol createMessageBundleSymbol(final String symbolName, final String bundleName, IJavaProject project)

    {

        // FUTURE USE

        throw new UnsupportedOperationException("see https://bugs.eclipse.org/bugs/show_bug.cgi?id=215461"); //$NON-NLS-1$

    }

    /**

     * FUTURE use: added to support future API feature.  Should not be used.

     * @param symbolName

     * @param fullyQualifiedName

     * @param source

     * @param description

     * @param javaProject

     * @return an instance symbol for the message bundle

     */

    public IBeanInstanceSymbol createManagedBeanSymbol(final String symbolName, final String fullyQualifiedName,

            ERuntimeSource source, final String description, final IJavaProject javaProject)

    {

        // FUTURE USE

        throw new UnsupportedOperationException("see https://bugs.eclipse.org/bugs/show_bug.cgi?id=215461"); //$NON-NLS-1$

    }

//  * @param symbolName

//  * @param signature

//  * @param javaProject

//  * @return a symbol for a bean

//  */

// public IComponentBeanSymbol createBeanSymbolFromSignature(

//         final String symbolName, final String signature,

//         final IJavaProject javaProject)

// {

//     IJavaTypeDescriptor2 desc = createTypeDescriptorFromSignature(

//             signature, javaProject);

//

//     IComponentBeanSymbol symbol = SymbolFactory.eINSTANCE

//             .createIComponentBeanSymbol();

//     symbol.setName(symbolName);

//     symbol.setTypeDescriptor(desc);

//     symbol.setRuntimeSource(ERuntimeSource.TAG_INSTANTIATED_SYMBOL_LITERAL);

//     return symbol;

// }

// /**

//  * @param symbolName

//  * @param bundleName

//  * @param project

//  * @return a symbol for a message bundle

//  */

// public IMessageBundleSymbol createMessageBundleSymbolFromBundleName(final String symbolName, final String bundleName, IJavaProject project) {

//     final IMessageBundleTypeDescriptor typeDesc = SymbolFactory.eINSTANCE.createIMessageBundleTypeDescriptor();

//     try {

//         Map mapSource = ResourceBundleMapSourceFactory.getResourceBundleMapSource(project.getProject(), bundleName);

//         typeDesc.setMapSource(mapSource);

//     } catch (JavaModelException e) {

//         JSFCorePlugin.log(e, "Error creating resource map for bundle '"bundleName  "'"); //$NON-NLS-1$ //$NON-NLS-2$

//     } catch (IOException e) {

//         JSFCorePlugin.log(e, "Error creating resource map for bundle '"bundleName  "'"); //$NON-NLS-1$ //$NON-NLS-2$

//     } catch (CoreException e) {

//         JSFCorePlugin.log(e, "Error creating resource map for bundle '"bundleName  "'"); //$NON-NLS-1$ //$NON-NLS-2$

//     }

//     final IMessageBundleSymbol symbol = SymbolFactory.eINSTANCE.createIMessageBundleSymbol();

//     symbol.setName(symbolName);

//     symbol.setTypeDescriptor(typeDesc);

//     symbol.setDetailedDescription(NLS.bind(Messages.getString("ComponentSymbolFactory.IMessageBundleSymbol.detailedDescription"), bundleName));  //$NON-NLS-1$

//     return symbol;

// }

//    /**

//     * Sets the symbol to be defined only inside the given element

//     *

//     * @param symbol

//     * @param slement

//     */

//    public void setDefinitionRange(final IComponentVar symbol,

//            final Element slement)

//    {

//        if (slement instanceof IndexedRegion)

//        {

//            final IndexedRegion defRegion = (IndexedRegion) slement;

//            final int defOffset = defRegion.getStartOffset();

//            final int defLength = defRegion.getLength();

//            symbol.setDefinitionRange(defOffset, defLength);

//        }

//    }