// PropertySelector.java
package org.eclipse.stem.ui.widgets;

/*******************************************************************************
 * Copyright (c) 2007 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
 *******************************************************************************/

import java.util.ArrayList;
import java.util.EventObject;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
import org.eclipse.emf.edit.provider.IItemLabelProvider;
import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
import org.eclipse.stem.core.graph.DynamicLabel;
import org.eclipse.stem.core.graph.Graph;
import org.eclipse.stem.core.model.Decorator;
import org.eclipse.stem.definitions.adapters.relativevalue.RelativeValueProvider;
import org.eclipse.stem.definitions.adapters.relativevalue.RelativeValueProviderAdapter;
import org.eclipse.stem.definitions.adapters.relativevalue.RelativeValueProviderAdapterFactory;
import org.eclipse.stem.diseasemodels.standard.DiseaseModel;
import org.eclipse.stem.jobs.simulation.ISimulation;
import org.eclipse.stem.populationmodels.standard.PopulationModel;
import org.eclipse.stem.ui.views.geographic.map.Messages;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.FormAttachment;
import org.eclipse.swt.layout.FormData;
import org.eclipse.swt.layout.FormLayout;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;

/**
 * This class is a compound SWT widget that allows for the selection of a
 * property or properties of one or more {@link Decorator}s.
 */
public class PropertySelector extends Composite {

	private final List<PropertySelectionListener> propertySelectionListeners = new CopyOnWriteArrayList<PropertySelectionListener>();

	private ISimulation simulation = null;

	/**
	 * This is the name of the property that should be displayed first (if
	 * possible).
	 * 
	 * @see #setPreferences()
	 */
	private String initialPropertyName;

	private final Label displayLabel;

	Combo decoratorsCombo;

	Combo propertiesCombo;

	Combo popIdsCombo;

	List<Decorator> decorators;

	Decorator selectedDecorator;

	List<ItemPropertyDescriptor> properties;

	ItemPropertyDescriptor selectedProperty;
	
	String selectedId;
	
	private DecoratorFilter decoratorFilter = new DecoratorFilter() {
		/**
		 * @see org.eclipse.stem.ui.widgets.PropertySelector.DecoratorFilter#accept(org.eclipse.stem.core.model.Decorator)
		 */
		public boolean accept(@SuppressWarnings("unused")
		Decorator decorator) {
			return true;
		}
	};

	/**
	 * The default sieve selects those properties that have relative values.
	 */
	private PropertySieve propertySieve = new PropertySieve() {
		/**
		 * @see org.eclipse.stem.ui.widgets.PropertySelector.PropertySieve#sieve(org.eclipse.stem.core.graph.DynamicLabel)
		 */
		public List<ItemPropertyDescriptor> sieve(DynamicLabel dynamicLabel) {
			final List<ItemPropertyDescriptor> retValue = new ArrayList<ItemPropertyDescriptor>();
			final RelativeValueProviderAdapter rvp = (RelativeValueProviderAdapter) RelativeValueProviderAdapterFactory.INSTANCE
					.adapt(dynamicLabel, RelativeValueProvider.class);

			// Does the label have relative values?
			if (rvp != null) {
				// Yes
				rvp.setTarget(dynamicLabel);

				for (final Object element : rvp.getProperties()) {
					final ItemPropertyDescriptor property = (ItemPropertyDescriptor) element;
					retValue.add(property);
				} // for each property
			} // if the label has relative values
			return retValue;
		} // sieve
	};

