/*

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

 *

 */

/*

 * GppTableSorter.java

 */

package com.nokia.carbide.cpp.pi.address;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Vector;

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

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

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

public class GppTableSorter

{

	private Vector<ProfiledGeneric> sortedList = null;

//	private int columnID;

	private int graphIndex;

	private boolean sortAscending;

	public void setupSort(int columnID, int graphIndex, boolean sortAscending)

	{

//		this.columnID      = columnID;

		this.graphIndex    = graphIndex;

		this.sortAscending = sortAscending;

	}

    public boolean isSortedByLoad(Vector<ProfiledGeneric> v)

	{

    	//	  check if ProfiledGeneric vector is already sorted by load

	  	int i = 0;

		ProfiledGeneric tmp1 = null;

		ProfiledGeneric tmp2 = null;

		for (Enumeration e = v.elements(); e.hasMoreElements() ;i++)

		{

			tmp2 = (ProfiledGeneric)e.nextElement();

			if (tmp1 != null)

			{

	      		float first  = tmp1.getPercentLoad(graphIndex);

	      		float second = tmp2.getPercentLoad(graphIndex);

	      		if ((first != second) && ((first < second) ^ sortAscending))

				{

					return false;

				}

			}

			tmp1 = (ProfiledGeneric)v.elementAt(i);

		}

		return true;

	}

	public void quickSortByShow(Vector<ProfiledGeneric> elements)

	{

		Vector<ProfiledGeneric> v = elements;

	  	if (!v.isEmpty())

	    {

	  		this.quickSortByShow(v, 0, v.size()-1);

	    }

	  	sortedList = v;

	}

	public void quickSortByAverageLoad(Vector<ProfiledGeneric> elements)

	{

	  	Vector<ProfiledGeneric> v = elements;

	  	if (!v.isEmpty() & !isSortedByLoad(v))

	    {

	  		this.quickSortByAverageLoad(v, 0, v.size()-1);

	    }

	  	sortedList = v;

	}

	public void quickSortByName(Vector<ProfiledGeneric> elements, boolean caseSensitive)

	{

		Vector<ProfiledGeneric> v = elements;

	  	if (!v.isEmpty())

	    {

	  		this.quickSortByName(v, 0, v.size()-1, caseSensitive);

	    }

	  	sortedList = v;

	}

	public void quickSortByThread(Vector<ProfiledGeneric> elements)

	{

		quickSortByName(elements, false);

	}

	public void quickSortByFunction(Vector<ProfiledGeneric> elements)

	{

		quickSortByName(elements, false);

	}

	public void quickSortByBinary(Vector<ProfiledGeneric> elements)

	{

		Vector<ProfiledGeneric> v = elements;

	  	if (!v.isEmpty())

	    {

	  		this.quickSortByBinary(v, 0, v.size()-1);

	    }

	  	sortedList = v;

	}

	public void quickSortByBinaryPath(Vector<ProfiledGeneric> elements)

	{

		Vector<ProfiledGeneric> v = elements;

	  	if (!v.isEmpty())

	    {

	  		this.quickSortByBinaryPath(v, 0, v.size()-1);

	    }

	  	sortedList = v;

	}

	public void quickSortByFullBinaryPath(Vector<ProfiledGeneric> elements)

	{

		Vector<ProfiledGeneric> v = elements;

	  	if (!v.isEmpty())

	    {

	  		this.quickSortByFullBinaryPath(v, 0, v.size()-1);

	    }

	  	sortedList = v;

	}

	public void quickSortByStartAddress(Vector<ProfiledGeneric> elements)

	{

		Vector<ProfiledGeneric> v = elements;

	  	if (!v.isEmpty())

	    {

	  		this.quickSortByStartAddress(v, 0, v.size()-1);

	    }

	  	sortedList = v;

	}

	public void quickSortByAssocBinary(Vector<ProfiledGeneric> elements)

	{

		Vector<ProfiledGeneric> v = elements;

	  	if (!v.isEmpty())

	    {

	  		this.quickSortByAssocBinary(v, 0, v.size()-1);

	    }

	  	sortedList = v;

	}

	public void quickSortByAssocBinaryPath(Vector<ProfiledGeneric> elements)

