/******************************************************************************
 * Copyright (c) 2005, 2006 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.gmf.runtime.emf.type.core.internal.descriptors;

import java.net.URL;
import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;

import org.eclipse.gmf.runtime.common.core.util.Log;
import org.eclipse.gmf.runtime.emf.type.core.ElementType;
import org.eclipse.gmf.runtime.emf.type.core.ElementTypeRegistry;
import org.eclipse.gmf.runtime.emf.type.core.IContainerDescriptor;
import org.eclipse.gmf.runtime.emf.type.core.IElementMatcher;
import org.eclipse.gmf.runtime.emf.type.core.IElementType;
import org.eclipse.gmf.runtime.emf.type.core.IElementTypeFactory;
import org.eclipse.gmf.runtime.emf.type.core.ISpecializationType;
import org.eclipse.gmf.runtime.emf.type.core.ISpecializationTypeDescriptor;
import org.eclipse.gmf.runtime.emf.type.core.edithelper.IEditHelperAdvice;
import org.eclipse.gmf.runtime.emf.type.core.internal.EMFTypePlugin;
import org.eclipse.gmf.runtime.emf.type.core.internal.EMFTypePluginStatusCodes;
import org.eclipse.gmf.runtime.emf.type.core.internal.impl.XMLExpressionMatcher;
import org.eclipse.gmf.runtime.emf.type.core.internal.l10n.EMFTypeCoreMessages;

/**
 * Descriptor for a specialization element type that has been defined in XML
 * using the <code>elementTypes</code> extension point.
 * 
 * @author ldamus
 */
