/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: 
*
*/



package com.nokia.s60tools.traceanalyser.ui.editors;


import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseMoveListener;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.PlatformUI;

import com.nokia.s60tools.traceanalyser.containers.RuleInformation;
import com.nokia.s60tools.traceanalyser.export.RuleEvent;
import com.nokia.s60tools.traceanalyser.export.TraceAnalyserRule;
import com.nokia.s60tools.traceanalyser.model.Engine;
import com.nokia.s60tools.traceanalyser.plugin.TraceAnalyserPlugin;


/**
 * HistoryGraph.
 * Graph UI-component for Trace Analyser
 */
public class HistoryGraph implements MouseMoveListener {

	// Margins for each border
	private static final int MARGIN_LEFT = 100;
	private static final int MARGIN_OTHERS = 40;
	private static final int GRAPHMARGIN = 10;
	
	/* RuleInformation that is drawn to screen */
	private RuleInformation information;
	
	/* TraceAnalyser engine */
	Engine engine;
	
	/* UI components */
	private Composite composite;
	private Canvas canvas;
	
	/**
	 * HistoryGraph.
	 * @param composite composite where components are placed.
	 * @param information information which is drawn to screen.
	 */
	HistoryGraph(Composite composite, RuleInformation information){
		this.composite = composite;
		this.information = information;
		this.engine = TraceAnalyserPlugin.getEngine();
	}
	
	/**
	 * drawGraph.
	 * Draws graph to screen.
	 */
	void drawGraph(){
		if(canvas != null){
			canvas.dispose();
		}
		canvas = new Canvas(composite, SWT.BORDER);
		canvas.setLayoutData(new GridData(GridData.FILL_BOTH));
		
		// Add mouse mouse listener.
		canvas.addMouseMoveListener(this);
		
		// Add paint listener
		canvas.addPaintListener(new PaintListener() {
			public void paintControl(PaintEvent e) {
				GC gc = e.gc;
				drawBox(gc);
				drawLimits(gc);
				drawEvents(gc);
			}

			
		});
		
	}
	
	
	/**
	 * redraw.
	 * Redraws screen.
	 */
	public void redraw(){
		canvas.redraw();
	}
	
	
	/**
	 * getCanvasSize.
	 * @return size or the canvas.
	 */
	private Point getCanvasSize(){
		Point point = canvas.getSize();
		point.x -= 5;
		point.y -= 5;
		return point;
	}
	
	/**
	 * drawBox.
	 * Draws box for graph into graphics content.
	 * @param gc graphics content where content is drawn
	 */
	private void drawBox(GC gc){

		gc.setBackground(Display.getCurrent().getSystemColor(SWT.COLOR_WHITE));

		// count start points of box
		int startPointX = MARGIN_LEFT - GRAPHMARGIN;
		int startPointY = MARGIN_OTHERS - GRAPHMARGIN;
		
		// Count width and height of box
		Point canvasSize = getCanvasSize();
		int width = canvasSize.x - (MARGIN_LEFT + MARGIN_OTHERS - GRAPHMARGIN*2);
		int height = canvasSize.y - (MARGIN_OTHERS*2 - GRAPHMARGIN*2);
		
		// draw and fill rectangle.
		gc.fillRectangle(startPointX, startPointY, width, height);
		gc.drawRectangle(startPointX, startPointY, width, height);
	

	}
	
	
	/**
	 * drawEvents.
	 * Draws all history events to screen.
	 * @param gc graphics content where content is drawn
	 */
	private void drawEvents(GC gc){
		
		ArrayList<RuleEvent> events = information.getEvents();
		Point canvasSize = getCanvasSize();
		
		// Count start points
		double sizeY = canvasSize.y - MARGIN_OTHERS * 2;
		double sizeX = canvasSize.x - (MARGIN_LEFT + MARGIN_OTHERS);
		
		
		int[] minAndMax = getMinAndMax();
		int min = minAndMax[0];
		int max = minAndMax[1];

		
		// get difference between min and max value.
		int difference = max - min;
		
		// get multiplier for Y values from that difference.
		double yMultiplier = sizeY / difference;
		
		// get multiplier for X values from canvas size and smount of events.
		double xMultiplier = sizeX / (events.size() - 1);
		
		gc.setBackground(Display.getCurrent().getSystemColor(SWT.COLOR_GRAY));
		int[] previousValues = new int[2]; 
		int i = 0;

		while(i < events.size()){
			
			gc.setForeground(Display.getCurrent().getSystemColor(SWT.COLOR_BLACK));
			
			// count x-value based on what event is drawn to screen
			int xValue = (int)(i * xMultiplier);
			
			// count y-value based on what event value is.
			double yValueDouble = events.get(i).getValue() - min;
			yValueDouble *= yMultiplier;
			int yValue = (int)(sizeY - yValueDouble);
			
			// add margins
			xValue += MARGIN_LEFT;
			yValue += MARGIN_OTHERS;
			
			// Draw mark on one event(currently disabled)
			//			drawMark(gc, xValue, yValue);
			
			gc.setForeground(Display.getCurrent().getSystemColor(SWT.COLOR_BLACK));

			// Draw line between this and previous event.
			if(i > 0 ){
				gc.drawLine(xValue, yValue, previousValues[0], previousValues[1]);
			}
			
			// save value to previous value variable
			previousValues[0] = xValue;
			previousValues[1] = yValue;
				
			i++;
		}
	}
	
