// RelativeValueHistoryPlotter.java
package org.eclipse.stem.ui.reports.views;

/*******************************************************************************
 * 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.Collections;
import java.util.HashMap;
import java.util.List;

import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
import org.eclipse.stem.core.common.Identifiable;
import org.eclipse.stem.core.graph.DynamicLabel;
import org.eclipse.stem.core.graph.DynamicNodeLabel;
import org.eclipse.stem.core.graph.Graph;
import org.eclipse.stem.core.graph.Node;
import org.eclipse.stem.core.graph.NodeLabel;
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.definitions.adapters.relativevalue.history.RelativeValueHistoryExtendedListener;
import org.eclipse.stem.definitions.adapters.relativevalue.history.RelativeValueHistoryProvider;
import org.eclipse.stem.definitions.adapters.relativevalue.history.RelativeValueHistoryProviderAdapter;
import org.eclipse.stem.definitions.adapters.relativevalue.history.RelativeValueHistoryProviderAdapterFactory;
import org.eclipse.stem.diseasemodels.standard.DiseaseModel;
import org.eclipse.stem.diseasemodels.standard.DiseaseModelLabel;
import org.eclipse.stem.jobs.simulation.ISimulation;
import org.eclipse.stem.jobs.simulation.ISimulationListener;
import org.eclipse.stem.jobs.simulation.SimulationEvent;
import org.eclipse.stem.jobs.simulation.SimulationManager;
import org.eclipse.stem.jobs.simulation.SimulationState;
import org.eclipse.stem.populationmodels.standard.StandardPopulationModelLabel;
import org.eclipse.stem.ui.widgets.DecoratorSelector;
import org.eclipse.stem.ui.widgets.DecoratorSelector.DecoratorSelectionEvent;
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.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;

/**
 * This class is a SWT GUI component that uses BIRT to plot
 */
