//-----------------------------------------------------------------------------

// sortTable(id, col, rev)

//

//  id  - ID of the TABLE, TBODY, THEAD or TFOOT element to be sorted.

//  col - Index of the column to sort, 0 = first column, 1 = second column,

//        etc.

//  rev - If true, the column is sorted in reverse (descending) order

//        initially.

//

// Note: the team name column (index 1) is used as a secondary sort column and

// always sorted in ascending order.

//-----------------------------------------------------------------------------



function sortTable(id, col, rev) 
{
	// Get the table or table section to sort.
	var tblEl = document.getElementById(id);

	// The first time this function is called for a given table, set up an array of reverse sort flags.
	
	if (tblEl.reverseSort == null) 
	{
		tblEl.reverseSort = new Array();
		// Also, assume the team name column is initially sorted.
		tblEl.lastColumn = 1;
	}

	// If this column has not been sorted before, set the initial sort direction.
	if (tblEl.reverseSort[col] == null)
		tblEl.reverseSort[col] = rev;

	// If this column was the last one sorted, reverse its sort direction.
	if (col == tblEl.lastColumn)
		tblEl.reverseSort[col] = !tblEl.reverseSort[col];

	// Remember this column as the last one sorted.
	tblEl.lastColumn = col;

	// Set the table display style to "none" - necessary for Netscape 6 browsers.
	var oldDsply = tblEl.style.display;
	tblEl.style.display = "none";

	// Sort the rows based on the content of the specified column using a
	// selection sort.

	var tmpEl;
	var i, j;
	var minVal, minIdx;
	var testVal;
	var cmp;

	for (i = 0; i < tblEl.rows.length - 1; i++) 
	{

		// Assume the current row has the minimum value.
		minIdx = i;
		minVal = getTextValue(tblEl.rows[i].cells[col]);
/*    var getlength1=minVal.length;

    if(minVal.match("$"))

    {

      minVal=minVal.substr(1,getlength1);

    }
*/
minVal=minVal.replace("$"," ");
//alert("minval: " + minVal);

		// Search the rows that follow the current one for a smaller value.
		for (j = i + 1; j < tblEl.rows.length; j++) 
		{
			testVal = getTextValue(tblEl.rows[j].cells[col]);
/*			    var getlength2=testVal.length;

     if(testVal.match("$"))

      {

        testVal=testVal.substr(1,getlength2);

      }*/
	  testVal=testVal.replace("$"," ");

			cmp = compareValues(minVal, testVal);
			
			// Negate the comparison result if the reverse sort flag is set.
			if (tblEl.reverseSort[col])
				cmp = -cmp;

			// Sort by the second column (team name) if those values are equal.
			if (cmp == 0 && col != 1)
			{
						
				var v1=getTextValue(tblEl.rows[minIdx].cells[1]);
				var v2=getTextValue(tblEl.rows[j].cells[1])
			   // var getlenv1=v1.length;
//			    var getlenv2=v2.length;

/* 	        if(v1.match("$"))
            {

                v1=v1.substr(1,getv1);
            }
			if(v2.match("$"))
            {

                v2=v2.substr(1,getv2);
            }*/
			v1=v1.replace("$"," ");
			v2=v2.replace("$"," ");


				cmp = compareValues(v1,v2);
			}	


			// If this row has a smaller value than the current minimum, remember its
			// position and update the current minimum value.

			if (cmp > 0) 
			{
				minIdx = j;
				minVal = testVal;
			}
		}

		// By now, we have the row with the smallest value. Remove it from the
		// table and insert it before the current row.
		
		if (minIdx > i) 
		{
			tmpEl = tblEl.removeChild(tblEl.rows[minIdx]);
			tblEl.insertBefore(tmpEl, tblEl.rows[i]);
		}
	}
// Make it look pretty.

  makePretty(tblEl, col);



  // Set team rankings.

  setRanks(tblEl, col, rev);

	// Restore the table's display style.
	tblEl.style.display = oldDsply;

	return false;
}

//-----------------------------------------------------------------------------
// Functions to get and compare values during a sort.
//-----------------------------------------------------------------------------

// This code is necessary for browsers that don't reflect the DOM constants
// (like IE).

if (document.ELEMENT_NODE == null) 
{
	document.ELEMENT_NODE = 1;
	document.TEXT_NODE = 3;
}

function getTextValue(el) 
{
	var i;
	var s;

	// Find and concatenate the values of all text nodes contained within the element.
	
	s = "";
	for(i=0; i < el.childNodes.length; i++)
	{
		if(el.childNodes[i].nodeType == document.TEXT_NODE)
		{
			s += el.childNodes[i].nodeValue;
		}
		else 
		{
			if (el.childNodes[i].nodeType == document.ELEMENT_NODE && el.childNodes[i].tagName == "BR")
			{
				s += " ";
			}
			else
			{
				//Use recursion to get text within sub-elements.
				s += getTextValue(el.childNodes[i]);
			}
		}
	}
	return normalizeString(s);
}

