/*******************************************************************************
 * Copyright (c) 2001, 2008 Oracle Corporation and others.
 * 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:
 *     Oracle Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jst.jsf.designtime.internal.view;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jst.jsf.common.runtime.internal.model.ViewObject;
import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentInfo;
import org.eclipse.jst.jsf.common.runtime.internal.model.datatypes.ELExpression;
import org.eclipse.jst.jsf.common.runtime.internal.view.model.common.ITagElement;
import org.eclipse.jst.jsf.common.runtime.internal.view.model.common.Namespace;
import org.eclipse.jst.jsf.context.IModelContext;
import org.eclipse.jst.jsf.context.resolver.structureddocument.IDOMContextResolver;
import org.eclipse.jst.jsf.context.resolver.structureddocument.IStructuredDocumentContextResolverFactory;
import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContext;
import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContextFactory;
import org.eclipse.jst.jsf.designtime.context.DTFacesContext;
import org.eclipse.jst.jsf.designtime.internal.view.IDTViewHandler.ViewHandlerException;
import org.eclipse.jst.jsf.designtime.internal.view.XMLViewObjectMappingService.ElementData;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;

/**
 * A view definition adapter base class for view definition that use XML to
 * define the view.
 * 
 * @author cbateman
 * 
 */
public abstract class XMLViewDefnAdapter extends
        AbstractViewDefnAdapter<Node, IDocument>
{
    private static final String GENERATED_ID = "_generatedId"; //$NON-NLS-1$

    @Override
    public abstract IDocument getContainer(DTFacesContext context, String viewId);

    @Override
    public String getId(final Node viewDefnObject)
            throws IllegalArgumentException
    {
        if (viewDefnObject instanceof Element)
        {
            return ((Element) viewDefnObject).getAttribute("id"); //$NON-NLS-1$
        }
        throw new IllegalArgumentException(
                "Only Elements can define view object ids"); //$NON-NLS-1$
    }

    @Override
    public ViewObject mapToViewObject(
            final Node viewDefnObject,
            final ViewObjectConstructionStrategy<? extends Node> constructionData,
            final IDocument document)
    {
        switch (viewDefnObject.getNodeType())
        {
            case Node.ELEMENT_NODE:
                return createFromElement(
                        (Element) viewDefnObject,
                        (ViewObjectConstructionStrategy<Element>) constructionData,
                        document);
        }

        return null;
    }

    /**
     * @param viewDefnObject
     * @param viewContainer
     * @return the tag element corresponding to viewDefnObject in the context of
     *         viewContainer or null if not found. Node must be an Element in
     *         order for this work.
     */
    public ITagElement mapToTagElement(final Node viewDefnObject,
            final IDocument viewContainer)
    {
        if (viewDefnObject instanceof Element)
        {
            return findTagElement((Element) viewDefnObject, viewContainer);
        }
        return null;
    }

    @Override
    public List<Node> getViewDefnRoots(final IDocument container)
    {
        final List<Node> roots = new ArrayList<Node>();

        final IStructuredDocumentContext context = IStructuredDocumentContextFactory.INSTANCE
                .getContext(container, -1);

        if (context != null)
        {
            final IDOMContextResolver resolver = IStructuredDocumentContextResolverFactory.INSTANCE
                    .getDOMContextResolver(context);

            if (resolver != null)
            {
                final Document doc = resolver.getDOMDocument();

                if (doc != null)
                {
                    roots.add(doc);
                }
            }
        }

        return roots;
    }

    @Override
    public ViewObject findViewObject(final Node viewDefnObject,
            final ComponentInfo root)
    {
        if (root instanceof DTUIViewRoot && viewDefnObject instanceof Element)
        {
            final IAdaptable services = ((DTUIViewRoot) root).getServices();
            final Object serviceAdapter = services
                    .getAdapter(XMLViewObjectMappingService.class);
            if (serviceAdapter instanceof XMLViewObjectMappingService)
            {
                final IStructuredDocumentContext context = getContext(viewDefnObject);

                if (context != null)
                {
                    final String uri = getNamespace((Element) viewDefnObject,
                            context.getStructuredDocument());
                    final ElementData elementData = XMLViewObjectMappingService
                            .createElementData(uri, viewDefnObject
                                    .getLocalName(), context,
                                    Collections.EMPTY_MAP);
                    return ((XMLViewObjectMappingService) serviceAdapter)
                            .findViewObject(elementData);
                }
            }
        }
        return null;
    }

    private IStructuredDocumentContext getContext(final Node viewDefnObject)
    {
        if (viewDefnObject instanceof IDOMNode)
        {
            final IStructuredDocument sdoc = ((IDOMNode) viewDefnObject)
                    .getStructuredDocument();
            return IStructuredDocumentContextFactory.INSTANCE.getContext(sdoc,
                    viewDefnObject);
        }
        return null;
    }

    @Override
    public Node findViewDefn(final ViewObject viewObject,
            final ComponentInfo root)
    {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public abstract DTELExpression getELExpression(IModelContext context)
            throws ViewHandlerException;

    // TODO: need to extend to other objects
    /**
     * @param element
     * @param constructionData
     * @param document
     * @return the component info for element
     */
    protected ViewObject createFromElement(final Element element,
            final ViewObjectConstructionStrategy<Element> constructionData,
            final IDocument document)
    {
        final ITagElement tagElement = findTagElement(element, document);
        return constructionData.createViewObject(element, tagElement);
    }

    /**
     * @param element
     * @param doc
     * @return the namespace uri for element in doc
     */
    public abstract String getNamespace(Element element, IDocument doc);

    /**
     * @param namespace
     * @param doc
     * @return the prefix in doc for namespace or null if none.
     */
    public abstract String getPrefix(final String namespace, IDocument doc);

    /**
     * @param node
     * @param document
     * @return the tag element for node in document or null if none
     */
    protected abstract ITagElement findTagElement(final Element node,
            final IDocument document);

    /**
     * @param nodeName
     * @param lib
     * @return the tag element with local name nodeName in lib or null if none.
     */
    protected static ITagElement findTagElement(final String nodeName,
            final Namespace lib)
    {
        return lib.getViewElement(nodeName);
    }

    /**
     * @param namespaces
     * @param uri
     * @return the namespace object in namespaces with uri, 'uri', or null if
     *         none.
     */
    protected static Namespace getTaglib(
            final Collection<? extends Namespace> namespaces, final String uri)
    {
        for (final Namespace namespace : namespaces)
        {
            if (uri.equals(namespace.getNSUri()))
            {
                return namespace;
            }
        }
        return null;
    }

    /**
     * @return the prefix string to which a running count will be added to
     *         produced the default generated id
     */
    public String getGeneratedIdPrefix()
    {
        return GENERATED_ID;
    }

    /**
     * @param element
     * @param componentAttrName
     * @return the attribute on element matching the component attribute called
     *         componentAttrName or null if not found (this may indicate either
     *         no such attribute or that it simply not populated on element; no
     *         guarantee is made as to which it is)
     */
    public Attr mapAttributeToComponent(final Element element,
            final String componentAttrName)
    {
        // TODO: need to make meta-data type driven and validate bad conversion

        final boolean mapByBeanName = true; // TODO: getMetadata for mapping
        // instead

        if (mapByBeanName)
        {
            return element.getAttributeNode(componentAttrName);
        }

        return null;
    }

    /**
     * A design time EL expression
     * 
     */
    public static class DTELExpression extends ELExpression
    {
        private final IStructuredDocumentContext _documentContext;
        private final String                     _originalText;

        /**
         * @param doc
         * @param text
         */
        public DTELExpression(final IStructuredDocumentContext doc,
                final String text)
        {
            _documentContext = doc;
            _originalText = text;
        }

        @Override
        public String getText()
        {
            return _originalText;
        }

        /**
         * @return the document context. The document relative position of the
         *         start of the EL expression is used
         * 
         */
        public IStructuredDocumentContext getDocumentContext()
        {
            return _documentContext;
        }

    }
}