// ###########################################################################
// dependency on reg.js
reg.importAll();

// ###########################################################################
// ARRAY COMPATIBILITY FUNCTIONS FOR JavaScript 1.6
(function(){

	var ap = Array.prototype;

	/**
	// create a new array with some items filtered out
	foo = [1,2,3,4,5];
	bar = foo.filter(function(x){return x%2==0;});
	// bar now equals [2,4]
	*/
	if (!ap.filter) {
		ap.filter = function(fun) {
			var len = this.length >>> 0;
			if (typeof fun != "function") { throw new TypeError(); }
			var res = new Array();
			var thisp = arguments[1];
			for (var i=0; i<len; i++) {
				if (i in this) {
					var val = this[i]; // in case fun mutates this
					if (fun.call(thisp, val, i, this)) { res.push(val); }
				}
			}
			return res;
		};
	}

	/**
	// runs a function against each item in array
	foo = ['potatoes','celery']
	foo.forEach(function(x){console.log("I like "+x);});
	// prints:
	// I like potatoes
	// I like celery
	*/
	if (!ap.forEach) {
		ap.forEach = function(fun) {
			var len = this.length >>> 0;
			if (typeof fun != "function") { throw new TypeError(); }
			var thisp = arguments[1];
			for (var i=0; i<len; i++) {
				if (i in this) { fun.call(thisp, this[i], i, this); }
			}
		};
	}

	/**
	// does the given function return true for every item in the array?
	foo = [4,8,6,1]
	function isEven(x){return x%2==0;}
	allEven = foo.every(isEven);
	// allEven is false
	*/
	if (!ap.every) {
		ap.every = function(fun) {
			var len = this.length >>> 0;
			if (typeof fun != "function") { throw new TypeError(); }
			var thisp = arguments[1];
			for (var i=0; i<len; i++) {
				if (i in this && !fun.call(thisp, this[i], i, this)) { return false; }
			}
			return true;
		};
	}

	/**
	// create a new array based on this array
	foo = [1,2,3];
	bar = foo.map(function(x){return x+"";});
	// bar now equals ["1","2","3"]
	*/
	if (!ap.map) {
		ap.map = function(fun) {
			var len = this.length >>> 0;
			if (typeof fun != "function") { throw new TypeError(); }
			var res = new Array(len);
			var thisp = arguments[1];
			for (var i=0; i<len; i++) {
				if (i in this) { res[i] = fun.call(thisp, this[i], i, this); }
			}
			return res;
	  	};
	}

	/**
	// does the given function return true for at least one item in the array?
	foo = [4,8,6,1]
	function isOdd(x){return x%2==1;}
	someOdd = foo.some(isOdd);
	// someOdd is true
	*/
	if (!ap.some) {
		ap.some = function(fun) {
			var i = 0, len = this.length >>> 0;
			if (typeof fun != "function") { throw new TypeError(); }
			var thisp = arguments[1];
			for (; i<len; i++) {
				if (i in this && fun.call(thisp, this[i], i, this)) { return true; }
			}
			return false;
		};
	}

})();

// ###########################################################################
// GENERIC XML HTTP REQUEST
function xhr(url, successFunc, failFunc, obj, postData){
	/*
	successFunc(responseText, obj)
	failFunc(statusCode, statusText, url, obj)
	*/
	var http_request = false;
	if (window.XMLHttpRequest) {
		http_request = new XMLHttpRequest();
	}else if (window.ActiveXObject) { // IE
		try { http_request = new ActiveXObject("Msxml2.XMLHTTP"); }
		catch(e){
			try{ http_request = new ActiveXObject("Msxml3.XMLHTTP"); }
			catch(ex1){
				try{ http_request = new ActiveXObject("Microsoft.XMLHTTP"); }
				catch(ex2){}
			}
		}
	}
	if (!http_request) { return false; }
	if (!postData) { postData = null; }
	var method = (postData) ? "POST" : "GET";
	http_request.open(method, url, true);
	http_request.setRequestHeader('User-Agent','XMLHTTP/1.0');
	if (postData) { http_request.setRequestHeader('Content-type','application/x-www-form-urlencoded'); }
	http_request.onreadystatechange = function() {
		if (http_request.readyState == 4) {
			if (http_request.status == 200) {
				successFunc(http_request.responseText, obj);
			}else{
				try { failFunc(http_request.status, http_request.statusText, url, obj); }
				catch (ex) { failFunc('', ex, url, obj); }
			}
		}
	};
	http_request.send(postData);
}

