/*

 * Copyright (c) 2008-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:  Definitions for the class AnalyzeToolGraph

 *

 */

package com.nokia.s60tools.analyzetool.internal.ui.graph;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.util.AbstractList;

import java.util.ArrayList;

import java.util.List;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.IResource;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.ListenerList;

import org.eclipse.draw2d.FigureCanvas;

import org.eclipse.draw2d.Graphics;

import org.eclipse.draw2d.KeyEvent;

import org.eclipse.draw2d.KeyListener;

import org.eclipse.draw2d.MouseEvent;

import org.eclipse.draw2d.MouseListener;

import org.eclipse.draw2d.MouseMotionListener;

import org.eclipse.draw2d.Panel;

import org.eclipse.draw2d.XYLayout;

import org.eclipse.draw2d.geometry.Point;

import org.eclipse.draw2d.geometry.PointList;

import org.eclipse.draw2d.geometry.Rectangle;

import org.eclipse.jface.dialogs.MessageDialogWithToggle;

import org.eclipse.jface.preference.IPreferenceStore;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.ISelectionProvider;

import org.eclipse.jface.viewers.SelectionChangedEvent;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.ControlAdapter;

import org.eclipse.swt.events.ControlEvent;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.events.SelectionListener;

import org.eclipse.swt.graphics.Image;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Display;

import org.eclipse.ui.IPartListener;

import org.eclipse.ui.IPartService;

import org.eclipse.ui.IWindowListener;

import org.eclipse.ui.IWorkbenchPart;

import org.eclipse.ui.IWorkbenchPartSite;

import org.eclipse.ui.IWorkbenchWindow;

import org.eclipse.ui.PartInitException;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.views.properties.PropertySheet;

import com.nokia.s60tools.analyzetool.Activator;

import com.nokia.s60tools.analyzetool.engine.IMemoryActivityModel;

import com.nokia.s60tools.analyzetool.engine.IMemoryActivityModelChangeListener;

import com.nokia.s60tools.analyzetool.engine.statistic.AllocInfo;

import com.nokia.s60tools.analyzetool.engine.statistic.BaseInfo;

import com.nokia.s60tools.analyzetool.engine.statistic.FreeInfo;

import com.nokia.s60tools.analyzetool.engine.statistic.ProcessInfo;

import com.nokia.s60tools.analyzetool.engine.statistic.SymReader;

import com.nokia.s60tools.analyzetool.global.Util;

import com.nokia.s60tools.analyzetool.internal.ui.util.ColorUtil;

import com.nokia.s60tools.analyzetool.internal.ui.util.GraphUtils;

import com.nokia.s60tools.analyzetool.ui.MainView;

import com.nokia.s60tools.analyzetool.ui.ResourceVisitor;

/**

 * A FigureCanvas containing the graph and X-axis area of the 

 * AnalyzeTool chart.

 */

public class AnalyzeToolGraph extends FigureCanvas implements IMemoryActivityModelChangeListener {

	private static final int BOUNDARY_OFFSET = 3;

	/** used for range model listener */

	private static final String PROP_MAXIMUM = "maximum"; //$NON-NLS-1$

	private static final int X_AXIS_HEIGHT = 50;

	/** used for "Don't ask again" dialog */

	private static final String PROMPT_KEY = "GraphOptimisationPrompt";//$NON-NLS-1$

	/** the scaling factor used for scaling the x-axis*/

	private double scale = 1.0;

	/** the model */

	private IMemoryActivityModel model;

	/** for synchronisation with the PropertySheet */

	private DotSelectionProvider iDotsSelecProv = new DotSelectionProvider();

	private IWorkbenchPartSite site;

	/** used when user selects a dot on the graph, and moves with arrow keys */

	private ISelection iCurrentSelectedDot = null;

	/** controls mouse and arrow key movements */

	private MouseAndKeyController mc;

	private SymReader iSymReader = null;

	private IProject iCurrentProject = null;

	/** Contains c++ files info for the current project. */