	/**
	 * @param parent
	 * @param style
	 */
	public PropertySelector(final Composite parent, final int style, boolean allowPropertySelection) {
		super(parent, style);
		final FormLayout retValueLayout = new FormLayout();
		this.setLayout(retValueLayout);

		displayLabel = new Label(this, SWT.CENTER);
		displayLabel.setText(Messages.getString("IMView.MProp") + " :"); //$NON-NLS-1$ //$NON-NLS-2$

		// Combo Box of Decorators
		decoratorsCombo = new Combo(this, SWT.DROP_DOWN | SWT.READ_ONLY
				| SWT.CENTER);

		// Combo Box of the Decorator Properties
		propertiesCombo = new Combo(this, SWT.DROP_DOWN | SWT.READ_ONLY
				| SWT.CENTER);

		popIdsCombo = new Combo(this, SWT.DROP_DOWN | SWT.READ_ONLY 
				| SWT.CENTER);
		
		final FormData decoratorsComboFormData = new FormData();
		decoratorsComboFormData.top = new FormAttachment(displayLabel, 0);
		decoratorsComboFormData.left = new FormAttachment(0, 0);
		decoratorsComboFormData.right = new FormAttachment(100, 0);
		decoratorsCombo.setLayoutData(decoratorsComboFormData);

		final FormData propertiesComboFormData = new FormData();
		propertiesComboFormData.top = new FormAttachment(decoratorsCombo, 0);
		propertiesComboFormData.left = new FormAttachment(0, 0);
		propertiesComboFormData.right = new FormAttachment(100, 0);
		propertiesCombo.setLayoutData(propertiesComboFormData);

		final FormData popIdsComboFormData = new FormData();
		popIdsComboFormData.top = new FormAttachment(propertiesCombo, 0);
		popIdsComboFormData.left = new FormAttachment(0, 0);
		popIdsComboFormData.right = new FormAttachment(100, 0);
		popIdsCombo.setLayoutData(popIdsComboFormData);

		this.pack();

		decoratorsCombo.addSelectionListener(new SelectionAdapter() {
			@Override
			public void widgetSelected(@SuppressWarnings("unused")
			final SelectionEvent e) {
				// Any decorators?
				if (!decorators.isEmpty()) {
					// Yes
					final Decorator tempDecorator = decorators
							.get(decoratorsCombo.getSelectionIndex());
					// Was there a change in selected Decorators?
					if (selectedDecorator != tempDecorator) {
						// Yes
						selectedDecorator = tempDecorator;
						List<String> ids = getIdsToDisplay(selectedDecorator);
						selectedId = ids.get(0);
						properties = getPropertiesToDisplay(selectedDecorator, selectedId);
						selectedProperty = selectCurrentDecoratorProperty(properties);
						initializeCombo(propertiesCombo,
								getPropertyNames(properties), getPropertyIndex(
										selectedProperty, properties));
						String [] propIds = ids.toArray(new String[]{});
						initializeCombo(popIdsCombo,
								propIds, 0);

						PropertySelector.this
								.notifyPropertySelection(selectedProperty, selectedId);
					} // if Decorators changed

				} // if any decorators
			}
		} // SelectionAdapter
		);

		propertiesCombo.addSelectionListener(new SelectionAdapter() {
			@Override
			public void widgetSelected(@SuppressWarnings("unused")
			final SelectionEvent e) {
				// Any Decorator properties?
				if (!properties.isEmpty()) {
					// Yes
					// Is it different?
					final ItemPropertyDescriptor temp = properties
							.get(propertiesCombo.getSelectionIndex());
					if (selectedProperty != temp) {
						// Yes
						selectedProperty = temp;
						PropertySelector.this
								.notifyPropertySelection(selectedProperty, selectedId);
					} // if

				} // if
			} // widgetSelected

		} // SelectionAdapter
				);
		popIdsCombo.addSelectionListener(new SelectionAdapter() {
			@Override
			public void widgetSelected(@SuppressWarnings("unused")
			final SelectionEvent e) {
				List<String>ids = getIdsToDisplay(selectedDecorator);
					final String temp = ids
							.get(popIdsCombo.getSelectionIndex());
					if (!selectedId.equals(temp)) {
						// Yes
						selectedId = temp;
						properties = getPropertiesToDisplay(selectedDecorator, selectedId);
						selectedProperty = selectCurrentDecoratorProperty(properties);
						initializeCombo(propertiesCombo,
								getPropertyNames(properties), getPropertyIndex(
										selectedProperty, properties));
						PropertySelector.this
								.notifyPropertySelection(selectedProperty, selectedId);
					} // if

			} // widgetSelected

		} // SelectionAdapter
				);
		if(!allowPropertySelection)propertiesCombo.setEnabled(false);
		setSimulation(null);
	} // PropertySelector

