// ---------------
// Event mechanism

// Self-descripting vars :D
var debugEvents = false;
var _callbacks = new Array ();

/*
 * The callback object. htmlElement is optional.
 */
function Callback (callbackFun, htmlElement, producerName, producerProps, callOnlyOnce, param) {
        this.htmlElement = htmlElement;
        this.callbackFun = callbackFun;
        this.producerName = producerName;
        this.producerProps = /*split!!*/ producerProps;
        this.callOnlyOnce = callOnlyOnce;
        this.param = param;
}

Callback.prototype.triggerCallback = function (firererName, firererProps) {

        this.callbackFun (firererName, firererProps, this.htmlElement, this.param);
}



/*
 * Register one HTML element as listener on a server-side bean, possibly with a set of 
 * properties to listen on.
 */
function registerCallback (callbackFun, htmlElement, producerName, producerProps, callOnlyOnce, param) {

        _callbacks [_callbacks.length] = new Callback (callbackFun, htmlElement, producerName, producerProps, callOnlyOnce, param);
}


function clearListenersOn (producerName, producerProps) {

        alert ("Calling 'clearListenersOn' is highly deprecated; use 'clearCallbacksOn' instead");
        return clearCallbacksOn (producerName, producerProps);
}

function clearCallbacksOn (producerName, producerProps) {

        var newCallbacks = new Array ();

        for (var i = 0; i < _callbacks.length; i ++) {

                var lis = _callbacks [i];
                if (lis.producerName != producerName) // FIXME: Still no
                                             // property
                                             // discrimination .... 
                        newCallbacks [newCallbacks.length] = lis;
        }
        _callbacks = newCallbacks;
}





/*
 * This will be called back by the snippet of javascript the server returns as a result for a 
 * /chained.do or /unique.do request, to dispatch the description of what happened server-side 
 * to the listening HTML elements
 */
function dispatchCallbackEvents (events) {
        // Remember what element's callback has already been triggered so we don't trigger it twice
        var triggered = new Array ();

        if (debugEvents) alert ('Dispatching events. Got a total of ' + _callbacks.length + 
                                ' callbacks. Events description is ' + events);
        for (var i = 0; i < events.length; i ++) {

                var callbackData = events [i].split(':');
                if (debugEvents) 
                        alert ('Dispatching for sside element ' + callbackData [0]);

                for (var l = 0; l < _callbacks.length; l ++) {

                        var callback = _callbacks [l];
                        if (debugEvents) 
                        	alert ('Callback ' + l + ' is on ' + callback.producerName + ' with HTML elt ' + callback.htmlElement + '; ' + ((callback.htmlElement && triggered [callback.htmlElement]) ? '-1- callback' : 'no callback') + ' has been triggered already.');

                        if (callback.producerName == callbackData [0]) {
                        
                                if (callback.htmlElement) {

                                        if (triggered [callback.htmlElement] != true) {
                                                callback.triggerCallback (callbackData [0], callbackData.slice (1));
                                                triggered [callback.htmlElement] = true;
                                        }
                                } else {
                                        callback.triggerCallback (callbackData [0], callbackData.slice (1));
				}
                        }
                }
        }
}








/* 
 * Events that are waiting to be sent
 */
var pendingEvents = new Array ();


/*
 * Actually send the pending events 
 */
function sendEvents () {

        var httpObj = getHTTPObject();
        if (! httpObj) {

                alert ("Cannot get XmlHTTPRequest");
                return false;
        }

        var builtReqStr = '';
        for (var i = 0; i < pendingEvents.length; i ++) {
                
                var ev = pendingEvents [i];

                for (var param = 0; param < ev.length; param += 2) {

                        builtReqStr += i + '.' + encodeURI(ev [param]) + '=' + encodeURI(ev [param + 1]) + '&';
                }
        }

        // Whatever happens, we _must_ clean the events, else
        // recursive use of the XMLHttpRequest will lead to wrong results
        pendingEvents = new Array();
		
        _root ().setTimeout (function () { 

                try {
						//alert('URL = ' + getActionUrl () + "?" + builtReqStr  + " " + new Date());
                        httpObj.open ("POST", getActionUrl () + "?" + builtReqStr, true);
                        httpObj.setRequestHeader("Content-Length",0); // Needed for resin
                        httpObj.onreadystatechange = function () {
								//alert('httpObj.readyState ' + httpObj.readyState);
                                if (httpObj.readyState == 4) {
                                		//alert('httpObj.status ' + httpObj.status);
                                        if (httpObj.status == 200) {

                                                var text = httpObj.responseText;
                                                eval (text);
                                        }
                                }
                        };        
                        //httpObj.send (null);
                        // FF 1.5 sets the Content-Length header
                        // automatically, except when sending null :D
                        httpObj.send ("");

                } catch (e) {

                        alert ("Couldn't send event to server: " + e);
                }
        }, 1);
}


/*
 * Add one event to the list
 */
function pushAsyncEvent (args) {

        // New pushAsyncEvent provided by services team. Proper
        // handling of radiobuttons/checkboxes in forms.
        var newArgs;
        
        if (args.tagName && args.tagName == "FORM") {

                newArgs = new Array();
                for (var j=0;j < args.elements.length;j++) {
                        //newArgs.push(args.elements[j].name,args.elements[j].value);
                        if (args.elements[j].tagName.toUpperCase() == "INPUT"){
                                if (args.elements[j].getAttribute('TYPE').toUpperCase() =='CHECKBOX'){

                                        if (args.elements[j].checked == true){

                                                newArgs[newArgs.length] = args.elements[j].name;
                                                newArgs[newArgs.length] = args.elements[j].value;
                                        }
                                }
                                else{
                                        if (args.elements[j].getAttribute('TYPE').toUpperCase() =='RADIO'){
                                                
                                                if (args.elements[j].checked == true){

                                                        newArgs[newArgs.length] = args.elements[j].name;
                                                        newArgs[newArgs.length] = args.elements[j].value;
                                                }
                                        } else {

                                                newArgs[newArgs.length] = args.elements[j].name;
                                                newArgs[newArgs.length] = args.elements[j].value;
                                        }
                                }
                        } else{ 
                                newArgs[newArgs.length] = args.elements[j].name;
                                newArgs[newArgs.length] = args.elements[j].value;
                        }
                }
        } else {
                
                newArgs = args;
        }
        
        if (newArgs.length > 0)
                pendingEvents [pendingEvents.length] = newArgs;
} 



/*
 * Add one event and send them all. This is the same as pushAsyncEvent(args);sendEvents();
 */ 
function pushflushAsyncEvent (args) {

        pushAsyncEvent (args);
        sendEvents ();
}

// End event mechanism
// -------------------