/*******************************************************************************
 * Copyright (c) 2005, 2008 IBM 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.dltk.core;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
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.IExtensionRegistry;
import org.eclipse.core.runtime.Platform;

/**
 * Abstract base class that can be used to manage extension point contributions
 * that may have more then one implementation.
 * 
 * <p>
 * Examples:
 * <ul>
 * <li>Source Parsers
 * <li>Debugging Engines
 * </ul>
 * </p>
 */
public abstract class DLTKContributionExtensionManager {
	private static final String NATURE_ID = "natureId"; //$NON-NLS-1$

	private static final String SELECTOR_TAG = "selector"; //$NON-NLS-1$
	public static final String CLASS_TAG = "class"; //$NON-NLS-1$

	private IDLTKContributionSelector defaultSelector;

	private Map natureToContribMap = new HashMap();
	private Map natureToSelectorMap = new HashMap();

	protected DLTKContributionExtensionManager() {
		this.defaultSelector = new DLTKPriorityContributionSelector();

		loadExtensionPoints();
	}

	public IDLTKContributedExtension[] getContributions(String natureId) {
		List contributions = getContributionsByNature(natureId);
		return (IDLTKContributedExtension[]) contributions
				.toArray(new IDLTKContributedExtension[contributions.size()]);
	}

	public IDLTKContributedExtension getSelectedContribution(IProject project,
			String natureId) {

		IDLTKContributedExtension[] contributions = getContributions(natureId);

		if (contributions.length > 0) {

			IDLTKContributionSelector selector = getSelector(natureId);
			if (selector == null) {
				selector = defaultSelector;
			}

			return selector.select(contributions, project);
		}

		return null;
	}

	/**
	 * Retrieves a registered contribution based upon its priority.
	 * 
	 * @param project
	 *            project
	 * @param natureId
	 *            nature id
	 */
	public IDLTKContributedExtension getPriorityContribution(IProject project,
			String natureId) {
		IDLTKContributedExtension[] contributions = getContributions(natureId);
		return defaultSelector.select(contributions, project);
	}

	/**
	 * Get the contributions registered for the given nature id
	 * 
	 * @param natureId
	 *            nature id
	 * 
	 * @return list of avaiable contributions or
	 *         <code>Collections.EMPTY_LIST</code> if no contributions have been
	 *         registered by the plugin
	 */
	protected final List getContributionsByNature(String natureId) {
		if (!hasContributions(natureId)) {
			return Collections.EMPTY_LIST;
		}

		return (List) natureToContribMap.get(natureId);
	}

	protected final IDLTKContributionSelector getSelector(String natureId) {
		return (IDLTKContributionSelector) natureToSelectorMap.get(natureId);
	}

	/**
	 * Checks if any contributions have been created for the given nature id
	 * 
	 * @param natureId
	 *            nature id
	 * 
	 * @return true if there are contributions, false otherwise
	 */
	protected final boolean hasContributions(String natureId) {
		if (natureToContribMap.containsKey(natureId)) {
			List list = (List) natureToContribMap.get(natureId);
			return !list.isEmpty();
		}

		return false;
	}

	/**
	 * Has a selector been configured for the contribution
	 * 
	 * @param natureId
	 *            nature id
	 * 
	 * @return true if a selector has been configured, false otherwise
	 */
	public final boolean hasSelector(String natureId) {
		return natureToSelectorMap.containsKey(natureId);
	}

	/**
	 * Returns a contributed extension implementation based on id.
	 * 
	 * @param id
	 *            contribution id
	 * 
	 * @return contribution implementation
	 */
	public final IDLTKContributedExtension getContributionById(String id) {
		Iterator keys = natureToContribMap.keySet().iterator();
		while (keys.hasNext()) {
			List list = (List) natureToContribMap.get(keys.next());

			for (Iterator iter = list.iterator(); iter.hasNext();) {
				IDLTKContributedExtension contrib = (IDLTKContributedExtension) iter
						.next();
				if (contrib.getId().equals(id)) {
					return contrib;
				}
			}
		}

		return null;
	}

	/**
	 * Returns the name of the contribution xml element
	 */
	protected abstract String getContributionElementName();

	/**
	 * Returns the name of the extension point to load
	 */
	protected abstract String getExtensionPoint();

	/**
	 * Checks if the passed object is valid for the given contribution.
	 * 
	 * <p>
	 * The passed object will have been created via a call to
	 * {@link IConfigurationElement#createExecutableExtension(String)}
	 * </p>
	 * 
	 * @param object
	 *            contribution implementation class
	 * 
	 * @return true if valid, false otherwise
	 */
	protected abstract boolean isValidContribution(Object object);

	/**
	 * Configure the object being contributed with any configuration data it may
	 * need.
	 * 
	 * <p>
	 * Sub-classes should override this method if the input object was not
	 * configured using
	 * {@link org.eclipse.core.runtime.IExecutableExtension#setInitializationData(IConfigurationElement, String, Object)}
	 * </p>
	 */
	protected Object configureContribution(Object object,
			IConfigurationElement config) {
		return object;
	}

	protected final void addContribution(String natureId,
			IConfigurationElement element) {
		try {
			Object object = element.createExecutableExtension(CLASS_TAG);

			if (isValidContribution(object)) {
				/*
				 * handle the case where the contribution is not the object that
				 * was just created.
				 */
				Object contrib = configureContribution(object, element);

				List list = (List) natureToContribMap.get(natureId);
				if (list == null) {
					list = new ArrayList();
					natureToContribMap.put(natureId, list);
				}

				list.add(contrib);
			}
		} catch (CoreException e) {
			e.printStackTrace();
		}

	}

	protected final void addSelector(String natureId,
			IConfigurationElement element) {
		try {
			Object object = element.createExecutableExtension(CLASS_TAG);
			if (object instanceof IDLTKContributionSelector) {
				// XXX: what if multiple extensions define a selector
				natureToSelectorMap.put(natureId, object);
			}
		} catch (CoreException e) {
			e.printStackTrace();
		}
	}

	private void loadChildren(String natureId,
			IConfigurationElement[] innerElements) {
		for (int j = 0; j < innerElements.length; j++) {
			IConfigurationElement innerElement = innerElements[j];
			String name = innerElement.getName();

			if (name.equals(getContributionElementName())) {
				addContribution(natureId, innerElement);
			} else if (name.equals(SELECTOR_TAG)) {
				addSelector(natureId, innerElement);
			}
		}
	}

	private void loadExtensionPoints() {
		IExtensionRegistry registry = Platform.getExtensionRegistry();
		IExtension[] extensions = registry.getExtensionPoint(
				getExtensionPoint()).getExtensions();

		for (int i = 0; i < extensions.length; i++) {
			IExtension extension = extensions[i];
			IConfigurationElement[] elements = extension
					.getConfigurationElements();
			for (IConfigurationElement main : elements) {
				if (isNatureContribution(main)) {
					String natureId = main.getAttribute(NATURE_ID);
					IConfigurationElement[] innerElements = main.getChildren();
					loadChildren(natureId, innerElements);
				}
			}
		}
	}

	/**
	 * @param main
	 * @return
	 * @since 2.0
	 */
	protected boolean isNatureContribution(IConfigurationElement main) {
		return true;
	}

}