	void notifyPropertySelection(final ItemPropertyDescriptor selectedProperty, String popid) {
		// Is there a property?
		if (selectedProperty != null) {
			// Yes
			firePropertySelectionEvent(new PropertySelectionEvent(
					selectedDecorator, selectedProperty, this,popid ));
		} // if
	} // notifyPropertySelection

	/**
	 * @return <code>true</code> if the control has been initialized.
	 */
	public boolean isInitialized() {
		return !(decorators == null || decorators.isEmpty());
	} // isInitialized

	/**
	 * @param decorators
	 */
	public void setDecorators(final List<Decorator> decorators) {
		this.decorators = decorators;
		selectedDecorator = decorators.isEmpty() ? null : decorators.get(0);
		initializeCombo(decoratorsCombo, getDecoratorNames(decorators),
				getDecoratorIndex(selectedDecorator, decorators));
		
		List<String> ids = getIdsToDisplay(selectedDecorator);
		if(ids != null) {
			String [] propIds = ids.toArray(new String[]{});
			initializeCombo(popIdsCombo,
					propIds, 0);
		}
		selectedId  = (ids==null)? null:ids.get(0);
		
		properties = getPropertiesToDisplay(selectedDecorator, selectedId);
		selectedProperty = selectCurrentDecoratorProperty(properties);
		initializeCombo(propertiesCombo, getPropertyNames(properties),
				getPropertyIndex(selectedProperty, properties));
		
		notifyPropertySelection(selectedProperty, selectedId);
	} // setDecorators

	/**
	 * Initialize the control from a
	 * {@link org.eclipse.stem.jobs.simulation.Simulation} instance.
	 * 
	 * @param simulation
	 *            the {@link org.eclipse.stem.jobs.simulation.Simulation}
	 */
	public void setSimulation(final ISimulation simulation) {
		this.simulation = simulation;
		setDecorators(getDecoratorsToDisplay(simulation));
	} // setSimulation

	/**
	 * @return the simulation
	 */
	public final ISimulation getSimulation() {
		return simulation;
	}

	/**
	 * @param decoratorFilter
	 *            the filter that determines which {@link Decorator}s will be
	 *            displayed.
	 */
	public void setDecoratorFilter(final DecoratorFilter decoratorFilter) {
		this.decoratorFilter = decoratorFilter;
	} // setDecoratorFilter

	/**
	 * @param propertySieve
	 *            the sieve that selects the properties of a {@link Decorator}
	 *            that should be displayed.
	 */
	public void setPropertySieve(final PropertySieve propertySieve) {
		this.propertySieve = propertySieve;
	} // setPropertySieve

	/**
	 * @param simulation
	 *            the simulation that contains {@link Decorator}s
	 * @return a {@link List} of the {@link Decorator}s whose properties
	 */
	private List<Decorator> getDecoratorsToDisplay(final ISimulation simulation) {
		final List<Decorator> retValue = new ArrayList<Decorator>();

		// Got Simulation?
		if (simulation != null) {
			// Yes
			final Graph canonicalGraph = simulation.getScenario()
					.getCanonicalGraph();
			// Is the canonicalGraph initialized yet?
			if (canonicalGraph != null) {
				// Yes
				// Go through the Decorators keeping the ones that the filter
				// says are ok.
				for (final Object element : canonicalGraph.getDecorators()) {
					final Decorator decorator = (Decorator) element;
					// Acceptable?
					if (decoratorFilter.accept(decorator)) {
						retValue.add(decorator);
					} // if has a title
				} // for each decorator
			} // if got graph
		} // if got simulation
		return retValue;
	} // getDecoratorsToDisplay

