/*******************************************************************************
 * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018,2021
 * IBM Corporation, BfR, and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation and new features
 *     Bundesinstitut für Risikobewertung - Pajek Graph interface, new Veterinary Models
 *     Bundesinstitut fur Risikobewertung
 *******************************************************************************/

package org.eclipse.stem.ui.views.graphmap;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.ConcurrentModificationException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
//import java.util.Observable;
//import java.util.Observer;
import java.util.Set;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.EMap;
import org.eclipse.emf.common.util.URI;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.stem.core.graph.DynamicLabel;
import org.eclipse.stem.core.graph.DynamicNodeLabel;
import org.eclipse.stem.core.graph.Edge;
import org.eclipse.stem.core.graph.EdgeLabel;
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.core.model.STEMTime;
import org.eclipse.stem.core.modifier.DoubleModifier;
import org.eclipse.stem.core.modifier.FeatureModifier;
import org.eclipse.stem.core.modifier.Modifier;
import org.eclipse.stem.core.predicate.And;
import org.eclipse.stem.core.predicate.ElapsedTimeTest;
import org.eclipse.stem.core.predicate.Not;
import org.eclipse.stem.core.predicate.Predicate;
import org.eclipse.stem.core.predicate.PredicateExpression;
import org.eclipse.stem.core.trigger.TriggerList;
import org.eclipse.stem.definitions.adapters.spatial.geo.LatLong;
import org.eclipse.stem.definitions.adapters.spatial.geo.LatLong.Segment;
import org.eclipse.stem.definitions.adapters.spatial.geo.LatLongProvider;
import org.eclipse.stem.definitions.adapters.spatial.geo.LatLongProviderAdapter;
import org.eclipse.stem.definitions.adapters.spatial.geo.LatLongProviderAdapterFactory;
import org.eclipse.stem.definitions.edges.MigrationEdge;
import org.eclipse.stem.definitions.edges.MigrationEdgeLabel;
import org.eclipse.stem.definitions.edges.PopulationEdge;
import org.eclipse.stem.diseasemodels.standard.DiseaseModelLabel;
import org.eclipse.stem.geography.centers.GeographicCenters;
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.populationmodels.standard.PopulationModelLabel;
import org.eclipse.stem.ui.adapters.color.ColorProviderAdapter;
import org.eclipse.stem.ui.adapters.color.ColorProviderAdapterFactory;
import org.eclipse.stem.ui.preferences.PreferenceConstants;
import org.eclipse.swt.SWT;
import org.eclipse.swt.SWTException;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.FormAttachment;
import org.eclipse.swt.layout.FormData;
import org.eclipse.swt.layout.FormLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.ui.PlatformUI;

/**
 * This class represents a visualization of the geographic attributes of a
 * {@link org.eclipse.stem.jobs.simulation.org.eclipse.stem.jobs.simulation.Simulation}
 * .
 */
