/*******************************************************************************
 * 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:
 *    Cameron Bateman/Oracle - initial API and implementation
 * 
 ********************************************************************************/

package org.eclipse.jst.jsf.designtime.internal;

import java.util.HashMap;
import java.util.Map;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jst.jsf.core.internal.JSFCorePlugin;
import org.eclipse.jst.jsf.designtime.el.IInstancePerProjectResolver;
import org.osgi.framework.Bundle;

/**
 * @author cbateman
 * @param <EXTENSIONTYPE>
 * 
 */
public class BasicExtensionFactory<EXTENSIONTYPE>
{
    private final Bundle                              _bundle;
    private final String                              _extName;
    private Map<String, ExtensionData<EXTENSIONTYPE>> _registeredResolvers;
    private final String                              _elementName;
    private final ExtensionDataFactory                _extensionDataFactory;

    /**
     * @param bundle
     * @param extName
     * @param elementName
     */
    public BasicExtensionFactory(final Bundle bundle, final String extName,
            final String elementName)
    {
        _bundle = bundle;
        _extName = extName;
        _elementName = elementName;
        _extensionDataFactory = new ExtensionDataFactory<EXTENSIONTYPE>();
    }

    /**
     * @return the resolvers. Lazily initialized.
     */
    public final Map<String, ExtensionData<EXTENSIONTYPE>> getExtensions()
    {
        if (_registeredResolvers == null)
        {
            _registeredResolvers = loadRegisteredExtensions();
        }

        return _registeredResolvers;
    }

    /**
     * @return the map of extensions by id.
     */
    protected Map<String, ExtensionData<EXTENSIONTYPE>> loadRegisteredExtensions()
    {
        final Map<String, ExtensionData<EXTENSIONTYPE>> resolvers = new HashMap<String, ExtensionData<EXTENSIONTYPE>>();

        final IExtensionPoint point = Platform.getExtensionRegistry()
                .getExtensionPoint(_bundle.getSymbolicName(), _extName);

        final IExtension[] extensions = point.getExtensions();

        for (final IExtension extension : extensions)
        {
            final IConfigurationElement[] elements = extension
                    .getConfigurationElements();

            for (final IConfigurationElement element : elements)
            {
                if (_elementName.equals(element.getName())
                        && element.getAttribute("class") != null //$NON-NLS-1$
                        && element.getAttribute("id") != null) //$NON-NLS-1$
                {
                    final ExtensionData extData = processExtension(element);

                    if (extData != null)
                    {
                        resolvers.put(extData.getId(), extData);
                    }
                }
            }
        }
        return resolvers;
    }

    /**
     * @param element
     * @return the extension data for the extension or null if can't be created
     */
    protected ExtensionData processExtension(final IConfigurationElement element)
    {
        return _extensionDataFactory.createExtensionData(element);
    }

    /**
     * @author cbateman
     * 
     * @param <EXTENSIONTYPE>
     */
    protected static class ExtensionDataFactory<EXTENSIONTYPE>
    {
        ExtensionData createExtensionData(final IConfigurationElement element)
        {
            if (isPerProjectExtension(element))
            {
                return new PerProjectExtensionData<EXTENSIONTYPE>(element);
            }
            return new SingleInstanceExtensionData<EXTENSIONTYPE>(element);
        }

        static boolean isPerProjectExtension(final IConfigurationElement element)
        {
            final String flag = element.getAttribute("instancePerProject");
            // must check for null for backward compatibility, since
            // this attribute wasn't part of the original.
            if (flag != null)
            {
                return Boolean.valueOf(flag).booleanValue();
            }
            return false;
        }
    }

    /**
     * @param <EXTENSIONTYPE>
     */
    protected static class PerProjectExtensionData<EXTENSIONTYPE> extends
            ExtensionData<EXTENSIONTYPE>
    {
        private Map<IProject, EXTENSIONTYPE> _extensions;

        /**
         * @param element
         */
        protected PerProjectExtensionData(IConfigurationElement element)
        {
            super(element);
        }

        @Override
        public EXTENSIONTYPE getInstance(final IProject project)
        {
            if (!project.isAccessible())
            {
                _extensions.remove(project);
                return null;
            }

            if (_extensions == null)
            {
                _extensions = new HashMap<IProject, EXTENSIONTYPE>();
            }

            EXTENSIONTYPE instance = _extensions.get(project);

            if (instance == null)
            {
                try
                {
                    instance = createInstance();
                    if (instance instanceof IInstancePerProjectResolver)
                    {
                        ((IInstancePerProjectResolver) instance)
                                .setProject(project);
                    }
                    _extensions.put(project, instance);
                }
                catch (Exception e)
                {
                    JSFCorePlugin.log(e,
                            "Instantiating extension class for id: " + getId());
                }
            }
            return instance;
        }
    }

    /**
     * @param <EXTENSIONTYPE>
     * 
     */
    protected static class SingleInstanceExtensionData<EXTENSIONTYPE> extends
            ExtensionData<EXTENSIONTYPE>
    {
        private EXTENSIONTYPE _instance;

        /**
         * @param element
         */
        protected SingleInstanceExtensionData(IConfigurationElement element)
        {
            super(element);
        }

        @Override
        public EXTENSIONTYPE getInstance(final IProject project)
        {
            if (_instance == null)
            {
                try
                {
                    _instance = createInstance();
                }
                catch (CoreException e)
                {
                    JSFCorePlugin.log(e,
                            "Instantiating extension class for id: " + getId());
                }
            }
            return _instance;
        }
    }

    /**
     * Extension data
     * 
     * @param <EXTENSIONTYPE>
     * 
     */
    public abstract static class ExtensionData<EXTENSIONTYPE>
    {
        private final IConfigurationElement _element;

        /**
         * @param element
         */
        protected ExtensionData(final IConfigurationElement element)
        {
            super();
            _element = element;
        }

        /**
         * @return the unique id of the variable resolver extension
         */
        public String getId()
        {
            return _element.getAttribute("id"); //$NON-NLS-1$
        }

        /**
         * @param project
         * @return the instance. project may be ignored if there is only one
         *         global instance for this factory.
         */
        public abstract EXTENSIONTYPE getInstance(final IProject project);

        /**
         * @return the resolver
         * @throws CoreException
         */
        protected EXTENSIONTYPE createInstance() throws CoreException
        {
            return (EXTENSIONTYPE) _element.createExecutableExtension("class");
        }

        /**
         * @return true if a single instance should be created per project.
         */
        public boolean isInstancePerProject()
        {
            return ExtensionDataFactory.isPerProjectExtension(_element);
        }
    }
}