	/**
	 * @param decorator
	 *            a {@link Decorator} that modifies the state of the canonical
	 *            {@link Graph} in the
	 *            {@link org.eclipse.stem.jobs.simulation.Simulation}.
	 * @param simulation
	 *            the {@link org.eclipse.stem.jobs.simulation.Simulation}
	 * @return a {@link List} of the properties of the {@link Decorator} that
	 *         can should be displayed.
	 */
	List<ItemPropertyDescriptor> getPropertiesToDisplay(
			final Decorator decorator, final String populationIdentifier) {
		final List<ItemPropertyDescriptor> retValue = new ArrayList<ItemPropertyDescriptor>();
		// Got Decorator?
		if (decorator != null) {
			// Yes
			// Are there any labels to update?
			if (!decorator.getLabelsToUpdate().isEmpty()) {
				// Yes
				if (decorator instanceof DiseaseModel) {
					// Different labels exist for different populations
					retValue.addAll(propertySieve.sieve(((DiseaseModel) decorator)
							.createDiseaseModelLabel(populationIdentifier)));
				} else {
					// The first one is good enough
					retValue.addAll(propertySieve.sieve(decorator
							.getLabelsToUpdate().get(0)));
				}
			} // if labels to update
		} // if got decorator
		return retValue;
	} // getPropertiesToDisplay

	/**
	 * @param decorator
	 *            a {@link Decorator} that modifies the state of the canonical
	 *            {@link Graph} in the
	 *            {@link org.eclipse.stem.jobs.simulation.Simulation}.
	 * @return a {@link List} of the ids, e.g. population ids
	 */
	List<String> getIdsToDisplay(
			final Decorator decorator) {
		if(decorator instanceof DiseaseModel) {
			return ((DiseaseModel)decorator).getAllLabelIdentifiers();
		}
		if(decorator instanceof PopulationModel) {
			return ((PopulationModel)decorator).getAllLabelIdentifiers();
		}
		return null; // none found
	} // getPropertiesToDisplay

	// /**
	// * @param decorators
	// * the {@link Decorators} in the simulation that whose state
	// * values can be visualized.
	// * @return one of the {@link Decorators}
	// */
	// private Decorator selectCurrentDecorator(final List<Decorator>
	// decorators) {
	// return decorators.get(0);
	// } // selectCurrentDecorator

	/**
	 * @param decoratorProperties
	 *            a list of properties
	 * @return the property of the decorator that should be the one to be
	 *         displayed or <code>null</code> if decoratorProperties is empty
	 */
	ItemPropertyDescriptor selectCurrentDecoratorProperty(
			final List<ItemPropertyDescriptor> decoratorProperties) {
		// Look for a property with a name that matches the one specified in
		// the preferences.
		for (final ItemPropertyDescriptor property : decoratorProperties) {
			// name match?
			if (property.getDisplayName(property).equals(initialPropertyName)) {
				// Yes
				return property;
			} // if
		} // for each ItemPropertyDescriptor
		// Didn't find a match, just use the first one.
		// Any to use?
		if (!decoratorProperties.isEmpty()) {
			// Yes
			return decoratorProperties.get(0);
		} // if
		return null;
	} // selectCurrentDecoratorProperty

