// ajax.js

function addStateChangeListener(objectId, changeListener) {
	getClientUIView().getChild(objectId).addStateChangeListener(changeListener);
}

function getHttpRequestObject()	{
	var obj = null;
	if (window.XMLHttpRequest) { 
		//firefox, mozilla, and safari
		obj = new XMLHttpRequest();
	} else {
		/* 
		compatibility errors can occurr with the transformation code if 
		any version greater than 3.0 is used.  It should not be necessary to 
		use anything greater than 3.0 since XMLHttpRequest will be a native
		object in IE 7.0 
		*/
	    var clsids = [
			"Msxml2.XMLHTTP.3.0",
			"Msxml2.XMLHTTP",
			"Microsoft.XMLHTTP"];
		for(var i=0; i < clsids.length && obj == null; i++) {
		    try {
			    obj = new ActiveXObject(clsids[i]);
		    } catch(e) {}
		}
	}
	return obj;
}

//************************************************
// HttpRequestX
//
//************************************************
function HttpRequestX(ctrlId) {
	this.id = ctrlId;
	this.resource = "";

	//variable needed for onreadystatechange function below
	var stateChangeListeners = new Array();
	this.stateChangeListeners = stateChangeListeners;

	//variable needed for onreadystatechange function below
	var requestObject = getHttpRequestObject();
	this.requestObject = requestObject;
	
	//variable needed for onreadystatechange function below
	var me = this;
	
	requestObject.onreadystatechange = function()	{
		var readyState = requestObject.readyState;
		var i
		if (readyState == 1) {
			for (i = 0; i < stateChangeListeners.length; i++) {
				stateChangeListeners[i].requestOpened(me);
			}
		} else if (readyState == 2) {
			for (i = 0; i < stateChangeListeners.length; i++) {
				stateChangeListeners[i].requestSent(me);
			}
		} else if (readyState == 3) {
			for (i = 0; i < stateChangeListeners.length; i++) {
				stateChangeListeners[i].dataReceived(me);
			}
		} else if (readyState == 4) {
			if (requestObject.status == 200) {
				for (i = 0; i < stateChangeListeners.length; i++) {
					stateChangeListeners[i].loadComplete(me);
				}
			} else {
				for (i = 0; i < stateChangeListeners.length; i++) {
					stateChangeListeners[i].loadError(me);
				}
			}
		}
	}		

	if (this.requestObject == null ) {
		alert("Unable to create XML Request Object");	
	}
}

HttpRequestX.prototype.addStateChangeListener = function(changeListener) {
	this.stateChangeListeners.push(changeListener);
}

HttpRequestX.prototype.setOnReadyStateChangedCallback = function(f) {
	//KEEP for backward compatibility of IND-JSF jars
	//this method is no longer used
}

HttpRequestX.prototype.getReadyState = function() {
	return this.requestObject.readyState;
}

HttpRequestX.prototype.getStatus = function() {
	return this.requestObject.status;
}

HttpRequestX.prototype.open = function(method, resource, body) {
	this.resource = resource;
	this.requestObject.open(method, resource, true);
	if (body) {
		this.requestObject.send(body);
	} else {
		this.requestObject.send(null);
	}
}
HttpRequestX.prototype.getTransformer = function() {
	var t = new Transformer(this.getDocument());
	return t;
}
HttpRequestX.prototype.getDocument = function() {
	return this.requestObject.responseXML;
}

HttpRequestX.prototype.getText = function() {
	return this.requestObject.responseText;
}
//End HttpRequestX

//************************************************
// Transformer
//
//************************************************
function Transformer(doc) {
	this.xslDoc = doc;
	this.transformToString = function(xmlDoc) {
		var result;
		if (isIE) {
			result = xmlDoc.transformNode(this.xslDoc);
		} else {
			var processor = new XSLTProcessor();
			processor.importStylesheet(this.xslDoc);
			var objXMLSerializer = new XMLSerializer;
			var domResult = processor.transformToDocument(xmlDoc);
			result = objXMLSerializer.serializeToString(domResult);
		}
		return result;
	}
	this.transformToDoc = function(xmlDoc) {
		var result;
		if (isIE) {
			var sResult = xmlDoc.transformNode(this.xslDoc);
			 try {
	    	    result = new ActiveXObject("Msxml2.DomDocument");
		    }
    		catch(e) {
    			result = new ActiveXObject("Microsoft.DomDocument");
    		}
			
			result.loadXML(sResult);
		} else {
			var processor = new XSLTProcessor();
			processor.importStylesheet(this.xslDoc);
			var objXMLSerializer = new XMLSerializer;
			result = processor.transformToDocument(xmlDoc);
		}
		return result;
	}
	
}
//End Transformer

