/*******************************************************************************
 * 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.io.IOException;
import java.io.Serializable;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.Path;
import org.eclipse.jst.jsf.common.dom.TagIdentifier;
import org.eclipse.jst.jsf.common.runtime.internal.model.ViewObject;
import org.eclipse.jst.jsf.context.resolver.structureddocument.IStructuredDocumentContextResolverFactory;
import org.eclipse.jst.jsf.context.resolver.structureddocument.IWorkspaceContextResolver;
import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContext;
import org.eclipse.jst.jsf.core.internal.JSFCorePlugin;
import org.eclipse.jst.jsf.core.internal.region.Region2ElementAdapter;
import org.eclipse.jst.jsf.core.internal.region.Region2ElementAdapter.NoElementException;
import org.eclipse.jst.jsf.core.internal.tld.TagIdentifierFactory;
import org.eclipse.wst.sse.core.StructuredModelManager;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion;
import org.w3c.dom.Element;

/**
 * @author cbateman
 * 
 */
public final class XMLViewObjectMappingService implements Serializable
{
    /**
     * 
     */
    private static final long serialVersionUID = -5371998199186683997L;
    private final Map<ElementData, ViewObject> _elementToViewObjMap;
    private final Map<ViewObject, ElementData> _viewObjToElementMap;

    /**
     * 
     */
    public XMLViewObjectMappingService()
    {
        _elementToViewObjMap = new HashMap<ElementData, ViewObject>();
        _viewObjToElementMap = new HashMap<ViewObject, ElementData>();
    }

    /**
     * @param elementData
     * @param viewObject
     */
    public void createMapping(final ElementData elementData,
            final ViewObject viewObject)
    {
        if (elementData == null)
        {
            throw new IllegalArgumentException("elementData cannot be null");
        }
        else if (viewObject == null)
        {
            throw new IllegalArgumentException("viewObject cannot be null");
        }

        synchronized(this)
        {
            _elementToViewObjMap.put(elementData, viewObject);
            _viewObjToElementMap.put(viewObject, elementData);
        }
    }

    /**
     * Remove all mappings
     */
    public void clearMappings()
    {
        synchronized (this)
        {
            _elementToViewObjMap.clear();
            _viewObjToElementMap.clear();
        }
    }

    /**
     * @param elementData
     * @return the view object for which the mapping was removed
     */
    public ViewObject removeMapping(final ElementData elementData)
    {
        if (elementData == null)
        {
            throw new IllegalArgumentException("elementData mustn't be null");
        }

        ViewObject viewObject = null;
        synchronized(this)
        {
            viewObject = _elementToViewObjMap.remove(elementData);
            if (viewObject != null)
            {
                _viewObjToElementMap.remove(viewObject);
            }
        }
        return viewObject;
    }

    /**
     * @param viewObject
     * @return the element data for which the mapping was removed
     */
    public ElementData removeMapping(final ViewObject viewObject)
    {
        if (viewObject == null)
        {
            throw new IllegalArgumentException("elementData mustn't be null");
        }
        
        ElementData elementData = null;
        synchronized(this)
        {
            elementData = _viewObjToElementMap.remove(viewObject);
            if (elementData != null)
            {
                _elementToViewObjMap.remove(elementData);
            }
        }
        return elementData;
    }

    /**
     * @param viewObject
     * @return the element data for the view object
     */
    public synchronized ElementData findElementData(final ViewObject viewObject)
    {
        return _viewObjToElementMap.get(viewObject);
    }

    /**
     * @param viewObject
     * @return the element for the viewObject
     */
    public Element findElement(final ViewObject viewObject)
    {
        final ElementData elementData = findElementData(viewObject);

        if (elementData != null)
        {
            final IFile file = ResourcesPlugin.getWorkspace().getRoot()
                    .getFile(new Path(elementData.getDocumentPath()));

            if (file != null && file.isAccessible())
            {
                IStructuredModel model = null;
                try
                {
                    model = StructuredModelManager.getModelManager()
                            .getModelForRead(file);
                    final IStructuredDocument sDoc = model
                            .getStructuredDocument();
                    final IStructuredDocumentRegion region = sDoc
                            .getRegionAtCharacterOffset(elementData
                                    .getStartOffset());
                    final Region2ElementAdapter adapter = new Region2ElementAdapter(
                            region);
                    final TagIdentifier tagId = adapter.getTagId();
                    if (tagId.equals(elementData.getTagId()))
                    {
                        return adapter.getElement();
                    }
                }
                catch (CoreException ce)
                {
                    JSFCorePlugin.log(ce,
                            "While finding element for viewObject: "
                                    + viewObject.toString() + " in "
                                    + file.getFullPath());
                }
                catch (IOException e)
                {
                    JSFCorePlugin.log(e,
                            "While finding element for viewObject: "
                                    + viewObject.toString() + " in "
                                    + file.getFullPath());
                }
                catch (NoElementException e)
                {
                    JSFCorePlugin.log(e,
                            "While finding element for viewObject: "
                                    + viewObject.toString() + " in "
                                    + file.getFullPath());
                }
                finally
                {
                    if (model != null)
                    {
                        model.releaseFromRead();
                    }
                }
            }
        }
        return null;
    }

