/*
           ,---------------------------------------------------------.
          /  wonderJSON is a lightweight javascript thingy            )
         /   to easily load padded JSON from other domains.          /
        /                                                           /
       (            Ioan Sameli, 04.2006 - 04.2007                 /
        `--\   /--------------------------------------------------´
           |  /
            \|
             `
           (")-''-(").___,.~-´'^`-._
            \O_ O  )   `-.  (     ).`-.__.´)
            (_Y_.)/  ._   )  `._ `. `´-..-´
          _,.`--´_,.-_/  /~-`_.´ ,´
         (il).-'´  (li).´  ((!.-´

             _________________________________________________
    ________|                                                 |_______
    \       |   For more informations about all this, check   |      /
     \      |   the official documentation! (not yet done)    |     /
     /      |_________________________________________________|     \
    /__________)                                            (________\

	TODO
		* Check function.apply(arguments)
*/

// Fake trace function if it doesn't exist yet...
if (typeof trace != 'function') trace = function(){};

  /***********************/
 /***   JSON module   ***/
/***********************/

	// The delay after wich a JSON request is considered as timed out, in milliseconds
	var delayTimeoutJSON = 5000;

	// Ioan Sameli, 10.05.2006
	// Call an URL, and set the function that will handle the answer
	// params (object, optional): To provide the properties as argument
	wonderJSON = function(params) {

		// A method that will be called after a timeout if the request doesn't get any answer.
		this.onTimeOut = function() {
			// alert('The request ' + this.id + ' seems to have failed!');
		}

		// If some properties have been given as parameter when creating the object, apply them
		// to the current object. Will override the previously set properties.
		if (params) for (var i in params) this[i] = params[i];

		// To inject HTML code into the target,
		// rResult (string, optional): Some text or HTML to inject in the target. If null, will empty the target.
		// sTarget (string, optional): to specify another target than the default rTarget's request property.
		this.fillTarget = function(rResult, sTarget) {

			sTarget = sTarget || this.rTarget;

			if (!sTarget) return;

			if (e = document.getElementById(sTarget)) e.innerHTML = rResult;
			else trace('fillTarget: Element ' + sTarget + ' not found \n(' + this.rSource + ')', 'error');
		}


		// Link the current request to another object, so we'll be able to address the request
		// directly, useful for example with JSON async callback functions.
		// TODO: maybe we should destroy the object once it's done, to avoid having many useless
		// expired properties in the parent (causing performance / memory problems ?)
		this.linkToParent = function(objParent) {

			// create a new property in the parent, with a unique ID based on the timestamp
			// Avoid having two similar ID by incrementing if the current ID is already used
			if (typeof objParent.wj == 'undefined') objParent.wj = {}
			this.id = new Date().getTime();
			while ((typeof objParent.wj[this.id]) != 'undefined') this.id++;

			// Add the current request object to the parent, add the parent to the current request object
			objParent.wj[this.id] = this;
			this.parent = objParent;

		}

		// This method will set the function that the JSON result will call.
		// It can be specified by the argument or generated automatically.
		// Will return the name of the function (string)
		this.setJSONCallbackFunctionName = function(nameFunction) {

			// If no function name, simply return the 'path' to the current request's handleJSON
			if (! nameFunction) return 'wj[' + this.id + '].handleJSON';

			// If a name has been specified in the argument, create a new function linked to the handleJSON
			var closure = this;
			window[nameFunction] = function(){closure.handleJSON.apply(closure, arguments);};
			// window[nameFunction] = function(){closure.handleJSON((arguments.length > 1) ? arguments : arguments[0]);};
			// window[nameFunction] = function(){closure.handleJSON.apply(arguments);};
		}

		this.handleJSON = function() {

			// First, cancel the timeout warning, the answer is here!
			this.onTimeOut = function(){};

			trace('wonderJSON.'+this.id+': answer received in ' + (new Date().getTime() - this.loadstart) + ' milliseconds, calling onAnswer function.');

			// And forward the result to the onAnswer() function
			// If only one argument, pass it, otherwise, pass all the arguments at once
			// this.onAnswer((arguments.length > 1) ? arguments : arguments[0]);
			if (this.onAnswer) this.onAnswer.apply(this, arguments);
		}

		// For crossdomain request, include a script that will contain JSON data with a callBack function
		this.launch = function() {

			// If there are arguments in rSourceArguments, add them to the URL
			if (this.rSourceArguments) {

				var p = '';

				for (var i in this.rSourceArguments) {
					var a = this.rSourceArguments[i];
					if (typeof a != 'undefined' && a != null ) p = addParam(i, encodeURIComponent(this.rSourceArguments[i]), p);
				}
				this.rSource = this.rSource + '?' + p;
			}

			// Set the name of the callback function
			this.linkToParent(window);
			this.rCallback = this.setJSONCallbackFunctionName(this.rCallback);

			// TODO: this is a quite ugly hack! Could be done better.
			if (this.addCallbackArgument) this.rSource += this.addCallbackArgument + this.rCallback;

			// "Calling" the JSON by adding a script to the document <head>
			loadScript(this.rSource, 'UTF-8');
			trace('wonderJSON.'+this.id+': load <a href="' + this.rSource + '">' + this.rSource + '</a>');
			this.loadstart = new Date().getTime();

			// Manage the timeout: call the timeout function with a timeout if the onAnswer function is set
			var closure = this;
			if ('function' == typeof this.onAnswer) window.setTimeout(function(){closure.onTimeOut();}, delayTimeoutJSON);
		}

	}

  /****************************/
 /***   Useful functions   ***/