	private final AbstractList<String> cppFileNames;

	/** "time ->" on axis*/

	private Image timeImage;

	private GraphPartServiceListener iGraphPartServiceListener;

	private boolean optimisedDrawing;

	private boolean userInformed;

	/**

	 * Constructor

	 * @param parent The parent composite

	 */

	public AnalyzeToolGraph(Composite parent) {

		super(parent);

		IPartService partService = PlatformUI.getWorkbench()

				.getActiveWorkbenchWindow().getPartService();

		iGraphPartServiceListener = new GraphPartServiceListener();

		partService.addPartListener(iGraphPartServiceListener);

		PlatformUI.getWorkbench().addWindowListener(iGraphPartServiceListener);

		cppFileNames = new ArrayList<String>();

	}

	/**

	 * Draws the graph on the canvas. Intended to be called on a paint event. 

	 * @param graphics

	 */

	public void paint(final Graphics graphics) {

		if (optimisedDrawing && !userInformed){

			userInformed = true;

			IPreferenceStore preferenceStore = Activator.getPreferences();

            if (!preferenceStore.getString(PROMPT_KEY).equals(MessageDialogWithToggle.ALWAYS)) {

                String dilaogTitle = "Optimised Graph";

                String message = "The process contains too many memory operations to display efficiently. To optimise, only leaks will be indicated on the graph.";

                String toggleMessage = "Don't show this again";

                MessageDialogWithToggle.openInformation(getShell(), dilaogTitle, message, toggleMessage, false, preferenceStore, PROMPT_KEY);

            }

		}

		Rectangle visibleRect = graphics.getClip(new org.eclipse.draw2d.geometry.Rectangle());

		YConverter yConverter = new YConverter(getClientArea().height, model.getHighestCumulatedMemoryAlloc());

		if (model.getSelectedProcess() != null && model.getSelectedProcess().getAllocsFrees().size() > 0){

			PointList pts = new PointList((model.getSelectedProcess().getAllocsFrees().size()*2)-1);

			Point prevPt = null;

			List<Point> dotLocations = new ArrayList<Point>();

			List<Integer> colorDotLocations = new ArrayList<Integer>();

			for (BaseInfo info : model.getSelectedProcess().getAllocsFrees()) {

				int x_point = (int) ((info.getTime() - model.getFirstProcessTime()) / getScale());

				int y_point = yConverter.bytesToY(info.getTotalMem());

				if (y_point < 0) {

					y_point = 0;

				}

				if (prevPt != null) {

					pts.addPoint(x_point, prevPt.y);

				}

				Point nextPt = new Point(x_point, y_point);

				if (visibleRect.contains(nextPt) && (isLeak(info) || (!optimisedDrawing && !dotLocations.contains(nextPt)))){

					//for improved performance, only draw dots that are in visible clip area

					//and don't draw a dot if there is one already, unless it's a leak

					dotLocations.add(nextPt);

					colorDotLocations.add(getColorForAllocType(info));

				}

				pts.addPoint(nextPt);

				prevPt = nextPt;

			}

			if (pts.size() > 0){

				graphics.pushState();

				graphics.setForegroundColor(Display.getDefault().getSystemColor(SWT.COLOR_DARK_YELLOW));

				graphics.setLineWidthFloat(optimisedDrawing ? 0.5f : 2.0f);

				graphics.drawPolyline(pts);

				graphics.setLineWidthFloat(optimisedDrawing ? 0.5f : 1.0f);

				graphics.setAntialias(SWT.ON);

				graphics.setForegroundColor(Display.getDefault().getSystemColor(SWT.COLOR_RED));

				graphics.setBackgroundColor(Display.getDefault().getSystemColor(SWT.COLOR_RED));

				int colourCode = SWT.COLOR_RED;

				for (int j = 0; j < dotLocations.size(); j++) {

					Point dotLocation = dotLocations.get(j);

					if (!optimisedDrawing && colorDotLocations.get(j) != colourCode) {

						colourCode = colorDotLocations.get(j);

						graphics.setBackgroundColor(Display.getDefault().getSystemColor(colourCode));

					}

					// paint the dot

					graphics.fillOval(dotLocation.x - 2, dotLocation.y - 2,	5, 5);

					if (!optimisedDrawing && colourCode == SWT.COLOR_RED) {

						// draw a red line

						graphics.drawLine(dotLocation.x, dotLocation.y,	dotLocation.x, yConverter.bytesToY(0));

					}

				}

				graphics.popState();

			}

		}

	}

