package org.eclipse.jst.jsf.common.internal.pde;

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

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.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.jst.jsf.common.JSFCommonPlugin;

/**
 * @author cbateman
 * @param <T>
 * 
 */
public abstract class AbstractSimpleClassExtensionRegistryReader<T> extends
        AbstractRegistryReader<T>
{
    /**
     * Indicates no sorting of extension.
     */
    protected final static Comparator NO_SORT = null;
    
    private final String _attributeName;
    private final String _configElementName;
    private final Comparator<SortableExecutableExtension<T>> _comparator;

	private boolean _logWarnings = false;

    /**
     * @param extPtNamespace
     * @param extPtId
     * @param configElementName
     * @param attributeName
     * @param listComparator
     *            May be null if no sorting of the extensions list is required.
     */
    protected AbstractSimpleClassExtensionRegistryReader(
            final String extPtNamespace, final String extPtId,
            final String configElementName, final String attributeName,
            final Comparator<SortableExecutableExtension<T>> listComparator)
    {
        super(extPtNamespace, extPtId);
        _configElementName = configElementName;
        _attributeName = attributeName;
        _comparator = listComparator;
    }

    @Override
    protected final void initialize()
    {
        final List<SortableExecutableExtension<T>> result = new ArrayList<SortableExecutableExtension<T>>();
        final IExtensionPoint extensionPoint = Platform.getExtensionRegistry()
                .getExtensionPoint(getExtPtNamespace(), getExtPtId());
        if (extensionPoint == null)
        {
            return;
        }
        IExtension[] extensions = extensionPoint.getExtensions();
        for (int i = 0; i < extensions.length; i++)
        {
            IExtension ext = extensions[i];
            IConfigurationElement[] tagConverter = ext
                    .getConfigurationElements();

            for (int j = 0; j < tagConverter.length; j++)
            {
                final IConfigurationElement element = tagConverter[j];

                if (element.getName().equals(_configElementName))
                {
                    element.getAttribute(_attributeName);
                    try
                    {
                        final T obj = (T) element
                                .createExecutableExtension(_attributeName);
                        result.add(new SortableExecutableExtension<T>(
                                _comparator, element.getContributor().getName(),
                                obj));
                    } catch (ClassCastException ce)
                    {
                        handleLoadFailure(new CoreException(new Status(
                                IStatus.ERROR, JSFCommonPlugin.PLUGIN_ID,
                                "Extension class is not the expected type", ce))); //$NON-NLS-1$
                    } catch (CoreException e)
                    {
                        handleLoadFailure(e);
                    }
                }
            }
        }

        if (result.size() > 0)
        {
            if (_comparator != NO_SORT)
            {
                Collections.sort(result, _comparator);
            }
        } else if (_logWarnings)
        {
            JSFCommonPlugin.log(IStatus.WARNING, String.format(
                    "No extensions found for: %s.%s", //$NON-NLS-1$
                    getExtPtNamespace(), getExtPtId()));
        }
        final List<T> finalExtensions = new ArrayList<T>();
        for (final SortableExecutableExtension<T> sortable : result)
        {
            finalExtensions.add(sortable.getExtensionObject());
        }
        internalSetExtensions(finalExtensions);
    }

    /**
     * Called by initialize when an error occurs trying to load a class from an
     * extension point. Sub-class should implement to handle the failure,
     * typically to log it using their bundle id.
     * 
     * @param ce
     */
    protected abstract void handleLoadFailure(final CoreException ce);

    /**
     * @param doLogWarnings
     */
    protected void logWarnings(final boolean doLogWarnings) {
    	_logWarnings = doLogWarnings;
    }
    
    /**
     * A comparator that sorts canonically by extension namespace and id, but
     * can make exceptions for certain prefices.
     * 
     * @param <T>
     * 
     */
    protected abstract static class CanonicalComparatorWithPrefixExceptions<T>
            implements Comparator<SortableExecutableExtension<T>>
    {

        public int compare(SortableExecutableExtension<T> o1,
                SortableExecutableExtension<T> o2)
        {
            int result = prefixSort(o1, o2);

            // if the prefix sort doesn't distinguish a sort order, then
            // compare it canonically
            if (result == 0)
            {
                result = o1.getContributorId().compareTo(o2.getContributorId());
            }

            return result;
        }

        /**
         * @param o1
         * @param o2
         * @return -1 if o1 should sort before o2 based on prefix. 1 if o2
         *         should sort before o1 or 0 if there is sort preference based
         *         on prefix.
         */
        protected abstract int prefixSort(SortableExecutableExtension<T> o1,
                SortableExecutableExtension<T> o2);
    }

    /**
     * Ensures that contributions from "org.eclipse.jst" plugins are sorted last
     *
     * @param <T>
     */
    public static class CompareOrgEclipseJstContributorsLastComparator<T> extends CanonicalComparatorWithPrefixExceptions<T> {
        @Override
        protected int prefixSort(
                SortableExecutableExtension<T> o1,
                SortableExecutableExtension<T> o2)
        {
	            // if o1 is contributed by open source, sort it
	            // after 
	            if (o1.getContributorId().startsWith("org.eclipse.jst")) //$NON-NLS-1$
	            {
	                return 1;
	            }
	            // if o2 is contributed by open source, sort o1 first
	            else if (o2.getContributorId().startsWith("org.eclipse.jst")) //$NON-NLS-1$
	            {
	                return -1;
	            }
	            // otherwise, we don't care
	            return 0;
        }

    }
    /**
     * Used to sort extensions before locking down the list.
     * 
     * @param <T>
     */
    protected final static class SortableExecutableExtension<T> implements
            Comparable<SortableExecutableExtension>
    {
        private final Comparator _comparator;
        private final String _contributorId;
        private final T _extensionObject;

        private SortableExecutableExtension(final Comparator comparator,
                final String contributorId, final T extensionObject)
        {
            if (comparator == null)
            {
                _comparator = new Comparator<T>()
                {
                    public int compare(T o1, T o2)
                    {
                        // always return equal.
                        return 0;
                    }
                };
            } else
            {
                _comparator = comparator;
            }
            _contributorId = contributorId;
            _extensionObject = extensionObject;
        }

        public int compareTo(SortableExecutableExtension o)
        {
            return _comparator.compare(this, o);
        }

        @Override
        public boolean equals(Object obj)
        {
            return _comparator.compare(this, obj) == 0;
        }

        @Override
        public int hashCode()
        {
            return _contributorId.hashCode() ^ _extensionObject.hashCode();
        }

        /**
         * @return the id of the bundle that contributed this extension
         */
        public String getContributorId()
        {
            return _contributorId;
        }

        /**
         * @return the extension object
         */
        public T getExtensionObject()
        {
            return _extensionObject;
        }
    }
}