	/**
	 * @return the {@link Decorator} selected in the control, or
	 *         <code>null</code> if one is not currently selected.
	 */
	// public Decorator getSelectedDecorator() {
	// return selectedDecorator;
	// } // getSelectedDecorator
	//
	// /**
	// * @return the {@link ItemPropertyDescriptor} selected in the control, or
	// * <code>null</code> if one is not currently selected.
	// */
	// public ItemPropertyDescriptor getSelectedProperty() {
	// return selectedDecoratorProperty;
	// } // getSelectedProperty
	//
	// /**
	// * @return a display name of the selected property. This is the key to the
	// * selected relative Value
	// *
	// */
	// public String getSelectedPropertyString() {
	// String retVal = "no property selected";
	// if (selectedDecoratorProperty != null) {
	// retVal = selectedDecoratorProperty
	// .getDisplayName(selectedDecoratorProperty);
	// }
	// return retVal;
	// } // getSelectedProperty
	/**
	 * @param combo
	 * @param names
	 * @param selectionIndex
	 */
	void initializeCombo(final Combo combo, final String[] names,
			final int selectionIndex) {
		combo.setItems(names);
		combo.select(selectionIndex);
	} // initializeCombo

	/**
	 * @param decorators
	 *            a list of {@link Decorator}s
	 * @return an array of the names of the {@link Decorators}.
	 */
	private String[] getDecoratorNames(final List<Decorator> decorators) {
		final List<String> retValue = new ArrayList<String>();
		if (decorators != null) {
			// Yes
			for (final Decorator decorator : decorators) {
				final ComposedAdapterFactory itemProviderFactory = new ComposedAdapterFactory(
						ComposedAdapterFactory.Descriptor.Registry.INSTANCE);

				final IItemLabelProvider lp = (IItemLabelProvider) itemProviderFactory.adapt(
						decorator, IItemLabelProvider.class);
				String title = lp.getText(decorator);
				title = title == null ? "null" : title;
				retValue.add(title);
			} // for each decorator
		} // if
		return retValue.toArray(new String[] {});
	} // getDecoratorNames

	/**
	 * @param selectedDecorator
	 * @param decorators
	 *            a list of {@link Decorator}s.
	 * @return the position (0 origin) of the selectedDecorator in decorators,
	 *         or 0, if the decorators list is empty.
	 */
	private int getDecoratorIndex(final Decorator selectedDecorator,
			final List<Decorator> decorators) {
		if (selectedDecorator != null && decorators != null
				&& !decorators.isEmpty()) {
			// Yes
			return decorators.indexOf(selectedDecorator);
		} // if
		return 0;
	} // getDecoratorIndex

	/**
	 * @param properties
	 *            a list of {@link Decorator} properties.
	 * @return the names of the properties.
	 */
	String[] getPropertyNames(final List<ItemPropertyDescriptor> properties) {
		final List<String> retValue = new ArrayList<String>();
		if (properties != null) {
			// Yes
			for (final ItemPropertyDescriptor property : properties) {
				retValue.add(property.getDisplayName(property));
			} // for each ItemPropertyDescriptor
		} // if
		return retValue.toArray(new String[] {});
	} // getPropertyNames

	/**
	 * @param selectedDecoratorProperty
	 * @param decoratorProperties
	 * @return the index of the selectedDecoratorProperty in the
	 *         decoratorProperites list, or 0 if selectedDecoratorProperty is
	 *         <code>null</code>
	 */
	int getPropertyIndex(
			final ItemPropertyDescriptor selectedDecoratorProperty,
			final List<ItemPropertyDescriptor> decoratorProperties) {
		if (selectedDecoratorProperty != null) {
			// Yes
			return decoratorProperties.indexOf(selectedDecoratorProperty);
		} // if
		return 0;
	} // getPropertyIndex

	/**
	 * This method may be used to initialize a properties combo to display
	 * (select) a particular property
	 * 
	 * @param preferredProperty
	 *            the name of the property to display.
	 * @return <code>true</code> if the preferredProperty was found,
	 *         <code>false</code> otherwise.
	 */
	public boolean setDisplayedProperty(final String preferredProperty) {
		final int index = propertiesCombo.indexOf(preferredProperty);
		if (index >= 0) {
			propertiesCombo.select(index);
			initialPropertyName = preferredProperty;
			properties = getPropertiesToDisplay(selectedDecorator, selectedId);
			for (final ItemPropertyDescriptor property : properties) {
				// name match?
				if (property.getDisplayName(property).equals(
						initialPropertyName)) {
					// Yes
					selectedProperty = property;
					break;
				} // if
			} // for each ItemPropertyDescriptor
			firePropertySelectionEvent(new PropertySelectionEvent(
					selectedDecorator, selectedProperty, propertiesCombo, selectedId));
			return true;
		}// if selector has items
		return false;
	}// setDisplayedPropperty()

