/*
    * @(#)$Id: WiiReaderPanel.java
    *
    * Author       :   Arthur Vogels, arthur.vogels@gmail.com
    *
    * Purpose      :	Draws the data recorded by the WiiReader into
    * 					planes and graphs on a JPanel.
    *
    *
   * -----------------------------------------------------------------------
   *
   * Revision Information:
   *
   * Date             Who         	Reason
   *
   * Dec 16, 2008     arthurvogels    Initial Release
   *
   * -----------------------------------------------------------------------
   *
   * Copyright 1999-2009 ETH Zurich. All Rights Reserved.
   *
   * This software is the proprietary information of ETH Zurich.
   * Use is subject to license terms.
   * 
   */
  
  package org.ximtec.igesture.algorithm.rubine3d.tools;
  
  import java.awt.Color;
  import java.awt.Cursor;
  import java.awt.Font;
  import java.awt.Graphics;
  import java.awt.Point;
  import java.awt.Rectangle;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Vector;
  
  import javax.swing.JPanel;
  
  import org.sigtec.ink.Note;
  import org.sigtec.ink.Trace;
  import org.ximtec.igesture.core.Gesture;
  import org.ximtec.igesture.core.GestureSample;
  import org.ximtec.igesture.core.GestureSample3D;
  import org.ximtec.igesture.util.additions3d.AccelerationSample;
  import org.ximtec.igesture.util.additions3d.Accelerations;
  
  public class WiiReaderPanel extends JPanel {
  
  	private WiiReader reader;
  	private GestureSample3D gs;
  
  	/**
  	 * Constructor
  	 * 
  	 * @param reader
  	 *            The WiiReader this WiiReaderPanel belongs to
  	 */
  	public WiiReaderPanel(WiiReader reader) {
  		this.reader = reader;
  		setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
  	}	
  	
  	/**
  	 * Override of the JPanel paintComponent method. Paints the gesture from
  	 * reader in 3 planes onto the Graphics object
  	 */
  	@Override
  	public void paintComponent(Graphics g) {
  		//System.err.println("paintComponent: reader = " + reader);
  		// Clear first
  //		g.clearRect(0, 0, getWidth(), getHeight());
  		g.setColor(Color.WHITE);
  		g.fillRect(0, 0, getWidth(), getHeight());
  		g.setColor(Color.BLACK);
  		
  		if (reader != null) {
  			// Get gesture to draw
  			gs = (GestureSample3D) reader.getGesture();
  		}
  		// Calculate the drawing fields for the planes
  		List<Rectangle> fields = calculateFieldSizes(0.02);
  		Rectangle XYfield = fields.get(0);
  		Rectangle YZfield = fields.get(1);
  		Rectangle ZXfield = fields.get(2);
  		Rectangle graphField = fields.get(3);
  		//Draw rectangles around the fields
  		g.drawRect((int) XYfield.getX(), (int) XYfield.getY(), (int) XYfield.getWidth(), (int) XYfield.getHeight());
  		g.drawRect((int) YZfield.getX(), (int) YZfield.getY(), (int) YZfield.getWidth(), (int) YZfield.getHeight());
  		g.drawRect((int) ZXfield.getX(), (int) ZXfield.getY(), (int) ZXfield.getWidth(), (int) ZXfield.getHeight());
  		g.drawRect((int) graphField.getX(), (int) graphField.getY(), (int) graphField.getWidth(), (int) graphField.getHeight());
  		//Draw titles in the fields
  		g.setColor(Color.RED);
  		g.drawString("XY-Plane", (int) (XYfield.getX() + 10),(int) (XYfield.getY() + 15));
  		g.drawString("YZ-Plane", (int) (YZfield.getX() + 10),(int) (YZfield.getY() + 15));
  		g.drawString("ZX-Plane", (int) (ZXfield.getX() + 10),(int) (ZXfield.getY() + 15));
  		g.drawString("Accelerations", (int) (graphField.getX() + 10),(int) (graphField.getY() + 15));
 		
 		
 		if (gs != null) {
 
 			Accelerations acc = gs.getGesture().getAccelerations();
 
 			//System.err.println("Accelerations: " + gs.getGesture().getAccelerations());
 			
 			// Split the gesture to three planes of type Gesture<Note>
 			List<Gesture<Note>> notes = gs.splitToPlanes();
 
 			// Get traces out of the note
 			List<Trace> traces = new Vector<Trace>();
 			for (int i = 0; i < notes.size(); i++) {
 				traces.add(notes.get(i).getGesture().get(0));
 			}
 			traces = scaleTraces(traces, 10, fields.subList(0, 3));
 			notes.clear();
 			for (int i = 0; i < traces.size(); i++) {
 				Note note = new Note();
 				note.add(traces.get(i));
 				Gesture<Note> gesture = new GestureSample(reader,"", note);
 				notes.add(gesture);
 			}
 
 			// Get the planes from the list for convenience
 			Gesture<Note> gest = notes.get(0);
 			Note noteXY = gest.getGesture();
 			gest = notes.get(1);
 			Note noteYZ = gest.getGesture();
 			gest = notes.get(2);
 			Note noteZX = gest.getGesture();
 			// Rectangle accelerationsField = fields.get(3);
 			// Draw planes on g
 			drawPlane(noteXY, XYfield, g);
 			drawPlane(noteYZ, YZfield, g);
 			drawPlane(noteZX, ZXfield, g);
 			// Draw acceleration graphs
 			drawAccelerationsGraph(acc, graphField, 0.02, g);
 		}
 	}
 
 	/**
 	 * Draws a graph with wiimote accelerations on g
 	 * 
 	 * @param acc
 	 *            The WiiAccelerations object containing the data for the graphs
 	 * @param field
 	 *            The rectangle in which the graph should be drawn
 	 * @param spacePercentage
 	 *            The space marging percentage at the sides
 	 * @param title
 	 *            The title of the graph
 	 * @param g
 	 *            The Graphics object on which the graph should be drawn
 	 */
 	private void drawAccelerationsGraph(Accelerations acc, Rectangle field,
 			double spacePercentage, Graphics g) {
 		g.setColor(Color.BLACK);
 
 		if (acc != null) {
 
 			// Calculate margin in pixels from spacePercentage
 			int margin = (int) (spacePercentage * field.getWidth());
 
 			// Define fields for X, Y and Z acceleration graphs
 			Rectangle fieldX = new Rectangle((int) field.getX() + margin,
 					(int) field.getY() + margin, (int) field.getWidth()
 							- (2 * margin), (int) (field.getHeight() / 3)
 							- (2 * margin));
 			Rectangle fieldY = new Rectangle((int) field.getX() + margin,
 					(int) (field.getY() + field.getHeight() / 3) + margin,
 					(int) field.getWidth() - (2 * margin), (int) (field
 							.getHeight() / 3)
 							- (2 * margin));
 			Rectangle fieldZ = new Rectangle((int) field.getX() + margin,
 					(int) (field.getY() + field.getHeight() * 0.67) + margin,
 					(int) field.getWidth() - (2 * margin), (int) (field
 							.getHeight() / 3)
 							- (2 * margin));
 
 			// Create buffers of points to draw for X, Y and Z acceleration
 			List<List<Point>> buffers = scaleAccelerations(acc, fieldX);
 
 			// Draw the graphs
 			drawGraph(buffers.get(0), fieldX, Color.GRAY, Color.RED, "X-Axis",
 					g);
 			drawGraph(buffers.get(1), fieldY, Color.GRAY, Color.GREEN,
 					"Y-Axis", g);
 			drawGraph(buffers.get(2), fieldZ, Color.GRAY, Color.BLUE, "Z-Axis",
 					g);
 
 		} else {
 //			Font originalFont = g.getFont();
 //			Font font = new Font("Arial", Font.PLAIN, 10);
 //			g.setFont(font);
 //			g.drawString("No acceleration data available",
 //					(int) (field.getX() + 5),
 //					(int) ((field.getY() + (0.5 * field.getHeight()))));
 //			g.setFont(originalFont);
 		}
 	}
 
 	/**
 	 * Scales acceleration data from acc to fit into a rectangle of the size of
 	 * fieldSize in order to be drawn. Returns a lists of 3 lists of points.
 	 * 
 	 * @param acc
 	 *            the WiiAccelerations object containing the input data
 	 * @param fieldSize
 	 *            A rectangle from which the size is used to scale into
 	 * @return A List of Lists of Points, cotaining the scaled data
 	 */
 	private List<List<Point>> scaleAccelerations(Accelerations acc,
 			Rectangle fieldSize) {
 		// Retrieve timestamp of first and last sample
 		long timeFirst = acc.getFirstSampleTime();
 		long timeLast = acc.getLastSampleTime();
 		// Retrieve maximum absolute acceleration value
 		double maxAbsAcc = acc.getMaxAbsoluteAccelerationValue();
 		// Find out how high and wide a graph can be
 		double graphWidth = fieldSize.getWidth();
 		double graphHeight = fieldSize.getHeight();
 		// Calculate the vertical scaling factor
 		double verticalScalingFactor = (0.5 * graphHeight) / maxAbsAcc;
 		// Calculate the horizontal scaling factor
 		long gestureLength = timeLast - timeFirst;
 		double horizontalScalingFactor = graphWidth / gestureLength;
 		// Calculate the positions to draw
 		List<Point> bufferX = new Vector<Point>();
 		List<Point> bufferY = new Vector<Point>();
 		List<Point> bufferZ = new Vector<Point>();
 		Iterator<AccelerationSample> i = acc.getSamples().iterator();
 		while (i.hasNext()) {
 			AccelerationSample s = i.next();
 			Point point = new Point();
 			// X position
 			double xPos = horizontalScalingFactor
 					* (s.getTimeStamp() - timeFirst);
 			double yPos = (graphHeight / 2)
 					- (verticalScalingFactor * (s.getXAcceleration()));
 			point.setLocation(xPos, yPos);
 			bufferX.add(point);
 			// Y position
 			point = new Point();
 			yPos = (graphHeight / 2)
 					- (verticalScalingFactor * (s.getYAcceleration()));
 			point.setLocation(xPos, yPos);
 			bufferY.add(point);
 			// Z position
 			point = new Point();
 			yPos = (graphHeight / 2)
 					- (verticalScalingFactor * (s.getZAcceleration()));
 			point.setLocation(xPos, yPos);
 			bufferZ.add(point);
 		}
 		List<List<Point>> buffers = new Vector<List<Point>>();
 		buffers.add(bufferX);
 		buffers.add(bufferY);
 		buffers.add(bufferZ);
 		return buffers;
 	}
 
 	/**
 	 * Draws Note plane in Rectangle field on Graphics g
 	 * 
 	 * @param plane
 	 *            the Note that should be drawn
 	 * @param field
 	 *            The rectangle in which the Note should be drawn
 	 * @param title
 	 *            The title of the plane
 	 * @param g
 	 *            The Graphics object onto which the Note should be drawn
 	 */
 	private void drawPlane(Note plane, Rectangle field, Graphics g) {
 		if (plane != null) {
 			g.setColor(Color.BLACK);
 			// Draw all traces from plane on g
 			for (Trace trace : plane.getTraces()) {
 				drawTrace(trace, 10, field, g);
 			}
 		}
 	}
 
 	/**
 	 * Draws Trace trace on Graphics g in Rectangle field, while maintaining
 	 * margin from the sides of the rectangle
 	 * 
 	 * @param trace
 	 *            The Trace that should be drawn
 	 * @param margin
 	 *            The margin to the sides of the field in pixels
 	 * @param field
 	 *            The Rectangle into which the trace should be drawn
 	 * @param g
 	 *            The Graphics object onto which the Trace should be drawn
 	 */
 	private void drawTrace(Trace trace, int margin, Rectangle field, Graphics g) {
 		// Scale trace to match the field size, taking margin at the sides into
 		// account
 		// Create a buffer containing all the points of the trace
 		List<Point> buffer = new ArrayList<Point>();
 		for (org.sigtec.ink.Point point : trace.getPoints()) {
 			buffer.add(new Point((int) point.getX(), (int) point.getY()));
 		}
 		// Draw lines on g from point to point within the field
 		for (int i = 0; i < buffer.size() - 1; i++) {
 			g.drawLine((int) (buffer.get(i).getX() + field.getX()),
 					(int) (buffer.get(i).getY() + field.getY()), (int) (buffer
 							.get(i + 1).getX() + field.getX()), (int) (buffer
 							.get(i + 1).getY() + field.getY()));
 		}
 		// Draw a small circle to mark the startpoint of the gesture
 		if (buffer.size() > 0)
 			g.fillOval((int) (buffer.get(0).getX() + +field.getX()),
 					(int) (buffer.get(0).getY() + field.getY()), 5, 5);
 	}
 
 	/**
 	 * Scales Traces to fit into the given Rectangles
 	 * 
 	 * @param traces
 	 *            List of traces that should be scaled
 	 * @param margin
 	 *            The margin to the sides of the fields in pixels
 	 * @param fields
 	 *            List of Rectangles into which the traces should be scaled
 	 * @return A list of scaled traces
 	 */
 	private List<Trace> scaleTraces(List<Trace> traces, int margin,
 			List<Rectangle> fields) {
 		List<Trace> tracesNew = new Vector<Trace>();
 		double scalingFactor = 0;
 		// find the scaling factor to use for all traces
 		double maxXUsed = 0;
 		double maxYUsed = 0;
 		double minXAvailable = 100000;
 		double minYAvailable = 100000;
 		for (int i = 0; i < traces.size(); i++) {
 			// Take trace and corresponding rectangle from lists
 			Trace trace = traces.get(i);
 			Rectangle field = fields.get(i);
 			// Find extremes
 			double maxFoundX = 0;
 			double minFoundX = 0;
 			double maxFoundY = 0;
 			double minFoundY = 0;
 			for (int j = 0; j < trace.getPoints().size(); j++) {
 				org.sigtec.ink.Point point = trace.getPoints().get(j);
 				if (point.getX() > maxFoundX)
 					maxFoundX = point.getX();
 				if (point.getY() > maxFoundY)
 					maxFoundY = point.getY();
 				if (point.getX() < minFoundX)
 					minFoundX = point.getX();
 				if (point.getY() < minFoundY)
 					minFoundY = point.getY();
 			}
 			double xSizeUsed = maxFoundX - minFoundX;
 			double ySizeUsed = maxFoundY - minFoundY;
 
 			if (xSizeUsed > maxXUsed)
 				maxXUsed = xSizeUsed;
 			if (ySizeUsed > maxYUsed)
 				maxYUsed = ySizeUsed;
 
 			// Define the playing field
 			double minAvailableX = field.getX() + margin;
 			double minAvailableY = field.getY() + margin;
 			double maxAvailableX = (field.getWidth() + field.getX()) - margin;
 			double maxAvailableY = (field.getHeight() + field.getY()) - margin;
 			double xSizeAvailable = maxAvailableX - minAvailableX;
 			double ySizeAvailable = maxAvailableY - minAvailableY;
 
 			if (xSizeAvailable < minXAvailable)
 				minXAvailable = xSizeAvailable;
 			if (ySizeAvailable < minYAvailable)
 				minYAvailable = ySizeAvailable;
 
 		}
 		// Calculate scaling factor
 		scalingFactor = findScalingFactor(minXAvailable, maxXUsed,
 				minYAvailable, maxYUsed);
 		// Scale every Trace using the found scalingfactor
 		for (int i = 0; i < traces.size(); i++) {
 			// Take trace and corresponding rectangle from lists
 			Trace trace = traces.get(i);
 
 			// Find extremes
 			double maxFoundX = 0;
 			double minFoundX = 0;
 			double maxFoundY = 0;
 			double minFoundY = 0;
 			for (int j = 0; j < trace.getPoints().size(); j++) {
 				org.sigtec.ink.Point point = trace.getPoints().get(j);
 				if (point.getX() > maxFoundX)
 					maxFoundX = point.getX();
 				if (point.getY() > maxFoundY)
 					maxFoundY = point.getY();
 				if (point.getX() < minFoundX)
 					minFoundX = point.getX();
 				if (point.getY() < minFoundY)
 					minFoundY = point.getY();
 			}
 
 			// Move every point inside the playing field
 			Trace traceNew = new Trace();
 			for (int k = 0; k < trace.getPoints().size(); k++) {
 				double xNew = scalingFactor
 						* (trace.getPoints().get(k).getX() - minFoundX)
 						+ margin;
 				double yNew = scalingFactor
 						* (trace.getPoints().get(k).getY() - minFoundY)
 						+ margin;
 				traceNew.add(new org.sigtec.ink.Point(xNew, yNew));
 			}
 			tracesNew.add(traceNew);
 		}
 		return tracesNew;
 	}
 
 	/**
 	 * Calculates scaling factor
 	 * 
 	 * @param xSizeAvailable
 	 *            Available size in x direction in pixels
 	 * @param xSizeUsed
 	 *            Used size in x direction in source data
 	 * @param ySizeAvailable
 	 *            Available size in y direction in pixels
 	 * @param ySizeUsed
 	 *            Used size in y direction in source data
 	 * @return The scaling factor
 	 */
 	private double findScalingFactor(double xSizeAvailable, double xSizeUsed,
 			double ySizeAvailable, double ySizeUsed) {
 		double scalingFactor = xSizeAvailable / xSizeUsed;
 		if ((ySizeAvailable / ySizeUsed) < scalingFactor) // take the smallest
 			// factor so it will
 			// definately fit
 			scalingFactor = ySizeAvailable / ySizeUsed;
 		return scalingFactor;
 	}
 
 	/**
 	 * Calculates the sizes and positions of the four fields on this panel,
 	 * using the size of the panel
 	 * 
 	 * @param spacePercentage
 	 *            The margin percentage for the fields from the sides of the
 	 *            panel
 	 * @return A list of 4 Rectangles, the fields for this panel
 	 */
 	private List<Rectangle> calculateFieldSizes(double spacePercentage) {
 		// Keep a distance from the sides of the panel
 		int spacerHorizontal = (int) (spacePercentage * getWidth());
 		int spacerVertical = (int) (spacePercentage * getHeight());
 		// Calculate width and height, they are the same for all four fields
 		int fieldWidth = (int) ((getWidth() - (4 * spacerHorizontal)) * 0.5);
 		int fieldHeight = (int) ((getHeight() - (4 * spacerVertical)) * 0.5);
 		// Create field rectangles
 		Rectangle field1 = new Rectangle(spacerHorizontal, spacerVertical,
 				fieldWidth, fieldHeight);
 		Rectangle field2 = new Rectangle((spacerHorizontal * 3) + fieldWidth,
 				spacerVertical, fieldWidth, fieldHeight);
 		Rectangle field3 = new Rectangle(spacerHorizontal, (spacerVertical * 3)
 				+ fieldHeight, fieldWidth, fieldHeight);
 		Rectangle field4 = new Rectangle((spacerHorizontal * 3) + fieldWidth,
 				(spacerVertical * 3) + fieldHeight, fieldWidth, fieldHeight);
 		// Add fields to return variable
 		List<Rectangle> fields = new Vector<Rectangle>();
 		fields.add(field1);
 		fields.add(field2);
 		fields.add(field3);
 		fields.add(field4);
 		// Return
 		return fields;
 	}
 
 	/**
 	 * Draws a graph in color from data into rectangle on g
 	 * 
 	 * @param data
 	 *            The source data for the graph
 	 * @param field
 	 *            The Rectangle into which the graph should be drawn
 	 * @param axisColor
 	 *            The color of the axis
 	 * @param dataColor
 	 *            The color of the data series in the graph
 	 * @param title
 	 *            The title of the graph
 	 * @param g
 	 *            The Graphics object onto which the graph should be drawn
 	 */
 	private void drawGraph(List<Point> data, Rectangle field, Color axisColor,
 			Color dataColor, String title, Graphics g) {
 		//System.err.println("Field: " + field.getX() + "," + field.getY() + " dimensions " + field.getWidth() + "," + field.getHeight());
 		// Save original color
 		Color originalColor = g.getColor();
 		// Draw axes
 		g.setColor(axisColor);
 		g.drawLine((int) field.getX(), (int) (field.getY() + (0.5 * field
 				.getHeight())), (int) (field.getX() + field.getWidth()),
 				(int) (field.getY() + (0.5 * field.getHeight())));
 		g.drawLine((int) field.getX(), (int) field.getY(), (int) field.getX(),
 				(int) (field.getY() + field.getHeight()));
 		// g.drawRect((int)field.getX(), (int)field.getY(),
 		// (int)field.getWidth(), (int)field.getHeight());
 		// Set data color
 		g.setColor(dataColor);
 		// Draw title
 		Font originalFont = g.getFont();
 		Font font = new Font("Arial", Font.PLAIN, 10);
 		g.setFont(font);
 		g.drawString(title, (int) (field.getX() + (0.5 * field.getWidth())),
 				(int) (field.getY() + 15));
 		g.setFont(originalFont);
 		// Draw data
 		Point lastPoint = new Point();
 		if (data.size() > 0)
 			lastPoint.setLocation((int) data.get(0).getX(), (int) data.get(0)
 					.getY()); // Startpoint
 		Iterator<Point> it = data.iterator();
 		while (it.hasNext()) {
 			Point p = it.next();
 			int oldX = (int) (field.getX() + lastPoint.getX());
 			int oldY = (int) (field.getY() + lastPoint.getY());
 			int newX = (int) (field.getX() + p.getX());
 			int newY = (int) (field.getY() + p.getY());
 			g.drawLine(oldX, oldY, newX, newY);
 			lastPoint = p;
 			//System.err.println("old: (" + oldX + "," + oldY + ") , new: " + newX + "," + newY + ")");
 		}
 		// Set color back to original
 		g.setColor(originalColor);
 	}
 
 	/**
 	 * Returns the gesture drawn by this panel
 	 * 
 	 * @return The gesture drawn by this panel
 	 */
 	public GestureSample3D getGesture() {
 		return gs;
 	}
 
 	/**
 	 * Sets the gesture to be drawn by this panel
 	 * 
 	 * @param gs
 	 *            The gesture to be drawn by this panel
 	 */
 	public void setGesture(GestureSample3D gs) {
 		//System.err.println("SAMPLE : " + gs.getName());
 		this.gs = gs;
 		if(gs != null){
 			System.err.println("WiiReaderPanel.setGesture() Displaying: " + gs.getName());
 		}
 		else {
 			System.err.println("WiiReaderPanel.setGesture() Displaying: null gesture");
 		}
 		this.paintComponent(this.getGraphics());
 	}
 	
 	public void clear()
 	{
 		System.out.println("clearing");
 		paintComponent(getGraphics());
 	}
 
 }