	{

		Vector<ProfiledGeneric> v = elements;

	  	if (!v.isEmpty())

	    {

	  		this.quickSortByAssocBinaryPath(v, 0, v.size()-1);

	    }

	  	sortedList = v;

	}

	public void quickSortByFullAssocBinaryPath(Vector<ProfiledGeneric> elements)

	{

		Vector<ProfiledGeneric> v = elements;

	  	if (!v.isEmpty())

	    {

	  		this.quickSortByFullAssocBinaryPath(v, 0, v.size()-1);

	    }

	  	sortedList = v;

	}

	public void quickSortBySampleCount(Vector<ProfiledGeneric> elements)

	{

	  	Vector<ProfiledGeneric> v = elements;

	  	if (!v.isEmpty())

	    {

	  		this.quickSortBySampleCount(v, 0, v.size()-1);

	    }

	  	sortedList = v;

	}

	public void quickSortByPriority(Vector<ProfiledGeneric> elements, Hashtable priorities)

	{

	    sortedList = new Vector<ProfiledGeneric>();

	    Vector<ProfiledGeneric> v = elements;

	  	int i = 0;

		ProfiledThread tmp1 = null;

		ProfiledThread tmp2 = null;

		for (Enumeration e = v.elements(); e.hasMoreElements() ;i++)

		{

			tmp2 = (ProfiledThread)e.nextElement();

			if (tmp1 != null)

			{

				Integer p1 = (Integer)priorities.get(new Integer(tmp1.getThreadId()));

				Integer p2 = (Integer)priorities.get(new Integer(tmp2.getThreadId()));

				p1 = (p1 == null) ? new Integer(Integer.MIN_VALUE) : p1;

				p2 = (p2 == null) ? new Integer(Integer.MIN_VALUE) : p2;

				if ((p1.compareTo(p2) != 0) && (p1.compareTo(p2) < 0) ^ sortAscending)

				{

					quickSortByPriority(v, 0, v.size()-1, priorities);

					sortedList = v;

					return;

				}

			}

			tmp1 = (ProfiledThread)v.elementAt(i);

		}

		sortedList = v;

		return;

	}

	private void quickSortByShow(Vector<ProfiledGeneric> elements, int lowIndex, int highIndex)

	{

		int lowToHighIndex;

	    int highToLowIndex;

	    int pivotIndex;

	    ProfiledGeneric pivotValue;  // change the values to suit your application

	    ProfiledGeneric lowToHighValue;

	    ProfiledGeneric highToLowValue;

	    ProfiledGeneric parking;

	    int newLowIndex;

	    int newHighIndex;

	    lowToHighIndex = lowIndex;

	    highToLowIndex = highIndex;

	    pivotIndex = (lowToHighIndex + highToLowIndex) / 2;

	    pivotValue = (ProfiledGeneric)elements.elementAt(pivotIndex);

	    newLowIndex = highIndex + 1;

	    newHighIndex = lowIndex - 1;

	    while ((newHighIndex + 1) < newLowIndex)

	    {

			lowToHighValue = (ProfiledGeneric)elements.elementAt(lowToHighIndex);

			while (lowToHighIndex < newLowIndex)

			{

				// chose false is less than true

				// when sortAscending is true, sort from false to true

	      		boolean first  = lowToHighValue.isEnabled(graphIndex);

	      		boolean second = pivotValue.isEnabled(graphIndex);

	      		if ((first == second) || ((!first && second) ^ sortAscending))

	      			break;

				newHighIndex = lowToHighIndex;

			    lowToHighIndex ++;

			    lowToHighValue = (ProfiledGeneric)elements.elementAt(lowToHighIndex);

			}

			highToLowValue = (ProfiledGeneric)elements.elementAt(highToLowIndex);

			while (newHighIndex <= highToLowIndex)

			{

				// chose false is less than true

				// when sortAscending is true, sort from false to true

	      		boolean first  = highToLowValue.isEnabled(graphIndex);

	      		boolean second = pivotValue.isEnabled(graphIndex);

	      		if ((first == second) || ((first && !second) ^ sortAscending))

	      			break;

				newLowIndex = highToLowIndex;

			    highToLowIndex --;

			    highToLowValue = (ProfiledGeneric)elements.elementAt(highToLowIndex);

			}

			// swap if needed

			if (lowToHighIndex == highToLowIndex)

			{

				newHighIndex = lowToHighIndex;

			}

			else if (lowToHighIndex < highToLowIndex)

			{

	      		boolean low  = lowToHighValue.isEnabled(graphIndex);

	      		boolean high = highToLowValue.isEnabled(graphIndex);

				if ((low == high) || ((!low & high) ^ sortAscending)) // swap even if equal

				{

					if (low != high) {

				    	parking = lowToHighValue;

				    	elements.setElementAt(highToLowValue, lowToHighIndex);

				    	elements.setElementAt(parking, highToLowIndex);

					}

			      	newLowIndex = highToLowIndex;

			      	newHighIndex = lowToHighIndex;

			      	lowToHighIndex ++;

			      	highToLowIndex --;

				}

			}

	    }

	    // Continue recursion for parts that have more than one element

	    if (lowIndex < newHighIndex)

	    {

	    	this.quickSortByShow(elements, lowIndex, newHighIndex); // sort lower subpart

	    }

	    if (newLowIndex < highIndex)

	    {

	    	this.quickSortByShow(elements, newLowIndex, highIndex); // sort higher subpart

	    }

	}

