/*
	Remote data loader code
	By Sergey Chernyshev

	For more details see http://www.sergeychernyshev.com/javascript/remoteloader/
*/
var SERGEYCHE = SERGEYCHE || { tools: {} };

SERGEYCHE.tools.add_js = function(url, bDefer)
{	
	// create SCRIPT tag
	var scrptElement = document.createElement("script");

	// set its attributes
	scrptElement.setAttribute("type", "text/javascript");
	scrptElement.setAttribute("language", "JavaScript");
	scrptElement.setAttribute("src", url);
	if (bDefer)
	{
		scrptElement.setAttribute("defer", true);
	}

	// add this new element to the head tag
	document.getElementsByTagName("head")[0].appendChild(scrptElement);	
};

SERGEYCHE.remoteloader = {
/*
	a queue of loader objects
*/
	loaders: {},
	callbacks: {},
/*
	Detach the loader and return it.

	It'll return null if loader is no longer in the queue
	Detaching will effectively cancel subsequent callback and timeout 
*/
	detach: function(request_id)
	{
		/*
			It would've been ideal if there was an atomic pop for hashes
			
			For now we'll assume that nothing happens between
			getting loader from the queue and removing it from
		*/
		var loader = this.loaders[request_id];
		if (loader !== null)
		{
			/*
				removing from queue so next call to detach would return null
			*/
			delete this.loaders[request_id];
		}

		return loader;
	},

	cancel: function(request_id)
	{
		var loader = this.detach(request_id);
		if (!loader)
		{
			return;
		}
		if (typeof loader.onCancel === "function")
		{
			loader.onCancel(request_id);
		}
	},

/*
	@loader		Loader object - must have following members
	
	  url:		URL to call (we can call only URLs b'cause it's a remote server)

	  success:	function to be called from SERGEYCHE.remoteloader.callback

	  timeout:	will call failure function if timed out (optional)

	  failure:	failure callback function to call in case of timeout
			(we can't really know if there is a problem - just timeout)
			optional, must be specified if timeout is set

	@request_id	optional unique identifier of data request,
			will be used to identify a loading object.

*/
	load: function(loader, request_id)
	{
		if (typeof loader === 'undefined' ||
			typeof loader.url === 'undefined' ||
			typeof loader.onSuccess !== 'function')
		{
			throw ('Loader object must have at least url property and onSuccess event handler');
		}

		this.loaders[request_id] = loader;
		this.callbacks[request_id] = function(request_id)
		{
			return function(data) {
				var r = request_id;
				/*
					This one can be called after loader got detached
					That's why it's here and not in detach method
				*/
				delete SERGEYCHE.remoteloader.callbacks[r];

				/*
					Calling callback function to 
				*/
				return SERGEYCHE.remoteloader.callback(data, r);
			}
		}(request_id);

		/*
			Run timeout function even if we don't have a onFailure handler
			At least it'll remove a loader object from memory
		*/
		if (loader.timeout > 0)
		{
			setTimeout("SERGEYCHE.remoteloader.timeout('" + request_id + "')",
				loader.timeout);
		}


		loader.request_id = request_id;

		/*
			Uncomment this to emulate timeout
		
			alert('waiting');
		*/

		SERGEYCHE.tools.add_js(loader.url);
	},

/*
	@callback_data	data returned by the call

	@request_id	optional unique identifier of data request,
			will be used to identify a loader object.

*/
	callback: function(callback_data, request_id)
	{
		var loader = this.detach(request_id);
		if (!loader)
		{
			return;
		}

		if (typeof loader.onSuccess === "function")
		{
			loader.onSuccess(callback_data, request_id);
		}
	},

/*
	@request_id	unique identifier of data request,
			will be used to identify a loader object.
*/
	timeout: function(request_id)
	{
		var loader = this.detach(request_id);
		if (!loader)
		{
			return;
		}

		if (typeof loader.onFailure === "function")
		{
			loader.onFailure(request_id);
		}
	}
};