//************************************************
// ReadyStateChangeListener abstract class/interface
//
//************************************************
function ReadyStateChangeListener() {
}

ReadyStateChangeListener.prototype.requestOpened = function(src) {
}

ReadyStateChangeListener.prototype.requestSent = function(src) {
}

ReadyStateChangeListener.prototype.dataReceived = function(src) {
}

ReadyStateChangeListener.prototype.loadComplete = function(src) {
}

ReadyStateChangeListener.prototype.loadError = function(src) {
}
//End ReadyStateChangeListener

//Start AlertReadyStateChangeListener extends ReadyStateChangeListener
AlertReadyStateChangeListener.prototype = new ReadyStateChangeListener();

function AlertReadyStateChangeListener() {
}

AlertReadyStateChangeListener.prototype.requestOpened = function(src) {
	println("request opened: " + src.resource);
}

AlertReadyStateChangeListener.prototype.requestSent = function(src) {
	println("requestSent: " + src.resource);
}

AlertReadyStateChangeListener.prototype.dataReceived = function(src) {
	println("dataReceived: " + src.resource);
}

AlertReadyStateChangeListener.prototype.loadComplete = function(src) {
	alert("loadComplete:"+src.resource);
	println("loadComplete: " + src.resource);
}

AlertReadyStateChangeListener.prototype.loadError = function(src) {
	println("request error: " + src.resource);
}

//End AlertReadyStateChangeListener

//************************************************
// SimpleAjaxListener
//
//	Used to do a simple request from JSP page
//************************************************
SimpleAjaxListener.prototype = new ReadyStateChangeListener();
function SimpleAjaxListener(wrapperId) {
	this.wrapperId = wrapperId;
}
SimpleAjaxListener.prototype.loadComplete = function(src) {
	text = src.getText();
	if ((text.length > 4) && (text.substring(0,4).toLowerCase() == "http"))	{
		window.location = text;
	} else	{
		document.getElementById(this.wrapperId).innerHTML = text;
	}
}
SimpleAjaxListener.prototype.loadError = function(src) {
	document.getElementById(this.wrapperId).innerHTML = "Request Failed.";
}

//***********************************************************
// ExtendedAjaxListener
//
//	Used to do a request from JSP page just like 
//  SimpleAjaxListener except it checks for a valid response.
//***********************************************************
ExtendedAjaxListener.prototype = new ReadyStateChangeListener();
function ExtendedAjaxListener(wrapperId) {
	this.wrapperId = wrapperId;
}
ExtendedAjaxListener.prototype.loadComplete = function(src) {
	text = src.getText();
	if (!validResponse(text)) {
		text = "";
	}
	if ((text.length > 4) && (text.substring(0,4).toLowerCase() == "http"))	{
		window.location = text;
	} else	{
		document.getElementById(this.wrapperId).innerHTML = text;
	}
}
ExtendedAjaxListener.prototype.loadError = function(src) {
	document.getElementById(this.wrapperId).innerHTML = "Request Failed.";
}

//**************************************************
// validResponse(responseText)
// 
// Checks the response text against a black list. 
// If the response contains any any of the black 
// listed strings it is not valid.
//**************************************************
function validResponse(responseText) {
	var isValid = true;
	var lcText = responseText.toLowerCase();
	if ((lcText.indexOf("<head") >= 0) || 
		(lcText.indexOf("<title") >= 0) ||
		(lcText.indexOf("<body") >= 0))
	{
		isValid = false;
	}
	return isValid;
}

