/*
*Function:Common use for ajax call
*Author: yuz
*Date:Nov. 1,2009
*/

var HTTP = (function(){

    var HTTP = {
    
        _HttpRequest : function(){
           if(window.ActiveXObject){
			 
                    var arrSignatures = ['MSXML2.XMLHTTP.5.0','MSXML2.XMLHTTP.4.0','MSXML2.XMLHTTP.3.0','MSXML2.XMLHTTP','Microsoft.XMLHTTP'];
                    for(var i=0;i<arrSignatures.length;i++){
                    try{
                         var oRequest = new ActiveXObject(arrSignatures[i]);
                             return oRequest;
                        }catch(oError){
                                alert("Your browser doesn't support HTTP requests.");
                                return null;
                            }
                    }
             }
             if(window.XMLHttpRequest){
                var oRequest = new XMLHttpRequest();
                return oRequest;
             }

        },
        
        _getResponse : function(request){  //private function
             switch(request.getResponseHeader("Content-Type")) {
                    case "text/xml":
                        // If it is an XML document, use the parsed Document object.
                    return request.responseXML;
                    
                    case "text/json":
                    case "text/javascript":
                    case "application/javascript":
                    case "application/x-javascript":
                        // If the response is JavaScript code, or a JSON-encoded value,
                        // call eval() on the text to "parse" it to a JavaScript value.
                        // Note: only do this if the JavaScript code is from a trusted server!
                    return eval(request.responseText);

                    default:
                        // Otherwise, treat the response as plain text and return as a string.
                    return request.responseText;
                }
        },
        _encodeFormData : function(data){ //private method
            var pairs = [];
            var regexp = /%20/g; // A regular expression to match an encoded space

            for(var name in data) {
                    var value = data[name].toString();
                    // Create a name/value pair, but encode name and value first
                    // The global function encodeURIComponent does almost what we want,
                    // but it encodes spaces as %20 instead of as "+". We have to
                    // fix that with String.replace()
                    var pair = encodeURIComponent(name).replace(regexp,"+") + '=' +
                    encodeURIComponent(value).replace(regexp,"+");
                    pairs.push(pair);
                }

            // Concatenate all the name/value pairs, separating them with &
            return pairs.join('&');
        },
            /**
            * Send an HTTP GET request for the specified URL. If a successful
            * response is received, it is converted to an object based on the
            * Content-Type header and passed to the specified callback function.
            * Additional arguments may be specified as properties of the options object.
            *
            * If an error response is received (e.g., a 404 Not Found error),
            * the status code and message are passed to the options.errorHandler
            * function. If no error handler is specified, the callback
            * function is called instead with a null argument.
            *
            * If the options.parameters object is specified, its properties are
            * taken as the names and values of request parameters. They are
            * converted to a URL-encoded string with HTTP.encodeFormData() and
            * are appended to the URL following a '?'.
            *
            * If an options.progressHandler function is specified, it is
            * called each time the readyState property is set to some value less
            * than 4. Each call to the progress-handler function is passed an
            * integer that specifies how many times it has been called.
            *
            * If an options.timeout value is specified, the XMLHttpRequest
            * is aborted if it has not completed before the specified number
            * of milliseconds have elapsed. If the timeout elapses and an
            * options.timeoutHandler is specified, that function is called with
            * the requested URL as its argument.
            **/
        get:function(url, callback, options) {
            var request = HTTP._HttpRequest();
            var n = 0;
            var timer;
            if (options.timeout){
                timer = setTimeout(function() {
                               request.abort();
                               if (options.timeoutHandler)
                                   options.timeoutHandler(url);
                           },
                           options.timeout);
            }

            request.onreadystatechange = function() {
            if (request.readyState == 4) {
                if (timer) 
                    clearTimeout(timer);
                if (request.status == 200) {
                    callback(HTTP._getResponse(request));
                }else {
                    if (options.errorHandler){
                        options.errorHandler(request.status,
                                         request.statusText);
                        }else callback(null);
                }
           }else if (options.progressHandler) {
                options.progressHandler(++n);
            }
        }

        var target = url;
        if (options.parameters)
                target += "?" + HTTP._encodeFormData(options.parameters)
                
            request.open("GET", target,true);
            request.send(null);
        },
        
        /*
         *
        */
        post : function(url,requestBody,callback,errorHandler){ // public function
	
            var request = HTTP._HttpRequest();
				
                request.onreadystatechange = function(){
                    if(request.readyState == 4){
                        if(request.status == 200){
                            callback(HTTP._getResponse(request));
                        } else {
                             if(errorHandler) 
                                errorHandler(request.status,request.statusText);
                            else callback(null);
                        }
                    }
            }
			
            request.open("POST", url,true);
            // This header tells the server how to interpret the body of the request.
            request.setRequestHeader("Content-Type","application/x-www-form-urlencoded");
            // Encode the properties of the values object and send them as the body of the request.
            request.send(HTTP._encodeFormData(requestBody));
        }
        
        
     };// HTPP object ended brace
    
    return HTTP;

})();