	private void quickSortByAverageLoad(Vector<ProfiledGeneric> elements, int lowIndex, int highIndex)

	{

		int lowToHighIndex;

		int highToLowIndex;

		int pivotIndex;

		ProfiledGeneric pivotValue;  // change the values to suit your application

		ProfiledGeneric lowToHighValue;

		ProfiledGeneric highToLowValue;

		ProfiledGeneric parking;

		int newLowIndex;

		int newHighIndex;

		lowToHighIndex = lowIndex;

		highToLowIndex = highIndex;

		pivotIndex = (lowToHighIndex + highToLowIndex) / 2;

		pivotValue = (ProfiledGeneric) elements.elementAt(pivotIndex);

		newLowIndex = highIndex + 1;

		newHighIndex = lowIndex - 1;

		// loop until low meets high

		while ((newHighIndex + 1) < newLowIndex) // loop until partition complete

		{

		  	lowToHighValue = (ProfiledGeneric)elements.elementAt(lowToHighIndex);

		  	while (lowToHighIndex < newLowIndex)

		  	{

		  		float first  = lowToHighValue.getPercentLoad(graphIndex);

		    	float second = pivotValue.getPercentLoad(graphIndex);

		    	if ((first == second) || ((first < second) ^ sortAscending))

		    		break;

			    newHighIndex = lowToHighIndex; // add element to lower part

			    lowToHighIndex ++;

			    lowToHighValue = (ProfiledGeneric)elements.elementAt(lowToHighIndex);

			}

		    highToLowValue = (ProfiledGeneric)elements.elementAt(highToLowIndex);

		    while (newHighIndex <= highToLowIndex)

		    {

		    	float first  = highToLowValue.getPercentLoad(graphIndex);

		    	float second = pivotValue.getPercentLoad(graphIndex);

			    if ((first == second) || ((first > second) ^ sortAscending))

			    	break;

			    newLowIndex = highToLowIndex; // add element to higher part

			    highToLowIndex --;

			    highToLowValue = (ProfiledGeneric)elements.elementAt(highToLowIndex);

		    }

		    // swap if needed

		    if (lowToHighIndex == highToLowIndex) // one last element, may go in either part

		    {

				newHighIndex = lowToHighIndex; // move element arbitrary to lower part

		    }

		    else if (lowToHighIndex < highToLowIndex) // not last element yet

		    {

				float first  = lowToHighValue.getPercentLoad(graphIndex);

				float second = highToLowValue.getPercentLoad(graphIndex);

				if ((first == second) || ((first < second) ^ sortAscending))

			    {

			       	if (first != second) {

			       		parking = lowToHighValue;

				        elements.setElementAt(highToLowValue, lowToHighIndex);

				        elements.setElementAt(parking, highToLowIndex);

			       	}

				    newLowIndex = highToLowIndex;

				    newHighIndex = lowToHighIndex;

				    lowToHighIndex ++;

				    highToLowIndex --;

			    }

		    }

		}

		// Continue recursion for parts that have more than one element

		if (lowIndex < newHighIndex)

		{

		  	// sort lower subpart

		  	this.quickSortByAverageLoad(elements, lowIndex, newHighIndex);

		}

		if (newLowIndex < highIndex)

		{

		  	// sort higher subpart

		  	this.quickSortByAverageLoad(elements, newLowIndex, highIndex);

		}

	}