public class SpecializationTypeDescriptor
	extends ElementTypeDescriptor
	implements ISpecializationTypeDescriptor {

	/**
	 * The matcher class name. May be <code>null</code>.
	 */
	private String matcherClassName;

	/**
	 * The container element matcher. May be <code>null</code>.
	 */
	private IElementMatcher matcher;

	/**
	 * The container matcher configuration element. May be <code>null</code>.
	 */
	private IConfigurationElement matcherConfig;

	/**
	 * The identifiers of the element types that this type specializes.
	 */
	private String[] specializedTypeIds;

	/**
	 * The element types that are specialized by this type.
	 */
	private IElementType[] specializedTypes;

	/**
	 * The container descriptor.
	 */
	private IContainerDescriptor containerDescriptor;

	/**
	 * The edit helper advice descriptor.
	 */
	private IEditHelperAdviceDescriptor editHelperAdviceDescriptor;
	
	/**
	 * The edit helper advice.
	 */
	private IEditHelperAdvice editHelperAdvice;

	/**
	 * The specialization type.
	 */
	private ISpecializationType specializationType;

	/**
	 * The class name of the edit helper advice.
	 */
	private String editHelperAdviceName;

	/**
	 * Create a descriptor from a specialization type.
	 * 
	 * @param specializationType the specialization type
	 */
	public SpecializationTypeDescriptor(ISpecializationType specializationType) {

		super(specializationType);

		this.containerDescriptor = specializationType.getEContainerDescriptor();
		this.editHelperAdvice = specializationType.getEditHelperAdvice();
		this.editHelperAdviceDescriptor = new EditHelperAdviceDescriptor(
			editHelperAdvice, this);
		this.matcher = specializationType.getMatcher();
		this.specializationType = specializationType;
		this.specializedTypeIds = specializationType.getSpecializedTypeIds();
		this.specializedTypes = specializationType.getSpecializedTypes();
	}
			
	/**
	 * Create a descriptor from a configuration element.
	 * 
	 * @param configElement
	 *            the configuration element
	 * @param metamodelDescriptor
	 *            the metamodel descriptor. Attributes of the container
	 *            descriptor are defined relative to this metmodel.
	 */
	public SpecializationTypeDescriptor(IConfigurationElement configElement,
			MetamodelDescriptor metamodelDescriptor)
		throws CoreException {

		super(configElement);

		editHelperAdviceName = configElement
			.getAttribute(ElementTypeXmlConfig.A_EDIT_HELPER_ADVICE);

		editHelperAdviceDescriptor = new EditHelperAdviceDescriptor(
			editHelperAdviceName, this);

		//SPECIALIZES
		List specializes = new ArrayList();
		IConfigurationElement[] specializesConfigs = configElement
			.getChildren(ElementTypeXmlConfig.E_SPECIALIZES);

		for (int i = 0; i < specializesConfigs.length; i++) {
			IConfigurationElement nextSpecializesConfig = specializesConfigs[i];

			String specializedId = nextSpecializesConfig
				.getAttribute(ElementTypeXmlConfig.A_ID);

			if (specializedId == null) {
				throw EMFTypePluginStatusCodes.getTypeInitException(getId(),
						EMFTypeCoreMessages.type_reason_no_specialized_id_WARN_, null);
			}

			specializes.add(specializedId);
		}
		specializedTypeIds = (String[]) specializes.toArray(new String[] {});

		if (specializedTypeIds.length < 1) {
			throw EMFTypePluginStatusCodes.getTypeInitException(getId(),
				EMFTypeCoreMessages.type_reason_no_specialized_WARN_, null);
		}

		// ECONTAINER
		IConfigurationElement[] containerConfigs = configElement
			.getChildren(ElementTypeXmlConfig.E_ECONTAINER);

		if (containerConfigs.length > 0) {
			containerDescriptor = new ContainerDescriptor(containerConfigs[0],
				metamodelDescriptor, getId());
		}

		// XML MATCHER EXPRESSION
		IConfigurationElement[] enablementConfigs = configElement
			.getChildren(ElementTypeXmlConfig.E_ENABLEMENT);

		if (enablementConfigs.length > 0) {
			matcher = new XMLExpressionMatcher(enablementConfigs[0], getId());
		}

		// MATCHER CLASS
		if (matcher == null) {
			IConfigurationElement[] matcherConfigs = configElement
				.getChildren(ElementTypeXmlConfig.E_MATCHER);

			if (matcherConfigs.length > 0) {
				matcherClassName = matcherConfigs[0]
					.getAttribute(ElementTypeXmlConfig.A_CLASS);

				if (matcherClassName == null) {
					throw EMFTypePluginStatusCodes
							.getInitException(
									getId(),
									EMFTypeCoreMessages.element_reason_matcher_no_class_WARN_,
									null);
				}
				matcherConfig = matcherConfigs[0];
			}
		}
	}

	/**
	 * Returns the specialization type for this descriptor. Lazy creation of the
	 * specialization type to avoid premature plugin loading.
	 * 
	 * @return the element type
	 */
	public IElementType getElementType() {

		if (specializationType == null) {

			if (getKindName() != null && getKindName().length() > 0) {
				IElementTypeFactory factory = ElementTypeRegistry.getInstance()
					.getElementTypeFactory(getKindName());

				if (factory != null) {
					specializationType = factory.createSpecializationType(this);
				}
			}
		}
		return specializationType;
	}

	/**
	 * Gets the identifiers of the element types that this type specializes. May
	 * be <code>null</code>.
	 * 
	 * @return the ids of the types that are specialized
	 */
	public String[] getSpecializationTypeIds() {
		return specializedTypeIds;
	}

	/**
	 * Gets the element matcher configuration element. May be <code>null</code>.
	 * 
	 * @return the element matcher configuration element
	 */
	public IConfigurationElement getMatcherConfiguration() {
		return matcherConfig;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.gmf.runtime.emf.type.core.ISpecializationTypeDescriptor#getContainerDescriptor()
	 */
	public IContainerDescriptor getContainerDescriptor() {
		return containerDescriptor;
	}

	/**
	 * Gets the edit helper advice. May be <code>null</code>.
	 * 
	 * @return the edit helper advice
	 */
	public IEditHelperAdviceDescriptor getEditHelperAdviceDescriptor() {
		return editHelperAdviceDescriptor;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.gmf.runtime.emf.type.core.ISpecializationTypeDescriptor#getSpecializedTypes()
	 */
	public IElementType[] getSpecializedTypes() {

		if (specializedTypes == null) {
			specializedTypes = new ElementType[specializedTypeIds.length];

			for (int i = 0; i < specializedTypeIds.length; i++) {
				specializedTypes[i] = ElementTypeRegistry.getInstance()
					.getType(specializedTypeIds[i]);
			}
		}
		return specializedTypes;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.gmf.runtime.emf.type.core.ISpecializationTypeDescriptor#getMatcher()
	 */
	public IElementMatcher getMatcher() {

		if (matcher == null && matcherClassName != null
			&& matcherConfig != null) {
			try {
				matcher = (IElementMatcher) matcherConfig
					.createExecutableExtension(ElementTypeXmlConfig.A_CLASS);

			} catch (CoreException e) {
				Log
						.error(
								EMFTypePlugin.getPlugin(),
								EMFTypePluginStatusCodes.MATCHER_CLASS_NOT_FOUND,
								EMFTypeCoreMessages
										.bind(
												EMFTypeCoreMessages.matcher_class_not_found_ERROR_,
												matcherClassName), e);

				// Don't try to recompute the matcher class if it has failed.
				matcherClassName = null;
			}
		}
		return matcher;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.gmf.runtime.emf.type.core.ISpecializationTypeDescriptor#getEditHelperAdvice()
	 */
	public IEditHelperAdvice getEditHelperAdvice() {

		if (editHelperAdvice == null && getEditHelperAdviceDescriptor() != null) {
			editHelperAdvice = getEditHelperAdviceDescriptor().getEditHelperAdvice();
		}
		return editHelperAdvice;
	}
	
	/**
	 * Gets the icon URL from the the first type I specialize, if I don't have an icon.
	 */
	public URL getIconURL() {

		if ((super.getIconURL() == null) && (getSpecializedTypes().length > 0)) {
			return getSpecializedTypes()[0].getIconURL();
		}
		return super.getIconURL();
	}
	
	public String toString() {
		return "SpecializationTypeDescriptor[" + getId()+ "]";  //$NON-NLS-1$//$NON-NLS-2$
	}
}