/*

 * 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.internal.pi.model;

import java.util.Enumeration;

import java.util.Vector;

public abstract class GenericSampledTrace extends GenericTrace

{

	private static final long serialVersionUID = -5030416972125713453L;

	public Vector samples;

	public GenericSampledTrace()

	{

	  this.samples = new Vector();

	}

	public void addSample(GenericSample sample)

	{

	  this.samples.add(sample);

	}

	public Enumeration getSamples()

	{

	  return samples.elements();

	}

	public GenericSample getSample(int number)

	{

	  return (GenericSample)this.samples.elementAt(number);

	}

	public Vector<GenericSample> getSamplesInsideTimePeriod(long start, long end)

	{

		Enumeration sEnum = samples.elements();

		Vector<GenericSample> okSamples = new Vector<GenericSample>();

		while(sEnum.hasMoreElements())

		{

			GenericSample s = (GenericSample)sEnum.nextElement();

			if (s.sampleSynchTime >= start)

			{

				if (s.sampleSynchTime <= end)

				{

					okSamples.add(s);

				}

			}

		}

		return okSamples;

	}

	public GenericSample[] getSamplesForTime(long time)

	{

		// start the search from the middle of the sample set

		long location = this.samples.size() / 2;

		// next, add or remove 1/4 of the length of the sample set

		int div = 4;

		// boolean value indicating that the search proceeds now one step at a time

		boolean saturated = false;

		// search algorithm, proceed until a value is found or 

		// reached the boundaries of the search area

		// note that the sample numbers MUST increase with growing

		// indices within the samples vector in order for this 

		// algorithm to work!

		while (true)

		{

			// take the sample from the location

			GenericSample s = (GenericSample)samples.elementAt((int)location);

			// if the searched value is larger than the value at the proposed location

			// increment the proposed location with the length of the data set divided

			// by the divisor

			if (s.sampleSynchTime < time)

			{

				if (!saturated)

				{

					int change = this.samples.size() / div;

					if (change >= 1)

					{

						location += change;

						div *= 2;

					}

					else 

					{

						saturated = true;

					}

				}

				else

				{

					// already saturated, go one step at a time

					location++;

				}				

			}

			// similarly, decrement the proposed location 

			// if the value is smaller than the searched value

			else if (s.sampleSynchTime > time)

			{

				if (!saturated)

				{					

					int change = this.samples.size() / div;

					if (change >= 1)

					{

						location -= change;

						div *= 2;

					}

					else 

					{

						saturated = true;

					}

				}

				else

				{

					// already saturated, go one step at a time

					location--;

				}

			}

			else if (s.sampleSynchTime == time)

			{

				return this.getSamplesWithSameTimeFrom(location);

			}

			// reached the end of the sample set without a match

			if (location < 0 || location >= this.samples.size())

				return null;

		}

	}

	private GenericSample[] getSamplesWithSameTimeFrom(long location)

	{

		long sameTime = ((GenericSample)samples.elementAt((int)location)).sampleSynchTime;

		int lowBound = (int)location;

		int highBound = (int)location;

		if (lowBound-1 >=0)

		{	

			// go backwards as long as there are samples with the same samplenumber

			while ( ((GenericSample)samples.elementAt(lowBound - 1)).sampleSynchTime == sameTime 

					&& (lowBound - 1) >= 0)

			{

				lowBound--;

			}

		}

		if (highBound + 1 < this.samples.size())

		{	

			// go backwards as long as there are samples with the same samplenumber

			while ( ((GenericSample)samples.elementAt(highBound + 1)).sampleSynchTime == sameTime 

					&& (highBound + 1) < this.samples.size())

			{

				highBound++;

			}

		}

		GenericSample[] sa = new GenericSample[highBound - lowBound + 1];

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

		{

			sa[i] = (GenericSample)samples.elementAt(lowBound + i);

		}

		return sa;

	}

	public int getSampleAmount()

	{

	  return this.samples.size();

	}

	public int getFirstSampleNumber()

	{

		if (this.samples.size() > 0)

			return (int)this.getSample(0).sampleSynchTime;

		else

			return 0;

	}

	public int getLastSampleNumber()

	{

		if (this.samples.size() > 0)

			return (int)((GenericSample)this.samples.lastElement()).sampleSynchTime;

		else

			return 0;

	}

	public String toString()

	{

		Enumeration sEnum = this.getSamples();

	  	Vector strings = new Vector();

	  	int totalLength = 0;

	  	while(sEnum.hasMoreElements())

	  	{	

	  		GenericSample s = (GenericSample)sEnum.nextElement();

	  		String uus = s.toString() + "\n"; //$NON-NLS-1$

	  		totalLength += uus.getBytes().length;

	  		strings.add(uus);

	  	}

	  	System.out.println(Messages.getString("GenericSampledTrace.totalLength") + totalLength); //$NON-NLS-1$

	  	byte[] bytes = new byte[totalLength];

	  	sEnum = strings.elements();

	  	int index = 0;

	  	while(sEnum.hasMoreElements())

	  	{

	  		String s = (String)sEnum.nextElement();

	  		byte[] sB = s.getBytes();

	  		for (int i = index; i < index + sB.length; i++)

	  		{

	  			bytes[i] = sB[i - index];

	  		}

	  		index += sB.length;

	  	}

	  	String total = new String(bytes);

	  	return total;

	  }

}