/*

 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). 

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of the License "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.carbide.cpp.pi.graphicsmemory;

import java.awt.Dimension;

import java.awt.event.FocusEvent;

import java.awt.event.FocusListener;

import java.text.DecimalFormat;

import java.util.ArrayList;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.TreeMap;

import org.eclipse.draw2d.ColorConstants;

import org.eclipse.draw2d.FigureCanvas;

import org.eclipse.draw2d.Graphics;

import org.eclipse.draw2d.MouseEvent;

import org.eclipse.draw2d.MouseMotionListener;

import org.eclipse.draw2d.Panel;

import org.eclipse.draw2d.geometry.PointList;

import org.eclipse.jface.action.Action;

import org.eclipse.jface.viewers.CheckboxTableViewer;

import org.eclipse.swt.SWT;

import org.eclipse.swt.custom.SashForm;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.graphics.Color;

import org.eclipse.swt.graphics.GC;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.graphics.RGB;

import org.eclipse.swt.graphics.Rectangle;

import org.eclipse.swt.layout.FillLayout;

import org.eclipse.swt.widgets.Combo;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Event;

import org.eclipse.swt.widgets.Menu;

import org.eclipse.swt.widgets.MenuItem;

import org.eclipse.ui.PlatformUI;

import com.nokia.carbide.cpp.internal.pi.analyser.NpiInstanceRepository;

import com.nokia.carbide.cpp.internal.pi.model.GenericSampledTrace;

import com.nokia.carbide.cpp.internal.pi.plugin.model.IContextMenu;

import com.nokia.carbide.cpp.internal.pi.plugin.model.ITitleBarMenu;

import com.nokia.carbide.cpp.internal.pi.visual.GenericTraceGraph;

import com.nokia.carbide.cpp.internal.pi.visual.GraphComposite;

import com.nokia.carbide.cpp.internal.pi.visual.PIEvent;

import com.nokia.carbide.cpp.internal.pi.visual.PIEventListener;

import com.nokia.carbide.cpp.pi.editors.PIPageEditor;

import com.nokia.carbide.cpp.pi.util.ColorPalette;

import com.nokia.carbide.cpp.pi.visual.IGenericTraceGraph;

public class GraphicsMemoryTraceGraph extends GenericTraceGraph implements

		FocusListener, PIEventListener, MouseMotionListener, IContextMenu,

		ITitleBarMenu {

	private enum UsageType {

		PRIVATE, SHARED, PRIVATE_SHARED

	};

	private boolean dynamicMemoryVisualisation = false;

	private GraphicsMemoryProcessTable graphicsMemoryProcessTable;

	private CheckboxTableViewer memoryTableViewer;

	// 3 tabs can share the same trace, but they need different graphs

	private GraphicsMemoryTrace memTrace;

	private FigureCanvas leftFigureCanvas;

	// whether any table items are enabled

	private boolean haveEnabled = false;

	private boolean readyToDraw = false;

	private int width = 600;

	private int height = 400;

	private UsageType paintMode;

	int[] sharedPoints;

	int[] privatePoints;

	private TreeMap<Long, Integer> eventPrivateListY;

	private TreeMap<Long, Integer> eventSharedListY;

	private TreeMap<Long, Integer> eventPrivateSharedListY;

	private int maxShared = 0;

	private int maxPrivate = 0;

	private int maxSharedPrivate = 0;

	private int maxUsedMemory = 0;

	private DecimalFormat memKBFormat = new DecimalFormat(Messages

			.getString("GraphicsMemoryTraceGraph.KBformat")); //$NON-NLS-1$

	private DecimalFormat memMBFloatFormat = new DecimalFormat(Messages

			.getString("GraphicsMemoryTraceGraph.MBformat")); //$NON-NLS-1$

	private static int xLegendHeight = 50;

	private boolean firstTimeDrawProcessList = true;

	private Composite holder;

	private boolean showMemoryUsageLine = true;

	public GraphicsMemoryTraceGraph(int graphIndex,

			GraphicsMemoryTrace memTrace, int uid) {

		super((GenericSampledTrace) memTrace);

		if (memTrace != null) {

			// if no version number is found from trace, we can assume

			// that the first version of the graphics memory model is in use

			this.memTrace = memTrace;

			if (memTrace.getVersion() == 0) {

				memTrace.setVersion(100);

			}

		}

		this.graphIndex = graphIndex;

		this.memTrace = memTrace;

		this.paintMode = UsageType.PRIVATE_SHARED;

		this.setScale(10);

		if (memTrace == null) {

			System.out.print(Messages

					.getString("GraphicsMemoryTraceGraph.traceDataNotFound")); //$NON-NLS-1$

			return;

		}

		memTrace.gatherDrawData();

		// create the label and a tableviewer

		holder = new Composite(NpiInstanceRepository.getInstance()

				.getProfilePage(uid, graphIndex).getBottomComposite(), SWT.NONE);

		PlatformUI.getWorkbench().getHelpSystem().setHelp(holder,

				GraphicsMemoryPlugin.HELP_CONTEXT_ID_MAIN_PAGE);

		holder.setLayout(new FillLayout());

		this.graphicsMemoryProcessTable = new GraphicsMemoryProcessTable(this,

				holder);

		this.memoryTableViewer = this.graphicsMemoryProcessTable

				.getTableViewer();

		this.readyToDraw = true;

	}

	public void action(String actionString) {

		if (actionString.equals("private_on")) //$NON-NLS-1$

		{

			paintMode = UsageType.PRIVATE;

		} else if (actionString.equals("shared_on")) //$NON-NLS-1$

		{

			paintMode = UsageType.SHARED;

		} else if (actionString.equals("private_shared_on")) //$NON-NLS-1$

		{

			paintMode = UsageType.PRIVATE_SHARED;

		} else if (actionString.equals("rescale_on")) //$NON-NLS-1$

		{

			dynamicMemoryVisualisation = true;

			makeProcessDrawLists();

		} else if (actionString.equals("rescale_off")) //$NON-NLS-1$

		{

			dynamicMemoryVisualisation = false;

			makeProcessDrawLists();

		} else if (actionString.equals("memory_usage_line_on")) //$NON-NLS-1$

		{

			showMemoryUsageLine = true;

		} else if (actionString.equals("memory_usage_line_off")) //$NON-NLS-1$

		{

			showMemoryUsageLine = false;

		} else {

			return;

		}

		this.repaint();

		if (this.leftFigureCanvas != null)

			this.leftFigureCanvas.redraw();

	}

	public void piEventReceived(PIEvent be) {

		switch (be.getType()) {

		// when the selection area changes, the maximum values shown for each

		// process

		// may change; if dynamicMemoryVisualisation is on, we'll also have a

		// new y-scaling factor

		case PIEvent.SELECTION_AREA_CHANGED:

			// before updating the tables, make sure that the memory trace has

			// computing the

			// maximum usage by each process within the new time interval

			double startTime = PIPageEditor.currentPageEditor().getStartTime();

			double endTime = PIPageEditor.currentPageEditor().getEndTime();

			memTrace.setMaxMemDataByInterval((int) (startTime * 1000),

					(int) (endTime * 1000));

			// send this message to the 2 other graphs

			PIEvent be2 = new PIEvent(be.getValueObject(),

					PIEvent.SELECTION_AREA_CHANGED2);

			for (int i = 0; i < 3; i++) {

				GraphicsMemoryTraceGraph graph = (GraphicsMemoryTraceGraph) memTrace

						.getTraceGraph(i);

				if (graph != this) {

					graph.piEventReceived(be2);

				}

			}

			be = be2;

			// FALL THROUGH

		case PIEvent.SELECTION_AREA_CHANGED2:

			double[] values = (double[]) be.getValueObject();

			this.setSelectionStart(values[0]);

			this.setSelectionEnd(values[1]);

			this.graphicsMemoryProcessTable.piEventReceived(be);

			this.repaint();

			break;

		case PIEvent.CHANGED_MEMORY_TABLE:

			this.makeProcessDrawLists();

			this.repaint();

			if (this.leftFigureCanvas != null)

				this.leftFigureCanvas.redraw();

			break;

		case PIEvent.SCALE_CHANGED:

			double scale = ((Double) be.getValueObject()).doubleValue();

			this.setScale(scale);

			this.repaint();

			break;

		case PIEvent.SCROLLED:

			Event event = ((Event) be.getValueObject());

			this.parentComponent.setScrolledOrigin(event.x, event.y,

					(FigureCanvas) event.data);

			this.repaint();

			break;

		default:

			break;

		}

	}

	public void focusGained(FocusEvent fe) {

	}

	public void focusLost(FocusEvent fe) {

	}

	public void paint(Panel panel, Graphics graphics) {

		if (!readyToDraw)

			return;

		this.setSize(this.getSize().width, getVisualSize().height);

		this.makeProcessDrawLists();

		this.paintProcesses(graphics);

		this.drawDottedLineBackground(graphics,

				GraphicsMemoryTraceGraph.xLegendHeight);

		if (showMemoryUsageLine) {

			paintMemoryUsageLine(graphics);

		}

		// draw the same selection as the Address/Process trace

		this.drawSelectionSection(graphics,

				GraphicsMemoryTraceGraph.xLegendHeight);

	}

	private void paintMemoryUsageLine(Graphics graphics) {

		Color black = ColorPalette.getColor(new RGB(0, 0, 0));

		graphics.setBackgroundColor(black);

		graphics.setForegroundColor(black);

		PointList pl = new PointList();

		Iterator<GraphicsMemorySampleByTime> iterator = memTrace

				.getDrawDataByTime().iterator();

		while (iterator.hasNext()) {

			GraphicsMemorySampleByTime msbt = iterator.next();

			// calculate new x coord's value and round it to integer

			int xCoord = (int) ((msbt.getTime() / getScale()) + 0.5);

			int maxBytes;

			if (dynamicMemoryVisualisation) {

				if (paintMode == UsageType.PRIVATE) {

					maxBytes = maxPrivate;

				} else if (paintMode == UsageType.SHARED) {

					maxBytes = maxShared;

				} else {

					maxBytes = maxSharedPrivate;

				}

			} else {

				if (paintMode == UsageType.PRIVATE) {

					if (showMemoryUsageLine) {

						maxBytes = memTrace.getTraceTotalMemory();

					} else {

						maxBytes = memTrace.getTraceMaxPrivate();

					}

				} else if (paintMode == UsageType.SHARED) {

					maxBytes = memTrace.getTraceMaxShared();

				} else {

					if (showMemoryUsageLine) {

						maxBytes = memTrace.getTraceTotalMemory();

					} else {

						maxBytes = memTrace.getTraceMaxTotal();

					}

				}

			}

			int yMultiplier = prettyMaxBytes(maxBytes) / height;

			// calculate new y-coord's value and round it to integer

			int yCoord = (int) (((double) height - (double) msbt

					.getUsedMemory()

					/ yMultiplier) + 0.5);

			if(pl.size() > 0) {

				pl.addPoint(xCoord, pl.getLastPoint().y);

			}	

			pl.addPoint(xCoord, yCoord);

		}

		graphics.setLineWidth(2);

		graphics.drawPolyline(pl);

	}

	private void paintPrivates(Graphics graphics) {

		graphics.setBackgroundColor(ColorConstants.lightBlue);

		graphics.fillPolygon(privatePoints);

		graphics.setBackgroundColor(ColorConstants.gray);

	}

	private void paintShared(Graphics graphics, UsageType paintMode) {

		if (eventSharedListY == null)

			return;

		// if needed, move every y-value that is 0 down a little so that the

		// line is more visible

		// boolean increase0 = paintMode != UsageType.SHARED;

		if (paintMode == UsageType.SHARED) {

			graphics.setBackgroundColor(ColorConstants.lightGreen);

			graphics.fillPolygon(sharedPoints);

			graphics.setBackgroundColor(ColorConstants.gray);

		} else {

			int lineWidth = graphics.getLineWidth();

			Color color = graphics.getForegroundColor();

			graphics.setForegroundColor(ColorConstants.lightGreen);

			graphics.setLineWidth(2);

			graphics.drawPolyline(sharedPoints);

			graphics.setForegroundColor(color);

			graphics.setLineWidth(lineWidth);

		}

	}

	private void paintProcesses(Graphics graphics) {

		// paints treads when using event based memory model

		// if there are no processes to draw

		if (!haveEnabled)

			return;

		int maxBytes = 0;

		double yMultiplier;

		double xMultiplier;

		xMultiplier = this.getScale();

		// get las x coordinate of trace

		long lastEvent = ((GraphicsMemorySample) memTrace.samples

				.get(memTrace.samples.size() - 1)).sampleSynchTime;

		int lastXCoord = (int) (lastEvent / xMultiplier);

		if (paintMode == UsageType.PRIVATE && eventPrivateListY != null) {

			privatePoints = new int[eventPrivateListY.size() * 4 + 6];

			if (dynamicMemoryVisualisation)

				maxBytes = maxPrivate;

			else {

				if (showMemoryUsageLine) {

					maxBytes = memTrace.getTraceTotalMemory();

				} else {

					maxBytes = memTrace.getTraceMaxPrivate();

				}

			}

			// multiplier is bytes / pixel in the graph

			yMultiplier = prettyMaxBytes(maxBytes) / height;

			createGraphPolygon(this.eventPrivateListY, privatePoints,

					xMultiplier, yMultiplier, lastXCoord);

			this.paintPrivates(graphics);

		} else if (paintMode == UsageType.SHARED && eventSharedListY != null) {

			sharedPoints = new int[eventSharedListY.size() * 4 + 6];

			if (dynamicMemoryVisualisation)

				maxBytes = maxShared;

			else {

				maxBytes = memTrace.getTraceMaxShared();				

			}

			// multiplier is bytes / pixel in the final graph

			yMultiplier = prettyMaxBytes(maxBytes) / height;

			createGraphPolygon(this.eventSharedListY, sharedPoints,

					xMultiplier, yMultiplier, lastXCoord);

			this.paintShared(graphics, paintMode);

		} else if (eventPrivateSharedListY != null) // private and shared

		{

			sharedPoints = new int[eventSharedListY.size() * 4 + 6];

			privatePoints = new int[eventPrivateListY.size() * 4 + 6];

			if (dynamicMemoryVisualisation)

				maxBytes = maxPrivate > maxShared ? maxPrivate : maxShared;

			else {

				if (showMemoryUsageLine) {

					maxBytes = memTrace.getTraceTotalMemory();

				} else {

					maxBytes = memTrace.getTraceMaxPrivate() > memTrace

							.getTraceMaxShared() ? memTrace

							.getTraceMaxPrivate() : memTrace

							.getTraceMaxShared();

				}

			}

			// multiplier is bytes / pixel in the final graph

			yMultiplier = prettyMaxBytes(maxBytes) / height;

			int totalSharedUsed = 1;

			createGraphPolygon(this.eventSharedListY, sharedPoints,

					xMultiplier, yMultiplier, lastXCoord);

			createGraphPolygon(this.eventPrivateListY, privatePoints,

					xMultiplier, yMultiplier, lastXCoord);

			this.paintPrivates(graphics);

			if (totalSharedUsed > 0)

				this.paintShared(graphics, paintMode);

		}

	}

	public void createGraphPolygon(TreeMap<Long, Integer> map, int[] points,

			double xMultiplier, double yMultiplier, int endXCoord) {

		// Creates graph polygon from TreeMap that contains all x and y values

		// of one graph.

		int index = 2;

		int xCoord = 0;

		int yCoord = 0;

		int previousYCoord = 0;

		// get first event and key from map.

		Iterator<Long> keys = map.keySet().iterator();

		Iterator<Integer> values = map.values().iterator();

		int previousXCoord = 0;

		int countOfSameXCoords = 1;

		// set first into zero so that polygon is drawn correctly

		points[0] = 0;

		points[1] = height;

		while (keys.hasNext()) {

			// create polygon's points so that each memory allocation is drawn

			// as one leap in graph

			// calculate new x coord's value and round it to integer

			xCoord = (int) (((double) keys.next() / xMultiplier) + 0.5);

			// calculate new y-coord's value and round it to integer

			yCoord = (int) (((double) height - (double) values.next()

					/ yMultiplier) + 0.5);

			if (xCoord == previousXCoord && index > 3) {

				// if more than one sample at one point in the screen, count

				// average value

				// for y coordinate

				// count average value

				double sum = ((double) yCoord + (double) previousYCoord

						* (double) countOfSameXCoords);

				countOfSameXCoords++;

				yCoord = (int) (sum / (double) (countOfSameXCoords));

				// add average coordinate to array

				index = index - 4;

				index = addCoordsToGraphArray(xCoord, yCoord, index, points);

			} else {

				countOfSameXCoords = 1;

			}

			index = addCoordsToGraphArray(xCoord, yCoord, index, points);

			// save coordinates to previousValues

			previousYCoord = yCoord;

			previousXCoord = xCoord;

		}

		// Set last coordinates to zero so that polygon is drawn correctly

		points[points.length - 4] = endXCoord;

		points[points.length - 3] = points[points.length - 5];

		points[points.length - 2] = endXCoord;

		points[points.length - 1] = height;

	}

	private int addCoordsToGraphArray(int xCoord, int yCoord, int arrayIndex,

			int[] array) {

		// adds coordinates to array so that polygon can be drawn from that

		// array