/*

 * Copyright (c) 2010 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.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.SortedMap;

import java.util.TreeMap;

import com.nokia.carbide.cpp.internal.pi.model.ProfiledGeneric;

public class ProfiledLibraryEvent extends ProfiledGeneric {

	class GraphSamplePoint {

		long firstSamplePoint;

		long lastSamplePoint;

		public GraphSamplePoint(long firstSamplePoint, long lastSamplePoint) {

			this.firstSamplePoint = firstSamplePoint;

			this.lastSamplePoint = lastSamplePoint;

		}

	}

	private TreeMap<Long, MemSample> memSamples;

	private List<GraphSamplePoint> grapSamplePoints;

	public ProfiledLibraryEvent(String name) {

		super(-1, 3);

		setNameString(name);

		this.memSamples = new TreeMap<Long, MemSample>();	

	}

	public void addMemSample(MemSample memSample){

		if(memSample.stackSize == 0 && memSample.sampleNum == 0){

			memSample.heapSize = 0;

		}

		memSamples.put(memSample.sampleSynchTime, memSample);

	}

	public void updateSelection(long startTime, long endTime) {

		if (memSamples.size() == 0) {

			return;

		}

		MemSample firstSample = (MemSample) memSamples

				.get(memSamples.lastKey());

		MemThread thread = firstSample.thread;

		MaxMemoryItem maxMemoryItem = thread.maxMemoryItem;

		SortedMap<Long, MemSample> subMap = memSamples.subMap(startTime,

				endTime);

		ArrayList<MemSample> samples = new ArrayList<MemSample>(subMap.values());		

		if(samples.isEmpty()){

			maxMemoryItem.maxChunks = 0;

			maxMemoryItem.maxTotal = 0;

		}else{

			int count = 0;

			maxMemoryItem.maxChunks = 0;

			for(MemSample memSample : samples){

				if(memSample.type != MemTraceParser.SAMPLE_CODE_INITIAL_CHUNK){

					count++;

				}		

				if(memSample.type == MemTraceParser.SAMPLE_CODE_NEW_CHUNK || memSample.type == MemTraceParser.SAMPLE_CODE_UPDATE_CHUNK){

					maxMemoryItem.maxChunks += memSample.heapSize;

				}else if(memSample.type == MemTraceParser.SAMPLE_CODE_DELETE_CHUNK ){

					if(memSample.heapSize == 0){

						maxMemoryItem.maxChunks = 0;

					}else{

						maxMemoryItem.maxChunks -= memSample.heapSize;

					}					

				}

			}

			if(maxMemoryItem.maxChunks  < 0 ){

				maxMemoryItem.maxChunks = 0;

			}

			maxMemoryItem.maxTotal = count;

		}	

	}

	public MemThread getLastMemThread(){

		return memSamples.get(memSamples.lastKey()).thread;

	}

	public TreeMap<Long, MemSample> getMemSamples() {

		return memSamples;

	}

	public List<GraphSamplePoint> getGraphSamplePoints() {

		if(grapSamplePoints == null){

			grapSamplePoints = calculateGraphSamplePoints();

		}

		return grapSamplePoints;

	}

	@Override

	public void setEnabled(int graphIndex, boolean enableValue) {

		super.setEnabled(graphIndex, enableValue);

		Iterator<MemSample> iterator = memSamples.values().iterator();

		while(iterator.hasNext()){

			MemSample memSample = iterator.next();

			memSample.thread.setEnabled(graphIndex, enableValue);

		}

	}

	private List<GraphSamplePoint> calculateGraphSamplePoints() {

		List<GraphSamplePoint> graphSamples = new ArrayList<GraphSamplePoint>();

		Iterator<MemSample> iterator = memSamples.values().iterator();

		while (iterator.hasNext()) {

			MemSample memSample = iterator.next();	

			if(memSample.type == MemTraceParser.SAMPLE_CODE_INITIAL_CHUNK){

				continue;

			}

			if (memSamples.values().size() == 1) {

				if (memSample.stackSize == 0) {

					// library unloaded

					graphSamples.add(new GraphSamplePoint(-100, memSample.sampleSynchTime));

				} else {

					// library loaded

					graphSamples.add(new GraphSamplePoint(memSample.sampleSynchTime, -100));

				}

			} else {

				if (memSample.stackSize == 0) {

					// library unloaded

					graphSamples.add(new GraphSamplePoint(-100, memSample.sampleSynchTime));

				} else {

					// library loaded

					graphSamples.add(new GraphSamplePoint(memSample.sampleSynchTime, -100));

				}

			}

		}

		return graphSamples;

	}

}