function compareValues(v1, v2) 
{
	var f1, f2;

	// If the values are numeric, convert them to floats.
	f1 = parseFloat(v1);
	f2 = parseFloat(v2);
	
	if (!isNaN(f1) && !isNaN(f2)) 
	{
		v1 = f1;
		v2 = f2;
	}

	// Compare the two values.
	if (v1 == v2)
		return 0;
	if (v1 > v2)
		return 1;

	return -1;
}

// Regular expressions for normalizing white space.

var whtSpEnds = new RegExp("^\\s*|\\s*$", "g");
var whtSpMult = new RegExp("\\s\\s+", "g");

function normalizeString(s) 
{
	s = s.replace(whtSpMult, " ");  // Collapse any multiple whites space.
	s = s.replace(whtSpEnds, "");   // Remove leading or trailing white space.

	return s;
}

//-----------------------------------------------------------------------------
// Functions to update the table appearance after a sort.
//-----------------------------------------------------------------------------

// Style class names.
var rowClsNm = "alternateRow";
var colClsNm = "sortedColumn";

// Regular expressions for setting class names.
var rowTest = new RegExp(rowClsNm, "gi");
var colTest = new RegExp(colClsNm, "gi");

function makePretty(tblEl, col) {



  var i, j;

  var rowEl, cellEl;



  // Set style classes on each row to alternate their appearance.

  for (i = 0; i < tblEl.rows.length; i++) {

   rowEl = tblEl.rows[i];

   rowEl.className = rowEl.className.replace(rowTest, "");

    if (i % 2 != 0)

      rowEl.className += " " + rowClsNm;

    rowEl.className = normalizeString(rowEl.className);

    // Set style classes on each column (other than the name column) to

    // highlight the one that was sorted.

    for (j = 2; j < tblEl.rows[i].cells.length; j++) {

      cellEl = rowEl.cells[j];

      cellEl.className = cellEl.className.replace(colTest, "");

      if (j == col)

        cellEl.className += " " + colClsNm;

      cellEl.className = normalizeString(cellEl.className);

    }

  }



  // Find the table header and highlight the column that was sorted.

  var el = tblEl.parentNode.tHead;

  rowEl = el.rows[el.rows.length - 1];

  // Set style classes for each column as above.

  for (i = 2; i < rowEl.cells.length; i++) {

    cellEl = rowEl.cells[i];

    cellEl.className = cellEl.className.replace(colTest, "");

    // Highlight the header of the sorted column.

    if (i == col)

      cellEl.className += " " + colClsNm;

      cellEl.className = normalizeString(cellEl.className);

  }

}



function setRanks(tblEl, col, rev) {



  // Determine whether to start at the top row of the table and go down or

  // at the bottom row and work up. This is based on the current sort

  // direction of the column and its reversed flag.



  var i    = 0;

  var incr = 1;

  if (tblEl.reverseSort[col])

    rev = !rev;

  if (rev) {

    incr = -1;

    i = tblEl.rows.length - 1;

  }



  // Now go through each row in that direction and assign it a rank by

  // counting 1, 2, 3...



  var count   = 1;

  var rank    = count;

  var curVal;

  var lastVal = null;



  // Note that this loop is skipped if the table was sorted on the name

  // column.

  while (col > 1 && i > 0 && i < tblEl.rows.length) {



    // Get the value of the sort column in this row.

    curVal = getTextValue(tblEl.rows[i].cells[col]);



    // On rows after the first, compare the sort value of this row to the

    // previous one. If they differ, update the rank to match the current row

    // count. (If they are the same, this row will get the same rank as the

    // previous one.)

    if (lastVal != null && compareValues(curVal, lastVal) != 0)

        rank = count;

    // Set the rank for this row.

    tblEl.rows[i].rank = rank;



    // Save the sort value of the current row for the next time around and bump

    // the row counter and index.

    lastVal = curVal;

    count++;

    i += incr;

  }



  // Now go through each row (from top to bottom) and display its rank. Note

  // that when two or more rows are tied, the rank is shown on the first of

  // those rows only.



  var rowEl, cellEl;

  var lastRank = 0;



  // Go through the rows from top to bottom.

/*  for (i = 0; i < tblEl.rows.length; i++) {

    rowEl = tblEl.rows[i];

    cellEl = rowEl.cells[0];

    // Delete anything currently in the rank column.

    while (cellEl.lastChild != null)

      cellEl.removeChild(cellEl.lastChild);

    // If this row's rank is different from the previous one, Insert a new text

    // node with that rank.

    if (col > 1 && rowEl.rank != lastRank) {

      cellEl.appendChild(document.createTextNode(rowEl.rank));

      lastRank = rowEl.rank;

    }

  }*/

}