/*******************************************************************************
 * 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.model.jsp;

import java.io.Serializable;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

import org.eclipse.core.runtime.jobs.ILock;
import org.eclipse.core.runtime.jobs.Job;
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.designtime.internal.view.model.jsp.persistence.SerializableTLDNamespace;
import org.eclipse.jst.jsp.core.internal.contentmodel.tld.provisional.TLDDocument;
import org.eclipse.jst.jsp.core.internal.contentmodel.tld.provisional.TLDElementDeclaration;
import org.eclipse.wst.xml.core.internal.contentmodel.CMNamedNodeMap;
import org.eclipse.wst.xml.core.internal.contentmodel.CMNode;

/**
 * Represents a JSP tag library namespace
 * 
 * @author cbateman
 * 
 */
public class TLDNamespace extends Namespace
{
    /**
     * 
     */
    private static final long          serialVersionUID = 9206460825737988441L;
    private TLDNamespaceData _tldData;

    /**
     * @param tldDoc
     * @param tagResolver
     */
    public TLDNamespace(
            final TLDDocument tldDoc,
            final ITagResolvingStrategy<TLDElementDeclaration, String> tagResolver)
    {
        _tldData = new DocumentTLDNamespaceData(tldDoc, tagResolver);
    }

    @Override
    public final String getDisplayName()
    {
        return _tldData.getDisplayName();
    }

    @Override
    public final String getNSUri()
    {
        return _tldData.getUri();
    }

    @Override
    public boolean isInitialized()
    {
        return _tldData.isInitialized();
    }

    public final ITagElement getViewElement(final String name)
    {
        // // bias the table small if this creates it
        // final Map<String, ITagElement> tags = getOrCreateMap(3);
        //
        // return _tldData.getOrCreateTagElement(name, tags);
        return _tldData.getViewElement(name);
    }

    @Override
    public final Collection<? extends ITagElement> getViewElements()
    {
        return Collections.unmodifiableCollection(_tldData.getAllViewElements().values());
    }

    /**
     * Differs from getViewElements because it won't include those elements
     * that haven't been lazily loaded.
     * 
     * @return an unmodifiable map of all elements currently calculated for
     * this namespaces
     */
    public final Map<String, ITagElement> getCurrentElements()
    {
        return Collections.unmodifiableMap(_tldData.getCurrentElements());
    }
    
    @Override
    public final boolean hasViewElements()
    {
        return _tldData.getNumTags() > 0;
    }
    

    private Object writeReplace()
    {
        return new SerializableTLDNamespace(this);
    }

    private static class DocumentTLDNamespaceData extends TLDNamespaceData
    {
        /**
         * 
         */
        private static final long serialVersionUID = -1098872687238068584L;
        private final transient TLDDocument                                          _tldDoc;
        private final transient ITagResolvingStrategy<TLDElementDeclaration, String> _tagResolver;
        private final transient ILock                                                _tagMapReadWriteLock;
        // should only be accessed directly in getOrCreateMap;
        private Map<String, ITagElement>                                             _tags; // lazy init in initializeTags

        public DocumentTLDNamespaceData(
                final TLDDocument tldDoc,
                final ITagResolvingStrategy<TLDElementDeclaration, String> tagResolver)
        {
            _tldDoc = tldDoc;
            _tagResolver = tagResolver;
            _tagMapReadWriteLock = Job.getJobManager().newLock();
        }

        @Override
        public String getDisplayName()
        {
            String displayName = _tldDoc.getDisplayName();
            if (displayName == null || "".equals(displayName.trim())) //$NON-NLS-1$
            {
                displayName = getUri();
            }
            return displayName;
        }

        @Override
        public String getUri()
        {
            return _tldDoc.getUri();
        }

        @Override
        public int getNumTags()
        {
            return _tldDoc.getElements().getLength();
        }

        private ITagElement createTagElement(final String name)
        {
            CMNode cmNode = _tldDoc.getElements().getNamedItem(name);
            ITagElement tagElement = null;
            if (cmNode instanceof TLDElementDeclaration)
            {
                tagElement = _tagResolver
                        .resolve((TLDElementDeclaration) cmNode);

                if (tagElement == _tagResolver.getNotFoundIndicator())
                {
                    // the not-found indicator may not be null.
                    tagElement = null;
                }
            }
            return tagElement;
        }

        public final Map<String, ITagElement> getAllViewElements()
        {
            final CMNamedNodeMap elementMap = _tldDoc.getElements();
            final Map<String, ITagElement> tags = getOrCreateMap(elementMap
                    .getLength());
            if (!isInitialized())
            {
                // if we create the table with this call, bias the table size
                // to be 1 bigger than the number of tags, since we know if it's
                // smaller, it'll cause at least one buffer resize
                
    
                for (int i = 0; i < elementMap.getLength(); i++)
                {
                    final CMNode cmNode = elementMap.item(i);
                    getViewElement(cmNode.getNodeName());
                }
            }
            return tags;
        }

        public ITagElement getViewElement(final String name)
        {
            ITagElement tagElement = null;

            _tagMapReadWriteLock.acquire();
            final Map<String, ITagElement> tags = getOrCreateMap(_tldDoc.getElements().getLength());
            try
            {
                tagElement = tags.get(name);

                if (tagElement == null)
                {
                    tagElement = createTagElement(name);

                    if (tagElement != null)
                    {
                        tags.put(tagElement.getName(), tagElement);
                    }
                }
            }
            finally
            {
                _tagMapReadWriteLock.release();
            }

            return tagElement;
        }

        /**
         * mapSizeHint will be used
         * 
         * @param mapSizeHint
         * @return the map
         */
        private synchronized Map<String, ITagElement> getOrCreateMap(
                final int mapSizeHint)
        {
            if (_tags == null)
            {
                final float loadFactor = 0.75f;
                final int initSize = ((int) (mapSizeHint / loadFactor)) + 1;
                _tags = Collections
                        .synchronizedMap(new HashMap<String, ITagElement>(
                                initSize));
            }
            return _tags;
        }

        @Override
        public boolean isInitialized()
        {
            int numTags = getNumTags();
            int tagMapSize = getOrCreateMap(3).size();

            // we are only initialized if the tag map is the equal in size
            // to the number of tags in the tld.
            return numTags == tagMapSize;
        }

        @Override
        public Map<String, ITagElement> getCurrentElements()
        {
            return getOrCreateMap(3);
        }
    }

    /**
     * Encapsulates all the data for a TLDNamespace.  Allows the model
     * to be separated from the Namespace interface for ease of serialization and 
     * controlled subclassing.
     *
     */
    public abstract static class TLDNamespaceData implements Serializable
    {
        /**
         * 
         */
        private static final long serialVersionUID = -1284294636936289804L;

        /**
         * @return the displayb
         */
        public abstract String getDisplayName();

//        public abstract ITagElement getOrCreateTagElement(String name,
//                Map<String, ITagElement> tags);

        /**
         * @return the number of tags
         */
        public abstract int getNumTags();

        /**
         * @return the namespace uri
         */
        public abstract String getUri();

        /**
         * @param name
         * @return the view element for name or null if not found.
         */
        public abstract ITagElement getViewElement(final String name);

        /**
         * May be long running since it will lazily calculate all unloaded
         * tags.
         * @return all view elements for this namespace
         */
        public abstract Map<String, ITagElement> getAllViewElements();

        /**
         * @return true if all elements have been lazily loaded
         */
        public abstract boolean isInitialized();
        
        /**
         * @return just the currently loaded elements for this namespace.
         */
        public abstract Map<String, ITagElement>  getCurrentElements();
    }
}