var TableSort = Class.create();

TableSort.prototype = {
	initialize : function(elm, options) {
		var table = $(elm);
		if(table.tagName !== "TABLE") {
			return;
		}
		TableSort.register(table,Object.extend(TableSort.options,options || {}));
		this.id = table.id;
		
		var op = (options != null && options.length != 0) ? TableSort.option(options, this.id) : TableSort.option('sortable resizable editable', this.id);
		if(op.sortable) {
			TableSort.Sortable.init(table);
		} 
		if(op.resizable) {
			TableSort.Resizable.init(table);
		}
		if(op.editable) {
			TableSort.Editable.init(table);
		}
	},
	sort : function(column, order) {
		TableSort.Sortable.sort(this.id, column, order);
	},
	resizeColumn : function(column, w) {
		TableSort.Resizable.resize(this.id, column, w);
	},
	editCell : function(row, column) {
		TableSort.Editable.editCell(this.id, row, column);
	}
};

Object.extend(TableSort, {
	getBodyRows : function(table) {
		table = $(table);
		var id = table.id;
		if(!TableSort.rows[id] || TableSort.rows[id].length == 0) {
			TableSort.rows[id] = (table.tHead && table.tHead.rows.length > 0) ? $A(table.tBodies[0].rows) : $A(table.rows).without(table.rows[0]);
		}
		return TableSort.rows[id];
	},
	getHeaderCells : function(table, cell) {
		if(!table) { table = $(cell).up('table'); }
		var id = table.id;
		if(!TableSort.heads[id]) {
			TableSort.heads[id] = $A((table.tHead && table.tHead.rows.length > 0) ? table.tHead.rows[table.tHead.rows.length-1].cells : table.rows[0].cells);
		}
		return TableSort.heads[id];
	},
	getCellIndex : function(cell) {
		return $A(cell.parentNode.cells).indexOf(cell);
	},
	getRowIndex : function(row) {
		return $A(row.parentNode.rows).indexOf(row);
	},
	getCellText : function(cell, refresh) {
		if(!cell) { return ""; }
		TableSort.registerCell(cell);
		var data = TableSort.cells[cell.id];
		if(refresh || data.refresh || !data.textContent) {
			data.textContent = cell.textContent ? cell.textContent : cell.innerText;
			data.refresh = false;
		}
		return data.textContent;
	},
	register : function(table, options) {
		if(!table.id) {
			TableSort._tblcount += 1;
			table.id = "TableSort-table-" + TableSort._tblcount;
		}
		var id = table.id;
		TableSort.tables[id] = TableSort.tables[id] ? Object.extend(TableSort.tables[id], options || {}) : Object.extend({sortable:false,resizable:false,editable:false}, options || {});
	},
	registerCell : function(cell) {
		if(!cell.id) {
			TableSort._cellcount += 1;
			cell.id = "TableSort-cell-" + TableSort._cellcount;
		}
		if(!TableSort.cells[cell.id]) {
			TableSort.cells[cell.id] = {textContent : '', htmlContent : '', active : false};
		}
	},
	isSortable : function(table) {
		return TableSort.tables[table.id] ? TableSort.tables[table.id].sortable : false;
	},
	isResizable : function(table) {
		return TableSort.tables[table.id] ? TableSort.tables[table.id].resizable : false;
	},
	isEditable : function(table) {
		return TableSort.tables[table.id] ? TableSort.tables[table.id].editable : false;
	},
	setup : function(o) {
		Object.extend(TableSort.options, o || {} );
	},
	option : function(s, id, o1, o2) {
		o1 = o1 || TableSort.options;
		o2 = o2 || (id ? (TableSort.tables[id] ? TableSort.tables[id] : {}) : {});
		var key = id + s;
		if(!TableSort._opcache[key]){
			TableSort._opcache[key] = $A($w(s)).inject([],function(a,v){
				a.push(a[v] = o2[v] || o1[v]);
				return a;
			});
		}
		return TableSort._opcache[key];
	},
	e : function(event) {
		return event || window.event;
	},
	tables : {},
	_opcache : {},
	cells : {},
	rows : {},
	heads : {},
	options : {
		autoLoad : true,
		stripe : true,
		sortable : true,
		resizable : true,
		editable : true,
		rowEvenClass : '',
		rowOddClass : 'odd',
		sortableSelector : ['table.sortable'],
		columnClass : 'sortcol',
		descendingClass : 'sortdesc',
		ascendingClass : 'sortasc',
		noSortClass : 'nosort',
		sortFirstAscendingClass : 'sortfirstasc',
		sortFirstDecendingClass : 'sortfirstdesc',
		resizableSelector : ['table.resizable'],
		minWidth : 10,
		showHandle : true,
		resizeOnHandleClass : 'resize-handle-active',
		editableSelector : ['table.editable'],
		formClassName : 'editable-cell-form',
		noEditClass : 'noedit',
		editAjaxURI : '/',
		editAjaxOptions : {}
	},
	_tblcount : 0,
	_cellcount : 0,
	load : function() {
		if(TableSort.options.autoLoad) {
			if(TableSort.options.sortable) {
				$A(TableSort.options.sortableSelector).each(function(s){
					$$(s).each(function(t) {
						TableSort.Sortable.init(t);
					});
				});
			}
			if(TableSort.options.resizable) {
				$A(TableSort.options.resizableSelector).each(function(s){
					$$(s).each(function(t) {
						TableSort.Resizable.init(t);
					});
				});
			}
			if(TableSort.options.editable) {
				$A(TableSort.options.editableSelector).each(function(s){
					$$(s).each(function(t) {
						TableSort.Editable.init(t);
					});
				});
			}
		}
	}
});