// ###########################################################################
// search field autoclear
reg.setup('input#searchterms@type="text"',function(){

	function getLabel(field) {
		var labelEl = getParent(field,'label');
		var id = field.id || field.name;
		if (!labelEl) {
			var labels = gebtn('label');
			for (var i=0;i<labels.length;i++){
				if (labels[i].htmlFor===id) {
					labelEl = labels[i];
					break;
				}
			}
		}
		return (labelEl) ? elemText(labelEl) : id;
	}

	var defText = getLabel(this);

	if (defText) {
		if (!this.value) { this.value = defText; }
		reg.focus('input#searchterms@type="text"',function(){
			if (this.value === defText) { this.value = ''; }
		},function(){
			if (this.value === '') { this.value = defText; }
		});
	}

},true);

// ###########################################################################
// smack ie7 upside the head
if (lteie7) { // just ie 7 and below
	reg.setup('p.blockheadextra',function(){
		/* add some structural information to enable certain css workarounds */
		acn(this.parentNode, "containsblockheadextra");
	});
	reg.setup('div#tagcloud',function(){
		// ugly hack for ie line height
		var p = gebtn('p',this)[0];
		p.appendChild(elem('span',{'class':'ender'},' '));
		p.appendChild(elem('br'));
		p.appendChild(elem('br'));
	},true);
}

// ###########################################################################
// setup the tags expand/collapse
reg.preSetup(function(){

	if (gebi("tagpage")) { return; } // don't do this on the actual tags page

	try {

		// first, alter the link
		var div = gebi('tagcloud');
		if (!div) { return; }
		div = getParent(div,'div.tags');
		var showMessage = 'more';
		var hideMessage = 'less';
		var togglerLink = gebs('.blockheadextra a@href',div)[0];
		var tagContainer = gebs('#tagcloud p',div)[0];
		acn(togglerLink, 'tagtoggler expandAction');
		togglerLink.innerHTML = showMessage;
		var bigContent = null;
		var smallContent = tagContainer.innerHTML;

		// next, add the behavior
		reg.click('a.tagtoggler',function(e){
			if (hcn(this,'processing')) { return; }
			else if (hcn(this,'collapseAction')) {
				acn(this,'processing');
				rcn(this,'collapseAction');
				acn(div,'tagscompact');
				tagContainer.innerHTML = smallContent;
				acn(this,'expandAction');
				rcn(this,'processing');
				this.innerHTML = showMessage;
			} else if (hcn(this,'expandAction')) {
				var tagToggler = this;
				acn(tagToggler,'processing');
				rcn(tagToggler,'expandAction');
				if (!bigContent) {
					var href = tagToggler.href;
					xhr(href,function(htmlString){
						// yay!
						var newDiv = elem('div');
						newDiv.innerHTML = htmlString;
						bigContent = gebs('#tagcloud p',newDiv)[0].innerHTML;
						tagContainer.innerHTML = bigContent;
						rcn(div,'tagscompact');
						// use timer to move below code out from under redraw caused by above code
						window.setTimeout(function(){
							tagToggler.innerHTML = hideMessage;
							acn(tagToggler,'collapseAction');
							rcn(tagToggler,'processing');
						},100);
					},function(statusCode, statusText){
						// oh no!
						location.href = href;
						console.log(statusCode+": "+statusText);
						acn(tagToggler,'expandAction');
						rcn(tagToggler, 'processing');
					});
				} else {
					tagContainer.innerHTML = bigContent;
					rcn(div,'tagscompact');
					// use timer to move below code out from under redraw caused by above code
					window.setTimeout(function(){
						tagToggler.innerHTML = hideMessage;
						acn(tagToggler,'collapseAction');
						rcn(tagToggler,'processing');
					},100);
				}
			}
			return false;
		});
	} catch (ex) {
		console.log(ex.message);
	}

});