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

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;

import org.eclipse.core.resources.IProject;
import org.eclipse.jst.jsf.common.runtime.internal.view.model.common.ITagElement;
import org.eclipse.jst.jsf.core.internal.JSFCorePlugin;
import org.eclipse.jst.jsf.core.internal.JSFCoreTraceOptions;
import org.eclipse.jst.jsf.designtime.internal.Messages;
import org.eclipse.jst.jsf.designtime.internal.view.model.jsp.JSPTagResolvingStrategy;
import org.eclipse.jst.jsf.designtime.internal.view.model.jsp.TLDNamespace;
import org.eclipse.jst.jsf.designtime.internal.view.model.jsp.TLDTagElement;
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.CMDocument;

/**
 * @author cbateman
 * 
 */
public class PersistedDataTagStrategy extends JSPTagResolvingStrategy
{
    /**
     * the identifier of this strategy
     */
    public final static String                    ID              = "org.eclipse.jst.jsf.designtime.PersistedDataTagStrategy"; //$NON-NLS-1$
    /**
     * the display name
     */
    public final static String                    DISPLAY_NAME    = Messages.PersistedDataTagStrategy_DisplayName;

    private final IProject                        _project;
    private final TagRepository                   _repository;
    private Map<String, SerializableTLDNamespace> _namespaces;
    private final transient AtomicBoolean         _reentrancyFlag = new AtomicBoolean(
                                                                          false);

    /**
     * @return the descriptor for this resolver strategy
     */
    public static StrategyDescriptor createDescriptor()
    {
        return new StrategyDescriptor(ID, DISPLAY_NAME);
    }

    /**
     * @param project
     */
    public PersistedDataTagStrategy(final IProject project)
    {
        _project = project;
        _repository = new TagRepository(_project);
    }

    /**
     * 
     */
    public void init()
    {
        if (JSFCoreTraceOptions.TRACE_JSPTAGPERSISTENCE)
        {
            JSFCoreTraceOptions
                    .log("Initializing PersistedDataTagStrategy for project: " //$NON-NLS-1$
                            + _project.toString());
        }
        try
        {
            _namespaces = _repository.load();
            return;
        }
        catch (final IOException e)
        {
            JSFCorePlugin
                    .log(e,
                            "JSP tag registry cached failed to load.  Strategy will not be used"); //$NON-NLS-1$
        }
        catch (final ClassNotFoundException e)
        {
            JSFCorePlugin
                    .log(e,
                            "JSP tag registry cached failed to load.  Strategy will not be used"); //$NON-NLS-1$
        }
        _namespaces = new HashMap<String, SerializableTLDNamespace>();
    }

    /**
     * @param namespace
     * @throws ClassNotFoundException
     * @throws IOException
     */
    public void save(final Map<String, TLDNamespace> namespace)
            throws IOException, ClassNotFoundException
    {
        if (JSFCoreTraceOptions.TRACE_JSPTAGPERSISTENCE)
        {
            JSFCoreTraceOptions
                    .log("Saving PersistedDataTagStrategy for project: " //$NON-NLS-1$
                            + _project.toString());
        }

        // namespace is considered authoritative for every key it contains
        // so copy them all in. However, preserve anything in our own namespace
        // map not found in namespace
        for (final Map.Entry<String, TLDNamespace> namespaceEntry : namespace
                .entrySet())
        {
            final TLDNamespace ns = namespaceEntry.getValue();
            final String nsName = namespaceEntry.getKey();
            final SerializableTLDNamespace myNs = _namespaces.get(nsName);

            if (myNs == null)
            {
                if (JSFCoreTraceOptions.TRACE_JSPTAGPERSISTENCE)
                {
                    JSFCoreTraceOptions.log(String.format(
                            "Adding namespace %s for project", ns.getNSUri(), //$NON-NLS-1$
                            _project.toString()));
                }

                _namespaces.put(nsName, new SerializableTLDNamespace(ns));
            }
            else
            {
                if (JSFCoreTraceOptions.TRACE_JSPTAGPERSISTENCE)
                {
                    JSFCoreTraceOptions.log(String.format(
                            "Updating namespace %s for project", ns.getNSUri(), //$NON-NLS-1$
                            _project.toString()));
                }

                for (final Map.Entry<String, ITagElement> elementEntry : ns
                        .getCurrentElements().entrySet())
                {
                    if (JSFCoreTraceOptions.TRACE_JSPTAGPERSISTENCE)
                    {
                        JSFCoreTraceOptions.log(String.format(
                                "Putting element %s", elementEntry.getKey())); //$NON-NLS-1$
                    }
                    myNs.put(elementEntry.getKey(), elementEntry.getValue());
                }
            }
        }

        _repository.save(_namespaces);
    }

    @Override
    public ITagElement resolve(final TLDElementDeclaration element)
    {
        if (JSFCoreTraceOptions.TRACE_JSPTAGPERSISTENCE)
        {
            JSFCoreTraceOptions.log(String.format(
                    "Attempting to resolve element %s for project %s", element //$NON-NLS-1$
                            .getElementName(), _project));
        }

        try
        {
            if (!_reentrancyFlag.compareAndSet(false, true))
            {
                throw new IllegalStateException("Reentrant call to resolve"); //$NON-NLS-1$
            }

            final String uri = getUri(element);
            final String tagName = element.getElementName();

            if (uri != null && tagName != null)
            {
                final SerializableTLDNamespace ns = _namespaces.get(uri);

                if (ns != null)
                {
                    final ITagElement tagElement = ns.getViewElement(tagName);

                    if (tagElement instanceof TLDTagElement)
                    {
                        if (JSFCoreTraceOptions.TRACE_JSPTAGPERSISTENCE)
                        {
                            JSFCoreTraceOptions.log(String.format(
                                    "Resolved element %s for project %s", //$NON-NLS-1$
                                    element.getElementName(), _project));
                        }
                        return tagElement;
                    }
                }
            }
            return getNotFoundIndicator();
        }
        finally
        {
            _reentrancyFlag.set(false);
        }
    }

    /**
     * Clears all cached data and removes it permanently from disk.
     */
    public void clear()
    {
        if (JSFCoreTraceOptions.TRACE_JSPTAGPERSISTENCE)
        {
            JSFCoreTraceOptions.log(String.format(
                    "Flushing all data for project %s", _project)); //$NON-NLS-1$
        }

        try
        {
            _repository.clearAll();
        }
        catch (IOException e)
        {
            JSFCorePlugin.log(e, "Failure during cache flushing on project: " //$NON-NLS-1$
                    + _project);
        }
        catch (ClassNotFoundException e)
        {
            JSFCorePlugin.log(e, "Failure during cache flushing on project: " //$NON-NLS-1$
                    + _project);
        }
        _namespaces.clear();
    }

    public String getDisplayName()
    {
        return DISPLAY_NAME;
    }

    private static String getUri(final TLDElementDeclaration element)
    {
        final CMDocument owner = element.getOwnerDocument();

        if (owner instanceof TLDDocument)
        {
            return ((TLDDocument) owner).getUri();
        }
        return null;
    }

    @Override
    public String getId()
    {
        return ID;
    }
}