/****************************/

	// Load a javascript file by appending a <script> tag to the head.
	// Parameters:
	//    jsFile (string): the path to the javascript file
	//    charset (string, optional): If a charset has to be specified (UTF-8 or so)
	function loadScript(jsFile, charset) {

		// Create script node
		var script = document.createElement('script');
		script.type = 'text/javascript';
		if (charset) script.charset = charset;
		script.src = jsFile;

		// Append it to document's head
		document.getElementsByTagName('head')[0].appendChild(script);
	}



	// To print something in the console, used from nearly everywhere
	// str (string): the string to display in the console
	// msgClass (string, optional): to apply a CSS class on the debug message (typically, "info", "error", "success")
	function trace(str, msgClass) {

		// If the debugZone object is available print the comment in it !
		if ((typeof debugZone) == 'object') {

			// Create a new dom element, and insert it at the top of the zone element
			var newEntry = document.createElement('p');
			newEntry.innerHTML = str;
			if (msgClass)newEntry.className = msgClass;
			debugZone.insertBefore(newEntry, debugZone.firstChild);
		}

		// If there's no loggingZone yet, save all the messages in an array to display later
		// I changed, it will always save them even when the log is displayed.
		// So if the panel is reoladed, will display the whole historic.
		if (typeof traceLog == 'undefined') traceLog = [];
		traceLog.push({str:str,msgClass:msgClass});
	}
	var debugZone;

	// Add, replace or remove a parameter in a given string.
	// Parameters :
	//    pName (string): the name of the parameter to add
	//    pValue (string, optional): the value for the param. If not provided and the param is present in the string, it will be removed.
	//    pString (string, optional): the string containing all the params, if not given, the current URL querystring will be used
	//    pSeparator (string, optional): the separator charachter, if not given, the "&" will be used
	function addParam(pName, pValue, pString, pSeparator) {

		// Default separator is '&', for urls
		pSeparator = pSeparator || '&';

		var allParams = getParam(null, pString, pSeparator);

		// Add or remove the param
		if (pValue) allParams[pName] = pValue;
		else delete allParams[pName];

		// Build the new string with the new param
		var newPString = '';

		for (var pKey in allParams) {

			// Separator if more than one item
			newPString += newPString ? pSeparator : '';
			newPString += pKey + '=' + allParams[pKey];
		}

		return newPString;
	}

	// Split a string, and return the value of the asked parameter.
	// When only pName is provided, will get a parameter from the URL
	// But can alse be useful to get a parameter's value from cookie, hash, or other random string...
	// Parameters :
	//    pName (string, optional): the parameter's name to get. If not provided, will return an object with all the parameters
	//    pString (string, optional): the string containing all the params, if not given, the current URL querystring will be used
	//    pSeparator (string, optional): the separator charachter, if not given, the "&" will be used
	function getParam(pName, pString, pSeparator) {

		// If there's no string to search in, use the current url, after removing the ' ? ' at the beggining.
		if (typeof pString != 'string') pString = window.location.search.substring(1,window.location.search.length);

		// Default separator is '&', for urls
		pSeparator = pSeparator || '&';

		// Initialize the object that will contain all the parameters
		var allParams = {};

		// Split the string with the separator to get separate tokens, and loop trough them
		// To add each parameter and its value to the allParams object
		pList = pString.split(pSeparator);

		for (var pKey in pList) {

			if (typeof pList[pKey] != 'string') continue;
			var cParam = pList[pKey].split('=');
			if (cParam[1]) allParams[cParam[0].replace(/\s/, '')] = cParam[1];

		}

		// If an argument has been specified and it is found, return it.
		// Otherwise, return the object containing all the params
		return pName ? (allParams[pName]) : (allParams);
	}



  /*************************/
 /***   getURLContent   ***/
/*************************/

	function getURLContent(loadURL, callback) {

	/*
	
*/
	var jstonserver_url = "http://www4.tsr.ch/vote/json-proxy.php";

		//	rSource: 'http://www4.tsr.ch/vote/json-proxy.php',
		// prompt('asdf',loadURL)

		// Create JSON request using tsrkit
		var newRequest = new wonderJSON({
			rSource: jstonserver_url,
			rSourceArguments: {
				'url': loadURL
			},
			addCallbackArgument: '&jsonp=',
			onAnswer: callback
		}).launch();
	}