/*

 * 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 StatisticView

 *

 */

package com.nokia.s60tools.analyzetool.ui.statistic;

import java.util.AbstractList;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Locale;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.IMarker;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.IResource;

import org.eclipse.core.resources.IWorkspaceRoot;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.Path;

import org.eclipse.swt.SWT;

import org.eclipse.swt.custom.CTabFolder;

import org.eclipse.swt.custom.CTabItem;

import org.eclipse.swt.custom.SashForm;

import org.eclipse.swt.events.MouseEvent;

import org.eclipse.swt.events.MouseListener;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.events.SelectionListener;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Combo;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Table;

import org.eclipse.swt.widgets.TableColumn;

import org.eclipse.swt.widgets.TableItem;

import org.eclipse.ui.IWorkbenchPage;

import org.eclipse.ui.PartInitException;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.ide.IDE;

import com.nokia.carbide.cdt.builder.CarbideBuilderPlugin;

import com.nokia.carbide.cdt.builder.project.ICarbideProjectInfo;

import com.nokia.cdt.debug.cw.symbian.symbolreader.IFunction;

import com.nokia.cdt.debug.cw.symbian.symbolreader.ISourceLocation;

import com.nokia.cdt.debug.cw.symbian.symbolreader.ISymbolFile;

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

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

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

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

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

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

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

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

/**

 * Creates a statistic view Provides functions to create memory usage statistic

 * from the AnalyzeTool trace file

 *

 * @author kihe

 *

 */

@SuppressWarnings("restriction")

public class StatisticView implements SelectionListener, MouseListener {

	/** Tab for the this view */

	CTabItem memoryTab;

	/** Table for the statistic information */

	Table memoryTable;

	/** Function column */

	TableColumn columnFunction;

	/** File column */

	TableColumn columnFile;

	/** Count column */

	TableColumn columnCount;

	/** Line column */

	TableColumn columnLine;

	/** Time column */

	TableColumn columnTime;

	/** Size column */

	TableColumn columnSize;

	/** User selected table item */

	TableItem selectedItem;

	/** Selected run id */

	int selectedRun = 0;

	/** Combo for run selection */

	Combo combo;

	/** Active project reference */

	IProject currProject;

	/** Contains project related results */

	HashMap<IProject, AbstractList<ProcessInfo>> projectRelatedRes;

	/** Contains only one(selected) project cache */

	HashMap<Integer, AbstractList<String[]>> cache;

	/** Time cache, this cache is used provide comparison by time */

	HashMap<String, Long> timeCache;

	/** Contains all created results */

	HashMap<IProject, HashMap<Integer, AbstractList<String[]>>> projectCache;

	/** Contains build platform and target information. */

	Label infoLabel;

	/** Default display string when no results are available. */

	String noResults = "---";

	/** Contains cpp files info. */

	private final AbstractList<String> cppFileNames;

	/** Symbol reader */

	SymReader reader;

	boolean errorOccurred = false;

	/**

	 * Constructor

	 */

	public StatisticView() {

		projectRelatedRes = new HashMap<IProject, AbstractList<ProcessInfo>>();

		cache = new HashMap<Integer, AbstractList<String[]>>();

		timeCache = new HashMap<String, Long>();

		projectCache = new HashMap<IProject, HashMap<Integer, AbstractList<String[]>>>();

		cppFileNames = new ArrayList<String>();

	}

	/**

	 * Cleans stored statistic

	 * @param project Project reference

	 */

