//-----------------------------------------------------------------
//	oXMLHTTP
//-----------------------------------------------------------------
//  Author:       Brent Michelsen
//	Description: 	This class is designed to instantiate the most recent
//                version of the MSXML.dll or use the XMLHttpRequest if IE7.
//
// Parameter 1:	url - string url of the xml file to load
//-----------------------------------------------------------------
function oXMLHTTP() {
    var me = this;
    this.doc = null;
    this.interval = 0;
    this.debug = false;
    this.desc = "";

    this.method = null;
    this.callBack = { onComplete: null, onTimeout: null, onError: null };

    this.arrParams = null;

    this.addParameter = function(p) {
        if (me.arrParams == null) {
            me.arrParams = new Array();
        }

        if (typeof (p) == 'string') {
            if (p.indexOf("\"") >= 0) {
                p = p.replaceAll("\"", "'");
            }
            if (p.indexOf("\n") >= 0) {
                p = p.replaceAll("\n", "");
            }
            if (p.indexOf("\r") >= 0) {
                p = p.replaceAll("\r", "");
            }

            me.arrParams[me.arrParams.length] = p;
        }
        else {
            me.arrParams[me.arrParams.length] = p;
        }
        if (me.debug) {
            if (log) {
                log.write("arrParams[" + (me.arrParams.length - 1) + "] = " + me.arrParams[me.arrParams.length - 1]);
            }
            else {
                alert("arrParams[" + (me.arrParams.length - 1) + "] = " + me.arrParams[me.arrParams.length - 1]);
            }
        }
        return;
    };

    this.run = function() {
        if (!me.method) { return; }
        try {
            var s = "me.method("

            if (me.arrParams) {
                for (c = 0; c < me.arrParams.length; c++) {
                    if ((typeof (me.arrParams[c]) == 'object') || (typeof (me.arrParams[c]) == 'string')) {
                        s += "me.arrParams[" + c + "],";
                        //      s += "\"' + me.arrParams[" + c + "] + '\",";
                    }
                    else {
                        s += "me.arrParams[" + c + "],";
                    }
                }
            }

            s += "me.onComplete, me.onTimeout, me.onError)";
            if (me.debug) {
                if (log) {
                    if (me.desc.length > 0) {
                        log.write(me.desc);
                    }
                    log.write(s);
                }
                else {
                    alert(s);
                }
            }

            eval(s);
        }
        catch (e) {
            if (me.debug) {
                if (log) {
                    log.write("Error:" + e.message);
                }
                else {
                    alert("Error:" + e.message);
                }
            }
        }
        return;
    };

    this.onComplete = function(data) {
        if (me.debug) {
            if (log) {
                log.write("onComplete");
                log.write("Response.length(" + data.toString().length + ")");
                //log.writeXMLNode(data);
                //log.writeXMLNode(data.toString());

            }
            else {
                alert("onComplete");
            }
        }


        me.loadXMLDoc(data.toString());

        try {
            var row = me.doc.documentElement.selectSingleNode("//row");
            var rv = true;
            if (row) {
                rv = row.getAttribute("rv");
                if (rv == "fail") {
                    if (me.debug) {
                        if (log) {
                            log.write(row.text);
                        }
                        else {
                            alert(row.text);
                        }
                    }
                }
            }
        }
        catch (e) {
            if (me.debug) {
                if (log) {
                    log.write("Error(" + e + ") creating xml doc in " + browser.strType() + " DESC(" + me.desc + ")");
                    log.write(me.doc);
                }
                else {
                    alert("Error creating xml doc in " + browser.strType());
                }
            }
            //return(null);
        }
        if (me.callBack.onComplete) {
            me.callBack.onComplete(me.doc);
        }

        if (!me.interval) { return; }
        setTimeout(me.run, me.interval);
        return;
    };

    this.onTimeout = function(data) {
        if (me.debug) {
            if (log) {
                log.write("onTimeout");
            }
            else {
                alert("onTimeout");
            }
        }
        if (me.callBack.onTimeout) {
            me.callBack.onTimeout();
        }

        if (!me.interval) { return; }
        setTimeout(me.run, me.interval);
        return;
    };

    this.onError = function(data) {
        if (me.debug) {
            if (log) {
                log.write("onError");
            }
            else {
                alert("onError");
            }
        }
        if (me.callBack.onError) {
            me.callBack.onError();
        }

        if (!me.interval) { return; }
        setTimeout(me.run, me.interval);
        return;
    };


    this.loadXMLDoc = function(strXML) {
        try {
            switch (browser.type) {
                case MSIE:
                    me.doc = new ActiveXObject("Microsoft.XMLDOM");
                    me.doc.loadXML(strXML);
                    break;

                case SAFARI:
                case FOX:
                case OPERA:
                case BLACKBERRY:
                case CHROME:
                case ANDROID:
                    if (document.implementation && document.implementation.createDocument) {
                        me.doc = document.implementation.createDocument("", "", null);
                        var oParser = new DOMParser();
                        me.doc = oParser.parseFromString(strXML, "text/xml");
                        break;
                    }
                    break;

                default:
                    if (log) {
                        log.write("Need to add xml dom support for " + browser.strType());
                    }
                    else {
                        alert("Need to add xml dom support for " + browser.strType());
                    }
                    return (null);
            }
        }
        catch (e) {
            if (log) {
                log.write(me.doc);
                log.write("Error creating xml doc in " + browser.strType());
            }
            else {
                alert(me.doc);
                alert("Error creating xml doc in " + browser.strType());
            }
            return (null);
        }
        return (me.doc);
    };
}