	private void quickSortByName(Vector<ProfiledGeneric> elements, int lowIndex, int highIndex, boolean caseSensitive)

	{

		int lowToHighIndex;

	    int highToLowIndex;

	    int pivotIndex;

	    ProfiledGeneric pivotValue;  // change the values to suit your application

	    ProfiledGeneric lowToHighValue;

	    ProfiledGeneric highToLowValue;

	    ProfiledGeneric parking;

	    int newLowIndex;

	    int newHighIndex;

	    int compareResult;

	    lowToHighIndex = lowIndex;

	    highToLowIndex = highIndex;

	    pivotIndex = (lowToHighIndex + highToLowIndex) / 2;

	    pivotValue = (ProfiledGeneric)elements.elementAt(pivotIndex);

	    newLowIndex = highIndex + 1;

	    newHighIndex = lowIndex - 1;

	    while ((newHighIndex + 1) < newLowIndex)

	    {

			lowToHighValue = (ProfiledGeneric)elements.elementAt(lowToHighIndex);

			while (lowToHighIndex < newLowIndex)

			{

				if (caseSensitive)

					compareResult = lowToHighValue.getNameString().compareTo(pivotValue.getNameString());

				else

					compareResult = lowToHighValue.getNameString().compareToIgnoreCase(pivotValue.getNameString());

				if ((compareResult == 0) || ((compareResult < 0) ^ sortAscending))

					break;

				newHighIndex = lowToHighIndex;

			    lowToHighIndex ++;

			    lowToHighValue = (ProfiledGeneric)elements.elementAt(lowToHighIndex);

			}

			highToLowValue = (ProfiledGeneric)elements.elementAt(highToLowIndex);

			while (newHighIndex <= highToLowIndex)

			{

				if (caseSensitive)

					compareResult = highToLowValue.getNameString().compareTo(pivotValue.getNameString());

				else

					compareResult = highToLowValue.getNameString().compareToIgnoreCase(pivotValue.getNameString());

				if ((compareResult == 0) || ((compareResult > 0) ^ sortAscending))

					break;

				newLowIndex = highToLowIndex;

			    highToLowIndex --;

			    highToLowValue = (ProfiledGeneric)elements.elementAt(highToLowIndex);

			}

			// swap if needed

			if (lowToHighIndex == highToLowIndex)

			{

				newHighIndex = lowToHighIndex;

			}

			else if (lowToHighIndex < highToLowIndex)

			{

				if (caseSensitive)

					compareResult = lowToHighValue.getNameString().compareTo(highToLowValue.getNameString());

				else

					compareResult = lowToHighValue.getNameString().compareToIgnoreCase(highToLowValue.getNameString());

				if ((compareResult == 0) || ((compareResult < 0) ^ sortAscending))

				{

			    	if (compareResult != 0) {

			    		parking = lowToHighValue;

				    	elements.setElementAt(highToLowValue, lowToHighIndex);

				    	elements.setElementAt(parking, highToLowIndex);

			    	}

			      	newLowIndex = highToLowIndex;

			      	newHighIndex = lowToHighIndex;

			      	lowToHighIndex ++;

			      	highToLowIndex --;

				}

			}

	    }

	    // Continue recursion for parts that have more than one element

	    if (lowIndex < newHighIndex)

	    {

	    	this.quickSortByName(elements, lowIndex, newHighIndex, caseSensitive); // sort lower subpart

	    }

	    if (newLowIndex < highIndex)

	    {

	    	this.quickSortByName(elements, newLowIndex, highIndex, caseSensitive); // sort higher subpart

	    }

	}

	private void quickSortByBinary(Vector<ProfiledGeneric> elements, int lowIndex, int highIndex)

	{

		int lowToHighIndex;

	    int highToLowIndex;

	    int pivotIndex;

	    ProfiledGeneric pivotValue;  // change the values to suit your application

	    ProfiledGeneric lowToHighValue;

	    ProfiledGeneric highToLowValue;

	    ProfiledGeneric parking;

	    int newLowIndex;

	    int newHighIndex;

	    int compareResult;

	    lowToHighIndex = lowIndex;