	public void clean(IProject project) {

		memoryTable.clearAll();

		combo.removeAll();

		if (project == null) {

			projectCache.clear();

			projectRelatedRes.clear();

			cppFileNames.clear();

			timeCache.clear();

			cache.clear();

		} else {

			projectRelatedRes.remove(project);

			projectCache.remove(project);

		}

		setDefaultContent();

		PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable() {

			public void run() {

				infoLabel.setText("");

			}

		});

	}

	/**

	 * Sorts the given statistic and displays it to user

	 * @param createAllResults Create all the results, not just one run results

	 */

	public void compareAndPrint(boolean createAllResults) {

		// if current project does not contain statistic => leave

		if (!projectRelatedRes.containsKey(currProject)) {

			return;

		}

		// if cache contains statistic for selected run use it

		if (cache.containsKey(selectedRun)) {

			AbstractList<String[]> items = cache.get(selectedRun);

			updateView(items, false);

			return;

		}

		if (reader == null) {

			reader = new SymReader(currProject);

			reader.loadProjectTargetsInfo();

		}

		// get project related results

		AbstractList<ProcessInfo> processes = projectRelatedRes

				.get(currProject);

		if (processes.isEmpty()) {

			setDefaultContent();

			return;

		}

		// create all the results

		else if (createAllResults) {

			int runIndex = 0;

			Iterator<ProcessInfo> iterProcess = processes.iterator();

			while (iterProcess.hasNext()) {

				ProcessInfo tempProcess = iterProcess.next();

				createResults(tempProcess, runIndex);

				runIndex++;

			}

			// all the runs results are generated => now display the first

			// results

			// compareAndPrint(false);

		}

		// create only one(specific) run results

		else {

			ProcessInfo tempProcessInfo = processes.get(selectedRun);

			createResults(tempProcessInfo, selectedRun);

		}

		if (reader != null) {

			reader.dispose();

			reader = null;

		}

	}

	/**

	 * Find symbol reader api pinpointed class file for project class files.

	 *

	 * @param fileName

	 *            Cpp file name

	 * @return Found cpp file location

	 */

	private String getFileNames(String fileName) {

		Iterator<String> iterFiles = cppFileNames.iterator();

		int slash = Util.getLastSlashIndex(fileName);

		String tempFile = fileName.substring(slash + 1, fileName.length());

		String realFileName = fileName;

		while (iterFiles.hasNext()) {

			String tempFileName = iterFiles.next();

			int slashTemp = Util.getLastSlashIndex(tempFileName);

			String tempFileWithoutExt = tempFileName.substring(slashTemp + 1,

					tempFileName.length());

			if (tempFileWithoutExt.equalsIgnoreCase(tempFile)) {

				realFileName = tempFileName;

				break;

			}

		}

		return realFileName;

	}

	/**

	 * Converts hex time to time value

	 *

	 * @param timeInHex

	 *            Time in hex

	 * @return Time

	 */

	public String converTime(Long timeInHex) {

		Calendar cal = Calendar.getInstance();

		cal.setTimeInMillis(timeInHex / 1000);

		StringBuffer timeStr = new StringBuffer();

		String[] monthName = { "Jan", "Feb", "March", "Apr", "May", "June",

				"July", "Aug", "Sep", "Oct", "Nov", "Dec" };

		char space = ' ';

		String[] day = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };

		timeStr.append(day[cal.get(Calendar.DAY_OF_WEEK) - 1]);

		timeStr.append(space);

		timeStr.append(monthName[cal.get(Calendar.MONTH)]);

		timeStr.append(space);

		timeStr.append(cal.get(Calendar.DAY_OF_MONTH));

		timeStr.append(space);

		timeStr.append(cal.get(Calendar.YEAR));

		timeStr.append(space);

		timeStr.append(cal.get(Calendar.HOUR_OF_DAY));

		timeStr.append(':');

		int minute = cal.get(Calendar.MINUTE);

		if (minute < 10) {

			timeStr.append('0');

		}

		timeStr.append(minute);

		timeStr.append(':');

		int second = cal.get(Calendar.SECOND);

		if (second < 10) {

			timeStr.append('0');

		}

		timeStr.append(second);

		timeStr.append('.');

		int millis = cal.get(Calendar.MILLISECOND);

		if (millis < 10) {

			timeStr.append("00");

		} else if (millis < 100) {

			timeStr.append('0');

		}

		timeStr.append(millis);

		return timeStr.toString();

	}

	/**

	 * Creates results

	 *

	 * @param tempProcessInfo

	 *           Process info

	 * @param runIndex

	 *            Selected run index

	 */

	private void createResults(ProcessInfo tempProcessInfo,

			int runIndex) {

		//create cache for found source files

		HashMap<Long, SourceFile> sourceFileCache = new HashMap<Long, SourceFile>();

		//list for found files

		AbstractList<SourceFile> files = new ArrayList<SourceFile>();

		//get process allocations

		AbstractList<AllocInfo> allocs = tempProcessInfo.getAllocs();

		Iterator<AllocInfo> iterAllocs = allocs.iterator();

		//thru allocations

		while (iterAllocs.hasNext()) {

			//get one allocation

			AllocInfo oneInfo = iterAllocs.next();

			//get allocation callstack

			Iterator<AllocCallstack> iterAllocCalls = allocCalls.iterator();

			//go thru callstack values until find first source file

			while (iterAllocCalls.hasNext()) {

				if( errorOccurred ) {

					return;

				}

				AllocCallstack oneCallstack = iterAllocCalls.next();

				//if callstack item do not contain dll load item => could not be pinpointed

				DllLoad tempLoad = oneCallstack.getDllLoad();

				if (tempLoad == null) {

					continue;

				}

				//if callstack item memory addreess match to dll load start address => skip these values

				if (oneCallstack.getMemoryAddress()== tempLoad.getStartAddress()) {

					continue;

				}

				//find memory address from the cache

				if (sourceFileCache

						.containsKey(oneCallstack.getMemoryAddress())) {

					SourceFile tempFile = sourceFileCache.get(oneCallstack

							.getMemoryAddress());

					int intValue = oneInfo.getSizeInt();

					tempFile.updateSize(intValue);

					tempFile.setTime(oneInfo.getTime());

					tempFile.updateHowManyTimes();

					break;

				}

				//not found in the cache => try to pinpoint it

				SourceFile file = pinpoint(oneCallstack.getMemoryAddress(),

						oneCallstack.getDllLoad());

				//if source file found

				if (file != null) {

					//set source file values

					int intValue = oneInfo.getSizeInt();

					file.updateSize(intValue);

					file.setTime(oneInfo.getTime());

					files.add(file);

					//add found source file to cache

					sourceFileCache.put(oneCallstack.getMemoryAddress(), file);

					break;

				}

			}

		}

		//store found results to cache

		storeResults(files, runIndex);

		//clear used cache

		sourceFileCache.clear();

	}

	/**

	 * Creates statistic view

	 *

	 * @param parent

	 *            View parent

	 * @return CTabItem created view

	 */

	public CTabItem createView(CTabFolder parent) {

		// create new sashform for the statistic view

		SashForm allFrom = new SashForm(parent, SWT.VERTICAL);

		/** new sashform for the run selection */

		SashForm infoFrom = new SashForm(allFrom, SWT.HORIZONTAL);

		/** new sashform for the memory statistic information */

		SashForm memoryFrom = new SashForm(allFrom, SWT.NONE);

		// create new tab

		memoryTab = new CTabItem(parent, SWT.NONE);

		memoryTab.setText(Constants.STATISTICS_TAB_TITLE);

		// initialize tab layout

		GridData gd = new GridData(SWT.FILL, SWT.FILL, true, true);

		gd.grabExcessVerticalSpace = true;

		gd.grabExcessHorizontalSpace = true;

		gd.horizontalSpan = 1;

		/** create new label */

		Label label = new Label(infoFrom, SWT.NONE);

		label.setText(Constants.STATISTICS_SELECT_RUN);

		/** create new choisebox */

		combo = new Combo(infoFrom, SWT.DROP_DOWN);

		combo.addSelectionListener(this);

		/** create empty label to fill non-used space */

		infoLabel = new Label(infoFrom, SWT.NONE);

		infoLabel.setText("");

		/** Set sashform layout */

		infoFrom.setWeights(new int[] { 1, 1, 9 });

		/** Set sashform layout */

		allFrom.setWeights(new int[] { 1, 14 });

		// create new table for the tab

		memoryTable = new Table(memoryFrom, SWT.VIRTUAL | SWT.FULL_SELECTION

				| SWT.BORDER | SWT.V_SCROLL);

		memoryTable.setHeaderVisible(true);

		memoryTable.setLinesVisible(true);

		memoryTable.setItemCount(12);

		memoryTab.setControl(allFrom);

		columnFile = new TableColumn(memoryTable, SWT.Selection);

		columnFile.setText(Constants.STATISTICS_NODE_FILE);

		columnFile.setWidth(160);

		// create table items

		columnFunction = new TableColumn(memoryTable, SWT.Selection);

		columnFunction.setText(Constants.STATISTICS_NODE_FUNCTION);

		columnFunction.setWidth(120);

		columnLine = new TableColumn(memoryTable, SWT.Selection);

		columnLine.setText(Constants.STATISTICS_NODE_LINE);

		columnLine.setWidth(60);

		columnCount = new TableColumn(memoryTable, SWT.Selection);

		columnCount.setText(Constants.STATISTICS_NODE_ALLOCS);

		columnCount.setWidth(60);

		columnCount.addListener(SWT.Selection, new ATComparator(this,

				memoryTable, 3, true));

		columnTime = new TableColumn(memoryTable, SWT.Selection);

		columnTime.setText(Constants.STATISTICS_NODE_TIME);

		columnTime.setWidth(60);

		columnTime.addListener(SWT.Selection, new ATComparator(this,

				memoryTable, 4, false));

		columnSize = new TableColumn(memoryTable, SWT.Selection);

		columnSize.setText(Constants.STATISTICS_NODE_SIZE);

		columnSize.setWidth(60);

		columnSize.addListener(SWT.Selection, new ATComparator(this,

				memoryTable, 5, true));

		memoryTable.addSelectionListener(this);

		memoryTable.addMouseListener(this);

		memoryTable.pack();

		memoryTable.update();

		setDefaultContent();

		return memoryTab;

	}

	/**

	 * Fit columns size to match column text size.

	 */

	public void doPack() {

		TableColumn[] columns = memoryTable.getColumns();

		for (int i = 0; i < columns.length; i++) {

			columns[i].pack();

		}

	}

	/**

	 * Return time from the time cache

	 *

	 * @param time

	 *            Time

	 * @return Time in milliseconds if time found otherwise null

	 */

	public Long getTimeFromCache(String time) {

		// if time is set to cache

		if (timeCache.containsKey(time)) {

			return timeCache.get(time);

		}

		return null;

	}

	/**

	 * Handles project changed actions

	 *

	 * @param projectRef