public class RelativeValueHistoryPlotter extends ReportControl implements
		RelativeValueHistoryExtendedListener, ISimulationListener {

	TimeSeriesCanvas timeSeriesCanvas;
	DecoratorSelector decoratorSelector;
	List<IItemPropertyDescriptor> selectedProperties;

	boolean plotUpdateScheduled = false;
	
	/**
	 * 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 sieve selects all of those properties that have relative values.
	 */
	private final PropertySieve propertySieve = new PropertySieve() {
		/**
		 * @see org.eclipse.stem.ui.widgets.DecoratorSelector.PropertySieve#sieve(org.eclipse.stem.core.graph.DynamicLabel)
		 */
		public List<ItemPropertyDescriptor> sieve(
				final 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
	 */
	public RelativeValueHistoryPlotter(final Composite parent) {
		super(parent, SWT.None);
		createContents();
	} // RelativeValueHistoryPlotter

	/**
	 * Create the contents of the plotter
	 */
	private void createContents() {
		setLayout(new FormLayout());

		identifiableTitle = new Label(this, SWT.NONE);
		timeSeriesCanvas = new TimeSeriesCanvas(this);
		decoratorSelector = new DecoratorSelector(this, SWT.NONE, true);

		removeButton = new Button(this, SWT.NONE);
		removeButton.setText(REMOVE_TEXT);

		final FormData titleFormData = new FormData();
		identifiableTitle.setLayoutData(titleFormData);
		titleFormData.top = new FormAttachment(0, 0);
		titleFormData.left = new FormAttachment(0, 0);
		titleFormData.right = new FormAttachment(100, 0);

		final FormData chartFormData = new FormData();
		timeSeriesCanvas.setLayoutData(chartFormData);
		chartFormData.top = new FormAttachment(identifiableTitle, 0);
		chartFormData.bottom = new FormAttachment(decoratorSelector, 0);
		chartFormData.left = new FormAttachment(0, 0);
		chartFormData.right = new FormAttachment(100, 0);

		// Property Selector
		final FormData decoratorSelectorFormData = new FormData();
		// decoratorSelectorFormData.top = new FormAttachment(timeSeriesCanvas,
		// 0);
		decoratorSelectorFormData.bottom = new FormAttachment(100, 0);
		decoratorSelectorFormData.left = new FormAttachment(0, 0);
		decoratorSelectorFormData.right = new FormAttachment(30, 0);
		decoratorSelector.setLayoutData(decoratorSelectorFormData);

		// RemoveButton
		final FormData removeButtonFormData = new FormData();
		// decoratorSelectorFormDataX.top = new FormAttachment(decoratorSelectorY,
		// 0);
		removeButtonFormData.bottom = new FormAttachment(100, 0);
		removeButtonFormData.left = new FormAttachment(decoratorSelector, 0);
		removeButtonFormData.right = new FormAttachment(60, 0);
		removeButton.setLayoutData(removeButtonFormData);

		decoratorSelector
				.addDecoratorSelectionListener(new DecoratorSelector.DecoratorSelectionListener() {

					/**
					 * @see org.eclipse.stem.ui.widgets.DecoratorSelector.PropertySelectionListener#propertySelected(org.eclipse.stem.ui.widgets.DecoratorSelector.PropertySelectionEvent)
					 */
					public void decoratorSelected(
							final DecoratorSelectionEvent decoratorSelectionEvent) {
						selectedDecorator = decoratorSelectionEvent
								.getDecorator();
						if(selectedDecorator!=null) {
							synchronized(timeSeriesCanvas) {
								
								String selectedPopId = decoratorSelectionEvent.getId();
								List<DynamicLabel>allLabels = decoratorToLabelsMap.get(selectedDecorator);
								if(allLabels != null) 
									for(DynamicLabel lab:allLabels) {
									if(lab instanceof DiseaseModelLabel && ((DiseaseModelLabel)lab).getPopulationModelLabel().getPopulationIdentifier().equals(selectedPopId)) {
										selectedDynamicLabel = lab;
										break;
									}
									if(lab instanceof StandardPopulationModelLabel && ((StandardPopulationModelLabel)lab).getPopulationIdentifier().equals(selectedPopId)) {
										selectedDynamicLabel = lab;
										break;
									}
								}
								// This will also remove the old rvhp as a listener
								if(selectedDynamicLabel != null)
									switchToRVHP((RelativeValueHistoryProviderAdapter) RelativeValueHistoryProviderAdapterFactory.INSTANCE
										.adapt(selectedDynamicLabel,
												RelativeValueHistoryProvider.class));
								selectedProperties = getPropertiesToDisplay(selectedDecorator, selectedPopId);
								timeSeriesCanvas.setDataSourceAndRedraw(rvhp, selectedProperties);
							}
						}// if decorator not null
					}
				});

		removeButton.addSelectionListener(new SelectionAdapter() {
			@Override
			public void widgetSelected(
					@SuppressWarnings("unused") final SelectionEvent e) {
				fireRemoveEvent(identifiable);
				remove();
			}
		});

	} // createContents

	/**
	 * to remove the control e.g. by a remove button event
	 */
	@Override
	@SuppressWarnings("cast")
	public void remove() {
		removeListeners.clear();
		switchToRVHP(null);
		relativeValueHistoryExtended(null);
		identifiableTitle.setText("");
		decoratorSelector
				.setDecorators((List<Decorator>) Collections.EMPTY_LIST);
		dispose();
	}

	/**
	 * @param identifiable
	 *            the {@link Identifiable} to be the source of the data to be
	 *            plotted.
	 */
	@Override
	public void setIdentifiable(final Identifiable identifiable) {

		// Same Identifiable?
		if (this.identifiable == identifiable) {
			// Yes
			return;
		} // if

		this.identifiable = identifiable;

		final List<Decorator> decorators = new ArrayList<Decorator>();
		decoratorToLabelsMap = new HashMap<Decorator, List<DynamicLabel>>();

		identifiableTitle.setText(identifiable.getDublinCore().getTitle());
		// Get the dynamic labels associated with this Identifiable
		// A node?
		if (identifiable instanceof Node) {
			// Yes
			final Node node = (Node) identifiable;
			for (final NodeLabel nodeLabel : node.getLabels()) {
				// Updated by a decorator?
				if (nodeLabel instanceof DynamicNodeLabel) {
					// Yes
					final DynamicNodeLabel dynamicNodeLabel = (DynamicNodeLabel) nodeLabel;
					// Can it provide relative values?
					final RelativeValueHistoryProviderAdapter rvhp = (RelativeValueHistoryProviderAdapter) RelativeValueHistoryProviderAdapterFactory.INSTANCE
							.adapt(nodeLabel, RelativeValueHistoryProvider.class);
					if (rvhp != null) {
						// Yes
						final Decorator decorator = dynamicNodeLabel
								.getDecorator();
						
						if(decorator != null) {
							if(decoratorToLabelsMap.get(decorator)!=null) {
								List<DynamicLabel>list = decoratorToLabelsMap.get(decorator);
								list.add(dynamicNodeLabel);
							} else {
								ArrayList<DynamicLabel>newList = new ArrayList<DynamicLabel>();
								newList.add(dynamicNodeLabel);
								decoratorToLabelsMap.put(decorator, newList);
							}
							if (!decorators.contains(decorator)) {
								decorators.add(decorator);
							}
						}
					} // if
				} // if DynamicNodeLabel
			} // for each NodeLabel

			// Are there any Decorators that we'll plot?
			if (decorators.size() > 0) {
				// Yes
				// We need to listen to the life-cycle of the Simulation
				// associated with the Graph that contains the Identifable that
				// was passed in. When it disappears, we need to "un-hook"
				// ourselves from the RelativeValueHistoryProviderAdapter
				// instance so that the Graph that it is attached to can be
				// garbage collected and we need to reset ourselves so that we
				// don't display a plot for a Simulation that doesn't exist any
				// more.
				final ISimulation newSimulation = SimulationManager
						.getManager().mapGraphToSimulation(getGraph(node));

				// Stop listening to the old one?
				if (simulation != null) {
					// Yes
					simulation.removeSimulationListener(this);
				} // if
				simulation = newSimulation;

				// Listen to the new one?
				if (simulation != null) {
					// Yes
					simulation.addSimulationListener(this);
				} // if
			} // if any Decorators to plot

		} // if Node
		decoratorSelector.setDecorators(decorators);
	} // setIdentifiable

	

	
	/**
	 * @see org.eclipse.stem.definitions.adapters.relativevalue.history.RelativeValueHistoryExtendedListener#relativeValueHistoryExtended(org.eclipse.stem.definitions.adapters.relativevalue.history.RelativeValueHistoryProviderAdapter)
	 */
	public void relativeValueHistoryExtended(
			final RelativeValueHistoryProviderAdapter rvhp) {
		// The event notification doesn't come from the UI thread so we need to
		// add a Runnable to the UI thread's execution queue to give the new
		// source to the chart
		
		// If a plot update is already scheduled, then don't add another to the queue
		if (plotUpdateScheduled) {
			return;
		}
		final Display display = Display.getDefault();
		if (!display.isDisposed()) {
			// Yes
			try {
				plotUpdateScheduled = true;
				display.asyncExec(new Runnable() {
					public void run() {
						try {
							if (!timeSeriesCanvas.isDisposed()) {
								synchronized(timeSeriesCanvas) {
									timeSeriesCanvas.draw();
								}
							}
						} finally {
							plotUpdateScheduled = false;
						}
					} // run
				}); // display.asyncExec
			} // try
			catch (final Exception e) {
				// Ignore there could be a race condition with the display being
				// disposed when the system is shut down with a running
				// simulation.
			} // catch Exception
		} // if
	} // relativeValueHistoryExtended

	/**
	 * Initialize the control from a
	 * {@link org.eclipse.stem.jobs.simulation.Simulation} instance.
	 * 
	 * @param simulation
	 *            the {@link org.eclipse.stem.jobs.simulation.Simulation}
	 *            whose state will be visualized in the control.
	 */
	@Override
	protected void initializeFromSimulation(final ISimulation simulation) {
		simulationNameLabel.setText(simulation.getName());
		decoratorSelector.setSimulation(simulation);

	} // initializeFromSimulation

	/**
	 * 
	 */
	@Override
	public void refresh2() {
		// nothing
	} // refresh2

	/**
	 * @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<IItemPropertyDescriptor> getPropertiesToDisplay(
			final Decorator decorator, final String populationIdentifier) {
		final List<IItemPropertyDescriptor> retValue = new ArrayList<IItemPropertyDescriptor>();
		// 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

	private Graph getGraph(final Node node) {
		return (Graph) node.eContainer().eContainer();
	} // getGraph

	/**
	 * @see org.eclipse.stem.jobs.simulation.ISimulationListener#simulationChanged(org.eclipse.stem.jobs.simulation.SimulationEvent)
	 */
	@SuppressWarnings("cast")
	public void simulationChanged(final SimulationEvent event) {
		if (event.getSimulationState() == SimulationState.RESET) {
			// Yes
			timeSeriesCanvas.resetData();
		} // if
		// Is the Simulation stopping (i.e. being deleted?)
		if (event.getSimulationState() == SimulationState.STOPPED) {
			// Yes
			if(simulation !=null) {
				simulation.removeSimulationListener(this);
				simulation = null;
				switchToRVHP(null);
				relativeValueHistoryExtended(null);
				identifiableTitle.setText("");
				decoratorSelector.setDecorators((List<Decorator>) Collections.EMPTY_LIST);
			} 
			
		} // if

	} // simulationChanged

	/**
	 * @see org.eclipse.swt.widgets.Widget#dispose()
	 */
	@Override
	public void dispose() {
		super.dispose();
		if (this.rvhp != null) {
			// Yes
			rvhp.removeExtensionListener(this);
		} // if
		if (simulation != null) {
			// Yes
			simulation.removeSimulationListener(this);
		} // if
	} // dispose

	/**
	 * @see org.eclipse.stem.ui.reports.views.ReportControl#getIdentifiable()
	 */
	@Override
	public Identifiable getIdentifiable() {
		return identifiable;
	}
	
	/**
	 * This Control is associated with an Identifiable
	 * @see org.eclipse.stem.ui.reports.views.ReportControl#getControlType()
	 */
	public String getControlType() {
		return ReportControlFactory.IDENTIFABLE_TYPE;
	}

} // RelativeValueHistoryPlotter