TableSort.Rows = {
	stripe : function(table) {
		var rows = TableSort.getBodyRows(table);
		rows.each(function(r,i) {
			TableSort.Rows.addStripeClass(table,r,i);
		});
	},
	addStripeClass : function(t,r,i) {
		t = t || r.up('table');
		var op = TableSort.option('rowEvenClass rowOddClass', t.id);
		var css = ((i+1)%2 === 0 ? op[0] : op[1]);
		// using prototype's assClassName/RemoveClassName was not efficient for large tables, hence:
		var cn = r.className.split(/\s+/);
		var newCn = [];
		for(var x = 0, l = cn.length; x < l; x += 1) {
			if(cn[x] !== op[0] && cn[x] !== op[1]) { newCn.push(cn[x]); }
		}
		newCn.push(css);
		r.className = newCn.join(" ");
	},
	moveSortColumn : function(table, sortColIndex){
		//add function to set style for search column
		var rows = TableSort.getBodyRows(table);
		rows.each(function(r,i) {
			TableSort.Rows.moveSortClass(r,sortColIndex);
		});		
	},
	moveSortClass : function (row, sortColIndex){
		//add the search style to the correct cell, remove from all other cells
		var cells = row.cells;
		for (var i = 0; i < cells.length; i++){
			var cell = cells[i];
			var classes = cell.className.split(/\s+/);
			//get rid of sorts but hold on to other classes
			for (var j = 0; j < classes.length; j++){
				if (classes[j] == "sortasc" || classes[j] == "sortdesc" || classes[j] == "sortcol"){
					classes[j] = "";
				}
			}
			if (i == sortColIndex ){
				//set style to sort column
				cell.className = classes.join(" ") + " sortasc";
			} else {
				cell.className = classes.join(" ");
			}
		}
	}
	
};