	/**

	 * Draws the background grid on the canvas. Intended to be called on a paint event.

	 * @param graphics

	 */

	public void drawBackGroundLines(Graphics graphics) {

		Rectangle canvasRect = graphics.getClip(new org.eclipse.draw2d.geometry.Rectangle());

		graphics.setForegroundColor(ColorUtil.COLOR_100); // middle grey

		graphics.setBackgroundColor(ColorUtil.COLOR_170); // lighter grey

		int height = getClientArea().height;

		int width = getClientArea().width;

		graphics.fillRectangle(new Rectangle(canvasRect.x, 0, width, height - X_AXIS_HEIGHT));

		double visY = height - X_AXIS_HEIGHT;

		int k = 0;

		// horizontal lines, height is divided into 10 sections, line is dotted

		// (5 pixel length)

		for (float y = 0; k <= 10; y += visY * 10000 / 100001, k++) {

			for (int x = canvasRect.x; x <= canvasRect.x + canvasRect.width; x += 5) {

				if ((x / 5) % 2 == 0)

					graphics.drawLine(x, ((int) y) + 1, x + 5, ((int) y) + 1);

			}

		}

		graphics.setForegroundColor(ColorUtil.COLOR_100);

		graphics.setBackgroundColor(ColorUtil.WHITE);

		int alignedLeftEdge = ((int)(canvasRect.x / 50))*50;

		// vertical lines (one darker, one lighter vertical line in turns every

		// 50 points in width)

		if (width > 0) {

			for (int x = alignedLeftEdge ; x <= canvasRect.x + canvasRect.width; x += 50) {

				if (x % 100 == 0)

					graphics.setForegroundColor(ColorUtil.COLOR_100);

				else

					graphics.setForegroundColor(ColorUtil.COLOR_200);

				for (int y = 0; y < height; y += 5) {

					if ((y / 5) % 2 == 0)

						graphics.drawLine(x, y, x, y + 5);

				}

			}

		}

		graphics.setForegroundColor(ColorUtil.COLOR_100);

		graphics.setBackgroundColor(ColorUtil.WHITE);

		for (int x = alignedLeftEdge; x <= canvasRect.x + canvasRect.width; x += 50) {

			String timeStringWithUnits = GraphUtils.getTimeStringWithUnits(x * scale);

			graphics.drawString(timeStringWithUnits, x + 5, height - 13);

		}

		if (timeImage == null){

			timeImage = GraphUtils.getVerticalLabel("Time");			

		}

		graphics.drawImage(timeImage, width / 2, height - 30);

	}

	/**

	 * Returns the content of the tooltip appropriate for the given coordinate

	 * @param x the X-coordinate

	 * @param y the Y-coordinate

	 * @return String containing the content of the tooltip

	 */

	public String getToolTipText(int x, int y) {

		StringBuilder text = new StringBuilder();

		if (model.getSelectedProcess() == null) {

			return "";

		}

		if (y > getClientArea().height - X_AXIS_HEIGHT) {

			return null;

		}

		double timeInMs = (x * getScale());// x value in milliseconds

		YConverter yConverter = new YConverter(getClientArea().height, model.getHighestCumulatedMemoryAlloc());

		double bytes = yConverter.yToBytes(y); // y value in bytes

		text.append(GraphUtils.renderTime(timeInMs)); 

		BaseInfo allocInfo = findClosestAlloc((int) timeInMs, (int) ((x - BOUNDARY_OFFSET) * getScale()), (int) ((x + BOUNDARY_OFFSET) * getScale()),

				(int) bytes, (int) yConverter.yToBytes(y + BOUNDARY_OFFSET), (int) yConverter.yToBytes(y - BOUNDARY_OFFSET));

		if (allocInfo != null) {

			text.append(String.format("%n%s: %,d B%nTotal: %,d B",

					getMemOpString(allocInfo), 

					Math.abs(allocInfo.getSizeInt()), 

					allocInfo.getTotalMem()));

		} else {

			text.append(", " + GraphUtils.formatBytes(bytes));

		}

		return text.toString();

	}

