/*
    * 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.chart;
  
  import java.awt.Color;
  import java.beans.Beans;
  import java.beans.PropertyChangeSupport;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Map;
  
  import javax.swing.SwingUtilities;
  
  import com.cosylab.gui.displayers.CommonDisplayer;
  import com.cosylab.gui.displayers.Displayer;
  import com.cosylab.util.CommonException;
  
  import de.desy.acop.displayers.AcopTrendChart;
  import de.desy.acop.displayers.selector.SelectorUtilities;
  import de.desy.acop.displayers.tools.AcopGraphHistoryParameters;
  import de.desy.acop.displayers.tools.AcopGraphParameters;
  
  /**
   * <code>AcopTrendChartConsumer</code> is a consumer used by <code>AcopTrendChart</code>
   * Each consumer can present one trend line in the chart which shows
   * the time evolution of some remote property. Consumers can be added 
   * or removed from the chart in runtime. This consumer works with 
   * <code>AcopGraphHistoryParameters</code> which specifiy all the properties 
   * required to customize a particular trend line.
   * 
   * @author Tilen Kusterle, Cosylab
   * @see AcopTrendChart
   * @see AcopGraphHistoryParameters
   */
  public class AcopTrendChartConsumer extends AcopChartConsumer {
  
  	public static final String SEQUENCE_LENGTH = "sequenceLength";
  	public static final String SEQUENCE_INDEX = "sequenceIndex";
  	// TODO AcopConst.max_points is protected!
  	public static final int MAX_POINTS = 524288;
  	
  	private PropertyChangeSupport propertyChangeSupport;
  	
  	private int sequenceLength = 0;
  	private int sequenceIndex = 0;
  	
  	private int plotLength = 0;
  	private double maxHistoryTimestamp = 0;
  	private HistoryDataConverter historyDataConverter;
  	
  	private boolean normalized = false;
  	
  	private double[] visibleYData;
  		
  	/**
  	 * Constructs a new AcopTrendChartConsumer.
  	 * 
  	 * @param acopTrendChart parent chart
  	 * @param name the name of the consumer
  	 */
  	public AcopTrendChartConsumer(AcopTrendChart acopTrendChart, String name) {
  		super(acopTrendChart, name);
  		super.setTrendChart(true);
  		xData = new double[0];
  		yData = new double[0];
  		visibleYData = new double[0];
  		historyDataConverter = new HistoryDataConverter();
  	}
  	
  	protected void updateChart() {
  		if (acopChartReorg == null) return;
  		
  		Runnable r = new Runnable(){
  			public void run() {
  				trimData();
  				prepareYData();
  				
  				synchronized(acopChartReorg) {
  					if (acopChartReorg == null) return;
 					if (displayHandle < 0) {
 						applyParameters();
 					    displayHandle = acopChartReorg.getAcop().draw(visibleYData,xData);//,disable,xLabels,arraySize,maxNumber);
 					    plotLength = xData.length;
 					}
 					else {
 						if (plotLength == xData.length) {
 							acopChartReorg.getAcop().refreshScreen(visibleYData, displayHandle, arraySize, 0, xData);
 						}
 						else reinitializePlot();
 					}
 					getAcopChart().autoScale();
 				}				
 			}
 		};
 		if (SwingUtilities.isEventDispatchThread()) {
 			r.run();
 		} else {
 			SwingUtilities.invokeLater(r);
 		}
 		
 	}
 
 	/* (non-Javadoc)
 	 * @see de.desy.acop.displayers.tools.AcopChartReorgConsumer#setCharacteristics(java.util.Map)
 	 */
 	@Override
 	public void setCharacteristics(Map characteristics) {
 
 		if (acopChartReorg == null) {
 			return;
 		}
 
 		Object o1 = null;
 		Object o2 = null;
 
 		o1 = characteristics.get(CommonDisplayer.C_GRAPH_MAX);
 
 		if (o1 == null) {
 			o1 = characteristics.get(CommonDisplayer.C_MAXIMUM);
 		}
 
 		o2 = characteristics.get(CommonDisplayer.C_GRAPH_MIN);
 
 		if (o2 == null) {
 			o2 = characteristics.get(CommonDisplayer.C_MINIMUM);
 		}
 
 		if (o1 != null || o2 != null) {
 			double max = o1 != null ? ((Number)o1).doubleValue()
 				: acopChartReorg.getYRangeMax();
 			double min = o2 != null ? ((Number)o2).doubleValue()
 				: acopChartReorg.getYRangeMin();
 			
 			setPreferredYMax(max);
 			setPreferredYMin(min);
 			acopChartReorg.updateYScale(this);
 		}
 
 		o1 = characteristics.get(CommonDisplayer.C_DISPLAY_NAME);
 		
 		String newName = (String) o1;
 		if (newName != null && !newName.equals(acopChartReorg.getTitle())) {
 			// TODO why was this here?
 //		    acopChart2.getAcop().setName(newName);
 		    acopChartReorg.setTitle(newName);
 		}
 		
 		o1 = characteristics.get(Displayer.C_UNITS);
 		if (o1 != null) {
 			acopChartReorg.getAcop().setYAxisLabel((String)o1);
 		}
 
 		//avoid setting colors through characterstics to avoid different threads
 		//setting the same property at the same time - consumer might end up with wrong color
 		o1 = characteristics.get(Displayer.C_COLOR);
 
 		if (o1 != null) {
 			color = (Color) o1;
 			acopChartReorg.getAcop().setForeground(color);
 		}
 			
 		o1 = characteristics.get("xLabels");
 		
 		o1 = characteristics.get(CommonDisplayer.C_SEQUENCE_LENGTH);
 		setSequenceLength((Integer) o1);
 		
 		if (!Beans.isDesignTime()) {
 			acopChartReorg.updateXScale(this);
 		}
 		acopChartReorg.repaint();
 	}
 
 	/* (non-Javadoc)
 	 * @see de.desy.acop.displayers.tools.AcopChartReorgConsumer#setDisplayerParameters(de.desy.acop.displayers.tools.AcopGraphParameters)
 	 */
 	@Override
 	public void setDisplayerParameters(AcopGraphParameters displayerParameters) {
 		this.displayerParameters = displayerParameters;
 		this.color = displayerParameters.getColor() != null ? displayerParameters.getColor() : acopChartReorg.getAcop().getForeground();
 		this.width = displayerParameters.getWidth();
 		this.dispalyMode = displayerParameters.getMode() > -1 ? displayerParameters.getMode() : acopChartReorg.getAcop().getDisplayMode();
 		setSequenceLength(SelectorUtilities.getSequenceLength(displayerParameters.getConnectionParameters()));
 		setSequenceIndex(displayerParameters.getArrayIndex());
 		historyDataConverter.useConverter(displayerParameters.getConverter());
 	}
 
 	private long lastLocalTimestamp;
 	private long lastDrawnTimestamp;
 	private long lastNow;
 	/* (non-Javadoc)
 	 * @see de.desy.acop.displayers.tools.AcopChartReorgConsumer#updateValue(long, double[])
 	 */
 	@Override
 	public void updateValue(long timestamp, double[] value) throws CommonException {
 		long now = System.currentTimeMillis();
 		if (lastTimestamp != timestamp) {
 			lastTimestamp = timestamp;
 			lastLocalTimestamp = now;
 		} else {
 			timestamp = lastTimestamp + now - lastLocalTimestamp;
 		}
 		if (lastDrawnTimestamp > timestamp) {
 			timestamp =  lastDrawnTimestamp + now - lastNow;
 		}
 		
 //		lastTimestamp=timestamp;
 		setSequenceLength(value.length);
 		((AcopTrendChart) acopChartReorg).setLastTimestamp(timestamp/1000.);
 		appendPoint(timestamp/1000., value[getSequenceIndex()]);
 		lastDrawnTimestamp = timestamp;
 		lastNow = now;
 		updateChart();
 	}
 
 	/* (non-Javadoc)
 	 * @see de.desy.acop.displayers.tools.AcopChartReorgConsumer#isTrendChart()
 	 */
 	@Override
 	public boolean isTrendChart() {
 		return true;
 	}
 
 	/* (non-Javadoc)
 	 * @see de.desy.acop.displayers.tools.AcopChartReorgConsumer#setTrendChart(boolean)
 	 */
 	@Override
 	public void setTrendChart(boolean isTrendChart) {
 		// TODO do nothing or some notification?
 	}
 	
 	private void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
 		getPropertyChangeSupport().firePropertyChange(propertyName, oldValue, newValue);
 	}
 
 	private PropertyChangeSupport getPropertyChangeSupport() {
 		if (propertyChangeSupport == null) {
 			propertyChangeSupport = new PropertyChangeSupport(this);
 		}
 		return propertyChangeSupport;
 	}
 	
 	/**
 	 * Sets the data in the consumer normalized or absolute.
 	 * When normalizes all data is scaled to be shown as the percentage of
 	 * its max-min value.
 	 * 
 	 * @param normalized true for normalized, false for absolute
 	 */
 	public void setNormalizedData(boolean normalized) {
 		if (this.normalized == normalized) return;
 		this.normalized = normalized;
 		firePropertyChange("normalizedData", !normalized, normalized);
 		updateChart();
 	}
 	
 	/**
 	 * Returns true if this consumer shows data as normalized.
 	 * 
 	 * @return
 	 */
 	public boolean isNormalizedData() {
 		return normalized;
 	}
 
 	private void trimData() {
 		if (acopChartReorg == null) return;
 		synchronized(acopChartReorg) {
     		if (!((AcopTrendChart) acopChartReorg).isAutoScaleToLiveData()) {
     			int index;
     			double presentTime = ((AcopTrendChart) acopChartReorg).getLastTimestamp();
     			double timeSpan = ((AcopTrendChart) acopChartReorg).getTimeSpan();
     			double startTime = presentTime-timeSpan;
     			for (index = 0; index < xData.length; index++) {
     				if (xData[index] > startTime) {
     					break;
     				}
     			}
     			if (index != 0) {
     				if (index > xData.length) index = xData.length;
     				double[] xDataCopy =  Arrays.copyOf(xData, xData.length);
     				double[] yDataCopy =  Arrays.copyOf(yData, yData.length);
     				xData = new double[xData.length-index];
     				yData = new double[yData.length-index];
     				System.arraycopy(xDataCopy, index, xData, 0, xDataCopy.length-index);
     				System.arraycopy(yDataCopy, index, yData, 0, yDataCopy.length-index);
     			}
     		}
     		if (xData.length > MAX_POINTS) {
     			int i;
     			for (i = 0; i < xData.length; i++) {
     				if (xData[i] > maxHistoryTimestamp) {
     					i--;
     					break;
     				}
     			}
     			if (i < 0 || i > MAX_POINTS) i = 0;
     			double[] xDataCopy =  Arrays.copyOf(xData, xData.length);
     			double[] yDataCopy =  Arrays.copyOf(yData, yData.length);
     			xData = new double[MAX_POINTS];
     			yData = new double[MAX_POINTS];
     			System.arraycopy(xDataCopy, 0, xData, 0, i);
     			System.arraycopy(yDataCopy, 0, yData, 0, i);
     			System.arraycopy(xDataCopy, xDataCopy.length-(MAX_POINTS-i), xData, i, MAX_POINTS-i);
     			System.arraycopy(yDataCopy, yDataCopy.length-(MAX_POINTS-i), yData, i, MAX_POINTS-i);
     			acopChartReorg.autoScaleXOnce();
     		}
 		}
 		
 	}
 	
 	private void prepareYData() {
 		synchronized(acopChartReorg) {
     		if (isNormalizedData()) {
     			visibleYData = new double[yData.length];
     			double min = getPreferredYMin();
     			double scale = (getPreferredYMax() - min)/100.;
     			for (int i = 0; i < visibleYData.length; i++) {
     				visibleYData[i] = (yData[i] - min)/scale;
     			}
     		} else {
     			visibleYData = yData;
     		}
 		}
 	}
 	
 	private void mergeData(double[][] historyData) {
 		synchronized(acopChartReorg) {
     		ArrayList<Double> xList = new ArrayList<Double>();
     		ArrayList<Double> yList = new ArrayList<Double>();
     		boolean skip = false;
     		for (int i = 0; i < historyData[0].length; i++) {
     			double t = historyData[0][i];
     			for (int j = 0; j < xList.size(); j++) {
     				if (xList.get(j) >= t) {
     					if (xList.get(j) > t) {
     						xList.add(j, t);
     						yList.add(j, historyData[1][i]);
     					}
     					skip = true;
     					break;
     				}
     			}
     			if (skip) {
     				skip = false;
     				continue;
     			}
     			xList.add(t);
     			yList.add(historyData[1][i]);
     		}
     		for (int i = 0; i < xData.length; i++) {
     			double t = xData[i];
     			for (int j = 0; j < xList.size(); j++) {
     				if (xList.get(j) >= t) {
     					if (xList.get(j) > t) {
     						xList.add(j, t);
     						yList.add(j, yData[i]);
     					}
     					skip = true;
     					break;
     				}
     			}
     			if (skip) {
     				skip = false;
     				continue;
     			}
     			xList.add(t);
     			yList.add(yData[i]);
     		}
     		if (historyData[0].length > 0) maxHistoryTimestamp = historyData[0][historyData[0].length-1];
     		xData = new double[xList.size()];
     		yData = new double[yList.size()];
     		for (int i = 0; i < xList.size(); i++) {
     			xData[i] = xList.get(i);
     			yData[i] = yList.get(i);
     		}
 		}
 	}
 	
 	private void appendPoint(double x, double y) {
 		synchronized (acopChartReorg) {
     		double[] xDataCopy =  Arrays.copyOf(xData, xData.length);
     		double[] yDataCopy =  Arrays.copyOf(yData, yData.length);
     		xData = new double[xData.length+1];
     		yData = new double[yData.length+1];
     		System.arraycopy(xDataCopy, 0, xData, 0, xDataCopy.length);
     		System.arraycopy(yDataCopy, 0, yData, 0, yDataCopy.length);
     		xData[xData.length-1] = x;
     		yData[yData.length-1] = y;
 		}
 	}
 
 	/* (non-Javadoc)
 	 * @see de.desy.acop.displayers.tools.AcopChartReorgConsumer#dumpData()
 	 */
 	@Override
 	public double[][] dumpData() {
 		double[][] clone = new double[2][xData.length];
 		System.arraycopy(xData, 0, clone[0] ,0,xData.length);
 		System.arraycopy(yData, 0, clone[1] ,0,xData.length);
 		return clone;
 	}
 
 	/**
 	 * Returns the sequence index.
 	 * @return the sequenceIndex
 	 */
 	public int getSequenceIndex() {
 		return sequenceIndex;
 	}
 
 	/**
 	 * Sets the sequence index.
 	 * @param sequenceIndex the sequenceIndex to set
 	 */
 	public void setSequenceIndex(int sequenceIndex) {
 		if (this.sequenceIndex == sequenceIndex) return;
 		int oldIndex = getSequenceIndex();
 		if (sequenceIndex >= getSequenceLength() || sequenceIndex < 0) {
 			sequenceIndex = 0;
 		}
 		this.sequenceIndex = sequenceIndex;
 		firePropertyChange(SEQUENCE_INDEX, oldIndex, getSequenceIndex());
 	}
 
 	/**
 	 * Returns the length of the sequence.
 	 * @return the sequenceLength
 	 */
 	public int getSequenceLength() {
 		return sequenceLength;
 	}
 
 	/**
 	 * Sets the length of the sequence.
 	 * @param sequenceLength the sequenceLength to set
 	 */
 	public void setSequenceLength(int sequenceLength) {
 		if (this.sequenceLength == sequenceLength) return;
 		int oldLength = getSequenceLength();
 		this.sequenceLength = sequenceLength;
 		if (getSequenceIndex() >= getSequenceLength()) {
 			setSequenceIndex(0);
 		}
 		firePropertyChange(SEQUENCE_LENGTH, oldLength, getSequenceLength());
 	}
 
 	/**
 	 * Returns the history parameters if this graph includes history data.
 	 * 
 	 * @return the history parameters
 	 */
 	public HistoryParameters getHistoryParameters() {
 		AcopGraphParameters parameters = getDisplayerParameters();
 		if (parameters instanceof AcopGraphHistoryParameters) return ((AcopGraphHistoryParameters) parameters).getHistoryParameters();
 		return null;
 	}
 
 	/**
 	 * Sets the history data for this graph. This first array holds the 
 	 * timestamp and the second array holds the values at those timestamps.
 	 * 
 	 * @param historyData data array: historyData[0] holds timestamp and historyData[1]
 	 * 				holds values
 	 */
 	public void loadHistoryData(double[][] historyData) {
 		double[] convertedHistoryData = historyDataConverter.convertHistoryData(historyData[1]);
 		historyData[1] = convertedHistoryData;
 		mergeData(historyData);
 		updateChart();
 	}
 	
 }