/*

 * Copyright (c) 2008-2010 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 ParseAnalyzeData

 *

 */

package com.nokia.s60tools.analyzetool.engine;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.AbstractList;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.Map;

import java.util.Map.Entry;

import org.eclipse.core.runtime.IStatus;

import com.nokia.s60tools.analyzetool.Activator;

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

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

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

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

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

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

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

/**

 * @author kihe

 */

public class ParseAnalyzeData {

	private FileOutputStream fis;

	/** File. */

	private File file;

	/** Contains information which processes are started. */

	private final Hashtable<String, Integer> processStart;

	/** Contains information which processes are ended. */

	private final AbstractList<Integer> processEnd;

	/** Contains information of where to save trace data. */

	private String usedFilePath;

	/** Contains active process information. */

	public Hashtable<Integer, ProcessInfo> processes;

	/**

	 */

	private final AbstractList<ProcessInfo> processList;

	/**

	 */

	private Hashtable<Long, AllocInfo> allocCache = null;

	/**

	 */

	private Map<BaseInfo, Integer> remainingCallstacksMap = null;

	/**

	 */

	private Hashtable<Long, FreeInfo> freeCache = null;

	/**

	 */

	private Hashtable<Long, DllLoad> dllLoadCache = null;

	/**

	 * Otherwise just parse the file/trace content.

	 */

	boolean saveDataToFile;

	boolean createGraphModel;

	boolean ignoreCallstacks;

	/** Callstacks will be read later on demand directly from file */

	private boolean deferCallstacks;

	private long filePos;

	private int lineBreakSize;

	/**

	 * Constructor.

	 * 

	 * @param saveData

	 * @param createModel

	 *            boolean indicating whether to create a graph model. Used to

	 *            improve performance.

	 * @param deferCallstackReading

	 *            true, if callstack reading is to be done later. This requires

	 *            saving the file position during parse phase, so saveData must

	 *            be true or use constructor with FileChannel.

	 */

		this(saveData, createModel, deferCallstackReading, 0);

