/*

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

 *

 */

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

import java.util.AbstractList;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Hashtable;

import java.util.List;

/**

 * Base class for {@link AllocInfo} and {@link FreeInfo}

 *

 * @author kihe

 *

 */

public class BaseInfo {

	private List<AllocCallstack> callstacks = null;

	/**

	 * Cache for callstack items. Used when allocation fragment is parsed wrong

	 * order.

	 */

	private Hashtable<Integer, AbstractList<AllocCallstack>> callstackCache = null;

	/** Memory address of this memory allocation. */

	private long memoryAddress;

	/** Memory allocation process id. */

	private int processID;

	/** Allocation time */

	private long time;

	/** Total memory size at this time */

	private int totalMemory;

	private int size;

	/** file position to defer callstack reading */

	private long filePos;

	/**

	 * Constructor

	 * @param memoryAddress The address for this memory operation

	 */

	public BaseInfo(String memoryAddress) {

		this.memoryAddress = Long.parseLong(memoryAddress, 16);

	}

	/**

	 * Sets memory allocation callstack. Use this method

	 * only for the first set of callstacks. 

	 *

	 * @param callstack

	 *            Memory allocation callstack

	 */

	public void addCallstack(AbstractList<AllocCallstack> callstack) {

		if (callstack.size() > 0){

			callstacks = new ArrayList<AllocCallstack>(callstack);						

		}

	}

	/**

	 * Returns memory allocation callstack. This method should only be called

	 * after all data has finished loading.

	 * 

	 * @return Callstack of memory allocation

	 */

	public List<AllocCallstack> getCallstack() {

		//we assume all data has been loaded at this point

		finaliseCallstack();

		return callstacks == null ? Collections.<AllocCallstack>emptyList() : Collections.unmodifiableList(callstacks);

	}

	/**

	 * Returns memory address

	 *

	 * @return Memory address

	 */

	public long getMemoryAddress() {

		return memoryAddress;

	}

	/**

	 * Returns process ID.

	 *

	 * @return Process ID.

	 */

	public int getProcessID() {

		return processID;

	}

	/**

	 * Returns time for the allocation

	 *

	 * @return Allocation time

	 */

	public long getTime() {

		return time;

	}

	/**

	 * Sets process ID.

	 *

	 * @param newProcessID

	 *            Process ID

	 */

	public void setProcessID(String newProcessID) {

		int iValue = Integer.parseInt(newProcessID, 16);

		this.processID = iValue;

	}

	/**

	 * @param newTime

	 */

	public void setTime(long newTime)

	{

		this.time = newTime;

	}

	/**

	 * Updates allocation fragment. Means that given callstack is addition to

	 * previous added alloc

	 *

	 * @param callstack

	 *            Addition callstack items

	 * @param packetNumber

	 *            AllocF id value

	 */

	public void updateFragment(AbstractList<AllocCallstack> callstack,

			String packetNumber) {

		int pck = Integer.parseInt(packetNumber, 16);

		if (pck == 1){

			//special case; this can be added to the end of the list straight away

			callstacks.addAll(callstack);

		} else {

			//packages may come out of order; this is managed in the callstackCache

			if (callstackCache == null){

				callstackCache = new Hashtable<Integer, AbstractList<AllocCallstack>>();			

			}

			callstackCache.put(pck, callstack);			

		}

	}

	/**

	 * Optimises internal callstack data structures.

	 * Should only be called after all data for this memory operation

	 * has been loaded (i.e. all fragments)

	 */

	public void finaliseCallstack(){

		if (callstacks == null && callstackCache != null){

			throw new IllegalStateException(); //first set of callstacks should always be in callstacks

		}

		if (callstackCache != null){

			int size = callstackCache.size();

			int i = 2;

			while(size != 0){

				AbstractList<AllocCallstack> nextCallStacks = callstackCache.get(i);

				if (nextCallStacks != null){

					size --;

					callstacks.addAll(nextCallStacks);

				} //TODO else: missing callstack: shall we report it or log it?

				i++;

			}

			callstackCache = null;

		}

	}

	/**

	 * set total memory used at this time.

	 * @param newSize 

	 */

	public void setTotalMem(int newSize) {

		totalMemory = newSize;

	}

	/**

	 * get total memory used at this time

	 * @return size

	 */

	public int getTotalMem() {

		return totalMemory;

	}

	/**

	 * Sets the number of bytes allocated or freed in this memory operation

	 * @param aSize size in bytes

	 */

	public void setSizeInt(int aSize) {

		size = aSize;

	}

	/**

	 * Gets the number of bytes allocated or freed in this memory operation

	 * @return size in bytes

	 */

	public int getSizeInt() {

		return size;

	}

	/**

	 * Getter for file position pointing to first record in 

	 * .dat file where callstack for this BaseInfo starts.

	 * @return the file position for the start of callstack information,

	 * or -1 if no callstack available for this BaseInfo

	 */

	public long getFilePos() {

		return filePos;

	}

	/**

	 * Setter for file position pointing to callstack information

	 * @param filePos the file position pointing to start of record with callstack information;

	 * or -1 if no callstack available for this BaseInfo

	 */

	public void setFilePos(long filePos) {

		this.filePos = filePos;

	}

	@Override

	public String toString() {

		if (filePos > -1 && (callstacks == null || callstacks.size() == 0)){

			return String.format(

					"BaseInfo [memoryAddress=0x%08X, processID=%s, time=%s, size=%s, totalMemory=%s, callstacks on demand]",

					memoryAddress, processID, time, size, totalMemory);  

		} else {

			return String.format(

					"BaseInfo [memoryAddress=0x%08X, processID=%s, time=%s, size=%s, totalMemory=%s, callstacks=%s]",

					memoryAddress, processID, time, size, totalMemory,  

					callstacksToString());

		}

	}

	private String callstacksToString() {

		if (callstacks == null){

			return "null";

		}

		StringBuilder sb = new StringBuilder();

		boolean addComma = false;

		for (AllocCallstack callstack : callstacks) {

			if (addComma){

				sb.append(", ");

			}

			addComma = true;

			sb.append(String.format("addr=0x%08X dll=%s", callstack.getMemoryAddress(), callstack.getDllLoad() == null ? "null" : callstack.getDllLoad().getName()));

		}

		return sb.toString();

	}

}