/*

 * 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 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.memory;

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.Enumeration;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.TreeMap;

import java.util.Map.Entry;

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.jface.viewers.CheckboxTableViewer;

import org.eclipse.swt.SWT;

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.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Event;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Menu;

import org.eclipse.swt.widgets.MenuItem;

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

import com.nokia.carbide.cpp.internal.pi.memory.actions.MemoryStatisticsDialog;

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.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;

public class MemTraceGraph extends GenericTraceGraph implements FocusListener,

		PIEventListener, MouseMotionListener, IContextMenu {

	private enum UsageType {

		CHUNKS, HEAPSTACK, CHUNKS_HEAPSTACK

	};

	private boolean dynamicMemoryVisualisation = false;

	private MemThreadTable memThreadTable;

	private CheckboxTableViewer memoryTableViewer;

	Hashtable<Integer, Integer> threadList;

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

	private MemTrace 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 final int defaultSamplingTime = 3000;

	private int samplingTime;

	private UsageType paintMode;

	private int[] chunkListY;

	private int[] stackListY;

	private int[] chunkStackListY;

	private int[] polyListX;

	int[] stackAndHeapPoints;

	int[] chunkPoints;

	private TreeMap<Long, Integer> eventChunkListY;

	private TreeMap<Long, Integer> eventStackListY;

	private TreeMap<Long, Integer> eventChunkStackListY;

	private int minStack = Integer.MAX_VALUE;

	private int maxStack = 0;

	private int minHeap = Integer.MAX_VALUE;

	private int maxChunks = 0;

	private int minStackHeap = Integer.MAX_VALUE;

	private int maxStackHeap = 0;

	private DecimalFormat memKBFormat = new DecimalFormat(Messages

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

	private DecimalFormat memMBFloatFormat = new DecimalFormat(Messages

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

	private static int xLegendHeight = 20;

	private boolean firstTimeDrawThreadList = true;

	public MemTraceGraph(int graphIndex, MemTrace memTrace, int uid) {

		super((GenericSampledTrace) memTrace);

		// 

		if (memTrace != null) {

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

			// that sampling based memory model is in use

			this.memTrace = memTrace;

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

				memTrace.setVersion(156);

			}

		}

		this.graphIndex = graphIndex;

		this.memTrace = memTrace;

		this.paintMode = UsageType.CHUNKS_HEAPSTACK;

		this.setScale(10);

		if (memTrace == null) {

			System.out.print(Messages

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

			return;

		}

		samplingTime = calcSamplingTime();

		memTrace.gatherDrawData();

		// create the label and a tableviewer

		Composite holder = new Composite(NpiInstanceRepository.getInstance()

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

		GridLayout gl = new GridLayout();

		gl.marginHeight = 0;

		gl.marginWidth = 0;

		gl.marginLeft = 0;

		gl.marginRight = 0;

		holder.setLayout(gl);

		Label label = new Label(holder, SWT.CENTER);

		label

				.setBackground(holder.getDisplay().getSystemColor(

						SWT.COLOR_WHITE));

		label.setFont(PIPageEditor.helvetica_8);

		label.setText(Messages.getString("MemTraceGraph.graphTitle")); //$NON-NLS-1$

		label.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

		this.memThreadTable = new MemThreadTable(this, holder);

		this.memoryTableViewer = this.memThreadTable.getTableViewer();

		this.readyToDraw = true;

	}

	public void action(String actionString) {

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

		{

			paintMode = UsageType.CHUNKS;

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

		{

			paintMode = UsageType.HEAPSTACK;

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

		{

			paintMode = UsageType.CHUNKS_HEAPSTACK;

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

		{

			dynamicMemoryVisualisation = true;

			makeThreadDrawLists();

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

		{

			dynamicMemoryVisualisation = false;

			makeThreadDrawLists();

		} 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

		// thread/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 thread/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++) {

				MemTraceGraph graph = (MemTraceGraph) 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.memThreadTable.piEventReceived(be);

			this.repaint();

			break;

		case PIEvent.CHANGED_MEMORY_TABLE:

			this.makeThreadDrawLists();

			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);

			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.makeThreadDrawLists();

		this.paintThreads(graphics);

		this.drawDottedLineBackground(graphics, MemTraceGraph.xLegendHeight);

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

		this.drawSelectionSection(graphics, MemTraceGraph.xLegendHeight);

	}

	private void paintSampledChunks(Graphics graphics) {

		if (chunkListY == null)

			return;

		int[] points = new int[chunkListY.length * 2];

		for (int i = 0, j = 0; i < chunkListY.length; i++) {

			points[j++] = polyListX[i];

			points[j++] = chunkListY[i];

		}

		graphics.setBackgroundColor(ColorConstants.orange);

		graphics.fillPolygon(points);

		graphics.setBackgroundColor(ColorConstants.gray);

	}

	private void paintEventBasedChunks(Graphics graphics) {

		/*

		 * if (chunkListY == null) return;

		 */

		/*

		 * int[] points = new int[chunkListY.length * 2];

		 * 

		 * for (int i = 0, j =0; i < chunkListY.length; i++) { points[j++] =

		 * polyListX[i]; points[j++] = chunkListY[i]; }

		 */

		graphics.setBackgroundColor(ColorConstants.orange);

		graphics.fillPolygon(chunkPoints);

		graphics.setBackgroundColor(ColorConstants.gray);

	}

	private void paintSampledStack(Graphics graphics, UsageType paintMode) {

		if (stackListY == 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.HEAPSTACK;

		int[] points = new int[stackListY.length * 2];

		for (int i = 0, j = 0; i < stackListY.length; i++) {

			points[j++] = polyListX[i];

			points[j] = stackListY[i];

			if (increase0 && (points[j] == 0))

				points[j] = 1;

			j++;

		}

		if (paintMode == UsageType.HEAPSTACK) {

			graphics.setBackgroundColor(ColorConstants.blue);

			graphics.fillPolygon(points);

			graphics.setBackgroundColor(ColorConstants.gray);

		} else {

			int lineWidth = graphics.getLineWidth();

			Color color = graphics.getForegroundColor();

			graphics.setForegroundColor(ColorConstants.blue);

			graphics.setLineWidth(2);

			graphics.drawPolyline(points);

			graphics.setForegroundColor(color);

			graphics.setLineWidth(lineWidth);

		}

	}

	private void paintEventBasedStack(Graphics graphics, UsageType paintMode) {

		if (eventStackListY == 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.HEAPSTACK;

		/*

		 * int[] points = new int[stackListY.length * 2];

		 * 

		 * for (int i = 0, j =0; i < stackListY.length; i++) { points[j++] =

		 * polyListX[i]; points[j] = stackListY[i];

		 * 

		 * if (increase0 && (points[j] == 0)) points[j] = 1;

		 * 

		 * j++; }

		 */

		if (paintMode == UsageType.HEAPSTACK) {

			graphics.setBackgroundColor(ColorConstants.blue);

			graphics.fillPolygon(stackAndHeapPoints);

			graphics.setBackgroundColor(ColorConstants.gray);

		} else {

			int lineWidth = graphics.getLineWidth();

			Color color = graphics.getForegroundColor();

			graphics.setForegroundColor(ColorConstants.blue);

			graphics.setLineWidth(2);

			graphics.drawPolyline(stackAndHeapPoints);

			graphics.setForegroundColor(color);

			graphics.setLineWidth(lineWidth);

		}

	}

	private void paintThreads(Graphics graphics) {

		if (memTrace.getVersion() >= 202) {

			paintEventBasedThreads(graphics);

		} else {

			paintSampledThreads(graphics);

		}

	}

	private void paintSampledThreads(Graphics graphics) {

		// if there are no threads to draw

		if (!haveEnabled)

			return;

		int maxBytes = 0;

		double multiplier;

		if (paintMode == UsageType.CHUNKS && chunkListY != null) {

			if (dynamicMemoryVisualisation)

				maxBytes = maxChunks;

			else

				maxBytes = memTrace.getTraceMaxChunks();

			// multiplier is bytes / pixel in the graph

			if (true)// !dynamicMemoryVisualisation)

				multiplier = prettyMaxBytes(maxBytes) / height;

			else

				multiplier = maxBytes / height;

			// System.out.println("maxBytes " + maxBytes + " multiplier " +

			// multiplier + " height " + height);

			for (int j = 1; j < chunkListY.length - 1; j++) {

				chunkListY[j] = (int) (height - chunkListY[j] / multiplier);

				if (chunkListY[j] < 0)

					chunkListY[j] = 0;

			}

			this.paintSampledChunks(graphics);

		} else if (paintMode == UsageType.HEAPSTACK && stackListY != null) {

			if (dynamicMemoryVisualisation)

				maxBytes = maxStack;

			else

				maxBytes = memTrace.getTraceMaxStackHeap();

			// multiplier is bytes / pixel in the final graph

			if (true)// !dynamicMemoryVisualisation)

				multiplier = prettyMaxBytes(maxBytes) / height;

			else

				multiplier = maxBytes / height;

			// System.out.println("maxBytes " + maxBytes + " multiplier " +

			// multiplier + " height " + height);

			for (int j = 1; j < stackListY.length - 1; j++) {

				stackListY[j] = (int) (height - stackListY[j] / multiplier);

				if (stackListY[j] < 0)

					stackListY[j] = 0;

			}

			this.paintSampledStack(graphics, paintMode);

		} else if (chunkStackListY != null) // heap and stack

		{

			if (dynamicMemoryVisualisation)

				maxBytes = maxChunks > maxStack ? maxChunks : maxStack;

			else

				maxBytes = memTrace.getTraceMaxChunks() > memTrace

						.getTraceMaxStackHeap() ? memTrace.getTraceMaxChunks()

						: memTrace.getTraceMaxStackHeap();

			// multiplier is bytes / pixel in the final graph

			if (true)// !dynamicMemoryVisualisation)

				multiplier = prettyMaxBytes(maxBytes) / height;

			else

				multiplier = maxBytes / height;

			// System.out.println("maxBytes " + maxBytes + " multiplier " +

			// multiplier + " height " + height);

			int totalStackUsed = 0;

			for (int j = 1; j < chunkListY.length - 1; j++) {

				totalStackUsed += stackListY[j];

				chunkListY[j] = (int) (height - chunkListY[j] / multiplier);

				stackListY[j] = (int) (height - stackListY[j] / multiplier);

				if (stackListY[j] < 0)

					stackListY[j] = 0;

				if (chunkListY[j] < 0)

					chunkListY[j] = 0;

			}

			this.paintSampledChunks(graphics);

			if (totalStackUsed > 0)

				this.paintSampledStack(graphics, paintMode);

		}

	}

	private void paintEventBasedThreads(Graphics graphics) {

		// paints treads when using event based memory model

		// if there are no threads to draw

		if (!haveEnabled)

			return;

		int maxBytes = 0;

		double yMultiplier;

		double xMultiplier;

		xMultiplier = this.getScale();

		// get las x coordinate of trace

		long lastEvent = ((MemSample) memTrace.samples.get(memTrace.samples

				.size() - 1)).sampleSynchTime;

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

		if (paintMode == UsageType.CHUNKS && eventChunkListY != null) {

			chunkPoints = new int[eventChunkListY.size() * 4 + 6];

			if (dynamicMemoryVisualisation)

				maxBytes = maxChunks;

			else

				maxBytes = memTrace.getTraceMaxChunks();

			// multiplier is bytes / pixel in the graph

			if (true)// !dynamicMemoryVisualisation)

				yMultiplier = prettyMaxBytes(maxBytes) / height;

			else

				yMultiplier = maxBytes / height;

			// System.out.println("maxBytes " + maxBytes + " multiplier " +

			// multiplier + " height " + height);

			createGraphPolygon(this.eventChunkListY, chunkPoints, xMultiplier,

					yMultiplier, lastXCoord);

			this.paintEventBasedChunks(graphics);

		} else if (paintMode == UsageType.HEAPSTACK && eventStackListY != null) {

			stackAndHeapPoints = new int[eventStackListY.size() * 4 + 6];