var AjaxUtil = {
	receiveArray: function(responseText) {
		if ( typeof responseText != 'string' ){
			return responseText;
		}
    	eval('var ret = ' + responseText);
    	return ret;
	},
	trim: function(str) {
    	return str.replace(/^(\s+)?(\S*)(\s+)?$/, '$2');
	},
	ltrim: function(str) {
    	return str.replace(/^\s*/, '');
	},
	rtrim: function(str) {
    	return str.replace(/\s*$/, '');
	},
	xmldoc2string: function(xmlDocObject){
		// use the jsolait xmlrpc module to parse the response text xml.
		// The jsolait 2.0 libraries must be included seperately.
		// @see http://jsolait.net/
		var xmlMod=null;
		try{
			var xmlMod = imprt("xml");
		} catch(e){
			//alert(e);
			throw "importing of xml module failed.";
		}
		// try to parse the response (fault responses will throw an exception)
		try {	
			var xmlString = xmlMod.node2XML(xmlDocObject.documentElement);
		} catch(e) {
			throw e;
		}
		return xmlString;
	},
	
	xmlrpc_extractpayload: function(responseText){
		// use the jsolait xmlrpc module to parse the response text xml.
		// The jsolait 2.0 libraries must be included seperately.
		// @see http://jsolait.net/
		// try to import the xmlrpc module
		var xmlrpcMod=null;
		try{
			var xmlrpcMod = imprt("xmlrpc");
		}catch(e){
			//alert(e);
			throw "importing of xmlrpc module failed.";
		}
		// try to parse the response (fault responses will throw an exception)
		try {
			var xmlPayload = xmlrpcMod.unmarshall(responseText);
		} catch(e) {
			if ( e.constructor == xmlrpcMod.Fault ){
				//alert(e.faultCode + ' ' + e.faultString);
				throw e;
			} else {
				alert(e);
			}
		}
		return xmlPayload;
	},
	
	xmlrpc_formatrequest: function(methodName, methodParameters){
		// Use the XMLRPCMessage class to format the request XML.
		// The XMLRPCMessage libraries must be included seperately.
		// @see http://www.scottandrew.com/xml-rpc
		
		// TODO: we could use the jsolait xmlrpc module to do this and
		// eliminate the duplicate functionality of XMLRPCMessage.
		
		var message = new XMLRPCMessage(methodName);
		message.addParameter(methodParameters);
		return message.xml();
	},

	xmlrpc_receivepayload: function(responseText) {
		// try to parse the response (fault responses will throw an exception)
		try {
			// extract the payload
			xmlPayload = this.xmlrpc_extractpayload(responseText);
	
			//create a DOMParser
			//var xmlDOMParser = new DOMParser();
			//create new document from string
			//var xmlDoc = xmlDOMParser.parseFromString(xmlPayload, "text/xml");
			var xmlDoc;
			try {
				// Mozilla, create a new DOMParser
				var xmlDOMParser = new DOMParser();
				xmlDoc = xmlDOMParser.parseFromString(xmlPayload, "text/xml");
			} catch(e){
				// Internet Explorer, create a new XML document using ActiveX
				// and use loadXML as a DOM parser.
				try {
					xmlDoc = new ActiveXObject("Microsoft.XMLDOM");
					xmlDoc.async="false";
					xmlDoc.loadXML(xmlPayload);
				} catch(e){
					throw e;
				}
			}
		} catch(e) {
			/// TODO: deal with exceptions
			if ( typeof e == 'object' && e.faultCode ){
				throw e;
			} else {
				alert(e);
			}
		}
		return xmlDoc;
	},
	
	requestState: function(req) {
		switch (req.readyState) {
			case 1: case 2: case 3:
				return true;
				break;
		default:
			return false;
			break;
		}
	}, 
	
	showTimeoutMessage: function() {
		alert('The request has timed out. Please try again.');
	},
	
	defaultOnFailure: function() {
		alert('The request has failed.');
	},
	
	isFailure: function(req) {
		if(AjaxFailure.isNotXmlHttpRequest(req)) {
			return true;
		}
		if(AjaxFailure.isHeaderlessContent(req)) {
			this.showTimeoutMessage();
			return true;
		}
		if(AjaxFailure.isFailureString(req)) {
			return true;
		}
		return false;
	}
}

var AjaxFailure = {
	isHeaderlessContent: function(req) {
		return (req.getResponseHeader('X-Headerless-Content') == 'YES' ? true : false);
	},
	
	isFailureString: function(req) {
		return (req.responseText == 'ajax_fail' ? true : false);
	},
	
	isNotXmlHttpRequest: function(req) {
		return (req.responseText ? false : true);
	}
}