/*

 * Copyright (c) 2009 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.instr;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Vector;

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

public class UndecidedPool 

{	

	private Hashtable undecidedLocations;

	private Vector unprocessed;

	private AdvancedMemoryMap amm;

	private Vector unDecided;

	public UndecidedPool(AdvancedMemoryMap amm)

	{

		this.amm = amm;

		// keys will be the binary names, and values wile be

		// their corresponding UndecidedLocation objects

		this.undecidedLocations = new Hashtable();

		this.unprocessed = new Vector();

		this.unDecided = new Vector();

	}

	public Vector getUnprocessed()

	{

		return this.unprocessed;

	}

	public void clearUnprocessed()

	{

		this.unprocessed = new Vector();

	}

	public Vector getUndecided()

	{

		return this.unDecided;

	}

	public void insertSample(IttSample sample,int decisionBoundary)

	{

		if (!this.unDecided.contains(sample))

			this.unDecided.add(sample);

		BinaryReaderResult brr = this.amm.getBinaryReader().findSequence(sample);

		for (int i=0;i<brr.possibleBinaries.length;i++)

		{

			Binary possibleBinary = brr.possibleBinaries[i];

			UndecidedLocation ul = 

				(UndecidedLocation)undecidedLocations.get(possibleBinary.getBinaryName());

			if (ul != null)

			{

				ul.addSample(sample,possibleBinary.getStartAddress());

			}

			else

			{

				ul = new UndecidedLocation(possibleBinary); 

				ul.addSample(sample,possibleBinary.getStartAddress());

				this.undecidedLocations.put(possibleBinary.getBinaryName(),ul);

			}

			// the value of decisionBoundary has to be reduced in the future

			// when no binaries can be resolved with the current value

			if (ul.getDecidedAddress(decisionBoundary) != -1)

			{

			 	// location of the binary has been resolved

				// refresh the samples that belong to the decision

				ul.refreshDecidedAndUndecidedSamples();

				// add all the samples that didn't fit to this binary, to

				// the pool of unprocessed samples				

				Vector undecided = ul.getUndecidedSamples();

				// add only those samples that are not present in the undecided

				// vector already

				Enumeration unEnum = undecided.elements();

				while(unEnum.hasMoreElements())

				{

					IttSample us = (IttSample)unEnum.nextElement();

					if (!this.unprocessed.contains(us)) this.unprocessed.add(us);

				}

				// then, pass the decision to the decidedPool

				Vector decided = ul.getDecidedSamples();

				this.amm.getDecidedPool().insertDecidedBinary(possibleBinary,decided);

				// then, remove the decided samples from all other possible binaries

				Enumeration renum = decided.elements();

				while(renum.hasMoreElements())

				{

					IttSample sampleToRemove = (IttSample)renum.nextElement();

					this.removeSampleFromAllPossibleLocations(sampleToRemove);

				}

			}

		}

	}

	private void removeSampleFromAllPossibleLocations(IttSample sample)

	{	

		Enumeration renum = this.undecidedLocations.keys();

		Vector removeList = new Vector();

		this.unDecided.remove(sample);

		while(renum.hasMoreElements())

		{

			String name = (String)renum.nextElement();

			UndecidedLocation ul = (UndecidedLocation)this.undecidedLocations.get(name);

			ul.removeSample(sample);

			if (ul.samplesForLocations.size() == 0) removeList.add(name);

		}

		if (removeList.size() > 0)

		{

			Enumeration enumer = removeList.elements();

			while(enumer.hasMoreElements())

			{

				this.undecidedLocations.remove(enumer.nextElement());

			}

		}

		if (this.unprocessed.contains(sample))

		{

			this.unprocessed.remove(sample);

		}

	} 

	private static class UndecidedLocation

	{

		private Hashtable samplesForLocations;

		private Binary binary;

		private int processedMostHits = 0;

		private Long addressWithMostHits = null;

		private Vector samplesWithMostHits = null;

		private boolean processedUndecided = false;

		private Vector undecidedSamples = null;

		private Vector decidedSamples = null; 

		public UndecidedLocation(Binary binary)

		{

			// key will be the address, and the value will be a

			// vector with all samples that support that location 

			this.samplesForLocations = new Hashtable();

			this.binary = binary;

		}

		public Binary getBinary()

		{

			return this.binary;

		}

		public void addSample(IttSample sample,long startAddress)

		{

			// clear the flags so that the values will be recalculated if needed

			this.processedMostHits = 0;

			this.processedUndecided = false;

			if (o != null)

			{

				// this location has already a vector associated with it

				Vector sampleVec = (Vector)o;

				Enumeration sampleEnum = sampleVec.elements();

				boolean isAlready = false;

				while(sampleEnum.hasMoreElements())

				{

					IttSample testSample = (IttSample)sampleEnum.nextElement();

					if (testSample.programCounter == sample.programCounter && 

							testSample.checksum == sample.checksum)

						{

							isAlready = true;

							break;

						}

				}

				// add the sample only if it is 

				// different from the other samples

				if (isAlready == false) 

				{

					//System.out.println("Added unique sample "+sample.programCounter+" to "+this.binary.binaryName);

					sampleVec.add(sample);

				}

				else

				{

					//System.out.println("Discarded "+sample.programCounter+" to "+this.binary.binaryName);

				}

			}

			else

			{

				//System.out.println("Added unique sample "+sample.programCounter+" to "+this.binary.binaryName);

				Vector sampleVec = new Vector();

				sampleVec.add(sample);

			}

		}

		public void removeSample(IttSample sample)

		{

			// clear the flags so that the values will be recalculated if needed

			this.processedMostHits = 0;

			this.processedUndecided = false;

			// remove this sample from all vectors, remove the vectors if they

			// become empty

			Enumeration enumer = this.samplesForLocations.keys();

			Vector removeList = new Vector();

			while(enumer.hasMoreElements())

			{

				Long address = (Long)enumer.nextElement();

				Vector v = (Vector)this.samplesForLocations.get(address);

				if (v.contains(sample)) 

				{

					v.remove(sample);

					// do not remove the vector yet because

					// it would mess the hashtable iteration

					if (v.size() == 0) removeList.add(address);

				}

			}

			// finally, remove the vectors that 

			// were emptied after removing the last sample

			if (removeList.size() > 0) 

			{

				Enumeration renum = removeList.elements();

				while(renum.hasMoreElements())

				{

					this.samplesForLocations.remove(renum.nextElement());

				}

			}

		}

		public long getDecidedAddress(int minSampleAmount)

		{

			if (minSampleAmount <= 0) return -1;

			if (this.processedMostHits == minSampleAmount)

			{

				// the function has been run with this value

				return this.addressWithMostHits.longValue();

			}

			Enumeration addresses = samplesForLocations.keys();

			int amountOfMaxValues = 0;

			while(addresses.hasMoreElements())

			{

				Long address = (Long)addresses.nextElement();

				Vector samples = (Vector)samplesForLocations.get(address);

				if (samples.size() >= minSampleAmount)

				{

					// there are at least minSampleAmount different samples

					// that support this binary being in this place

					if (samplesWithMostHits != null)

					{

						// there is already a value, check do we exceed it

						if (samples.size() > samplesWithMostHits.size())

						{

							samplesWithMostHits = samples;

							addressWithMostHits = address;

							amountOfMaxValues = 1;

						}

						else if (samples.size() == samplesWithMostHits.size())

						{

							amountOfMaxValues++;

						}

					}

					else

					{

						// there is no max value yet

						samplesWithMostHits = samples;

						addressWithMostHits = address;

						amountOfMaxValues = 1;

					}

				}

			}

			// this function does not need to be run again

			// if the values do not change

			this.processedMostHits = minSampleAmount;

			// there are two or more max values

			// or no max values at all

			if (amountOfMaxValues != 1) return -1;

				else return addressWithMostHits.longValue();

		}

		public void refreshDecidedAndUndecidedSamples()

		{

			if (this.processedUndecided == true) return;

			this.undecidedSamples = new Vector();

			this.decidedSamples = new Vector();

			Enumeration enumer = this.samplesForLocations.elements();

			while(enumer.hasMoreElements())

			{

				Vector v = (Vector)enumer.nextElement();

				if (!v.equals(this.samplesWithMostHits))

				{

					// count all samples but the one with 

					undecidedSamples.addAll(v);

				}

				else

				{

					// add the decided samples

					this.decidedSamples.addAll(v);

				}

			}

			this.processedUndecided = true;

		}

		public Vector getDecidedSamples()

		{

			// there is no value according to which the decision

			// could base on

			if (this.processedMostHits == 0) return new Vector();

			this.refreshDecidedAndUndecidedSamples();

			return this.decidedSamples;

		}

		public Vector getUndecidedSamples()

		{

			// there is no value according to which the decision

			// could base on

			if (this.processedMostHits == 0) return new Vector();

			this.refreshDecidedAndUndecidedSamples();			

			return this.undecidedSamples;

		}

	}

}