/*
    * 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.util.Map;
  
  import com.cosylab.gui.displayers.CommonDisplayer;
  import com.cosylab.gui.displayers.DataConsumer;
  import com.cosylab.gui.displayers.DataState;
  import com.cosylab.gui.displayers.Displayer;
  import com.cosylab.gui.displayers.DisplayerUtilities;
  import com.cosylab.gui.displayers.DoubleSeqConsumer;
  import com.cosylab.util.CommonException;
  
  import de.desy.acop.chart.Acop;
  import de.desy.acop.chart.AcopDisplayMode;
  import de.desy.acop.chart.AcopGraphStyleEnum;
  import de.desy.acop.displayers.AcopChart;
  import de.desy.acop.displayers.AcopChartReorg;
  import de.desy.acop.displayers.tools.AcopGraphParameters;
  
  /**
   * <code>AcopChartConsumer</code> is the common consumer used by the 
   * <code>AcopChart</code> and <code>AcopChartReorg</code>.
   * Each consumer can present one graph in the chart and can be added
   * or removed from the chart in runtime. This consumer works with 
   * <code>AcopGraphParameters</code> which specifiy all the properties 
   * required to customize a particular graph.
   *  
   * 
   * @author ikriznar
   * @see AcopChart
   * @see AcopChartReorg
   *
   */
  public class AcopChartConsumer implements DoubleSeqConsumer {
  
  	@SuppressWarnings("unchecked")
  	public static final Class[] SUPPORTED_CONSUMER_TYPES = {
  		DoubleSeqConsumer.class
  		};
  	public static final String[] SUPPORTED_CHARACTERISTICS = {
  		CommonDisplayer.C_GRAPH_MAX, CommonDisplayer.C_GRAPH_MIN
  		};
  	
  	protected String name;
  	protected AcopChartReorg acopChartReorg;
  
  	protected double[] xData;
  	protected double[] yData;
  	protected int displayHandle = -1;
  	protected int textHandle = -1;
  	protected long lastTimestamp;
  	protected Color color= Color.RED;
  	protected int width = 1;
  	protected int dispalyMode = 0;
  	protected String[] xLabels;
  	protected Object disable;
  	protected int arraySize;
  	protected int maxNumber;
  	private boolean chubbyLines;
  	private AcopDisplayMode displayMode;
      
      private boolean isTrendChart = false;
      
      private double preferredYMax;
      private double preferredYMin;
      
      protected AcopGraphParameters displayerParameters;
      	
  	/**
  	 * Constructs new AcopChartConsumer.
  	 * 
  	 * @param acopChartReorg parent chart
  	 * @param name the name of the consumer
  	 */
  	public AcopChartConsumer(AcopChartReorg acopChartReorg, String name) {
 		super();
 		this.name=name;
 		this.acopChartReorg=acopChartReorg;
 		preferredYMax = acopChartReorg.getAcop().getYMax();
 		preferredYMin = acopChartReorg.getAcop().getYMin();
 		
 		//color= new Color((int)(Math.random()*255),(int)(Math.random()*255),(int)(Math.random()*255));
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DataConsumer#getDataConsumer(java.lang.Class)
 	 */
 	@SuppressWarnings("unchecked")
     public DataConsumer getDataConsumer(Class type) {
 		if (type.isAssignableFrom(getClass())) {
 			return this;
 		}
 		return null;
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DataConsumer#getDefaultDataConsumer()
 	 */
 	public DataConsumer getDefaultDataConsumer() {
 		return this;
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DataConsumer#updateDataState(com.cosylab.gui.displayers.DataState)
 	 */
 	public void updateDataState(DataState state) {
 		// TODO Auto-generated method stub
 
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DataConsumer#setCharacteristics(java.util.Map)
 	 */
 	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();
 			
 			this.preferredYMax = max;
 			this.preferredYMin = min;
 			acopChartReorg.updateYScale(this);
 		}
 
 		o1 = characteristics.get(CommonDisplayer.C_DISPLAY_NAME);
 		
 		String newName = (String) o1;
 		if (newName != null && !newName.equals(acopChartReorg.getTitle())) {
 			// TODO what was this used for?
 //		    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");
 		if (o1 != null && !isTrendChart) {
 			setXLabels((String[])o1);
 		}
 		
 		o1 = characteristics.get(CommonDisplayer.C_SEQUENCE_LENGTH);
 		if (getArraySize() == 0 || getArraySize() == -1 && o1 != null) {
 			setArraySize((Integer)o1);
 		}
 		
 		if (!Beans.isDesignTime()) {
 			acopChartReorg.updateXScale(this);
 		}
 		acopChartReorg.repaint();
 
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DataConsumer#getName()
 	 */
 	public String getName() {
 		return name;
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DataConsumer#getSupportedCharacteristics()
 	 */
 	public String[] getSupportedCharacteristics() {
 		return DisplayerUtilities.combineCharacteristics(DisplayerUtilities.COMMON_NUMERIC_DISPLAYER_CHARACTERISTICS,
 			    SUPPORTED_CHARACTERISTICS);
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DataConsumer#getSupportedConsumerTypes()
 	 */
 	@SuppressWarnings("unchecked")
 	public Class<DataConsumer>[] getSupportedConsumerTypes() {
 		return SUPPORTED_CONSUMER_TYPES;
 	}
 	
 	protected void updateChart() {
 		if (acopChartReorg==null) {
 			return;
 		}
 		
 		synchronized (acopChartReorg) {
 
 	        //System.out.println("disp id : " + displayHandle);
 	//	    acop.clearScreen(-1,0); <- this will wipe out all display references
 	        //Acop aChart = acop.getAcopChart();
 	//      aChart.clearScreen(displayHandle,0); <- this removes the given reference (but Acop will reuse the handle, so we don't want to use this inside the AcopDataConsumer)
 	//	    acop.draw(y,x,null,null,141,100);
 	        if (displayHandle < 0)
 	        { // display the initial data set ...
 	          applyParameters();
 		      displayHandle = acopChartReorg.getAcop().draw(yData,xData,disable,xLabels,getArraySize(),maxNumber);
 	//        System.out.println("assigned display handle : " + displayHandle + "  color : " + color.toString());
 	        }
 	        else
 	        {
 	          if (!isTrendChart)
 	          { // not a trend chart : just refresh the display ...
 	            acopChartReorg.getAcop().refreshScreen(yData, displayHandle, getArraySize(), 0, xData);
 	//          System.out.println("refresh display handle : " + displayHandle + "  color : " + color.toString());
 	          }
 	          else
 	          { // append 1 value to the end ...  (ACOP should be in LIN_TIME or LOG_TIME graph mode)
 	            double[] yValue = new double[1];
 	            yValue[0] = yData[0];
 	            double[] xValue = new double[1];
 	            xValue[0] = lastTimestamp/1000.;
 	            
 //	            System.out.println("Append: ["+xValue[0]+", "+yValue[0]+"]");
 	            acopChartReorg.getAcop().appendScreen(yData, displayHandle, xValue);            
 	            
 //	            double[][] data= dumpData();
 //	            System.out.print("X: ");
 //	            System.out.println(Arrays.toString(data[0]));
 //	            System.out.print("Y: ");
 //	            System.out.println(Arrays.toString(data[1]));
 	          }
 	        }
 	//	    a.GetDataSize(d,null,-1);
 	//	    acopLabel.setText(a.getStatus() + " " + a.GetDataSize(-1) + " elements " + a.getTimeStamp().toString());
 		    //acop.setForeground(Color.BLUE);
 	//	    a.draw(z,x,null,null,141,100);
 		    //acop.draw(z);
 	        getAcopChart().autoScale();
 		}
 		
 	}
 	
 	/**
 	 * Refreshes all drawn points.
 	 * @see Acop#refreshScreen(Object, int, int, int, Object)
 	 *
 	 */
 	public void refreshPlot() {
 		synchronized (acopChartReorg) {
 			applyParameters();
 			acopChartReorg.getAcop().refreshScreen(yData, displayHandle, getArraySize(), 0, xData);
 		}
 	}
 	
 	/**
 	 * Redraws all graphs.
 	 *
 	 */
 	public void reinitializePlot() {
 		acopChartReorg.getAcop().clearScreen(displayHandle);
 		displayHandle = -1;
 		updateChart();
 	}
 
 	/**
 	 * Returns all data from chart. First index is 0 for X data array and 1 for Y data array.
 	 * @return all dat a from chart in X and Y array
 	 */
 	public double[][] dumpData() {
 		
 		double[][] array= new double[2][getArraySize()];
 		
 		acopChartReorg.getAcop().getDrawnData(array[0], array[1], getArraySize(), 0, displayHandle);
 		
 		return array;
 	}
 	
 	/**
 	 * Removes the graph that this consumer shows from the chart.
 	 *
 	 */
 	public void destroy() {
 		acopChartReorg.getAcop().clearScreen(displayHandle);
 		acopChartReorg=null;
 	}
 	
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DoubleSeqConsumer#updateValue(long, double[])
 	 */
 	public void updateValue(long timestamp, double[] value) throws CommonException {
 		lastTimestamp=timestamp;
 		yData=value;
 		updateChart();
 	}
 
 	/**
 	 * Returns the x data
 	 * @return x values of the data
 	 */
 	public double[] getXData() {
 		return xData;
 	}
 
 	/**
 	 * Returns the y data.
 	 * @return y values of the data
 	 */
 	public double[] getYData() {
 		return yData;
 	}
 
 	/**
 	 * Returns the parent chart component.
 	 * 
 	 * @return the acop chart
 	 */
 	public AcopChartReorg getAcopChart() {
 		return acopChartReorg;
 	}
 
 	/**
 	 * Returns the last timestamp when value was updated.
 	 * 
 	 * @return last timestamp
 	 */
 	public long getLastTimestamp() {
 		return lastTimestamp;
 	}
 
 	/**
 	 * Returns the color of this graph.
 	 * 
 	 * @return the color of the graph
 	 */
 	public Color getColor() {
 		return color;
 	}
 
 	/**
 	 * Sets the color for this graph. Can only be set before first draw.
 	 * 
 	 * @param color the color of the graph 
 	 */
 	public void setColor(Color color) {
 		this.color = color;
 	}
 
 	/**
 	 * Returns the horizotanl axis labels. Can only be set before the first
 	 * draw.
 	 * 
 	 * @return the horizontal axis labels
 	 */
 	public String[] getXLabels() {
 		return xLabels;
 	}
 
 	/**
 	 * Sets the labels for the horizontal axis. Can only be set before the first
 	 * draw.
 	 * 
 	 * @param labels new horizontal axis labels
 	 */
 	public void setXLabels(String[] labels) {
 		xLabels = labels;
 	}
 
 	/**
 	 * Returns the array size of the consumer.
 	 * 
 	 * @return the arraySize
 	 */
 	public int getArraySize() {
 		return arraySize;
 	}
 
 	/**
 	 * Sets the array size for this consumer.
 	 * 
 	 * @param arraySize
 	 */
 	private void setArraySize(int arraySize) {
 		this.arraySize = arraySize;
 	}
 
 	/**
 	 * Returns the preferred maximum of the vertical axis.
 	 * 
      * @return the preferred maximum of y axis
      */
     public double getPreferredYMax() {
     	return preferredYMax;
     }
 
 	/**
 	 * Sets the preferred maximum of the vertical axis.
      * @param preferredYMax new maximum for the vertical axis.
      */
     public void setPreferredYMax(double preferredYMax) {
     	this.preferredYMax = preferredYMax;
     	getAcopChart().updateYScale(this);
     }
 
 	/**
 	 * Returns the preferred minimum of the vertical axis.
 	 * 
      * @return the preferred minimum of y axis
      */
     public double getPreferredYMin() {
     	return preferredYMin;
     }
     
     /**
      * Returns the preferred minimum of the horizontal axis.
      * 
      * @return preferred minimum of the x axis
      */
     public double getPreferredXMin() {
     	return 0;
     }
     
     /**
      * Returns the preferred maximum of the horizontal axis.
      * 
      * @return horizontal maximum
      */
     public double getPreferredXMax() {
     	return getArraySize();
     }
 
 	/**
 	 * Sets the preferred minimum of the vertical axis.
 	 * 
      * @param preferredYMin new preferred minimum
      */
     public void setPreferredYMin(double preferredYMin) {
     	this.preferredYMin = preferredYMin;
     	getAcopChart().updateYScale(this);
     }
     
     protected void applyParameters() {
     	if (displayerParameters != null) {
 	    	acopChartReorg.getAcop().setForeground(displayerParameters.getColor());
 	    	acopChartReorg.getAcop().setDrawStyle(displayerParameters.getDrawStyle());
 	    	acopChartReorg.getAcop().setFFT(displayerParameters.getFFT());
 	    	if (displayMode == null) {
 	    		acopChartReorg.getAcop().setDisplayMode(displayerParameters.getMode());
 	    	} else {
 	    		acopChartReorg.getAcop().setDisplayMode(displayMode.ordinal());
 	    	}
 	    	if (chubbyLines) {
 	    		acopChartReorg.getAcop().setDrawWidth(2*displayerParameters.getWidth());
 	    	} else {
 	    		acopChartReorg.getAcop().setDrawWidth(displayerParameters.getWidth());
 	    	}
 	    	if (displayerParameters.isTrend()) {
 	    		acopChartReorg.getAcop().setGraphStyle(AcopGraphStyleEnum.TimeLin.ordinal());
 	    		double[] data = new double[displayerParameters.getTrendLength()];
 	    		if (yData != null) {
 		    		for (int i = 0; i < yData.length && i < data.length; i++) {
 		    			data[i] = yData[i];
 		    		}
 	    		}
 	    		yData = data;
 	    		maxNumber = data.length;
 	    	}
     	} else {
     		if (color != null) {
     			acopChartReorg.getAcop().setForeground(color);
     		}
     		if (chubbyLines) {
     			acopChartReorg.getAcop().setDrawWidth(2*width);
     		} else {
     			acopChartReorg.getAcop().setDrawWidth(width);
     		}
     		if (displayMode == null) {
     			acopChartReorg.getAcop().setDisplayMode(dispalyMode);
     		} else {
     			acopChartReorg.getAcop().setDisplayMode(displayMode.ordinal());
     		}
     	}
     }
 
     /**
      * Returns the AcopGraphParameters associated with this consumer.
      * 
      * @return the acop graph parameters
      */
 	public AcopGraphParameters getDisplayerParameters() {
 		return displayerParameters;
 	}
 
 	/**
 	 * Associates AcopGraphParameters with this consumer.
 	 * 
 	 * @param displayerParameters
 	 */
 	public void setDisplayerParameters(AcopGraphParameters displayerParameters) {
 		this.displayerParameters = displayerParameters;
 		this.color = displayerParameters.getColor() != null ? displayerParameters.getColor() : this.color;
 		this.width = displayerParameters.getWidth();
 		this.dispalyMode = displayerParameters.getMode() > -1 ? displayerParameters.getMode() : acopChartReorg.getAcop().getDisplayMode();
 		setTrendChart(displayerParameters.isTrend());
 		if (isTrendChart()) {
 			setArraySize(displayerParameters.getTrendLength());
 		} else {
 			setArraySize(displayerParameters.getConnectionParameters().getPropertySize());
 		}
 	}
 	
 	/**
 	 * Returns true if data is plotted on the chart.
 	 * 
 	 * @return true data is plotted.
 	 */
 	public boolean isDataDrawn() {
 		return displayHandle > -1;
 	}
 
 	/**
 	 * Returns true if this graph is a trend.
 	 * 
 	 * @return true if this is a trend
 	 */
 	public boolean isTrendChart() {
 		return isTrendChart;
 	}
 
 	/**
 	 * Sets the trend chart mode for this graph. Can only be set before the first 
 	 * draw.
 	 * 
 	 * @param isTrendChart
 	 */
 	public void setTrendChart(boolean isTrendChart) {
 		this.isTrendChart = isTrendChart;
 	}
 
 	/**
 	 * Returns true if this graph is drawn with a thicker line.
 	 * 
 	 * @return the chubbyLines
 	 */
 	public boolean isChubbyLines() {
 		return chubbyLines;
 	}
 
 	/**
 	 * If true this graph is drawn with a thicker line.
 	 * 
 	 * @param chubbyLines the chubbyLines to set
 	 */
 	public void setChubbyLines(boolean chubbyLines) {
 		if (this.chubbyLines == chubbyLines) return;
 		this.chubbyLines = chubbyLines;
 		reinitializePlot();
 		// TODO this does not work! refreshPlot();
 	}
 
 	/**
 	 * Returns the display mode of this graph.
 	 * 
 	 * @return the displayMode
 	 */
 	public AcopDisplayMode getDisplayMode() {
 		return displayMode;
 	}
 
 	/**
 	 * Sets the display mode for this graph.
 	 * 
 	 * @param displayMode new display mode
 	 */
 	public void setDisplayMode(AcopDisplayMode displayMode) {
 		if (this.displayMode == displayMode) return;
 		this.displayMode = displayMode;
 		reinitializePlot();
 	}
 
 }