    /**
     * @param elementData
     * @return the mapped view object for elementData or null if not found.
     */
    public synchronized ViewObject findViewObject(final ElementData elementData)
    {
        return _elementToViewObjMap.get(elementData);
    }

    /**
     * @param namespace
     * @param tagName
     * @param context
     * @param attributeToPropertyMap 
     * @return a new Element data for the namespace/element name in 'context'
     */
    public static ElementData createElementData(final String namespace,
            final String tagName, final IStructuredDocumentContext context, 
            final Map<String, String> attributeToPropertyMap)
    {
        final IFile file = getFile(context);
        final int offset = context.getDocumentPosition();

        if (file != null && file.isAccessible() && offset > -1
                && tagName != null && namespace != null)
        {
            return new ElementData(offset, file.getFullPath().toString(),
                    TagIdentifierFactory
                            .createJSPTagWrapper(namespace, tagName),
                     attributeToPropertyMap);
        }
        return null;
    }

    private static IFile getFile(final IStructuredDocumentContext context)
    {
        final IWorkspaceContextResolver resolver = IStructuredDocumentContextResolverFactory.INSTANCE
                .getWorkspaceContextResolver(context);
        IResource res = resolver.getResource();
        if (res instanceof IFile)
        {
            return (IFile) res;
        }
        // fall through.
        return null;
    }

    /**
     * Describes enough information about an element instance to look it up
     * again, without storing possibly transient references to it.
     * 
     * @author cbateman
     * 
     */
    public final static class ElementData implements Serializable
    {
        /**
         * serializable id
         */
        private static final long       serialVersionUID = 7937312530318827977L;

        private transient TagIdentifier _tagId;
        private Map<String, String>     _attributeToPropertyMap;
        private String                  _documentPath;
        private int                     _startOffset;

        /**
         * @param startOffset
         * @param documentPath
         * @param tagId
         * @param attributeToPropertyMap constructor takes copy of map
         */
        private ElementData(final int startOffset, final String documentPath,
                final TagIdentifier tagId, Map<String, String> attributeToPropertyMap)
        {
            super();
            _startOffset = startOffset;
            
            _tagId = tagId;
            _documentPath = documentPath;
            _attributeToPropertyMap = Collections.unmodifiableMap(
                    new HashMap<String,String>(attributeToPropertyMap));
        }

        /**
         * Default constructor
         */
        protected ElementData()
        {
            // for serialization
        }

        /**
         * @return the tag identifier for this element
         */
        public final TagIdentifier getTagId()
        {
            return _tagId;
        }

        /**
         * @param forTagAttribute
         * @return the name of the view object property that forTagAttribute
         * maps to on this element or null if none.
         */
        public final String getPropertyName(final String forTagAttribute)
        {
            return _attributeToPropertyMap.get(forTagAttribute);
        }

        final int getStartOffset()
        {
            return _startOffset;
        }

        final String getDocumentPath()
        {
            return _documentPath;
        }

        private void writeObject(final java.io.ObjectOutputStream out)
                throws IOException
        {
            out.defaultWriteObject();
            out.writeObject(_tagId.getUri());
            out.writeObject(_tagId.getTagName());
        }

        private void readObject(final java.io.ObjectInputStream in)
                throws IOException, ClassNotFoundException
        {
            in.defaultReadObject();
            final String uri = (String) in.readObject();
            final String tagName = (String) in.readObject();
            _tagId = TagIdentifierFactory.createJSPTagWrapper(uri, tagName);
        }

        @Override
        public boolean equals(final Object obj)
        {
            if (this == obj)
            {
                return true;
            }
            if (obj instanceof ElementData)
            {
                final ElementData other = (ElementData) obj;
                return _startOffset == other._startOffset
                        && _documentPath.equals(other._documentPath)
                        && _tagId.equals(other._tagId);
            }
            return false;
        }

        @Override
        public int hashCode()
        {
            int hashCode = _tagId.hashCode();
            hashCode ^= _documentPath.hashCode();
            // startOffsets will generally fit in the first 10 bits, so mix
            // it up a bit.
            hashCode ^= ~(_startOffset * 104551);
            return hashCode;
        }
    }
}