/**
* @contributor Matthew Foster
* @date 		February 4th 2007
* @purpose 	To allow for a short cut to document.createElement with an implementation of parameterism.
*/
$C = function(name, options) {
    return Element.extend(Object.extend(document.createElement(name || "div"), options || {}));
}
/**
* @contributor Matthew Foster
* @date 		February 4th 2007
* @purpose 	This class should be considered an "abstract" it is never intended to be a concrete class, notice there is no initialize function.
*				This class is intended to be extended from, allowing an overwritable yet base functions for processing ajax requests.  The proposed advantage to this structure
*				Is that during debugging all of your requests are being processed in the same area, thus allowing an easier target for reviewing ajax data.  As well as handling
*				more of what I believe to be the monotoneous routines involved in sending ajax requests.
*/
Ajax.Application = {}

Ajax.Application.Base = Class.create();
Ajax.Application.Cache = Class.create();

Object.extend(Ajax.Application.Base.prototype,
						{
						    method: "post",

						    sendRequest: function(dto, cb) {
						        var p = this.compileDTO(dto);


						        new Ajax.Request(this.url,
							{
							    'parameters': p,
							    'method': this.method,
							    'onSuccess': this.receiveRequest.bind(this, cb),
							    'onFailure': this.ajaxFailure.bind(this),
							    'onException': this.ajaxException.bind(this)
							}
						);
						    },

						    receiveRequest: function(cb, eAja) {

						        cb(eAja);

						    },
						    ajaxFailure: function() {
						        if (typeof console == "object")
						            console.log("Ajax Request failed args = %o ", arguments);
						        else
						            alert("Ajax request has failed. Application integrity has been compromised.");
						    },
						    ajaxException: function() {

						        if (typeof console == "object")
						            console.log("ajax exception occured args = %o", arguments);


						    },
						    compileDTO: function(dto) {

						        if (typeof dto == "object")
						            return $H(dto).toQueryString();
						        else if (typeof dto == "string")
						            return dto;
						        else
						            throw { message: "object sent to sendRequest was invalid type.  Type = " + typeof dto };


						    }


						}
			);

/**
* @author Matthew Foster
* @date   April 24th 2007
* @purpose	This class is an extension of the base class with added functionality to allow for transparent caching.  The idea is to save the query string as a key in a hash object
* 			and if that query string has already been sent for it will already have an ajax response and it will simply pass that immediately to the call back function
*/
Object.extend(Object.extend(Ajax.Application.Cache.prototype, Ajax.Application.Base.prototype),
					{
					    getCache: function() {

					        if (!this.requestCache)
					            this.requestCache = {};

					        return this.requestCache;

					    },
					    setCache: function(obj) {

					        Object.extend(this.requestCache, obj || {});

					    },
					    sendRequest: function(dto, cb) {

					        var cache = this.getCache();

					        var key = this.compileDTO(dto);

					        if (!cache[key]) {
					            var cachedCallBack = this.registerCache.bind(this, cb, key);
					            Ajax.Application.Base.prototype.sendRequest.apply(this, [key, cachedCallBack]);
					        }
					        else
					            cb(cache[key]);
					    },
					    registerCache: function(cb, key, eAja) {
					        var cache = {};

					        cache[key] = eAja;

					        this.setCache(cache);

					        cb(eAja);

					    }
					}
			);