/*
    * Copyright (c) 2006 Stiftung Deutsches Elektronen-Synchroton,
    * Member of the Helmholtz Association, (DESY), HAMBURG, GERMANY.
    *
    * THIS SOFTWARE IS PROVIDED UNDER THIS LICENSE ON AN "../AS IS" BASIS.
    * WITHOUT WARRANTY OF ANY KIND, EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED
    * TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR PARTICULAR PURPOSE AND
    * NON-INFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
    * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
   * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
   * THE USE OR OTHER DEALINGS IN THE SOFTWARE. SHOULD THE SOFTWARE PROVE DEFECTIVE
   * IN ANY RESPECT, THE USER ASSUMES THE COST OF ANY NECESSARY SERVICING, REPAIR OR
   * CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE.
   * NO USE OF ANY SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.
   * DESY HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
   * OR MODIFICATIONS.
   * THE FULL LICENSE SPECIFYING FOR THE SOFTWARE THE REDISTRIBUTION, MODIFICATION,
   * USAGE AND OTHER RIGHTS AND OBLIGATIONS IS INCLUDED WITH THE DISTRIBUTION OF THIS
   * PROJECT IN THE FILE LICENSE.HTML. IF THE LICENSE IS NOT INCLUDED YOU MAY FIND A COPY
   * AT HTTP://WWW.DESY.DE/LEGAL/LICENSE.HTM
   */
  
  package de.desy.acop.displayers;
  
  import java.beans.PropertyVetoException;
  import java.util.ArrayList;
  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.ThreadPoolExecutor;
  import java.util.concurrent.TimeUnit;
  
  import com.cosylab.gui.displayers.DataConsumer;
  import com.cosylab.gui.displayers.DataSource;
  import com.cosylab.util.CommonException;
  
  import de.desy.acop.chart.AcopGraphStyleEnum;
  import de.desy.acop.displayers.chart.AcopChartConsumer;
  import de.desy.acop.displayers.chart.AcopTrendChartConsumer;
  import de.desy.acop.displayers.chart.HistoryParameters;
  import de.desy.acop.displayers.chart.THistoryConnector;
  import de.desy.acop.displayers.tools.AcopTrendChartEvent;
  import de.desy.acop.displayers.tools.AcopTrendChartListener;
  import de.desy.acop.displayers.tools.AcopGraphParameters;
  import de.desy.acop.displayers.tools.AcopGraphHistoryParameters;
  import de.desy.acop.displayers.tools.DismissableBlockingQueue;
  import de.desy.acop.transport.ConnectionParameters;
  
  /**
   * <code>AcopTrendChart</code> is a wrapper for the <code>Acop</code> which can
   * show multiple trends in a single chart.
   * 
   * @author <a href="mailto:jaka.bobnar@cosylab.com">Jaka Bobnar</a>
   * @version $Id: Templates.xml,v 1.10 2004/01/13 16:17:13 jbobnar Exp $
   *
   */
  public class AcopTrendChart extends AcopChartReorg {
  	
  	private static final long serialVersionUID = 1L;
  
  	public static final String TIME_SPAN = "timeSpan";
  	public static final String AUTOSCALE_TO_LIVE_DATA = "autoScaleToLiveData";
  	public static final String CHECK_FOR_BAD_DATA = "checkForBadData";
  	public static final String TIMEOUT = "timeout";
  	
  	private boolean scaleInitialized = false;
  	private boolean autoScaleToLiveData = true;
  	private double loadedHistoryStart;
  	private double loadedHistoryStop;
  //	private boolean loading = false;
  	private boolean normalized = false;
  	private THistoryConnector tHistoryConnector;
  	private ExecutorService executorService;
  	private ArrayList<AcopTrendChartListener> acopTrendChartListeners = new ArrayList<AcopTrendChartListener>();
  	
  	/**
  	 * Constructs a new AcopTrendChart.
  	 *
  	 */
  	public AcopTrendChart() {
  		super();
  		getAcop().setGraphStyle(AcopGraphStyleEnum.TimeLin.ordinal());
  	}
  	
  	/**
  	 * Returns the {@link THistoryConnector}.
  	 * 
  	 * @return the connector
  	 */
  	public THistoryConnector getTHistoryConnector() {
  		if (tHistoryConnector == null) {
  			tHistoryConnector = new THistoryConnector();
  		}
  		return tHistoryConnector;
  	}
  	
  	/**
  	 * Returns the single thread executor service.
  	 * @return
  	 */
  	public ExecutorService getExecutorService() {
 		if (executorService == null) {
 			executorService = new ThreadPoolExecutor(1, 1, 0, TimeUnit.NANOSECONDS,
 		              new DismissableBlockingQueue<Runnable>(1)){
 				@Override
 				protected void afterExecute(Runnable r, Throwable t) {
 					super.afterExecute(r, t);
 					if (t != null) {
 						reportProgress(new AcopTrendChartEvent(AcopTrendChart.this, AcopTrendChartEvent.EventType.ERROR, t));
 					}
 				}
 			};
 		}
 		return executorService;
 	}
 	
 	private void loadHistory() {
 		//why this???
 //		if (getLastTimestamp()-getTimeSpan() < loadedHistoryStart) {
 //			if (loading) {
 //				getExecutorService().shutdownNow();
 //				executorService = null;
 //				loading = false;
 //			}
 //			obtainHistory();
 //		}
 //		else {
 //			loadedHistoryStart = getLastTimestamp()-getTimeSpan();
 //		}
 		obtainHistory();		
 	}
 	
 	private void obtainHistory() {
 		loadedHistoryStart = getLastTimestamp()-getTimeSpan();
 		loadedHistoryStop = getLastTimestamp();
 //		loading = true;
 		getExecutorService().execute(new Runnable() {
 
 			public void run() {
 				double start = loadedHistoryStart;
 				double stop = loadedHistoryStop;
 				boolean reload;
 				double[][] hd;
 				reportProgress(new AcopTrendChartEvent(
 						AcopTrendChart.this,
 						AcopTrendChartEvent.EventType.MULTIPLE_OPERATION_STARTED,
 						"Started loading histories."));
 				for (AcopChartConsumer c : consumersList) {
 					reload = true;
 					if (c instanceof AcopTrendChartConsumer) {
 						HistoryParameters hp = ((AcopTrendChartConsumer) c).getHistoryParameters();
 						if (hp == null) continue;
 						reportProgress(new AcopTrendChartEvent(
 								AcopTrendChart.this,
 								AcopTrendChartEvent.EventType.OPERATION_STARTED,
 								"Started loading history for "+hp,
 								(AcopGraphHistoryParameters) c.getDisplayerParameters()));
 						while (reload) {
 							hd = getTHistoryConnector().loadHistory(hp, start, stop);
 							if (hd == null) {
 								reload = reportError(new AcopTrendChartEvent(
 										AcopTrendChart.this,
 										AcopTrendChartEvent.EventType.ERROR,
 										AcopTrendChartEvent.TIMEOUT,
 										(AcopGraphHistoryParameters) c.getDisplayerParameters()));
 							}
 							else if (hd.length == 0) {
 								reload = reportError(new AcopTrendChartEvent(
 										AcopTrendChart.this,
 										AcopTrendChartEvent.EventType.ERROR,
 										AcopTrendChartEvent.NO_DATA,
 										(AcopGraphHistoryParameters) c.getDisplayerParameters()));
 							}
 							else {
 								reload = false;
 								((AcopTrendChartConsumer) c).loadHistoryData(hd);
 							}
 						}
 						reportProgress(new AcopTrendChartEvent(
 								AcopTrendChart.this,
 								AcopTrendChartEvent.EventType.OPERATION_ENDED,
 								"Finished loading history for "+hp,
 								(AcopGraphHistoryParameters) c.getDisplayerParameters()));
 					}
 				}
 //				loading = false;
 				reportProgress(new AcopTrendChartEvent(
 						AcopTrendChart.this,
 						AcopTrendChartEvent.EventType.MULTIPLE_OPERATION_ENDED,
 						"Finished loading histories."));
 			}});
 	}
 	
 	private void obtainHistory(final AcopTrendChartConsumer c) {
 		final HistoryParameters hp = c.getHistoryParameters();
 		if (hp == null) return;
 		getExecutorService().execute(new Runnable() {
 
 			public void run() {
 				double start = getLastTimestamp()-getTimeSpan();
 				double stop = getLastTimestamp();
 				boolean reload = true;
 				double[][] hd;
 				reportProgress(new AcopTrendChartEvent(
 						AcopTrendChart.this,
 						AcopTrendChartEvent.EventType.OPERATION_STARTED,
 						"Started loading history for "+hp,
 						(AcopGraphHistoryParameters) c.getDisplayerParameters()));
 				while (reload) {
 					hd = getTHistoryConnector().loadHistory(hp, start, stop);
 					if (hd == null) {
 						reload = reportError(new AcopTrendChartEvent(
 								AcopTrendChart.this,
 								AcopTrendChartEvent.EventType.ERROR,
 								AcopTrendChartEvent.TIMEOUT,
 								(AcopGraphHistoryParameters) c.getDisplayerParameters()));
 					}
 					else if (hd.length == 0) {
 						reload = reportError(new AcopTrendChartEvent(
 								AcopTrendChart.this,
 								AcopTrendChartEvent.EventType.ERROR,
 								AcopTrendChartEvent.NO_DATA,
 								(AcopGraphHistoryParameters) c.getDisplayerParameters()));
 					}
 					else {
 						reload = false;
 						c.loadHistoryData(hd);
 					}
 				}
 				reportProgress(new AcopTrendChartEvent(
 						AcopTrendChart.this,
 						AcopTrendChartEvent.EventType.OPERATION_ENDED,
 						"Finished loading history for "+hp,
 						(AcopGraphHistoryParameters) c.getDisplayerParameters()));
 			}});
 	}
 	
 	protected void reportProgress(AcopTrendChartEvent event) {
 		for (AcopTrendChartListener listener : getAcopTrendChartListeners()) {
 			listener.reportProgress(event);
 		}
 	}
 	
 	protected boolean reportError(AcopTrendChartEvent event) {
 		for (AcopTrendChartListener listener : getAcopTrendChartListeners()) {
 			if (listener.reportError(event)) {
 				String operation = (event.getMessage() == null) ? "" : ": "+event.getMessage();
 				AcopTrendChartEvent e = new AcopTrendChartEvent(listener, AcopTrendChartEvent.EventType.PROGRESS, "Operation "+operation+" aborted.");
 				reportProgress(e);
 				return true;
 			}
 		}
 		return false;
 	}
 	
 	/**
 	 * Adds the AcopTrendChartListener. Listener receives notifications
 	 * about the progress and errors during the history loading.
 	 * 
 	 * @param listener listener to be added
 	 */
 	public void addAcopTrendChartListener(AcopTrendChartListener listener) {
 		if (acopTrendChartListeners.contains(listener)) return;
 		acopTrendChartListeners.add(listener);
 	}
 	
 	/**
 	 * Removes the AcopTrendChartListener.
 	 * 
 	 * @param listener listener to be removed
 	 */
 	public void removeAcopTrendChartListener(AcopTrendChartListener listener) {
 		acopTrendChartListeners.remove(listener);
 	}
 	
 	/**
 	 * Returns an array of all AcopTrendChartListeners.
 	 * 
 	 * @return all trend chart listeners
 	 */
 	public AcopTrendChartListener[] getAcopTrendChartListeners() {
 		return acopTrendChartListeners.toArray(new AcopTrendChartListener[acopTrendChartListeners.size()]);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see de.desy.acop.displayers.AcopChartReorg#getConsumer(java.lang.String, java.lang.Class)
 	 */
 	@Override
 	public <D extends DataConsumer> D getConsumer(String name, Class<D> type) {
 		if (type.isAssignableFrom(AcopChartConsumer.class)) {
 			for (AcopChartConsumer c : consumersList) {
 				if (c.getName().equals(name)) return type.cast(c);
 			}
 			
 			DataConsumer[] oldConumers = getConsumers();
 			AcopTrendChartConsumer c= new AcopTrendChartConsumer(this, name);
 			c.setNormalizedData(isNormalizedData());
 			c.setColor(colorManager.pickColor());
 			maxLinkIndex++;
 			consumersList.add(c);
 			firePropertyChange(CONSUMERS, oldConumers, getConsumers());
 			return type.cast(c);
 		}
 		return null;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see de.desy.acop.displayers.AcopChartReorg#addDisplayerParameters(de.desy.acop.displayers.tools.AcopGraphParameters)
 	 */
 	@Override
 	public void addDisplayerParameters(AcopGraphParameters parameters) throws CommonException, PropertyVetoException {
 		super.addDisplayerParameters(parameters);
 		reloadHistory(parameters);
 	}
 	
 	/**
 	 * Reloads the history for selected parameters.
 	 * 
 	 * @param parameters the parameters for which the history should be reloaded.
 	 */
 	public void reloadHistory(AcopGraphParameters parameters) {
 		ConnectionParameters cp = parameters.getConnectionParameters();
 		for (AcopChartConsumer c : consumersList) {
 			if (c instanceof AcopTrendChartConsumer && c.getDisplayerParameters().getConnectionParameters().equals(cp)) {
 				obtainHistory((AcopTrendChartConsumer) c);
 			}
 		}
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see de.desy.acop.displayers.AcopChartReorg#synchronizeGraphParameters(de.desy.acop.displayers.tools.AcopGraphParameters)
 	 */
 	@Override
 	protected AcopGraphParameters synchronizeGraphParameters(AcopGraphParameters parameters) {
 		HistoryParameters hp = null;
 		if (parameters instanceof AcopGraphHistoryParameters) {
 			hp = ((AcopGraphHistoryParameters) parameters).getHistoryParameters();
 		}
 		AcopGraphHistoryParameters trendParameters = new AcopGraphHistoryParameters(super.synchronizeGraphParameters(parameters), hp);
 		return trendParameters;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see de.desy.acop.displayers.AcopChartReorg#updateXScale(de.desy.acop.displayers.chart.AcopChartConsumer)
 	 */
 	@Override
 	public void updateXScale(AcopChartConsumer consumer) {
 		// do nothing (XScale is handled by timeSpan)
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see de.desy.acop.displayers.AcopChartReorg#updateXScaleOnRemove(de.desy.acop.displayers.chart.AcopChartConsumer)
 	 */
 	@Override
 	protected void updateXScaleOnRemove(AcopChartConsumer consumer) {
 		// do nothing (XScale is handled by timeSpan)
 	}
 
 	/**
 	 * Returns the time span for this </code>AcopTrendChart</code>.
 	 * @return the timeSpan
 	 */
 	public double getTimeSpan() {
 		return getXRangeMax() - getXRangeMin();
 	}
 
 	/**
 	 * Sets time span for this </code>AcopTrendChart</code>.
 	 * @param timeSpan the timeSpan to set
 	 */
 	public void setTimeSpan(double timeSpan) {
 		if (getTimeSpan() == timeSpan) return;
 		double oldSpan = getTimeSpan();
 		setXRangeMin(getLastTimestamp() - timeSpan);
 		firePropertyChange(TIME_SPAN, oldSpan, getTimeSpan());
 		loadHistory();
 	}
 
 	/**
 	 * Returns last time stamp for this </code>AcopTrendChart</code>.
 	 * @return the last timestamp
 	 */
 	public double getLastTimestamp() {
 		return getXRangeMax();
 	}
 
 	/**
 	 * Sets last time stamp for this </code>AcopTrendChart</code>. Its value can only
 	 * be increased.
 	 * @param timestamp the timestamp to set
 	 */
 	public void setLastTimestamp(double timestamp) {
 		if (!scaleInitialized) {
 			if (isAutoScaleToLiveData()) {
 				// workaround for Acop.setXMin method: sca[0].usermax = xMin + 0.5 * Math.abs(xMin);
 				setXRangeMax(timestamp+1);
 				setXRangeMin(timestamp);
 				loadedHistoryStart = timestamp;
 			}
 			scaleInitialized = true;
 		}
 		if (getXRangeMax() >= timestamp) return;
 		if (!isAutoScaleToLiveData()) {
 			setXRangeMin(timestamp - getTimeSpan());
 		}
 		setXRangeMax(timestamp);
 	}
 
 	/**
 	 * Returns true if history data is checked for bad data. Bad data is any
 	 * value higher than 1E30.
 	 * 
 	 * @return the checkForBadData 
 	 */
 	public boolean isCheckForBadData() {
 		return getTHistoryConnector().isCheckForBadData();
 	}
 
 	/**
 	 * Enables/disables checking for bad data in the history. Bad data is any
 	 * value higher than 1E30. These values are filtered out if this property is true.
 	 * 
 	 * @param checkForBadData new checkForBadData
 	 */
 	public void setCheckForBadData(boolean checkForBadData) {
 		boolean oldValue = isCheckForBadData();
 		getTHistoryConnector().setCheckForBadData(checkForBadData);
 		firePropertyChange(CHECK_FOR_BAD_DATA, oldValue, checkForBadData);
 	}
 
 	/**
 	 * Returns the history simulator switch.
 	 * 
 	 * @return the simulate
 	 */
 	public boolean isSimulate() {
 		return getTHistoryConnector().isSimulate();
 	}
 
 	/**
 	 * Sets the history simulator.
 	 * 
 	 * @param simulate the simulate to set
 	 */
 	public void setSimulate(boolean simulate) {
 		getTHistoryConnector().setSimulate(simulate);
 	}
 
 	/**
 	 * Returns the timeout in millis.
 	 * 
 	 * @return the timeout
 	 */
 	public int getTimeout() {
 		return getTHistoryConnector().getTimeout();
 	}
 
 	/**
 	 * Sets the timeout for all history based TINE calls. All calls will terminate
 	 * after timeout even if no data was obtained yet.
 	 * 
 	 * @param timeout the timeout to set
 	 */
 	public void setTimeout(int timeout) {
 		int oldValue = getTimeout();
 		getTHistoryConnector().setTimeout(timeout);
 		firePropertyChange(TIMEOUT, oldValue, timeout);
 	}
 
 	/**
 	 * Returns true if charts automatically scales to live data.
 	 * 
 	 * @return the autoScaleToLiveData
 	 */
 	public boolean isAutoScaleToLiveData() {
 		return autoScaleToLiveData;
 	}
 
 	/**
 	 * Enables/disables autoscaling to live data. If this flag is true
 	 * the cart will automatically adjust its vertical axis to include
 	 * all the values in all graphs.
 	 * 
 	 * @param autoScaleToLiveData the autoScaleToLiveData to set
 	 */
 	public void setAutoScaleToLiveData(boolean autoScaleToLiveData) {
 		boolean oldValue = isAutoScaleToLiveData();
 		this.autoScaleToLiveData = autoScaleToLiveData;
 		firePropertyChange(AUTOSCALE_TO_LIVE_DATA, oldValue, autoScaleToLiveData);
 		if (!autoScaleToLiveData) {
 			setXRangeMin(getLastTimestamp() - getTimeSpan());
 		}
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see de.desy.acop.displayers.AcopChartReorg#removeDisplayerParameters(de.desy.acop.displayers.tools.AcopGraphParameters)
 	 */
 	@Override
 	public DataSource removeDisplayerParameters(AcopGraphParameters parameters) {
 		DataSource ds = super.removeDisplayerParameters(parameters);
 		if (getDisplayerParameters().length == 0) scaleInitialized = false;
 		return ds;
 	}
 		
 	/**
 	 * Sets the data normalized or absolute. When normalized, data is plotted
 	 * as percentage in the min-max area.
 	 * 
 	 * @param normalized true for normalzied or false for absolute
 	 */
 	public void setNormalizedData(boolean normalized) {
 		if (this.normalized == normalized) return;
 		this.normalized = normalized;
 		DataConsumer[] consumers = getConsumers();
 		for (DataConsumer c : consumers) {
 			if (c instanceof AcopTrendChartConsumer) {
 				((AcopTrendChartConsumer)c).setNormalizedData(normalized);
 			}
 		}
 		updateYScale(null);
 		firePropertyChange("normalizedData",!normalized, normalized);
 	}
 	
 	/**
 	 * Returns true if the data in the channels is normalzied.
 	 * 
 	 * @return true if normalized or false otherwise
 	 */
 	public boolean isNormalizedData() {
 		return normalized;
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see de.desy.acop.displayers.AcopChartReorg#updateYScale(de.desy.acop.displayers.chart.AcopChartConsumer)
 	 */
 	@Override
 	public void updateYScale(AcopChartConsumer consumer) {
 		if (isNormalizedData()) {
 			//do this twice (acop has scaling issues)
 			setYRangeMax(100.);
 			setYRangeMin(0.);
 			setYRangeMax(100.);
 			setYRangeMin(0.);
 		} else {
     		DataConsumer[] consumers = getConsumers();
     		double max = -Double.MAX_VALUE;
     		double min = Double.MAX_VALUE;
     		for (DataConsumer c : consumers) {
     			if (!(c instanceof AcopChartConsumer)) continue;
     			max = Math.max(max, ((AcopChartConsumer)c).getPreferredYMax());
     			min = Math.min(min, ((AcopChartConsumer)c).getPreferredYMin());
     		}
     		setYRangeMax(max);
     		setYRangeMin(min);
 		}
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see de.desy.acop.displayers.AcopChartReorg#updateYScaleOnRemove(de.desy.acop.displayers.chart.AcopChartConsumer)
 	 */
 	@Override
 	protected void updateYScaleOnRemove(AcopChartConsumer consumer) {
 		updateYScale(consumer);
 	}
 
 }