TableSort.Sortable = {
	init : function(elm, options){
		var table = $(elm);
		if(table.tagName !== "TABLE") {
			return;
		}
		TableSort.register(table,Object.extend(options || {},{sortable:true}));
		var sortFirst;
		var cells = TableSort.getHeaderCells(table);
		var op = TableSort.option('noSortClass columnClass sortFirstAscendingClass sortFirstDecendingClass', table.id);
		cells.each(function(c){
			c = $(c);
			if(!c.hasClassName(op.noSortClass)) {
				Event.observe(c, 'mousedown', TableSort.Sortable._sort);
				c.addClassName(op.columnClass);
				if(c.hasClassName(op.sortFirstAscendingClass) || c.hasClassName(op.sortFirstDecendingClass)) {
					sortFirst = c;
				}
			}
		});

		if(sortFirst) {
			if(sortFirst.hasClassName(op.sortFirstAscendingClass)) {
				TableSort.Sortable.sort(table, sortFirst, 1);
			} else {
				TableSort.Sortable.sort(table, sortFirst, -1);
			}
		} else { // just add row stripe classes
			TableSort.Rows.stripe(table);
		}
	},
	reload : function(table) {
		table = $(table);
		var cells = TableSort.getHeaderCells(table);
		var op = TableSort.option('noSortClass columnClass', table.id);
		cells.each(function(c){
			c = $(c);
			if(!c.hasClassName(op.noSortClass)) {
				Event.stopObserving(c, 'mousedown', TableSort.Sortable._sort);
				c.removeClassName(op.columnClass);
			}
		});
		TableSort.Sortable.init(table);
	},
	_sort : function(e) {
		if(TableSort.Resizable._onHandle) {return;}
		e = TableSort.e(e);
		Event.stop(e);
		var cell = Event.element(e);
		while(!(cell.tagName && cell.tagName.match(/td|th/gi))) {
			cell = cell.parentNode;
		}
		TableSort.Sortable.sort(null, cell);
	},
	sort : function(table, index, order) {
		var cell;
		if(typeof index === 'number') {
			if(!table || (table.tagName && table.tagName !== "TABLE")) {
				return;
			}
			table = $(table);
			index = Math.min(table.rows[0].cells.length, index);
			index = Math.max(1, index);
			index -= 1;
			cell = (table.tHead && table.tHead.rows.length > 0) ? $(table.tHead.rows[table.tHead.rows.length-1].cells[index]) : $(table.rows[0].cells[index]);
		} else {
			cell = $(index);
			table = table ? $(table) : cell.up('table');
			index = TableSort.getCellIndex(cell);
		}
		var op = TableSort.option('noSortClass descendingClass ascendingClass', table.id);
		if(cell.hasClassName(op.noSortClass)) {return;}	
		
		order = order ? order : (cell.hasClassName(op.descendingClass) ? 1 : -1);
		var rows = TableSort.getBodyRows(table);

		if(cell.hasClassName(op.ascendingClass) || cell.hasClassName(op.descendingClass)) {
			rows.reverse(); // if it was already sorted we just need to reverse it.
		} else {
			var datatype = TableSort.Sortable.getDataType(cell,index,table);
			//console.log("Data type",datatype);
			var tkst = TableSort.Sortable.types;
			rows.sort(function(a,b) {
				return order * tkst[datatype].compare(TableSort.getCellText(a.cells[index]),TableSort.getCellText(b.cells[index]));
			});
		}
		var tb = table.tBodies[0];
		var tkr = TableSort.Rows;
		rows.each(function(r,i) {
			tb.appendChild(r);
			tkr.addStripeClass(table,r,i);
		});
		tkr.moveSortColumn(table,index);
		var hcells = TableSort.getHeaderCells(null, cell);
		$A(hcells).each(function(c,i){
			c = $(c);
			c.removeClassName(op.ascendingClass);
			c.removeClassName(op.descendingClass);
			//the current css requires handling the first column differently
			if (i == 0) {
				if (i == index){
					c.setStyle({background:"#24640E"});//highlight color
				} else {
					c.setStyle({background:"#23669D"});//reset to default
				}
			}
			if(index === i) {
				if(order === 1) {
					c.removeClassName(op.descendingClass);
					c.addClassName(op.ascendingClass);
				} else {
					c.removeClassName(op.ascendingClass);
					c.addClassName(op.descendingClass);
				}
			}
		});
	},
	types : {},
	detectors : [],
	addSortType : function() {
		$A(arguments).each(function(o){
			TableSort.Sortable.types[o.name] = o;
		});
	},
	getDataType : function(cell,index,table) {
		cell = $(cell);
		index = (index || index === 0) ? index : TableSort.getCellIndex(cell);
		
		var colcache = TableSort.Sortable._coltypecache;
		var cache = colcache[table.id] ? colcache[table.id] : (colcache[table.id] = {});
		
		if(!cache[index]) {
			var t = '';
			// first look for a data type id on the heading row cell
			if(cell.id && TableSort.Sortable.types[cell.id]) {
				t = cell.id;
			}
			t = cell.classNames().detect(function(n){ // then look for a data type classname on the heading row cell
				return (TableSort.Sortable.types[n]) ? true : false;
			});
			if(!t) {
				var rows = TableSort.getBodyRows(table);
				cell = rows[0].cells[index]; // grab same index cell from body row to try and match data type
				t = TableSort.Sortable.detectors.detect(
						function(d){
							return TableSort.Sortable.types[d].detect(TableSort.getCellText(cell));
						});
			}
			cache[index] = t;
		}
		return cache[index];
	},
	_coltypecache : {}
};

