/*
This is the Friendly Table Sorter, by Tony Boyd:
	http://www.outshine.com/

It is based upon a script by Joost de Valk:
	http://www.joostdevalk.nl/code/sortable-table/

And Joost's script was based upon a script by Stuart Langridge:
	http://www.kryogenix.org/code/browser/sorttable/

All three scripts are distributed under the MIT license:
	http://www.kryogenix.org/code/browser/licence.html

Copyright 1997-2008 Stuart Langridge, Joost de Valk, Tony Boyd.

Version 1.0.0
Released 2008-jun-04

Changelog:
* Doesn't accidentally use the table header to try to determine the sort type.
* Space allowed as separator between date fields.
* Created sort type override feature.
* Replaced broken arrow images with arrow glyph from standard font.
* Refactored into a namespace so that there are no name collisions.
* Better handling of US vs. non-US number formats.
* Better handling of currency.
* Faster trim function (imperceptible).
* Cleaner sorting code (not faster, just neater).
* Consistent naming convention for functions/methods.
* Very clear comments to walk you through the code.
*/

var outshine = {
	/*
	These initial variables can be changed as follows:
		europeanDate -> true if dates are DD-MM-YYYY or DD-MM-YY
		europeanDate -> false if dates are MM-DD-YYYY or MM-DD-YY
		numberSeparator -> ',' for US syntax (1,000,000)
		alternateRowColors -> true for a light-dark color set for your table rows
		alternateRowColors -> false if you don't use alternating row colors
	You need to put 2 classes into your CSS to affect the row colors:
		rowlight -> a light color
		rowdark -> a different color
	*/
	europeanDate: false,
	numberSeparator: ',',
	alternateRowColors: true,

	/*
	From here on down, probably don't change stuff.  Geek note: if you're trying
	to read the code, the control flow is reversed, so read bottom-up.
	*/
	SORT_COLUMN_INDEX: null,
	headerExists: false,

	/*
	This is a long but accurate list of currency symbols, in Unicode syntax.
	*/
	currencySymbols: /[\x24\u0024\u00a2\u00a3\u00a4\u00a5\u20a0\u20a1\u20a2\u20a3\u20a4\u20a5\u20a6\u20a7\u20a8\u20a9\u20aa\u20ab\u20ac\u20ad\u20ae\u20af\u20b0\u20b1]/g,

	ts_cleanNum: function(data) {
		/*
		Converts a string to a number.  If conversion doesn't work, it returns 0.
		*/
		var numSeparator = new RegExp(this.numberSeparator, 'g');
		data = parseFloat(data.replace(this.currencySymbols, '').replace(numSeparator, ''));
		return (isNaN(data)) ? 0 : data;
	},

	ts_convertDate: function(date) {
		/*
		Feed this a string that looks like a date and it will attempt to convert
		it into a number in this format: YYYYMMDD.  For example, 20090131.
		*/
		var dt = '00000000';
		if (date.length == 11) {
			var mtstr = date.substr(3,3);
			mtstr = mtstr.toLowerCase();
			var mt = '00';
			switch(mtstr) {
				case 'jan': mt = '01'; break;
				case 'feb': mt = '02'; break;
				case 'mar': mt = '03'; break;
				case 'apr': mt = '04'; break;
				case 'may': mt = '05'; break;
				case 'jun': mt = '06'; break;
				case 'jul': mt = '07'; break;
				case 'aug': mt = '08'; break;
				case 'sep': mt = '09'; break;
				case 'oct': mt = '10'; break;
				case 'nov': mt = '11'; break;
				case 'dec': mt = '12'; break;
			}
			dt = date.substr(7,4) + mt + date.substr(0,2);
			return dt;
		}
		else if (date.length == 10) {
			if (this.europeanDate == false) {
				dt = date.substr(6,4) + date.substr(0,2) + date.substr(3,2);
				return dt;
			}
			else {
				dt = date.substr(6,4) + date.substr(3,2) + date.substr(0,2);
				return dt;
			}
		}
		else if (date.length == 8) {
			var yr = date.substr(6,2);
			/*
			Two-digit years less than 50 are treated as 20XX, greater than 50 are
			treated as 19XX.
			*/
			if (parseInt(yr) < 50) { 
				yr = '20' + yr; 
			}
			else { 
				yr = '19' + yr; 
			}
			if (this.europeanDate == true) {
				dt = yr + date.substr(3,2) + date.substr(0,2);
				return dt;
			}
			else {
				dt = yr + date.substr(0,2) + date.substr(3,2);
				return dt;
			}
		}
		return dt;
	},

	ts_sortDate: function(a, b) {
		/*
		Get the contents of the a & b fields, do some clean up, convert the dates
		to numbers, compare numbers.
		*/
		var aa = this.ts_getInnerText(a.cells[this.SORT_COLUMN_INDEX]);
		aa = this.ts_trim(aa);
		aa = this.ts_convertDate(aa);
		aa = this.ts_cleanNum(aa);
		var bb = this.ts_getInnerText(b.cells[this.SORT_COLUMN_INDEX]);
		bb = this.ts_trim(bb);
		bb = this.ts_convertDate(bb);
		bb = this.ts_cleanNum(bb);
		return aa - bb;
	},

	ts_sortNumeric: function(a, b) {
		/*
		Get the contents of the a & b fields, do some clean up, compare numbers.
		*/
		var aa = this.ts_getInnerText(a.cells[this.SORT_COLUMN_INDEX]);
		aa = this.ts_trim(aa);
		aa = this.ts_cleanNum(aa);
		var bb = this.ts_getInnerText(b.cells[this.SORT_COLUMN_INDEX]);
		bb = this.ts_trim(bb);
		bb = this.ts_cleanNum(bb);
		return aa - bb;
	},

	ts_sortCaseInsensitive: function(a, b) {
		/*
		Lowercase the strings then compare them.
		*/
		var aa = this.ts_getInnerText(a.cells[this.SORT_COLUMN_INDEX]).toLowerCase();
		var bb = this.ts_getInnerText(b.cells[this.SORT_COLUMN_INDEX]).toLowerCase();
		if (aa==bb) {
			return 0;
		}
		if (aa<bb) {
			return -1;
		}
		return 1;
	},

	ts_trim: function(str) {
		/*
		Removes white space.  Slightly faster than the old version.
		*/
		return str.replace(/^\s+/, '').replace(/\s+$/, '');
	},

	ts_getParent: function(el, pTagName) {
		/*
		Mostly just a wrapper around parentNode, with some intelligence built in.
		*/
		if (el == null) {
			return null;
		}
		else if (el.nodeType == 1 && el.tagName.toLowerCase() == pTagName.toLowerCase()) {
			return el;
		}
		else {
			return this.ts_getParent(el.parentNode, pTagName);
		}
	},

	ts_resortTable: function(lnk, clid) {
		/*
		Re-sort the table based upon the column clicked.
		*/
		var span;
		for (var ci=0; ci<lnk.childNodes.length; ci++) {
			if (lnk.childNodes[ci].tagName && lnk.childNodes[ci].tagName.toLowerCase() == 'span') {
				span = lnk.childNodes[ci];
			}
		}
		var spantext = this.ts_getInnerText(span);
		var td = lnk.parentNode;
		var column = clid || td.cellIndex;
		var t = this.ts_getParent(td,'TABLE');
		if (t.rows.length <= 1) {
			return;
		}
		/*
		Loop through the fields until content is found, then attempt to guess
		the type of data (and thus which type of sorting to use).
		*/
		var itm = '';
		var i = 1;
		while (itm == '' && i < t.tBodies[0].rows.length) {
			itm = this.ts_getInnerText(t.tBodies[0].rows[i].cells[column]);
			itm = this.ts_trim(itm);
			if (itm.substr(0,4) == "<!--" || itm.length == 0) {
				itm = '';
			}
			i++;
		}
		if (itm == '') {
			return;
		}
		/*
		If you pass sort() a namespace function, it gets an isolated copy which
		can't use the "this" keyword.  So we use an anonymous function as a
		wrapper -- it can't use "this" but doesn't need to.  That should explain
		what you see below.
		*/
		var sortfn = function (a, b) {return outshine.ts_sortCaseInsensitive(a, b)};
		if (itm.match(/^\d\d[\s\/\.-][a-zA-z][a-zA-Z][a-zA-Z][\s\/\.-]\d\d\d\d$/)) {
			sortfn = function (a, b) {return outshine.ts_sortDate(a, b)};
		}
		if (itm.match(/^\d\d[\/\.-]\d\d[\/\.-]\d\d\d{2}?$/)) {
			sortfn = function (a, b) {return outshine.ts_sortDate(a, b)};
		}
		itm = itm.replace(this.currencySymbols, '');
		if (itm.match(/^-?(\d+[,\.]?)+(E[-+][\d]+)?%?$/)) {
			sortfn = function (a, b) {return outshine.ts_sortNumeric(a, b)};
		}
		/*
		Override the sorting guess if the table header has a sort type specified.
		*/
		if (t.tBodies[0].rows[0].cells[column].className.indexOf('sortAlpha') != -1) {
			sortfn = function (a, b) {return outshine.ts_sortCaseInsensitive(a, b)};
		}
		else if (t.tBodies[0].rows[0].cells[column].className.indexOf('sortNumeric') != -1) {
			sortfn = function (a, b) {return outshine.ts_sortNumeric(a, b)};
		}
		else if (t.tBodies[0].rows[0].cells[column].className.indexOf('sortDate') != -1) {
			sortfn = function (a, b) {return outshine.ts_sortDate(a, b)};
		}
		this.SORT_COLUMN_INDEX = column;
		var firstRow = new Array();
		var newRows = new Array();
		for (k=0; k<t.tBodies.length; k++) {
			for (i=0;i<t.tBodies[k].rows[0].length;i++) { 
				firstRow[i] = t.tBodies[k].rows[0][i]; 
			}
		}
		for (k=0; k<t.tBodies.length; k++) {
			if (!this.headerExists) {
				// Skip the first row
				for (j=1;j<t.tBodies[k].rows.length;j++) { 
					newRows[j-1] = t.tBodies[k].rows[j];
				}
			}
			else {
				// Do NOT skip the first row
				for (j=0; j<t.tBodies[k].rows.length; j++) { 
					newRows[j] = t.tBodies[k].rows[j];
				}
			}
		}
		newRows.sort(sortfn);
		if (span.getAttribute("sortdir") == 'down') {
			ARROW = '&nbsp;&darr;';
			newRows.reverse();
			span.setAttribute('sortdir','up');
		}
		else {
			ARROW = '&nbsp;&uarr;';
			span.setAttribute('sortdir','down');
		}
		/*
		We appendChild rows that already exist to the tbody, so it moves them
		rather than creating new ones
		*/
		for (i=0; i<newRows.length; i++) { 
			if (!newRows[i].className || (newRows[i].className && (newRows[i].className.indexOf('sortbottom') == -1))) {
				t.tBodies[0].appendChild(newRows[i]);
			}
		}
		for (i=0; i<newRows.length; i++) {
			if (newRows[i].className && (newRows[i].className.indexOf('sortbottom') != -1)) {
				t.tBodies[0].appendChild(newRows[i]);
			}
		}
		/*
		Delete any other arrows there may be showing
		*/
		var allspans = document.getElementsByTagName("span");
		for (var ci=0; ci<allspans.length; ci++) {
			if (allspans[ci].className == 'sortarrow') {
				/*
				In the same table as us?
				*/
				if (this.ts_getParent(allspans[ci],"table") == this.ts_getParent(lnk,"table")) {
					allspans[ci].innerHTML = '<span style="visibility: hidden;">&nbsp;&darr;</span>';
				}
			}
		}		
		span.innerHTML = ARROW;
		this.ts_colorizeRows(t);
	},

	ts_colorizeRows: function(thisTable) {
		/*
		Loop through the rows, alternating the assigned color class.
		*/
		var tableBodies = thisTable.getElementsByTagName('tbody');
		if (tableBodies.length == 0) {
			tableBodies[0] = thisTable;
		}
		for (var i = 0; i < tableBodies.length; i++) {
			var tableRows = tableBodies[i].getElementsByTagName('tr');
			for (var j = 0; j < tableRows.length; j++) {
				if ((j % 2) == 0) {
					if ( !(tableRows[j].className.indexOf('rowlight') == -1) ) {
						tableRows[j].className = tableRows[j].className.replace('rowlight', 'rowdark');
					}
					else if ( tableRows[j].className.indexOf('rowdark') == -1 ) {
						tableRows[j].className += " rowdark";
					}
				}
				else {
					if ( !(tableRows[j].className.indexOf('rowdark') == -1) ) {
						tableRows[j].className = tableRows[j].className.replace('rowdark', 'rowlight');
					}
					else if ( tableRows[j].className.indexOf('rowlight') == -1 ) {
						tableRows[j].className += " rowlight";
					}
				} 
			}
		}
	},

	ts_getInnerText: function(el) {
		/*
		Return the contents of an element as a string.
		*/
		if ((typeof el == 'string') || (typeof el == 'undefined')) {
			return el;
		}
		if (el.innerText) {
			/*
			Not needed but it is faster.
			*/
			return el.innerText;
		}
		var str = '';
		var cs = el.childNodes;
		var l = cs.length;
		for (var i = 0; i < l; i++) {
			switch (cs[i].nodeType) {
				case 1: //ELEMENT_NODE
					str += this.ts_getInnerText(cs[i]);
					break;
				case 3:	//TEXT_NODE
					str += cs[i].nodeValue;
					break;
			}
		}
		return str;
	},

	ts_makeSortable: function(t) {
		/*
		Loop through the rows & determine the header.
		*/
		if (t.rows && t.rows.length > 0) {
			if (t.tHead && t.tHead.rows.length > 0) {
				var firstRow = t.tHead.rows[t.tHead.rows.length-1];
				this.headerExists = true;
			}
			else {
				var firstRow = t.rows[0];
			}
		}
		if (!firstRow) return;
		/*
		A header exists, so make its contents clickable links.
		*/
		for (var i=0;i<firstRow.cells.length;i++) {
			var cell = firstRow.cells[i];
			var txt = this.ts_getInnerText(cell);
			if (cell.className != 'unsortable' && cell.className.indexOf('unsortable') == -1) {
				cell.innerHTML = '<a href="#" class="sortheader" onclick="outshine.ts_resortTable(this, '+i+');return false;" style="text-decoration: none;">'+txt+'<span class="sortarrow"><span style="visibility: hidden;">&nbsp;&darr;</span></span></a>';
			}
		}
		/*
		Colorize the rows.
		*/
		if (this.alternateRowColors) {
			this.ts_colorizeRows(t);
		}
	},

	ts_init: function() {
		/*
		Find all tables with a class of "sortable" and make them sortable.
		*/
		if (!document.getElementsByTagName) {
			return;
		}
		var tbls = document.getElementsByTagName('table');
		for (var ti=0; ti<tbls.length; ti++) {
			var thisTbl = tbls[ti];
			if (((' '+thisTbl.className+' ').indexOf('sortable') != -1) && (thisTbl.id)) {
				this.ts_makeSortable(thisTbl);
			}
		}
	}
};

function loadTableSort() {
	outshine.ts_init();
}

/*
Cross-browser event handling for IE5+, NS6, & Mozilla.  By Scott Andrew.
*/
function addEventByScott(elm, evType, fn, useCapture) {
	if (elm.addEventListener) {
		elm.addEventListener(evType, fn, useCapture);
	}
	else if (elm.attachEvent){
		var success = elm.attachEvent('on' + evType, fn);
	}
}

addEventByScott(window, 'load', loadTableSort, false);