	/**
	 * @param listener
	 */
	public void addPropertySelectionListener(
			final PropertySelectionListener listener) {
		propertySelectionListeners.add(listener);
	}

	/**
	 * @param listener
	 */
	public void removePropertySelectionListener(
			final PropertySelectionListener listener) {
		propertySelectionListeners.remove(listener);
	}

	private void firePropertySelectionEvent(final PropertySelectionEvent pse) {
		for (final PropertySelectionListener listener : propertySelectionListeners) {
			listener.propertySelected(pse);
		} // for each PropertySelectionListener
	} // firePropertySelectionEvent

	/**
	 * This interface is implemented by classes that determine if a
	 * {@link Decorator} meets some specified criteria.
	 */
	public interface DecoratorFilter {
		/**
		 * @param decorator
		 * @return <code>true</code> if the {@link Decorator} is acceptable.
		 */
		boolean accept(final Decorator decorator);
	} // DecoratorFilter

	/**
	 * This interface is implemented by classes that select out the properties
	 * to be displayed.
	 */
	public interface PropertySieve {
		/**
		 * @param dynamicLabel
		 *            the label that contains the candidate properties to be
		 *            displayed.
		 * @return a <code>List</code> of the properties that should be
		 *         displayed in the order that they should be displayed.
		 */
		List<ItemPropertyDescriptor> sieve(final DynamicLabel dynamicLabel);
	} // PropertySieve

	/**
	 * This interface is implemented by classes that wish to be notified
	 * whenever a property is selected in this widget.
	 */
	public interface PropertySelectionListener {
		/**
		 * @param propertySelectionEvent
		 */
		void propertySelected(PropertySelectionEvent propertySelectionEvent);
	} // PropertySelectionListener

	/**
	 * This class represents the event of a property being selected in the
	 * widget.
	 */
	public static class PropertySelectionEvent extends EventObject {
		private static final long serialVersionUID = 1L;
		private transient final ItemPropertyDescriptor property;
		private transient final Decorator decorator;
		private transient final String id;
		
		/**
		 * @param decorator
		 *            the {@link Decorator}
		 * @param property
		 *            the property that was selected.
		 * @param source
		 */
		public PropertySelectionEvent(final Decorator decorator,
				final ItemPropertyDescriptor property, final Object source, String id) {
			super(source);
			this.decorator = decorator;
			this.property = property;
			this.id = id;
		}

		/**
		 * @return the decorator
		 */
		public final Decorator getDecorator() {
			return decorator;
		}

		/**
		 * @return the property
		 */
		public final ItemPropertyDescriptor getProperty() {
			return property;
		}

		/**
		 * getId. Get the id (e.g. population id)
		 */
		
		public String getId() {
			return id;
		}
		/**
		 * @see java.util.EventObject#toString()
		 */
		@Override
		public String toString() {
			final StringBuilder sb = new StringBuilder(
					decorator == null ? "null," : decorator.getDublinCore()
							.getTitle());
			sb.append(property == null ? "null" : property
					.getDisplayName(property));
			return sb.toString();
		}
	} // PropertySelectionEvent

	/**
	 * @return the display label
	 */
	public String getDisplayLabel() {
		return displayLabel.getText();
	}

	/**
	 * @param displayLabel
	 *            the label to display above the property selector
	 */
	public void setDisplayLabel(final String displayLabel) {
		this.displayLabel.setText(displayLabel);
	}

} // PropertySelector