TableSort.Sortable.detectors = $A($w('date-iso date date-eu time currency datasize number casesensitivetext text')); // setting it here because Safari complained when I did it above...

TableSort.Sortable.Type = Class.create();
TableSort.Sortable.Type.prototype = {
	initialize : function(name, options){
		this.name = name;
		options = Object.extend({
			normal : function(v){
				return v;
			},
			pattern : /.*/
		}, options || {});
		this.normal = options.normal;
		this.pattern = options.pattern;
		if(options.compare) {
			this.compare = options.compare;
		}
		if(options.detect) {
			this.detect = options.detect;
		}
	},
	compare : function(a,b){
		return TableSort.Sortable.Type.compare(this.normal(a), this.normal(b));
	},
	detect : function(v){
		return this.pattern.test(v);
	}
};

TableSort.Sortable.Type.compare = function(a,b) {
	return a < b ? -1 : a === b ? 0 : 1;
};

TableSort.Sortable.addSortType(
	new TableSort.Sortable.Type('number', {
		pattern : /^[-+]?[\d]*\.?[\d]+(?:[eE][-+]?[\d]+)?/,
		normal : function(v) {
			// This will grab the first thing that looks like a number from a string, so you can use it to order a column of various srings containing numbers.
			v = v.replace(/,/g,"");
			v = parseFloat(v.replace(/^.*?([-+]?[\d]*\.?[\d]+(?:[eE][-+]?[\d]+)?).*$/,"$1"));
			return isNaN(v) ? 0 : v;
		}}),
	new TableSort.Sortable.Type('text',{
		normal : function(v) {
			return v ? v.toLowerCase() : '';
		}}),
	new TableSort.Sortable.Type('casesensitivetext',{pattern : /^[A-Z]+$/}),
	new TableSort.Sortable.Type('datasize',{
		pattern : /^[-+]?[\d]*\.?[\d]+(?:[eE][-+]?[\d]+)?\s?[k|m|g|t]b$/i,
		normal : function(v) {
			var r = v.match(/^([-+]?[\d]*\.?[\d]+([eE][-+]?[\d]+)?)\s?([k|m|g|t]?b)?/i);
			var b = r[1] ? Number(r[1]).valueOf() : 0;
			var m = r[3] ? r[3].substr(0,1).toLowerCase() : '';
			var result = b;
			switch(m) {
				case  'k':
					result = b * 1024;
					break;
				case  'm':				
					result = b * 1024 * 1024;
					break;
				case  'g':
					result = b * 1024 * 1024 * 1024;
					break;
				case  't':
					result = b * 1024 * 1024 * 1024 * 1024;
					break;
			}
			return result;
		}}),
	new TableSort.Sortable.Type('date-us',{
		pattern : /^\d{2}\/\d{2}\/\d{4}\s?(?:\d{1,2}\:\d{2}(?:\:\d{2})?\s?[a|p]?m?)?/i,
		normal : function(v) {
			if(!this.pattern.test(v)) {return 0;}
			var r = v.match(/^(\d{2})\/(\d{2})\/(\d{4})\s?(?:(\d{1,2})\:(\d{2})(?:\:(\d{2}))?\s?([a|p]?m?))?/i);
			var yr_num = r[3];
			var mo_num = parseInt(r[1],10)-1;
			var day_num = r[2];
			var hr_num = r[4] ? r[4] : 0;
			if(r[7] && r[7].toLowerCase().indexOf('p') !== -1) {
				hr_num = parseInt(r[4],10) + 12;
			}
			var min_num = r[5] ? r[5] : 0;
			var sec_num = r[6] ? r[6] : 0;
			return new Date(yr_num, mo_num, day_num, hr_num, min_num, sec_num, 0).valueOf();
		}}),
	new TableSort.Sortable.Type('date-eu',{
		pattern : /^\d{2}-\d{2}-\d{4}/i,
		normal : function(v) {
			if(!this.pattern.test(v)) {return 0;}
			var r = v.match(/^(\d{2})-(\d{2})-(\d{4})/);
			var yr_num = r[3];
			var mo_num = parseInt(r[2],10)-1;
			var day_num = r[1];
			return new Date(yr_num, mo_num, day_num).valueOf();
		}}),
	new TableSort.Sortable.Type('date-iso',{
		pattern : /[\d]{4}-[\d]{2}-[\d]{2}(?:T[\d]{2}\:[\d]{2}(?:\:[\d]{2}(?:\.[\d]+)?)?(Z|([-+][\d]{2}:[\d]{2})?)?)?/, // 2005-03-26T19:51:34Z
		normal : function(v) {
			if(!this.pattern.test(v)) {return 0;}
		    var d = v.match(/([\d]{4})(-([\d]{2})(-([\d]{2})(T([\d]{2}):([\d]{2})(:([\d]{2})(\.([\d]+))?)?(Z|(([-+])([\d]{2}):([\d]{2})))?)?)?)?/);		
		    var offset = 0;
		    var date = new Date(d[1], 0, 1);
		    if (d[3]) { date.setMonth(d[3] - 1) ;}
		    if (d[5]) { date.setDate(d[5]); }
		    if (d[7]) { date.setHours(d[7]); }
		    if (d[8]) { date.setMinutes(d[8]); }
		    if (d[10]) { date.setSeconds(d[10]); }
		    if (d[12]) { date.setMilliseconds(Number("0." + d[12]) * 1000); }
		    if (d[14]) {
		        offset = (Number(d[16]) * 60) + Number(d[17]);
		        offset *= ((d[15] === '-') ? 1 : -1);
		    }
		    offset -= date.getTimezoneOffset();
		    if(offset !== 0) {
		    	var time = (Number(date) + (offset * 60 * 1000));
		    	date.setTime(Number(time));
		    }
			return date.valueOf();
		}}),
	new TableSort.Sortable.Type('date',{
		pattern: /^(?:sun|mon|tue|wed|thu|fri|sat)\,\s\d{1,2}\s(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\s\d{4}(?:\s\d{2}\:\d{2}(?:\:\d{2})?(?:\sGMT(?:[+-]\d{4})?)?)?/i, //Mon, 18 Dec 1995 17:28:35 GMT
		compare : function(a,b) { // must be standard javascript date format
			if(a && b) {
				return TableSort.Sortable.Type.compare(new Date(a),new Date(b));
			} else {
				return TableSort.Sortable.Type.compare(a ? 1 : 0, b ? 1 : 0);
			}
		}}),
	new TableSort.Sortable.Type('time',{
		pattern : /^\d{1,2}\:\d{2}(?:\:\d{2})?(?:\s[a|p]m)?$/i,
		compare : function(a,b) {
			var d = new Date();
			var ds = d.getMonth() + "/" + d.getDate() + "/" + d.getFullYear() + " ";
			return TableSort.Sortable.Type.compare(new Date(ds + a),new Date(ds + b));
		}}),
	new TableSort.Sortable.Type('currency',{
		pattern : /^[$ŁĄ?¤]/, // dollar,pound,yen,euro,generic currency symbol
		normal : function(v) {
			return v ? parseFloat(v.replace(/[^-\d\.]/g,'')) : 0;
		}})
);

TableSort.Resizable = {
	init : function(elm, options){
		var table = $(elm);
		if(table.tagName !== "TABLE") {return;}
		TableSort.register(table,Object.extend(options || {},{resizable:true}));		 
		var cells = TableSort.getHeaderCells(table);
		cells.each(function(c){
			c = $(c);
			Event.observe(c, 'mouseover', TableSort.Resizable.initDetect);
			Event.observe(c, 'mouseout', TableSort.Resizable.killDetect);
		});
	},
	resize : function(table, index, w) {
		var cell;
		if(typeof index === 'number') {
			if(!table || (table.tagName && table.tagName !== "TABLE")) {return;}
			table = $(table);
			index = Math.min(table.rows[0].cells.length, index);
			index = Math.max(1, index);
			index -= 1;
			cell = (table.tHead && table.tHead.rows.length > 0) ? $(table.tHead.rows[table.tHead.rows.length-1].cells[index]) : $(table.rows[0].cells[index]);
		} else {
			cell = $(index);
			table = table ? $(table) : cell.up('table');
			index = TableSort.getCellIndex(cell);
		}
		var pad = parseInt(cell.getStyle('paddingLeft'),10) + parseInt(cell.getStyle('paddingRight'),10);
		w = Math.max(w-pad, TableSort.option('minWidth', table.id)[0]);
		
		cell.setStyle({'width' : w + 'px'});
	},
	initDetect : function(e) {
		e = TableSort.e(e);
		var cell = Event.element(e);
		Event.observe(cell, 'mousemove', TableSort.Resizable.detectHandle);
		Event.observe(cell, 'mousedown', TableSort.Resizable.startResize);
	},
	detectHandle : function(e) {
		e = TableSort.e(e);
		var cell = Event.element(e);
  		if(TableSort.Resizable.pointerPos(cell,Event.pointerX(e),Event.pointerY(e))){
  			cell.addClassName(TableSort.option('resizeOnHandleClass', cell.up('table').id)[0]);
  			TableSort.Resizable._onHandle = true;
  		} else {
  			cell.removeClassName(TableSort.option('resizeOnHandleClass', cell.up('table').id)[0]);
  			TableSort.Resizable._onHandle = false;
  		}
	},
	killDetect : function(e) {
		e = TableSort.e(e);
		TableSort.Resizable._onHandle = false;
		var cell = Event.element(e);
		Event.stopObserving(cell, 'mousemove', TableSort.Resizable.detectHandle);
		Event.stopObserving(cell, 'mousedown', TableSort.Resizable.startResize);
		cell.removeClassName(TableSort.option('resizeOnHandleClass', cell.up('table').id)[0]);
	},
	startResize : function(e) {
		e = TableSort.e(e);
		if(!TableSort.Resizable._onHandle) {return;}
		var cell = Event.element(e);
		Event.stopObserving(cell, 'mousemove', TableSort.Resizable.detectHandle);
		Event.stopObserving(cell, 'mousedown', TableSort.Resizable.startResize);
		Event.stopObserving(cell, 'mouseout', TableSort.Resizable.killDetect);
		TableSort.Resizable._cell = cell;
		var table = cell.up('table');
		TableSort.Resizable._tbl = table;
		if(TableSort.option('showHandle', table.id)[0]) {
			TableSort.Resizable._handle = $(document.createElement('div')).addClassName('resize-handle').setStyle({
				'top' : Position.cumulativeOffset(cell)[1] + 'px',
				'left' : Event.pointerX(e) + 'px',
				'height' : table.getDimensions().height + 'px'
			});
			document.body.appendChild(TableSort.Resizable._handle);
		}
		Event.observe(document, 'mousemove', TableSort.Resizable.drag);
		Event.observe(document, 'mouseup', TableSort.Resizable.endResize);
		Event.stop(e);
	},
	endResize : function(e) {
		e = TableSort.e(e);
		var cell = TableSort.Resizable._cell;
		TableSort.Resizable.resize(null, cell, (Event.pointerX(e) - Position.cumulativeOffset(cell)[0]));
		Event.stopObserving(document, 'mousemove', TableSort.Resizable.drag);
		Event.stopObserving(document, 'mouseup', TableSort.Resizable.endResize);
		if(TableSort.option('showHandle', TableSort.Resizable._tbl.id)[0]) {
			$$('div.resize-handle').each(function(elm){
				document.body.removeChild(elm);
			});
		}
		Event.observe(cell, 'mouseout', TableSort.Resizable.killDetect);
		TableSort.Resizable._tbl = TableSort.Resizable._handle = TableSort.Resizable._cell = null;
		Event.stop(e);
	},
	drag : function(e) {
		e = TableSort.e(e);
		if(TableSort.Resizable._handle === null) {
			try {
				TableSort.Resizable.resize(TableSort.Resizable._tbl, TableSort.Resizable._cell, (Event.pointerX(e) - Position.cumulativeOffset(TableSort.Resizable._cell)[0]));
			} catch(e) {}
		} else {
			TableSort.Resizable._handle.setStyle({'left' : Event.pointerX(e) + 'px'});
		}
		return false;
	},
	pointerPos : function(element, x, y) {
    	var offset = Position.cumulativeOffset(element);
	    return (y >= offset[1] &&
	            y <  offset[1] + element.offsetHeight &&
	            x >= offset[0] + element.offsetWidth - 5 &&
	            x <  offset[0] + element.offsetWidth);
  	},
	_onHandle : false,
	_cell : null,
	_tbl : null,
	_handle : null
};


TableSort.Editable = {
	init : function(elm, options){
		var table = $(elm);
		if(table.tagName !== "TABLE") {return;}
		TableSort.register(table,Object.extend(options || {},{editable:true}));
		Event.observe(table.tBodies[0], 'click', TableSort.Editable._editCell);
	},
	_editCell : function(e) {
		e = TableSort.e(e);
		var cell = Event.findElement(e,'td');
		TableSort.Editable.editCell(null, cell);
	},
	editCell : function(table, index, cindex) {
		var cell, row;
		if(typeof index === 'number') {
			if(!table || (table.tagName && table.tagName !== "TABLE")) {return;}
			table = $(table);
			index = Math.min(table.tBodies[0].rows.length, index);
			index = Math.max(1, index);
			index -= 1;
			cindex = Math.min(table.rows[0].cells.length, cindex);
			cindex = Math.max(1, cindex);
			cindex -= 1;
			row = $(table.tBodies[0].rows[index]);
			cell = $(row.cells[cindex]);
		} else {
			cell = $(index);
			table = (table && table.tagName && table.tagName !== "TABLE") ? $(table) : cell.up('table');
			row = cell.up('tr');
		}
		var op = TableSort.option('noEditClass', table.id);
		if(cell.hasClassName(op.noEditClass)) {return;}
		
		var head = $(TableSort.getHeaderCells(table, cell)[TableSort.getCellIndex(cell)]);
		if(head.hasClassName(op.noEditClass)) {return;}
		
		TableSort.registerCell(cell);
		var data = TableSort.cells[cell.id];
		if(data.active) {return;}
		data.htmlContent = cell.innerHTML;
		var ftype = TableSort.Editable.types['text-input'];
		if(head.id && TableSort.Editable.types[head.id]) {
			ftype = TableSort.Editable.types[head.id];
		} else {
			var n = head.classNames().detect(function(n){
					return (TableSort.Editable.types[n]) ? true : false;
			});
			ftype = n ? TableSort.Editable.types[n] : ftype;
		}
		ftype.edit(cell);
		data.active = true;
	},
	types : {},
	addCellEditor : function(o) {
		if(o && o.name) { TableSort.Editable.types[o.name] = o; }
	}
};

TableSort.Editable.CellEditor = Class.create();
TableSort.Editable.CellEditor.prototype = {
	initialize : function(name, options){
		this.name = name;
		this.options = Object.extend({
			element : 'input',
			attributes : {name : 'value', type : 'text'},
			selectOptions : [],
			showSubmit : true,
			submitText : 'OK',
			showCancel : true,
			cancelText : 'Cancel',
			ajaxURI : null,
			ajaxOptions : null
		}, options || {});
	},
	edit : function(cell) {
		cell = $(cell);
		var op = this.options;
		var table = cell.up('table');
		
		var form = $(document.createElement("form"));
		form.id = cell.id + '-form';
		form.addClassName(TableSort.option('formClassName', table.id)[0]);
		form.onsubmit = this._submit.bindAsEventListener(this);
		
		var field = document.createElement(op.element);
			$H(op.attributes).each(function(v){
				field[v.key] = v.value;
			});
			switch(op.element) {
				case 'input':
				case 'textarea':
				field.value = TableSort.getCellText(cell);
				break;
				
				case 'select':
				var txt = TableSort.getCellText(cell);
				$A(op.selectOptions).each(function(v){
					field.options[field.options.length] = new Option(v[0], v[1]);
					if(txt === v[1]) {
						field.options[field.options.length-1].selected = 'selected';
					}
				});
				break;
			}
			form.appendChild(field);
			if(op.element === 'textarea') {
				form.appendChild(document.createElement("br"));
			}
			if(op.showSubmit) {
				var okButton = document.createElement("input");
				okButton.type = "submit";
				okButton.value = op.submitText;
				okButton.className = 'editor_ok_button';
				form.appendChild(okButton);
			}
			if(op.showCancel) {
				var cancelLink = document.createElement("a");
				cancelLink.href = "#";
				cancelLink.appendChild(document.createTextNode(op.cancelText));
				cancelLink.onclick = this._cancel.bindAsEventListener(this);
				cancelLink.className = 'editor_cancel';      
				form.appendChild(cancelLink);
			}
			cell.innerHTML = '';
			cell.appendChild(form);
	},
	_submit : function(e) {
		var cell = Event.findElement(e,'td');
		var form = Event.findElement(e,'form');
		Event.stop(e);
		this.submit(cell,form);
	},
	submit : function(cell, form) {
		var op = this.options;
		form = form ? form : cell.down('form');
		var head = $(TableSort.getHeaderCells(null, cell)[TableSort.getCellIndex(cell)]);
		var row = cell.up('tr');
		var table = cell.up('table');
		var s = '&row=' + (TableSort.getRowIndex(row)+1) + '&cell=' + (TableSort.getCellIndex(cell)+1) + '&id=' + row.id + '&field=' + head.id + '&' + Form.serialize(form);
		this.ajax = new Ajax.Updater(cell, op.ajaxURI || TableSort.option('editAjaxURI', table.id)[0], Object.extend(op.ajaxOptions || TableSort.option('editAjaxOptions', table.id)[0], {
			postBody : s,
			onComplete : function() {
				var data = TableSort.cells[cell.id];
				data.active = false;
				data.refresh = true; // mark cell cache for refreshing, in case cell contents has changed and sorting is applied
			}
		}));
	},
	_cancel : function(e) {
		var cell = Event.findElement(e,'td');
		Event.stop(e);
		this.cancel(cell);
	},
	cancel : function(cell) {
		this.ajax = null;
		var data = TableSort.cells[cell.id];
		cell.innerHTML = data.htmlContent;
		data.htmlContent = '';
		data.active = false;
	},
	ajax : null
};

TableSort.Editable.textInput = function(n,attributes) {
	TableSort.Editable.addCellEditor(new TableSort.Editable.CellEditor(n, {
		element : 'input',
		attributes : Object.extend({name : 'value', type : 'text'}, attributes||{})
	}));
};
TableSort.Editable.textInput('text-input');

TableSort.Editable.multiLineInput = function(n,attributes) {
	TableSort.Editable.addCellEditor(new TableSort.Editable.CellEditor(n, {
		element : 'textarea',
		attributes : Object.extend({name : 'value', rows : '5', cols : '20'}, attributes||{})
	}));	
};	
TableSort.Editable.multiLineInput('multi-line-input');

TableSort.Editable.selectInput = function(n,attributes,selectOptions) {
	TableSort.Editable.addCellEditor(new TableSort.Editable.CellEditor(n, {
		element : 'select',
		attributes : Object.extend({name : 'value'}, attributes||{}),
		'selectOptions' : selectOptions
	}));	
};

/*
TableSort.Bench = {
	bench : [],
	start : function(){
		TableSort.Bench.bench[0] = new Date().getTime();
	},
	end : function(s){
		TableSort.Bench.bench[1] = new Date().getTime();
		alert(s + ' ' + ((TableSort.Bench.bench[1]-TableSort.Bench.bench[0])/1000)+' seconds.') //console.log(s + ' ' + ((TableSort.Bench.bench[1]-TableSort.Bench.bench[0])/1000)+' seconds.')
		TableSort.Bench.bench = [];
	}
} */

if(window.FastInit) {
	FastInit.addOnLoad(TableSort.load);
} else {
	Event.observe(window, 'load', TableSort.load);
}