function initXMLSupport() {

    // mozXPath [http://km0ti0n.blunted.co.uk/mozxpath/] km0ti0n@gmail.com
    // Code licensed under Creative Commons Attribution-ShareAlike License
    // http://creativecommons.org/licenses/by-sa/2.5/


    if (document.implementation.hasFeature("XPath", "3.0")) {

        if (typeof XMLDocument == "undefined") { XMLDocument = Document; }

        XMLDocument.prototype.selectNodes = function(cXPathString, xNode) {

            if ((browser.type == ANDROID) || (browser.type == BLACKBERRY)) {
                if (!xNode) { xNode = this; }

                //log.write(cXPathString);

                cXPathString = cXPathString.toString().replace("//", "");
                cXPathString = cXPathString.toString().replace("$and$", "][");

                var p = new RegExp("/]|@|'/");
                var cXPathString = cXPathString.toString().replace(p, "");

                var arrNodesName = cXPathString.split("[");

                strNode = arrNodesName[0];
                //log.write("strNode(" + strNode + ")");
                var arrNodes = xNode.getElementsByTagName(strNode);

                if (arrNodesName.length > 1) {
                    var arrAttrib = arrNodesName[1].split("=");

                    for (var c = 0; c < arrNodes.length; c++) {
                        if (arrNodes[c].getAttribute(arrAttrib[0]) == arrAttrib[1])
                        { return (arrNodes[c]); }
                    }
                }

                return (arrNodes);

            } else {
                if (!xNode) { xNode = this; }
                var oNSResolver = this.createNSResolver(this.documentElement)

                if (cXPathString.count('@') > 1) {
                    cXPathString = cXPathString.replace("$and$", "][");
                    //         alert("were gona have a problem");
                }

                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;
            }

        }
        
        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.selectNodes = function(cXPathString) {
            if (this.ownerDocument.selectNodes) { return this.ownerDocument.selectNodes(cXPathString, this); }
            else { throw "For XML Elements Only"; }
        }
        Element.prototype.selectSingleNode = function(cXPathString) {
            if (this.ownerDocument.selectSingleNode) { return this.ownerDocument.selectSingleNode(cXPathString, this); }
            else { throw "For XML Elements Only"; }
        }

        XMLDocument.prototype.xml = function() {
            var xmlSerializer = new XMLSerializer();
            return (xmlSerializer.serializeToString(this));
        }

        Element.prototype.xml = function() {
            var xmlSerializer = new XMLSerializer();
            return (xmlSerializer.serializeToString(this));
        }

        Element.prototype.text = function() {
            return (this.childNodes[0].nodeValue);
        }

    }
}