	/**

	 * 

	 * @param saveData

	 * @param createModel

	 *            boolean indicating whether to create a graph model. Used to

	 *            improve performance.

	 * @param deferCallstackReading

	 *            true, if callstack reading is to be done later. This requires

	 *            saving the file position during parse phase, so saveData must

	 *            be true or use constructor with FileChannel.

	 * @param lineBreakSize

	 */

		}

		processStart = new Hashtable<String, Integer>();

		processEnd = new ArrayList<Integer>();

		processes = new Hashtable<Integer, ProcessInfo>();

		processList = new ArrayList<ProcessInfo>();

		saveDataToFile = saveData;

		createGraphModel = createModel;

			allocCache = new Hashtable<Long, AllocInfo>();

			freeCache = new Hashtable<Long, FreeInfo>();

			remainingCallstacksMap = new HashMap<BaseInfo, Integer>();

			dllLoadCache = new Hashtable<Long, DllLoad>();

		}

		this.lineBreakSize = lineBreakSize;

	}

	/**

	 * Add one dllLoad object to process related list

	 * @param dllLoad

	 *            One DllLoad

	 */

	private void addDllLoad(DllLoad dllLoad) {

		if (processes.containsKey(dllLoad.getProcessID())) {

			ProcessInfo tempProcessInfo = processes.get(dllLoad.getProcessID());

			tempProcessInfo.addOneDllLoad(dllLoad);

		}

	}

	/**

	 * Add one memory allocation info to process related list

	 * @param info

	 *            One memory allocation info

	 */

	private void addMemAddress(AllocInfo info) {

		// if one of the started process contains same process id what memory

		if (processes.containsKey(info.getProcessID())) {

			ProcessInfo tempProcessInfo = processes.get(info.getProcessID());

			tempProcessInfo.addOneAlloc(info);

		}

	}

	/**

	 */

	private void removeMemAddress(FreeInfo info) {

		if (processes.containsKey(info.getProcessID())) {

			ProcessInfo tempProcessInfo = processes.get(info.getProcessID());

			tempProcessInfo.free(info);

		}

	/**

	 * Closes the input stream if it is open.

	 */

	private final void closeStreams() {

		try {

			// if fis exists => close fis

			if (fis != null) {

				fis.close();

				// clear file and fis

				file = null;

				fis = null;

				filePos = 0;

			}

		} catch (IOException ioe) {

			ioe.printStackTrace();

		}

	}

	/**

	 * Finish the writing.

	 */

	public final void finish() {

		try {

			// if some data is not write to file yet => do it now

			if (fis != null) {

				fis.flush();

			}

		} catch (IOException ioe) {

			return;

		} finally {

			// close needed streams

			closeStreams();

		}

		// clear stored data

		processList.clear();

		processes.clear();

		processStart.clear();

		processEnd.clear();

		}

			freeCache.clear();

		}

		}

			remainingCallstacksMap.clear();

		}

	}

	/**

	 * Return memory allocation size for all started processes.

	 * @return Memory allocation size for all started processes

	 */

	public final int getAllocationsSize() {

		int allocCnt = 0;

		// get memory allocations count from ongoing processes

		for (ProcessInfo p : processes.values()) {

			allocCnt += p.getMemLeaksNumber();

		}

		Iterator<ProcessInfo> iterPro = processList.iterator();

			ProcessInfo oneInfo = iterPro.next();

			allocCnt += oneInfo.getMemLeaksNumber();

		}

		return allocCnt;

	}

	/**

	 * Gets used data file name.

	 * @return Data file name

	 */

	public final String getDataFileName() {

		return usedFilePath;

	}

	/**

	 * Checks given path if it is null set used path to point java temp

	 * directory.

	 * @param path

	 *            Given path

	 * @return Data file location

	 */

	private final String getFileName(final String path) {

		if (path == null || ("").equals(path)) {

			// null path given => use java temp dir

			usedFilePath = System.getProperty("java.io.tmpdir")

					+ Constants.FILENAME;

		} else if (!path.contains(Constants.FILENAME)) {

			usedFilePath = path + Constants.FILENAME;

		}

		return usedFilePath;

	}

	/**

	 * Gets started process info.

	 * @return Hashtable<String, String> Started processes info

	 */

	public final Hashtable<String, Integer> getStartedProcesses() {

		if (processStart.isEmpty()) {

			return null;

		}

		return processStart;

	}

	/**

	 * Returns stored statistic

	 * @return Stored statistic

	 */

	public AbstractList<ProcessInfo> getStatistic() {

		return processList;

	}

	/**

	 * Opens the needed streams.

	 * @param filePath

	 *            File name and path where to save trace data

	 * @return True if stream could be opened otherwise false

	 */

	public final boolean openStreams(final String filePath) {

		boolean returnValue = false;

		try {

			// store used data file name

			usedFilePath = getFileName(filePath);

			// if file did not exists => create it

			if (file == null) {

				file = new File(usedFilePath);

			}

			// if fis did not exists => open it

			if (fis == null) {

				fis = new FileOutputStream(file, false);

			}

			returnValue = true;

		} catch (FileNotFoundException fno) {

			// if error occurs => close open streams

			closeStreams();

			returnValue = false;

		}

		return returnValue;

	}

	/**

	 * Executes parser.

	 * @param data

	 *            File name to be used

	 * @return true on success

	 */

	public final boolean parse(final String data) {

			// if no data => leave

			if (data == null) {

				return true;

			}

			}

			}

			}

			return true;

			return false;

			return false;

		}

	}

	/**

	 * because data file format is changed.

	 * 

	 * @param dllLoad

	 * @param splittedText

	 *            One line of trace data file.

	 */

	private void fillDllLoadInfo(DllLoad dllLoad, String[] splittedText) {

		int processID = dllLoad.getProcessID();

			ProcessInfo processInfo = processes.get(processID);