public class GraphMapControl extends Composite implements ISimulationListener,
		GeoViewOptionsBar.PropertySelectionListener {

	private ISimulation simulation;
	private GraphMapCanvas canvas;
	private String selectedEdge;
	private Job refreshJob;
	private boolean refreshPending;
	private StemPolygonList polygonsToDraw;
	private ColorProviderAdapter colorProviderAdapter;
	private GeoViewOptionsBar optionsBar;
	private Map<Decorator, DecoratorDisplayData> decoratorToDecoratorDisplayDataMap;
	private Map<LatLong, StemPolygonList> polygonListMap;
	private GraphMapView view;
	private boolean showOptionsBar;
	private FormData optionsBarFormData;
	private Composite topComposite;
	
	public GraphMapControl(Composite parent, int style, GraphMapView view) {
		super(parent, style);
		this.view = view;
		decoratorToDecoratorDisplayDataMap = new HashMap<Decorator, DecoratorDisplayData>();
		polygonListMap = new HashMap<LatLong, StemPolygonList>();

		canvas = new GraphMapCanvas(this, SWT.NONE, this.view);
		canvas.setColorProvider(colorProviderAdapter);
		canvas.addPaneChangeListener(new PaneChangeListener(this));

		setLayout(new FormLayout());

		topComposite = new Composite(this, SWT.NONE);
		topComposite.setLayout(new FillLayout(SWT.HORIZONTAL));
		canvas.setGainScaleLabel(new Label(topComposite, SWT.RIGHT));

		optionsBar = new GeoViewOptionsBar(this, SWT.NONE, view);  
		optionsBar.addPropertySelectionListener(this);

		FormData topCompositeFormData = new FormData();
		topComposite.setLayoutData(topCompositeFormData);
		topCompositeFormData.top = new FormAttachment(0, 0);
		topCompositeFormData.left = new FormAttachment(0, 0);
		topCompositeFormData.right = new FormAttachment(100, 0);

		FormData geoRendererFormData = new FormData();
		canvas.setLayoutData(geoRendererFormData);
		geoRendererFormData.top = new FormAttachment(topComposite, 0);
		geoRendererFormData.bottom = new FormAttachment(optionsBar, 0);
		geoRendererFormData.left = new FormAttachment(0, 0);
		geoRendererFormData.right = new FormAttachment(100, 0);

		optionsBarFormData = new FormData();
		optionsBar.setLayoutData(optionsBarFormData);
		optionsBarFormData.bottom = new FormAttachment(100, 0);
		optionsBarFormData.left = new FormAttachment(0, 0);
		optionsBarFormData.right = new FormAttachment(100, 0);
		// XXX for now
		this.showOptionsBar = true;
		pack();
	}

	public ISimulation getSimulation() {
		return simulation;
	}

	/**
	 * Setting the {@link org.eclipse.stem.jobs.simulation.Simulation} has the
	 * side-effect of causing the control to remove itself as a listener from
	 * any previously set {@link org.eclipse.stem.jobs.simulation.Simulation}
	 * and adding itself as a listener to the new one. It will also cause the
	 * image to be initialized from the contents of the new
	 * {@link org.eclipse.stem.jobs.simulation.Simulation} as appropriate.
	 * 
	 * @param simulation
	 *            the {@link org.eclipse.stem.jobs.simulation.Simulation} whose
	 *            Lat/Long data will be rendered.
	 */
	public void setSimulation(ISimulation simulation) {
		// Any need to switch?
		if (this.simulation == simulation) {
			// No
			return;
		} // if no need to switch?

		// Should we remove ourselves as listeners from the current simulation?
		if (this.simulation != null) {
			// Yes
			this.simulation.removeSimulationListener(this);
		}

		this.simulation = simulation;

		// Was there a new simulation to switch to?
		if (this.simulation != null) {
			// Yes
			this.simulation.addSimulationListener(this);
			optionsBar.setSimulation(this.simulation);
			setGeoViewProperties();
		}
		refresh();
	}

	public void showOptionsBar(boolean toggle){
		this.showOptionsBar = toggle;
		if (this.showOptionsBar){
			optionsBarFormData.top = null;
			this.layout();
		} else{
			optionsBarFormData.top = new FormAttachment(100,0);
			this.layout();
		}
		redraw();
	}
	/**
	 * Update the contents of {@link #geographicRenderer} from the contents of
	 * the {@link #simulation}. This method should only be called by the UI
	 * thread otherwise it contains a race condition that can lock up the
	 * refreshing of the map canvas.
	 */
	public void refresh() {
		// This is complex and potential confusing code. The basic idea is that
		// we want to determine what to draw on the mapCanvas in a thread
		// separate from the UI thread, but we also want to capture a request to
		// refresh the mapCanvas that comes while a background Job is already
		// running. This request could have been generated because something
		// significant like a decorator or a property has changed and
		// we don't want to lose that switch.
		// We have two fields that capture the state of the refresh. The first
		// is the flag refreshPending which if true indicates that a call to
		// refreshMapCanvas was processed while a background Job was executing.
		// This flag is set instead of creating another background Job. The
		// second is the field refreshJob which is set to the background Job if
		// it is present and running.
		//
		// If we enter the method and refreshPending is true then we immediately
		// exit because a refresh job will be created and there's nothing more
		// for us to request. If, instead, refreshPending is false, then we
		// check to see if a refreshJob is already running. If so, we set
		// refreshPending to true, and exit. If not, we create the background
		// refresh job and assign it to the field refreshJob.
		//
		// In the background refreshing job we process the Lat/Long data and
		// then when done we add a Runnable on to the UI thread to redraw the
		// mapCanvas. That Runnable also checks to see if the refresh pending
		// flag is set and if so, resets the flag and then adds another Runnable
		// to the UI thread to re-enter the refreshMapCanvas method.
		//
		// There is a race condition in the method if called by other than the
		// UI thread. If a thread different from the UI thread were to call this
		// method then it could reach position "RC #2" in the code below and
		// then be preempted. The UI thread could then execute the test at "RC
		// #1" below and find that there is no refresh pending. It would exit
		// and then the other thread would resume at "RC #2" and set the
		// refreshPending flag. This would cause all subsequent method
		// invocations to immediately exit and the map canvas would never be
		// refreshed again.

		if (refreshJob != null) {
			refreshPending = true;
			return;
		}

		refreshJob = new Job(Messages.getString("IMView.MRefresh")) {

			@Override
			protected IStatus run(IProgressMonitor monitor) {
				polygonsToDraw = createPolygonsToDraw(monitor);

				if (polygonsToDraw == null || polygonsToDraw.isEmpty()) {
					return Status.OK_STATUS;
				}

				try {
					if (PlatformUI.isWorkbenchRunning()) {
						Display display = Display.getDefault();

						if (!display.isDisposed()) {
							display.asyncExec(new Runnable() {

								@Override
								public void run() {
									if (!canvas.isDisposed()) {
										canvas.render(polygonsToDraw,
												simulation);
										refreshJob = null;

										if (refreshPending) {
											refreshPending = false;
											refresh();
										}
									} else {
										refreshJob = null;
									}
								}
							});
						}
					}
				} catch (NullPointerException npe) {
					// See 177966:
					// We ignore the exception, there's nothing to do
				} catch (SWTException se) {
					// Sometimes this happens when shutting down STEM with
					// simulations
					// still running. Nothing we can do about it, so just
					// ignore.
				}

				monitor.done();

				return Status.OK_STATUS;
			}
		};
		refreshJob.schedule();
	}

	@Override
	public void simulationChanged(SimulationEvent event) {
		switch (event.getSimulationState()) {
		case COMPLETED_CYCLE:
			// It could be that the propertySelector is not initialized
			// yet. This could happen if, when the simulation is first set, its
			// scenario was not completely initialized, and so didn't have a
			// canonical graph. If this is the case, we need to try again.

			if (!optionsBar.isInitialized()) {
				optionsBar.setSimulation(getSimulation());
			}

			refresh();
			break;
		case RESET:
			refresh();
			break;
		case RUNNING:
		case COMPLETED_SEQUENCE:
		case PAUSED:
		case STOPPED:
		}
	}

	@Override
	public void dispose() {
		super.dispose();
		optionsBar.removePropertySelectionListener(this);

		if (simulation != null) {
			simulation.removeSimulationListener(this);
		}
	}

	public void addSelectionChangedListener(ISelectionChangedListener listener) {
		canvas.addSelectionChangedListener(listener);
	}

	public void removeSelectionChangedListener(
			ISelectionChangedListener listener) {
		canvas.removeSelectionChangedListener(listener);
	}

	public Image getMapCanvasImage() {
		return canvas.getCanvasImage();
	}

	@Override
	public void propertySelected() {
		setGeoViewProperties();
		layout();
		refresh();
	}

	private void setGeoViewProperties() {
		Decorator decorator = optionsBar.getSelectedDecorator();
		if (decorator != null) {
			AdapterFactory adapterFactory = ColorProviderAdapterFactory.INSTANCE
					.getFactoryForType(optionsBar.getSelectedColorProvider());
		
			Adapter adapter = adapterFactory.adapt(decorator.getGraph(), optionsBar.getSelectedColorProvider());
		
			if (adapter instanceof ColorProviderAdapter) {
				colorProviderAdapter = (ColorProviderAdapter) adapter;
				colorProviderAdapter.setSelectedDecorator(optionsBar
						.getSelectedDecorator());
				colorProviderAdapter.setSelectedPopulationIdentifier(optionsBar
						.getSelectedPopulationIdentifier());
				canvas.setColorProvider(colorProviderAdapter);
				selectedEdge = optionsBar.getSelectedEdge();
	
				if (optionsBar.getSelectedProperty() != null) {
					colorProviderAdapter.setSelectedProperty(optionsBar
							.getSelectedProperty());
				}
			}
		}
	}

	/**
	 * This runs in the background {@link Job} created in {@link #refresh()}
	 * 
	 * @param decorator
	 *            the {@link Decorator} for whom that data is being retrieved.
	 * @param monitor
	 *            the progress monitor to use to report the progress of
	 *            obtaining the data
	 * @return the {@link DecoratorDisplayData} for the {@link Decorator}.
	 */
	private DecoratorDisplayData getDecoratorDisplayData(Decorator decorator,
			IProgressMonitor monitor) {
		DecoratorDisplayData retValue = decoratorToDecoratorDisplayDataMap
				.get(decorator);

		// Is there already an instance for this decorator?
		if (retValue == null) {
			retValue = new DecoratorDisplayData();
			decoratorToDecoratorDisplayDataMap.put(decorator, retValue);

			if (decorator instanceof TriggerList) {
				Graph graph = simulation.getScenario().getCanonicalGraph();
//				Node randomNode = null;
//
				for (Node node : graph.getNodes().values()) {
					retValue.addNode(node);
//					randomNode = node;
				}
//				if (randomNode != null) {
//					LatLongProviderAdapter latLongProvider = (LatLongProviderAdapter) LatLongProviderAdapterFactory.INSTANCE
//							.adapt(randomNode, LatLongProvider.class);
//
//					retValue.setLatLongProviderAdapter(latLongProvider);
//				}
			} else {
				if (decorator.getLabelsToUpdate() == null
						|| decorator.getLabelsToUpdate().isEmpty()) {
					return retValue;
				}

//				DynamicNodeLabel firstNodeLabel = (DynamicNodeLabel) decorator
//						.getLabelsToUpdate().get(0);
//				if (firstNodeLabel != null) {
//					Node node = firstNodeLabel.getNode();
//					LatLongProviderAdapter latLongProvider = (LatLongProviderAdapter) LatLongProviderAdapterFactory.INSTANCE
//							.adapt(node, LatLongProvider.class);
//
//					retValue.setLatLongProviderAdapter(latLongProvider);
//				}

				for (DynamicLabel label : decorator.getLabelsToUpdate()) {
					retValue.addNode(((DynamicNodeLabel) label).getNode());
				}
			}
		}

		// Does the instance have all of it's lat/long data retrieved yet?
		if (!retValue.hasAllLatLong()) {
			monitor.subTask(decorator.getDublinCore().getTitle());
			retValue.updateLatLong(monitor);
		}

		return retValue;
	}

	/**
	 * This runs in the background {@link Job} created in
	 * {@link #refreshMapCanvas()}.
	 * 
	 * @param monitor
	 *            progress monitor for obtaining the polygons
	 * @return a collection of polygon values to render in the
	 *         {@link #mapCanvas}
	 */
	private StemPolygonList createPolygonsToDraw(IProgressMonitor monitor) {
		Decorator selectedDecorator = optionsBar.getSelectedDecorator();
		String selectedPopulationIdentifier = optionsBar
				.getSelectedPopulationIdentifier();
		StemPolygonList retValue = new StemPolygonList();

		if (selectedDecorator == null) {
			return null;
		}

		DecoratorDisplayData displayData = getDecoratorDisplayData(
				selectedDecorator, monitor);

		if (displayData == null) {
			return null;
		}

		monitor.beginTask(selectedDecorator.getDublinCore().getTitle(),
				displayData.getNodeData().size());

		if (selectedDecorator instanceof TriggerList) {
			Map<URI, Double> nodeValues = getMigrationNodeValues();

			for (Map.Entry<Node, LatLong> labelData : displayData.getNodeData()
					.entrySet()) {
				// This is the Identifiable that will produce the lat/long data.
				Node node = labelData.getKey();
				LatLong latLong = labelData.getValue();

				monitor.subTask(node.getDublinCore().getTitle());

				if (latLong != null && latLong.size() > 0) {
					StemPolygonList stemPolygonsList = polygonListMap
							.get(latLong);
					Double value = nodeValues.get(node.getURI());

					if (stemPolygonsList == null) {
						stemPolygonsList = new StemPolygonList(latLong, node);
						polygonListMap.put(latLong, stemPolygonsList);
					}

					if (value != null) {
						stemPolygonsList.setValueToDisplay(value);
					} else {
						stemPolygonsList.setValueToDisplay(0.0);
					}

					retValue.addAll(stemPolygonsList);
				}

				monitor.worked(1);
			}
		} else {
			for (Map.Entry<Node, LatLong> labelData : displayData.getNodeData()
					.entrySet()) {
				// This is the Identifiable that will produce the lat/long data.
				Node node = labelData.getKey();
				LatLong latLong = labelData.getValue();

				boolean foundLabel = false;

				boolean success=true;
				do {
					success = true;
					try {
						for (NodeLabel lab : labelData.getKey().getLabels()) {
							if (lab instanceof DiseaseModelLabel
									&& ((DiseaseModelLabel) lab)
											.getPopulationModelLabel()
											.getPopulationIdentifier()
											.equals(selectedPopulationIdentifier)) {
								foundLabel = true;
								break;
							} else if (lab instanceof PopulationModelLabel
									&& ((PopulationModelLabel) lab)
											.getPopulationIdentifier().equals(
													selectedPopulationIdentifier)) {
								foundLabel = true;
								break;
							}
						}
					} catch(ConcurrentModificationException cme) { // Occational occurence. Retry if it happens
						success = false;
					}
				} while(!success);
				
				if (!foundLabel) {
					continue;
				}

				monitor.subTask(node.getDublinCore().getTitle());

				if (latLong != null && latLong.size() > 0) {
					StemPolygonList stemPolygonsList = polygonListMap
							.get(latLong);

					if (stemPolygonsList == null) {
						stemPolygonsList = new StemPolygonList(latLong, node);
						polygonListMap.put(latLong, stemPolygonsList);
					}

					stemPolygonsList.setValueToDisplay(Double.NaN);
					retValue.addAll(stemPolygonsList);
				}

				monitor.worked(1);
			}
		}

		if (selectedEdge == null) {
			return retValue;
		}

		Map<URI, Double> edgeValues = null;
		String selectedEdgeCopy = selectedEdge;

		if (selectedEdge.startsWith("triggered")) {
			selectedEdgeCopy = selectedEdge.replaceFirst("triggered", "");
			edgeValues = getMigrationEdgeValues(false);
		} else if (selectedEdge.startsWith("history")) {
			selectedEdgeCopy = selectedEdge.replaceFirst("history", "");
			edgeValues = getMigrationEdgeValues(true);
		}

		EMap<URI, Edge> allEdges = selectedDecorator.getGraph().getEdges();
		List<Edge> edges = new ArrayList<Edge>();

		for (URI uri : allEdges.keySet()) {
			if (uri.toString().startsWith(selectedEdgeCopy)) {
				Edge edge = allEdges.get(uri);

				if (edge instanceof PopulationEdge) {
					String popID = ((PopulationEdge) edge)
							.getPopulationIdentifier();

					if (selectedPopulationIdentifier.equals(popID)) {
						edges.add(edge);
					}
				} else {
					edges.add(edge);
				}
			}
		}

		if (edges.isEmpty()) {
			return retValue;
		}

		Set<URI> addedEdges = new HashSet<URI>();

		for (Edge nextEdge : edges) {
			Node nodeA = nextEdge.getA();
			Node nodeB = nextEdge.getB();

			if (nodeA == null || nodeB == null) {
				// It is possible that edges for air transport has a missing
				// node if sub model is not included in the scenario.
				continue;
			}

			String nodeAISOKey = nodeA.getURI().lastSegment();
			String nodeBISOKey = nodeB.getURI().lastSegment();
			double[] centerA = GeographicCenters.getCenter(nodeAISOKey);
			double[] centerB = GeographicCenters.getCenter(nodeBISOKey);

			if (centerA == null) {
				LatLongProviderAdapter latLongProviderA = (LatLongProviderAdapter) LatLongProviderAdapterFactory.INSTANCE
						.adapt(nodeA, LatLongProvider.class);

				//latLongProviderA.setTarget(nodeA);
				centerA = latLongProviderA.getCenter();
			}

			if (centerB == null) {
				LatLongProviderAdapter latLongProviderB = (LatLongProviderAdapter) LatLongProviderAdapterFactory.INSTANCE
						.adapt(nodeB, LatLongProvider.class);

				//latLongProviderB.setTarget(nodeB);
				centerB = latLongProviderB.getCenter();
			}

			if (centerA == null || centerB == null) {
				continue;
			}

			if (!addedEdges.contains(nextEdge.getURI())) {
				Segment edgeSegment = new Segment(new double[][] { centerA,
						centerB });
				StemPolygon stemPolygon = new StemPolygon(edgeSegment, nextEdge);

				if (edgeValues == null) {
					stemPolygon.setValueToDisplay(Double.NaN);
					retValue.add(stemPolygon);
					addedEdges.add(nextEdge.getURI());
				} else {
					Double value = edgeValues.get(nextEdge.getURI());

					if (value != null) {
						stemPolygon.setValueToDisplay(value);
						retValue.add(stemPolygon);
						addedEdges.add(nextEdge.getURI());
					}
				}
			}
		}

		return retValue;
	}

	private Map<URI, Double> getMigrationNodeValues() {
		EMap<URI, Edge> edges = simulation.getScenario().getCanonicalGraph()
				.getEdges();
		Map<URI, Double> edgeValues = getMigrationEdgeValues(true);
		Map<URI, Double> nodeValues = new HashMap<URI, Double>();

		for (URI edgeURI : edgeValues.keySet()) {
			double value = edgeValues.get(edgeURI);
			MigrationEdge edge = (MigrationEdge) edges.get(edgeURI);
			URI nodeURI = edge.getNodeBURI();
			Double oldValue = nodeValues.get(nodeURI);

			if (oldValue == null) {
				nodeValues.put(nodeURI, value);
			} else {
				nodeValues.put(nodeURI, oldValue + value);
			}
		}

		return nodeValues;
	}

	private Map<URI, Double> getMigrationEdgeValues(boolean history) {
		EMap<URI, Edge> edges = simulation.getScenario().getCanonicalGraph()
				.getEdges();
		Map<URI, EdgeLabel> edgeLabels = new HashMap<URI, EdgeLabel>();
		Map<URI, Double> edgeValues = new HashMap<URI, Double>();

		for (Edge edge : edges.values()) {
			EdgeLabel edgeLabel = edge.getLabel();

			edgeLabels.put(edgeLabel.getURI(), edgeLabel);
		}

		for (Decorator deco : simulation.getScenario().getScenarioDecorators()) {
			if (!(deco instanceof TriggerList)) {
				continue;
			}

			TriggerList triggerList = (TriggerList) deco;

			for (int i = 0; i < triggerList.getPredicateList().size(); i++) {
				Predicate predicate = triggerList.getPredicateList().get(i);
				Decorator action = triggerList.getActionList().get(i);
				Interval interval = getTimeInterval(predicate);
				long time = simulation.getScenario().getSequencer()
						.getCurrentTime().getTime().getTime();

				if (interval == null) {
					continue;
				}

				if (history && time < interval.startTime) {
					continue;
				} else if (!history
						&& (time < interval.startTime || time > interval.endTime)) {
					continue;
				}

				if (!(action instanceof Modifier)) {
					continue;
				}

				Modifier modifier = (Modifier) action;
				EdgeLabel label = edgeLabels.get(modifier.getTargetURI());

				if (label == null || !(label instanceof MigrationEdgeLabel)) {
					continue;
				}

				MigrationEdgeLabel migrationLabel = (MigrationEdgeLabel) label;

				for (FeatureModifier fm : modifier.getFeatureModifiers()) {
					if (!fm.getFeatureName().equals("migrationRate")) {
						continue;
					}

					double value = ((DoubleModifier) fm).getValue();
					URI edgeURI = migrationLabel
							.getURIOfIdentifiableToBeLabeled();
					Double oldValue = edgeValues.get(edgeURI);

					if (oldValue == null) {
						edgeValues.put(edgeURI, value);
					} else {
						edgeValues.put(edgeURI, oldValue + value);
					}
				}
			}
		}

		return edgeValues;
	}

	private Interval getTimeInterval(Predicate predicate) {
		if (!(predicate instanceof PredicateExpression)) {
			return null;
		}

		Predicate and = ((PredicateExpression) predicate).getPredicate();

		if (!(and instanceof And)) {
			return null;
		}

		EList<Predicate> operands = ((And) and).getOperands();

		if (operands.size() != 2) {
			return null;
		}

		ElapsedTimeTest timeTest1 = null;
		Not not = null;

		if (operands.get(0) instanceof ElapsedTimeTest
				&& operands.get(1) instanceof Not) {
			timeTest1 = (ElapsedTimeTest) operands.get(0);
			not = (Not) operands.get(1);
		} else if (operands.get(1) instanceof ElapsedTimeTest
				&& operands.get(0) instanceof Not) {
			timeTest1 = (ElapsedTimeTest) operands.get(1);
			not = (Not) operands.get(0);
		} else {
			return null;
		}

		if (!(not.getOperand() instanceof ElapsedTimeTest)) {
			return null;
		}

		ElapsedTimeTest timeTest2 = (ElapsedTimeTest) not.getOperand();
		long millis1 = timeTest1.getReferenceTime().getTime().getTime()
				+ timeTest1.getNumberofDays()
				* STEMTime.Units.DAY.getMilliseconds();
		long millis2 = timeTest2.getReferenceTime().getTime().getTime()
				+ timeTest2.getNumberofDays()
				* STEMTime.Units.DAY.getMilliseconds();

		return new Interval(millis1, millis2);
	}

	private class Interval {

		public long startTime;
		public long endTime;

		public Interval(long startTime, long endTime) {
			this.startTime = startTime;
			this.endTime = endTime;
		}

	}

	private class PaneChangeListener implements PropertyChangeListener {
		GraphMapControl thiss;
		
		public PaneChangeListener(GraphMapControl ctrl) {
			this.thiss = ctrl;
		}

		public void propertyChange(PropertyChangeEvent evt) {
			
			  double[] mapScale =  (double[]) evt.getNewValue();
			  double scaleX = mapScale[0];
			  double relTransX = mapScale[1];
			  double relTransY = mapScale[2];
			  int viewId = GraphMapRegistry.getInstance().getViewId(thiss.view); 
			  GraphMapPreferences prefs = GraphMapPreferences.getInstance();
			  prefs.updatePreferenceState(viewId, thiss.getSimulation(),
			  PreferenceConstants.GRAPHMAP_PERSISTANT_VIEW_TRANS_X, relTransX);
			  prefs.updatePreferenceState(viewId, thiss.getSimulation(),
			  PreferenceConstants.GRAPHMAP_PERSISTANT_VIEW_TRANS_Y, relTransY);
			  prefs.updatePreferenceState(viewId, thiss.getSimulation(),
			  PreferenceConstants.GRAPHMAP_PERSISTANT_VIEW_SCALE_FACTOR,scaleX);
			 
		}

		

		// update method commented out since use of Observable has deprecated in Java 11
		/*
		 * @Override public void update(Observable o, Object arg) { PaneChangeEvent e =
		 * (PaneChangeEvent) arg; int viewId =
		 * GraphMapRegistry.getInstance().getViewId(thiss.view); GraphMapPreferences
		 * prefs = GraphMapPreferences.getInstance();
		 * prefs.updatePreferenceState(viewId, thiss.getSimulation(),
		 * PreferenceConstants.GRAPHMAP_PERSISTANT_VIEW_TRANS_X, e.getTranformationX());
		 * prefs.updatePreferenceState(viewId, thiss.getSimulation(),
		 * PreferenceConstants.GRAPHMAP_PERSISTANT_VIEW_TRANS_Y, e.getTranformationY());
		 * prefs.updatePreferenceState(viewId, thiss.getSimulation(),
		 * PreferenceConstants.GRAPHMAP_PERSISTANT_VIEW_SCALE_FACTOR,
		 * e.getScaleFactor()); }
		 */
		 

		

	    
		
	}
}