var __methodsDefined = false;
var __isIE=true;
if(navigator.appName=="Netscape") __isIE=false;

function CreateXMLDoc()
{
    var ret ; 
    
    if(__isIE) { ret = new ActiveXObject("MSXML2.DOMDocument"); }
    else { ret = document.implementation.createDocument("", "", null);  if(!__methodsDefined) CreateBasicMethods(); }
    
    return ret;
}

function CreateBasicMethods() // Some very basic stuff that require a scientist to make work in Mozilla 
{

    if( document.implementation.hasFeature("XPath", "3.0") ) {  
    
        XMLDocument.prototype.selectNodes = function(cXPathString, xNode)  {     
            if( !xNode ) { xNode = this; }      
        
            var oNSResolver = this.createNSResolver(this.documentElement);
            var aItems = this.evaluate(cXPathString, xNode, oNSResolver, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
        
            var aResult = [];     
            for( var i = 0; i < aItems.snapshotLength; i++)     {        
                aResult[i] =  aItems.snapshotItem(i);     
            }     
            return aResult;  
        }  
        
        Element.prototype.selectNodes = function(cXPathString)  { 
            if(this.ownerDocument.selectNodes) { 
                return this.ownerDocument.selectNodes(cXPathString, this);     
            }     
            else { throw "For XML Elements Only"; }  
        }
    }
        
    if( document.implementation.hasFeature("XPath", "3.0") ) {  
        XMLDocument.prototype.selectSingleNode = function(cXPathString, xNode)  {  
            if( !xNode ) { xNode = this; }      
            
            var xItems = this.selectNodes(cXPathString, xNode);  
            
            if( xItems.length > 0 ) { 
                return xItems[0];     
            } else { return null; }  
        }    
        
        Element.prototype.selectSingleNode = function(cXPathString)  {         
            if(this.ownerDocument.selectSingleNode) { 
                return this.ownerDocument.selectSingleNode(cXPathString, this);     
            } else { throw "For XML Elements Only"; }  
        }
    } 
    
    Document.prototype.loadXML = function(strXML) {
        
       var doc2 = (new DOMParser()).parseFromString(strXML, "text/xml");

       while (this.hasChildNodes())
          this.removeChild(this.lastChild);

       for (var i = 0; i < doc2.childNodes.length; i++) {
          this.appendChild(this.importNode(doc2.childNodes[i], true));
       }

     
    } 
    
    Node.prototype.__defineGetter__("xml", _Node_getXML);
    Node.prototype.__defineGetter__("text", _Node_getTEXT);
    
    function _Node_getXML() {
    
        var objXMLSerializer = new XMLSerializer();
        var strXML="";
        
        try { strXML = objXMLSerializer.serializeToString(this); } catch(e) {}
        
        return strXML;
    }
    
    function _Node_getTEXT() {
    
        var i, strXML="";
        
        try {
            for(i=0;i<this.documentElement.childNodes.length;i++) { // replace documentElement with firstChild!?
                strXML += (this.documentElement.childNodes[i].nodeValue);
            }
        } catch(e1) { 
            try {
                strXML = (this.firstChild.data);  
            } catch(e2) { strXML = ""; } //e2.message; }
        }
        
        return strXML;
    }
    
    //__methodsDefined = true;

}



function Communicator()
{
    this.initComm = InitComm;
    this.sendCommand = SendCommand;
    this.getPendingId = GetPendingId;
    this.getCurrentId = GetCurrentId;
    
    var GlobalIndex = 0;
    var Commander = new Array();
    
    function GetPendingId()
    {
        return (Commander.length+0);
    }
    
    function GetCurrentId()
    {
        return (Commander.length-0);
    }
    
    function InitComm() 
    {
        var instanceId = Commander.length;
         
        Commander[instanceId] = new Object();
        Commander[instanceId].Comm = (window.XMLHttpRequest ? new window.XMLHttpRequest() : new ActiveXObject("Microsoft.XMLHTTP"));
        
        return instanceId;
    }
    
    function SendCommand(content, callback, taskName, hashCode)
    {
        var instanceId = InitComm();
        var contentExt = "<RQPACKET><CALLID>"+instanceId+"</CALLID>"+content+"</RQPACKET>";
        var XmlDoc;
        
        //alert(instanceId);
        
        XmlDoc = CreateXMLDoc(); 
        
        XmlDoc.loadXML(contentExt);
        
        //alert(contentExt);
        
        //ResetSessionTimeout();
        Commander[instanceId].taskId = Proc.addTask(taskName);
        Commander[instanceId].instanceId = instanceId; 
        Commander[instanceId].callback = callback;
        Commander[instanceId].Comm.onreadystatechange=CommonCallback;
        Commander[instanceId].Comm.open("POST","/code/serverside/listener.aspx",true);
        Commander[instanceId].finished = false;
        Commander[instanceId].hashCode = hashCode;
        Commander[instanceId].Comm.send(XmlDoc);
    }
    
    function CommonCallback(postbackdata)
    {
        var i, instanceId;
        var XmlDoc; 
        
        XmlDoc = CreateXMLDoc(); 
        
        for(i=0;i<Commander.length;i++) {
            if(!Commander[i].finished) {
                if(Commander[i].Comm.readyState==4) {
                    if(Commander[i].Comm.status==200) {
                        XmlDoc.loadXML(Commander[i].Comm.responseText);
                        //debugger;
                        Commander[i].finished = true;
                        //Commander[i].Comm = null;
                        Proc.removeTask(Commander[i].taskId);
                        //alert(XmlDoc.selectSingleNode("REPACKET/CALLID").text+XmlDoc.selectSingleNode("REPACKET").xml);
                        Commander[i].callback(GetResponse(XmlDoc), Commander[i].hashCode);
                    } else {
                        alert("Error: "+Commander[i].Comm.statusText+" ("+Commander[i].Comm.status+")");
                    }
                }
            }
        }
    }
    
    function GetResponse(AsyncResponse)
    {
        var response, type;
        
        response = CreateXMLDoc(); 
        
        response.loadXML(AsyncResponse.selectSingleNode("REPACKET/RET").xml); 
        type = response.selectSingleNode("RET").attributes.getNamedItem("type").value;
       
        
        switch(type) {
            case "text":
                return response.text;
                break;
            case "xml":
                return response;
                break;
            default:
                //alert("Unknown response type - returning as text");
                return response.text;
                break;
        }
        
        return null;
    }
    
    
} // end Communicator class