	/**
	 * drawMark.
	 * Draws mark of one event into given coordinate
	 * @param gc graphics content where content is drawn
	 * @param xValue x-coordinate
	 * @param yValue y-coordinate
	 */
	@SuppressWarnings("unused")
	private void drawMark(GC gc, int xValue, int yValue){
		gc.fillOval(xValue - 3, yValue - 3, 6, 6);
		gc.drawOval(xValue - 3, yValue - 3, 6, 6);
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.swt.events.MouseMoveListener#mouseMove(org.eclipse.swt.events.MouseEvent)
	 */
	public void mouseMove(MouseEvent event) {
		
		// sets tooltip based on what is x-coordinate of mouse.
		
		Point canvasSize = getCanvasSize();
		int drawingAreaSize = canvasSize.x - (MARGIN_LEFT + MARGIN_OTHERS) ;
		
		// Count divider for x-coordinate
		double unit = (double)drawingAreaSize / ((double)information.getEvents().size() - 1);
		
		// If mouse pointer is over graph area
		if(event.x < (canvasSize.x - (MARGIN_OTHERS-GRAPHMARGIN)) && 
		   event.x > (MARGIN_LEFT - GRAPHMARGIN) &&
		   event.y > (MARGIN_OTHERS - GRAPHMARGIN) &&
		   event.y < (canvasSize.y - (MARGIN_OTHERS-GRAPHMARGIN)) )
		{
			// Count item's index based on x-coordinate
			double indexDouble = (event.x - MARGIN_LEFT) / unit;
			indexDouble += 0.5;
			int index = (int)indexDouble;
			
			if(index > information.getEvents().size()){
				index = information.getEvents().size()-1;
			}
			
			// Get time and measured value from object and set tooltip
			Date date = information.getEvents().get(index).getTime();
			SimpleDateFormat formatter = new SimpleDateFormat("dd.MM.yyyy HH:mm:ss:SSS");
			canvas.setToolTipText("Time:" + formatter.format(date) + " Value:" + Integer.toString(information.getEvents().get(index).getValue()));

		}
		else{
			canvas.setToolTipText(null);
		}

		
		
	}
	
	/**
	 * dispose.
	 */
	public void dispose(){
		canvas.dispose();
	}
	
	
	/**
	 * drawLimits.
	 * Draws y-axis max and min values + 3 values between those into given graphics content.
	 * @param gc graphics content where content is drawn
	 */
	private void drawLimits(GC gc) {
		
		// Left margin before texts
		int numberMargin = 20;
		int letterSize = 12;
		Point canvasSize = getCanvasSize();
		
		int min = 0;
		int max = 0;
		
		int[] minAndMax = getMinAndMax();
		min = minAndMax[0];
		max = minAndMax[1];

		// get difference between min and max value.
		double difference = max - min;
		
		// get multiplier for Y values from that difference.
		double yMultiplier = (canvasSize.y - MARGIN_OTHERS * 2) / difference;
		
		
		double xCoordDifference = ((double)(canvasSize.y - MARGIN_OTHERS * 2)) / 4;
		double valueDifference = ((double)(difference)) / 4;

		// Set colors
		gc.setForeground(Display.getCurrent().getSystemColor(SWT.COLOR_BLACK));
		gc.setBackground(Display.getCurrent().getSystemColor(SWT.COLOR_WIDGET_BACKGROUND));
		
		// Get start values
		double yCoord = (double)MARGIN_OTHERS;
		double value = (double)max;

		int i = 0;
		while(i < 5){
			
			// draw value
			String printedValueText = Integer.toString((int)(value + 0.5)) + information.getRule().getUnit();
			gc.drawText(printedValueText, numberMargin, (int) yCoord - letterSize);
			
			// draw text
			drawLine(gc, (int)yCoord, numberMargin, Display.getCurrent().getSystemColor(SWT.COLOR_GRAY));
			yCoord += xCoordDifference;
			value -= valueDifference;
			i++;
		
		}
		
		// draw "Time ->" text into x-axis.
		Point timeText = new Point(canvasSize.x / 2, canvasSize.y - MARGIN_OTHERS + 12); 
		gc.drawText("Time ->", timeText.x, timeText.y);
		
		
		// draw limits into graph
		
		TraceAnalyserRule rule = engine.getRule(this.information.getRule().getName());
		int[] limits = rule.getLimits();

		
		for(int item : limits){
			int yValue = (int)((item - min) * yMultiplier);
			yCoord = canvasSize.y - MARGIN_OTHERS - yValue;
			drawLine(gc, (int)yCoord, numberMargin, Display.getCurrent().getSystemColor(SWT.COLOR_RED));
		}
		
	}
	
	/**
	 * drawLine.
	 * Draws straight line into given y-coordinate.
	 * @param gc graphics content where content is drawn
	 * @param yCoord y-coordinate
	 * @param numbeMargin margin in front of line.
	 */
	private void drawLine(GC gc, int yCoord, int numberMargin, Color color){
		Color previousColor = gc.getForeground();
		gc.setForeground(color);	
		gc.drawLine(numberMargin, yCoord,getCanvasSize().x-(MARGIN_OTHERS-GRAPHMARGIN), yCoord );
		gc.setForeground(previousColor);


	}
	
	/**
	 * Returnns min and max value from one rule's history
	 * @return
	 */
	private int[] getMinAndMax(){
		TraceAnalyserRule rule = engine.getRule(this.information.getRule().getName());

		int[] limits = rule.getLimits();

		int min = information.getMin();
		int max = information.getMax();
		
		for(int item : limits){
			if(item > max){
				max = item;
			}
			else if(item < min){
				min = item;
			}
		}
		
		return new int[]{min,max};
	}

	/**
	 * sets context sensitive helps
	 */
	public void setHelps(){
		PlatformUI.getWorkbench().getHelpSystem().setHelp( canvas, com.nokia.s60tools.traceanalyser.resources.HelpContextIDs.TRACE_ANALYSER_HISTORY_VIEW);

	}
}