	/**

	 * Returns a string representation of the type of the given memory operation

	 * @param allocInfo the memory operation to use

	 * @return 

	 */

	private String getMemOpString(BaseInfo allocInfo){

		return allocInfo instanceof AllocInfo ? (((AllocInfo) allocInfo).isFreed() ? "Alloc" : "Leak"  ): "Free";

	}

	/**

	 * Convenience method for

	 * {@link #findClosestAlloc(int, int, int, int, int, int)} wrapping

	 * conversion from x,y coordinates to time and byte values.

	 * 

	 * @param x

	 *            X-coordinate

	 * @param y

	 *            Y-coordinate

	 * @return closest BaseInfo within bounds, or null if none found

	 */

	private BaseInfo findClosest(int x, int y) {

		if (y > getClientArea().height - X_AXIS_HEIGHT) {

			return null;

		}

		YConverter yConverter = new YConverter(getClientArea().height, model.getHighestCumulatedMemoryAlloc());

		return findClosestAlloc((int) (x * getScale()), (int) ((x - BOUNDARY_OFFSET) * getScale()), (int) ((x + BOUNDARY_OFFSET) * getScale()),

				(int) (yConverter.yToBytes(y)), (int) yConverter.yToBytes(y + BOUNDARY_OFFSET), (int) yConverter.yToBytes(y - BOUNDARY_OFFSET));

	}

	/**

	 * Finds the closest matching BaseInfo in the model. BaseInfo has to fit

	 * into the given bounds and be a better match than other BaseInfo in the

	 * same bounds.

	 * 

	 * @param timeInMsMidPoint

	 *            time in milliseconds for the exact point of interest

	 * @param timeInMsBoundLeft

	 *            Left boundary for time in milliseconds

	 * @param timeInMsBoundRight

	 *            Right boundary for time in milliseconds

	 * @param bytesMidPoint

	 *            Cumulative memory in bytes for the exact point of interest

	 * @param bytesBoundLeft

	 *            Left boundary for cumulative memory in bytes

	 * @param bytesBoundRight

	 *            Right boundary for cumulative memory in bytes

	 * @return

	 */

	private BaseInfo findClosestAlloc(int timeInMsMidPoint, int timeInMsBoundLeft, int timeInMsBoundRight, int bytesMidPoint, int bytesBoundLeft,

			int bytesBoundRight) {

		BaseInfo ret = null;

		if (model.getSelectedProcess() == null){

			return ret;

		}

		int marginEnd = timeInMsBoundRight;

		ProcessInfo process = model.getSelectedProcess();

		AbstractList<BaseInfo> allocsFrees = process.getAllocsFrees();

		Long firstTime = model.getFirstProcessTime();

		for (BaseInfo info : allocsFrees) {

			Long infoRelativeTime = info.getTime() - firstTime;

			// check current alloc info is within given bounds

			if (infoRelativeTime >= timeInMsBoundLeft && infoRelativeTime <= marginEnd && info.getTotalMem() >= bytesBoundLeft

					&& info.getTotalMem() <= bytesBoundRight) {

				// check whether current alloc info is a better match than

				// previously found

				if (ret == null

						|| (Math.abs(infoRelativeTime - timeInMsMidPoint) < Math.abs((ret.getTime() - firstTime) - timeInMsMidPoint))

						|| ((ret.getTime() - firstTime) == infoRelativeTime && Math.abs(info.getTotalMem() - bytesMidPoint) < Math.abs(ret

								.getTotalMem()

								- bytesMidPoint))) {

					ret = info;

				}

			} else if ((info.getTime() - firstTime) > timeInMsBoundRight) {

				break;

			}

		}

		return ret;

	}