//************************************************
// doAjaxRequest
//
//	Used to do a simple request from JSP page
//************************************************
function doAjaxRequest(url, wrapperId)	{
	if (document.getElementById(wrapperId) != null) {
		var simpleRequest = new HttpRequestX("myRequest");
		var simpleListener = new SimpleAjaxListener(wrapperId);
		simpleRequest.addStateChangeListener(simpleListener);
		simpleRequest.open("GET",url);
	}
}

//************************************************
// doExtendedAjaxRequest
//
//	Used to do a simple request from JSP page
//************************************************
function doExtendedAjaxRequest(url, wrapperId)	{
	if (document.getElementById(wrapperId) != null) {
		var extendedRequest = new HttpRequestX("myRequest");
		var extendedListener = new ExtendedAjaxListener(wrapperId);
		extendedRequest.addStateChangeListener(extendedListener);
		extendedRequest.open("GET",url);
	}
}


//************************************************
// DropDownAjaxListener
//
//	Used in dependent dropdown solution from JSP page
//************************************************
DropDownAjaxListener.prototype = new ReadyStateChangeListener();
function DropDownAjaxListener(ctrl) {
	this.ctrl = ctrl;
}
DropDownAjaxListener.prototype.loadComplete = function(src) {
    var idNext = parseInt(this.ctrl.substring(this.ctrl.length - 1)) + 1;
    var ctrlNext = this.ctrl.substring(0, this.ctrl.length - 1) + idNext;
    var list = document.getElementById(ctrlNext);
    var currentValue = list.value;
	list.options.length = 0;

	// Building a DOM parser from Response Object
    var response = src.getDocument();
	
	// Checking for the Root Node Tag
	var x = response.getElementsByTagName("option");
 	for(var i = 0;i < x.length; i++)	{
		var opt = document.createElement("OPTION");
		opt.value = x[i].getAttribute('value');
		opt.text = x[i].getAttribute('text');
        if (opt.value == currentValue)          
        	opt.selected = true;
        	
		// Adding the Set Element to the Drop-Down
		list.options.add(opt);
	}
	
	//call onchange method
	var child = getClientUIView().getChild(ctrlNext);
	var evt = new ClientEvent(child.getHTMLControl(), child);
	child.processChangeListeners(evt);
}
DropDownAjaxListener.prototype.loadError = function(src) {
	alert("Request Failed.");
}

//************************************************
// AjaxUpdateDropdown
//
//	Used to update dependent dropdowns in JSP page
//************************************************
function AjaxUpdateDropdown(servlet, list)	{
	this.servlet = servlet;
	this.list = list;
	this.skip = true;
	this.processValueChanged = function(evt) {
		if (this.skip)	{
			//this skips for onLoad;
			this.skip = false;
			return;
		}
		
		var ctrl = evt.uiControl.getHTMLControl().id;
		var ctrlRoot = ctrl.substring(0, ctrl.length-1);
		var ctrlSeq = ctrl.substring(ctrl.length - 1);

		var values = "";
		var value;
		for (i=1; i<10; i++)	{
			if (i <= ctrlSeq)	{
				value = document.getElementById(ctrlRoot + i).value;
				if (i == 1)
					values = value;
				else
					values = values + "," + value;
			}
		}
		
		var myRequest = new HttpRequestX("myRequest");
		var myListener = new DropDownAjaxListener(ctrl);
		myRequest.addStateChangeListener(myListener);
		myRequest.open("GET",this.servlet + "?list=" + this.list + "&values=" + values,false);
	}
}

//************************************************
// AjaxUpdateDropdownCopyValue
//
//	Used to copy value to secondary control in order
//		to update another list.  This is for scenarios
//		where a dropdown needs to change values for
//		more than one list.
//************************************************
function AjaxUpdateDropdownCopyValue(id)	{
	this.id = id;
	this.skip = true;
	this.processValueChanged = function(evt) {
		if (this.skip)	{
			//this skips for onLoad;
			this.skip = false;
			return;
		}
				
		var ctrl = getClientUIView().getChild(this.id);
		ctrl.setValue(evt.uiControl.getValue());
		var evt = new ClientEvent(ctrl.getHTMLControl(), ctrl);
		ctrl.processChangeListeners(evt);
		
	}
}