	/**

	 * Finds the next AllocInfo in the model.

	 * 

	 * @param allocInfo

	 *            AllocInfo prior to the one to return

	 * @return The next AllocInfo in the model. This may return null if the

	 *         passed object was the last in the model.

	 */

	private BaseInfo findNextAlloc(BaseInfo allocInfo, boolean forward) {

		BaseInfo ret = null;

		ProcessInfo processInfo = model.getSelectedProcess();

		if (processInfo == null){

			return ret;

		}

		AbstractList<BaseInfo> allocsFrees = processInfo.getAllocsFrees(); 

		int i = allocsFrees.indexOf(allocInfo);

		if (forward) {

			if (i < allocsFrees.size() - 1) {

				ret = allocsFrees.get(i + 1);

			}

		} else {

			if (i > 0) {

				ret = allocsFrees.get(i - 1);

			}

		}

		return ret;

	}

	/**

	 * This method first zooms in graph to the maximum possible scale and zooms

	 * out so that it fits in the canvas area.

	 * 

	 */

	public void zoomGraph() {

		int width = getClientArea().width;

		if (width <= 0 || model == null)

			return;

		double new_scale = getMaxTimeValueInMilliSeconds() / width;

		setScale(new_scale);

		setZoomedSize(0);

	}

	/**

	 * Returns the current scaling factor for the graph's width

	 * @return

	 */

	public double getScale() {

		return scale;

	}

	/**

	 * Sets the scaling factor for the graph's width

	 * @param scale

	 */

	public void setScale(double newScale) {

		this.scale = newScale;

	}

	/**

	 * Returns the highest time value of the current graph in milliseconds

	 * @return

	 */

	public long getLastTimeValueInMilliSeconds() {

		return model.getLastProcessTime() - model.getFirstProcessTime();

	}

	/**

	 * Returns the last time value in the model plus 1 per cent.

	 * 

	 * @return

	 */

	private long getMaxTimeValueInMilliSeconds() {

		return getLastTimeValueInMilliSeconds() + (int) (getLastTimeValueInMilliSeconds() * 0.01);

	}

	/**

	 * Adds a new model to this class 

	 * @param model the IMemoryActivityModel to use

	 */

	public void setInput(IMemoryActivityModel newModel) {

		if (this.model != null){

			this.model.removeListener(this);

		}

		this.model = newModel;

		this.model.addListener(this);

	}

	/**

	 * Creates the content of the FigureCanvas. Intended to be called

	 * once in creating the ViewPart content. 

	 */

	public void createContent() {

		mc = new MouseAndKeyController();

		Panel panel = new Panel() {

			@Override

			public void paint(Graphics graphics) {

				if (model != null) {

					drawBackGroundLines(graphics);

					AnalyzeToolGraph.this.paint(graphics);

					mc.render(graphics);

				} else {

					erase();

				}

			}

		};

		panel.setLayoutManager(new XYLayout());

		panel.addMouseMotionListener(mc);

		panel.addMouseListener(mc);

		panel.addKeyListener(mc);

		setContents(panel);

		panel.setFocusTraversable(true);

		final org.eclipse.swt.widgets.ScrollBar horizontalBar = getHorizontalBar();

		horizontalBar.addSelectionListener(new SelectionListener() {

			public void widgetDefaultSelected(SelectionEvent arg0) {

			}

			public void widgetSelected(SelectionEvent event) {

				AnalyzeToolGraph.this.redraw();

			}

		});

		addControlListener(new ControlAdapter() {

			@Override

			public void controlResized(ControlEvent e) {

				horizontalBar.setPageIncrement(getBounds().width);

				redraw();

			}

		});

	}