/*
此函数为ajax区域 要求所有后台请求来自于这里
应该5秒内返回给用户一个提示信息。涉及到提示信息可以传递时间参数到此ajax，如果5秒未收到结果，则弹出重试的提示。
ajax 跨域有问题 没有到回调里面去
*/
/*
变量命名编写规范：
变量类型   变量名称
string       str
object       obj。
Array        arr
Element      el
bool         b
用户信息     userinfo
硬盘信息     diskinfo
好友信息     frindinfo
群信息       groupinfo
回调callback       cb
函数         fun
错误         err
参数数组aruguments   arg    
*/

//补充错误的定义。
//错误状态写在r.request.status里面。如果r.request.status==200,则表示成功。其余状态码表示有错误，如果是我们系统发生错误，统一状态码为500,即r.request.status==500，其他由web服务器自己决定。
//详细错误信息在r.value里面.




Namespace.register("U.A"); //A为Ajax简写

//所有请求的ajax对象.
U.A.allAjaxRequest =
    {
        requestNumber: 0, //总共请求次数
        requestObject: [], //请求的所有ajax对象
        forrequest: 0 //可能存在的循环请求的次数
    };


//服务器返回值结构图
/*_returnobj = { //返回的ajax对象
httpRequest: ajaxobject,  //xmlrequest对象
status: 200,  //服务器响应的状态 200成功，其他的都是失败
value: null, //服务器返回的值
context: cbparams //回调函数的参数
};*/


//开发后端程序时需要返回的结构体
var serverInfo = {
    affectRows: null,  //数据库影响行数,插入，修改，删除时，如果大于0，表示成功，否则，表示失败
    value: null, //数据库查询时的取值。如果错误，请查看其他变量的值
    error: null,  //数据库及服务器错误信息
    statusCode: null  //服务器状态码,服务器响应的状态 200成功，其他的都是失败
}

//uform前端ajax返回值结构体
var serverReturnObj = { //返回的ajax对象
    httpRequest: null,  //xmlrequest对象,前台标准
    status: 200,  //服务器响应的状态 200成功，其他的都是失败，，这是历史遗留，以后要删除
    serverInfo: serverInfo, //等于后端结构体
    value: null, //服务器返回的值,历史遗留，以后删除
    context: null //回调函数的参数，前台标准
};


//#region ajax

/**
* ajax初始化区域
*
* @param  {string} 访问的地址
* @param  {array} 数据库地址，数据库名，存储过程名，存储过程参数的数组
* @param  {function} 回调函数
* @param  {array} 函数传参
* @param  {object} 需要写入的header对象
* @returns {object} ajax对象 
*/
U.A.Request = function (url, params, cb, cbparams, header) {
    //判断是否为攻击
    if (U.A.Request.ifAttack()) {
        var _isdomain = U.A.Request.isDomain(url); //判断请求的ajax是否是跨域请求，这里是做跨域请求的方案
        //如果是在本域名下请求的处理，或者是跨域请求，没有做其他跨域方案。
        if (_isdomain == 1) {
            var _header = header || {}, //ajax对象header的设置处理
                _ajaxtype = _header.type || "POST", //设置ajax请求的类型 Get 或者是post
                _isasync = U.UF.C.isFunction(cb), //判断请求为异步函数同步
                _params = U.A.Request.toAjaxFormat(params); //把数组传参转化成ajax传参
            //创建一个全兼容的ajax对象
            var _ajaxobject = U.A.Request.createAjaxObject(url);
            //记录Ajax的创建时间,创建的请求地址,记录是否攻击及请求所花费的时间.
            U.A.Request.attack(url, params, cb, cbparams, header, _ajaxobject);

            //如果请求的类型是get，那么请求拼接链接
            if (_ajaxtype.toUpperCase() == "GET") {
                url += "?" + _params;
            }
            //打开请求，设置ajax请求方法 url 是否异步
            _ajaxobject.open(_ajaxtype, url, _isasync);

            //给ajax对象的header设置值
            U.A.Request.writeHeader(_ajaxobject, _header);

            //发送请求
            _ajaxobject.send(_params);

            //等待服务器返回的数据库的结果。
            //如果是异步，那么用异步的处理
            if (_isasync) {
                U.A.Request.asyn(_ajaxobject, cb, cbparams);
            }
            //如果是同步的处理
            else {
                return U.A.Request.getData(_ajaxobject, null);
            }
        }
        else {
            return U.A.Request.handleDomain(url, params, cb, cbparams, header, _isdomain);
        }
    }
}


/**
* 自定义传参ajax初始化区域
* 由于U.A.Request发送的请求默认传递为mode传参后的拼接参数，但有部分接口的参数名并不为mode，
* 因此定义此接口为自定义请求所服务。
* @param  {string} 访问的地址
* @param  {array} 数据库地址，数据库名，存储过程名，存储过程参数的数组
* @param  {function} 回调函数
* @param  {array} 函数传参
* @param  {object} 需要写入的header对象
* @returns {object} ajax对象 
*/
U.A.Request.Post = function (url, params, cb, cbparams, header) {
    //判断是否为攻击
    if (U.A.Request.ifAttack()) {
        var _isdomain = U.A.Request.isDomain(url); //判断请求的ajax是否是跨域请求，这里是做跨域请求的方案
        //如果是在本域名下请求的处理，或者是跨域请求，没有做其他跨域方案。
        if (_isdomain == 1) {
            var _header = header || {}, //ajax对象header的设置处理
                _ajaxtype = _header.type || "POST", //设置ajax请求的类型 Get 或者是post
                _isasync = U.UF.C.isFunction(cb), //判断请求为异步函数同步
                _params = U.A.Request.Post.toAjaxFormat(params); //把数组传参转化成ajax传参
            //创建一个全兼容的ajax对象
            var _ajaxobject = U.A.Request.createAjaxObject(url);
            //记录Ajax的创建时间,创建的请求地址,记录是否攻击及请求所花费的时间.
            U.A.Request.attack(url, params, cb, cbparams, header, _ajaxobject);
            //打开请求，设置ajax请求方法 url 是否异步
            _ajaxobject.open(_ajaxtype, url, _isasync);

            //给ajax对象的header设置值
            U.A.Request.writeHeader(_ajaxobject, _header);

            //发送请求
            _ajaxobject.send(_params);

            //等待服务器返回的数据库的结果。
            //如果是异步，那么用异步的处理
            if (_isasync) {
                U.A.Request.asyn(_ajaxobject, cb, cbparams);
            }
            //如果是同步的处理
            else {
                return U.A.Request.getData(_ajaxobject, null);
            }
        }
        else {
            return U.A.Request.handleDomain(url, params, cb, cbparams, header, _isdomain);
        }
    }
}


/**
* Post请求数据拼接
*
* @param  {array} 数组的传参
*/
U.A.Request.Post.toAjaxFormat = function (params) {
    var _key;
    var _params = '';
    for (_key in params) {
        _params += _key + '=' + encodeURIComponent(encodeURIComponent(params[_key])) + '&';
    }
    return _params.substr(0, _params.length - 1);
}

/**
* 记录Ajax的创建时间,创建的请求地址,记录是否攻击及请求所花费的时间.
*
* @param  {string} 访问的地址
* @param  {array} 数据库地址，数据库名，存储过程名，存储过程参数的数组
* @param  {function} 回调函数
* @param  {array} 函数传参
* @param  {object} 需要写入的header对象
* @returns {object} ajax对象 
*/
U.A.Request.attack = function (url, params, cb, cbparams, header, ajaxobject) {
    var _preajax = U.A.allAjaxRequest.requestObject[U.A.allAjaxRequest.requestObject.length - 1], //上一个请求
        _ajaxarray = {
            "win": window, //执行的域
            "ajax": ajaxobject, //ajax对象
            "url": url, //后台的地址
            "params": params, //后台的传参
            "cb": cb, //执行后的回调
            "cbparams": cbparams, //回调函数的传参
            "header": header, //ajax的header的处理
            "time": new Date().getTime() //ajax创建的时间
        };
    U.A.allAjaxRequest.requestNumber += 1; //这个是总的请求数
    U.A.allAjaxRequest.requestObject.push(_ajaxarray); //把ajax对象添加到全局
    //如果有上一个ajax请求的处理
    if (_preajax) {
        //如果第一次请求和第二次请求时间差为50毫秒的话，这里就默认是循环请求
        if (_ajaxarray.time - _preajax.time < 50) {
            U.A.allAjaxRequest.forrequest += 1;
        }
        else {
            U.A.allAjaxRequest.forrequest = 0;
        }
    }
    return _ajaxarray;
}

/**
* ajax把参数转成ajax的传参
* @param  {array} 数组的传参
*
*/
U.A.Request.toAjaxFormat = function (params) {
    params = params || [];
    var _userinfo,
        _params = "mode=" + U.UF.C.urlEncode(params.concat()); //参数加密处理拼接处理
    try {
        //由于1473后台对loginid 、 userid 、pageid 、systemid是直接通过url获取的，没有进行传参，那么下面就是进行1473 url的拼接
        if (parent && parent.US) { //如果有parent.US那么就是1473的项目
            _userinfo = parent.US.userInfo; //获取用户的信息
            //如果用户的信息存在那么拼接用户的信息
            if (_userinfo && _userinfo.UserId) {
                _params += "&UserId=" + _userinfo.UserId + "&LoginId=" + _userinfo.LoginId;
            }
            //设置1473项目传参的id
            _params += "&PageId=" + US.pageId + "&SystemId=" + US.systemId;
        }
    } catch (e) { }
    return _params;
}

/**
* 创建ajax请求对象 XMLHttpRequest或者 ActiveXObject对象
* @param  {string} ajaxurl的地址
*
*/
U.A.Request.createAjaxObject = function (url) {
    //ie8,ie9跨域兼容
    var _locationurl = window.location ? (window.location.protocol + "//" + window.location.host) : ""; //url的链接
    if (url.indexOf(_locationurl) == -1 && window.XDomainRequest) {//在ie8、9中允许用ajax跨域访问 但是不支持XMLHttpRequest跨域而是一个新的函数XDomainRequest，后面废除了。
        return new window.XDomainRequest();
    }
    //这里创建Ajax对象
    try { return new XMLHttpRequest(); } catch (e) { }
    //ie6以下的浏览器处理，包含一些可解析脚本插件处理,//ie6系列等直接脚本的浏览器支持的插件
    //Internet Explorer
    try { return new ActiveXObject('Msxml2.XMLHTTP.6.0'); } catch (e) { }
    try { return new ActiveXObject('Msxml2.XMLHTTP'); } catch (e) { }
    try { return new ActiveXObject('MSXML3.XMLHTTP'); } catch (e) { }
    try { return new ActiveXObject('MSXML.XMLHTTP'); } catch (e) { }
    try { return new ActiveXObject("Microsoft.XMLHTTP"); } catch (e) { }
    try { return new ActiveXObject('MSXML2.ServerXMLHTTP'); } catch (e) { }
    //alert("你的浏览器不支持xmlhttp对象,所以一些功能无法使用,建议使用高版本的浏览器!!");
}

/**
* 给ajax对象写入head
* @param  {object} ajax对象
* @param  {object} 需要写入的header
*/
U.A.Request.writeHeader = function (ajax, header) {
    header["CONTENT-TYPE"] = header["CONTENT-TYPE"] || "application/x-www-form-urlencoded;charset=UTF-8"; //请求写入数据的格式，必须传值，否则后台获取值会报错
    //header["Connection"] = "keep-alive";
    header["timeout"] = 10000;
    try {
        header["type"] = null;
        delete header["type"];
    }
    catch (e) { }
    //循环给ajax对象设置header
    for (var i in header) {
        try {
            //ajax属性里面有方法的设置
            if (i in ajax) {
                ajax[i] = header[i];
            }
            //不是ajax属性的设置header
            else {
                ajax.setRequestHeader(i, header[i]);
            }
        }
        catch (e) { }
    }
    // 指定服务器返回数据的MIME类型 firfox设置兼容，不设置frifox浏览器后台无法获取值
    if (ajax.overrideMimeType) {
        if (header["responseType"] == "blob") {
            ajax.overrideMimeType("text/plain; charset=x-user-defined");
        } else {
            ajax.overrideMimeType("text/html");
        }
    }
}

/**
* ajax异步处理函数
* @param  {object} ajax对象
* @param  {function} 回调函数
* @param  {array} 回调参数
*/
U.A.Request.asyn = function (ajaxobject, cb, params) {
    //判断是否需要loading处理，如果需要loading处理，那么在第一个元素中添加loading
    if (params && params[0] && U.UF.C.isElement(params[0])) {
        U.UF.DL.loading(params[0]);
    }

    //正常的ajax的回调处理
    if (ajaxobject.onreadystatechange !== undefined) {
        //设置ajax回调处理
        ajaxobject.onreadystatechange = function () {
            if (ajaxobject.readyState == 4) { //已经加载成功
                //判断是否有loading处理，如果有则移除
                if (params && params[0] && U.UF.C.isElement(params[0])) {
                    U.UF.DL.uploading(params[0]);
                }
                var _data = U.A.Request.getData(ajaxobject, params); //获取ajax的返回值
                cb.call(cb, _data); //回调处理
            }
        }
        //ajax超时处理
        ajaxobject.ontimeout = function () {
            return false;
        }
    }
    //ajax支持onload事件的处理，由于ie8、ie9跨域的XDomainRequest对象只支持onload
    else {
        ajaxobject.ontimeout = function () { }
        //错误处理，下面用onreadystatechange已经把这个功能包含进去
        ajaxobject.onerror = function () {
            ajaxobject.status = 500; //由于这个请求对象不会自动设置500错误，但是为了统一判断，这里设置默认的错误500
            cb.call(cb, { //返回的ajax对象
                httpRequest: ajaxobject,  //xmlrequest对象
                status: {  //服务器响应的状态 200成功，其他的都是失败
                    "status": ajaxobject.status,
                    "statusText": ajaxobject.statusText
                },
                value: null, //服务器返回的值
                context: params //回调函数的参数
            }); //回调处理
        };
        //设置ajax回调处理
        ajaxobject.onload = function () {
            //判断是否有loading处理，如果有则移除
            if (params && params[0] && U.UF.C.isElement(params[0])) {
                U.UF.DL.uploading(params[0]);
            }
            var _data = U.A.Request.getData(ajaxobject, params); //获取ajax的返回值
            cb.call(cb, _data); //回调处理
        }
    }
}

/**
* 获取ajax的值
* @param  {object} ajax对象
* @param  {function} 回调函数
*/
U.A.Request.getData = function (ajaxobject, cbparams) {
    var _data, //服务器返回的值
        _returnobj = { //返回的ajax对象
            httpRequest: ajaxobject,  //xmlrequest对象
            status: 200,  //服务器响应的状态 200成功，其他的都是失败
            value: null, //服务器返回的值
            context: cbparams //回调函数的参数
        };

    //返回值的正确处理
    if (ajaxobject.status == 200 || ajaxobject.status == null) {
        //服务器返回的是xml对象的处理
        if (ajaxobject.responseXML && ajaxobject.responseXML.xml) {
            _data = ajaxobject.responseXML.xml; //xml的值
        }
        //服务器返回的是string的处理
        else {
            _data = U.UF.C.toJson(ajaxobject.responseText); //获取转化成ajax的对象
        }
        _returnobj.value = _data; //设置服务器返回的值
    }
    //错误处理
    else {
        //ajax错误处理
        _returnobj.status = {
            "status": ajaxobject.status,
            "statusText": ajaxobject.statusText
        };
    }

    //关闭连接，释放资源
    if (ajaxobject.abort) {
        ajaxobject.abort();
    }

    //请求得到值的整个过程的时间差处理
    U.A.Request.timeSpan(ajaxobject, _returnobj);
    //返回得到的值
    return _returnobj;
}


/**
* 判断ajax是否跨域处理
* @param  {string} 请求的地址
*返回值：1相同域名不跨域*2为跨子域，3为完全跨域
*/
U.A.Request.isDomain = function (url) {
    var _frame,
        _a = $$("a", { "href": url }) //创建一个a标签能得到 url请求的地址的域
        ;
    //如果是直接浏览器打开文件的方式 如e:/a.html这样打开的则没有window.location
    if (window.location) {
        //相同域名也不跨子域的情况
        if (_a.host.indexOf(document.domain) >= -1) {
            return 1;
        }
        //相同域名也跨子域的情况
        else if (window.location.host.split(".").slice(-2).join(".") == _a.hostname.split(".").slice(-2).join(".")) {
            _frame = window.frames; //所有加载的域，对1473域下所有iframe进行循环，目的是找到可跨域的iframe。
            //循环所有可跨域的iframe进行处理
            for (i = 0; i < _frame.length; i++) {
                try {
                    if (_frame[i].location.host && _a.host.indexOf(_frame[i].location.host) == 0) { //找到指定的跨域
                        return 2; //跨域获取
                    }
                }
                catch (e) {
                }
            }
        }
    }
    //完全跨域的情况,这里的要求是必须创建iframe id和name为U_Domain的
    // if ($("#U_Domain")[0]) {
    //    return 3;
    //}
    return 1; //如果开发者跨域了，也没有用跨域解决方案，也默认给他调用ajax的方法，因为在高版本的浏览器中已经支持xmlrequest跨域了
}

/**
* ajax异步处理的方式
*
* @param  {string} 访问的地址
* @param  {array} 数据库地址，数据库名，存储过程名，存储过程参数的数组
* @param  {function} 回调函数
* @param  {array} 函数传参
* @param  {object} 需要写入的header对象
* @param  {object} 跨域的方式 2 相同域名也跨子域的情况 3 完全跨域的情况
*/
U.A.Request.handleDomain = function (url, params, cb, arg, header, isdomain) {
    var _newsinfo,
        _a = $$("a", { "href": url }), //创建一个a标签能得到 url请求的地址的域
        _frame;
    //相同域名也跨子域的情况
    if (isdomain == 2) {
        _frame = window.frames; //所有加载的域，对1473域下所有iframe进行循环，目的是找到可跨域的iframe。
        //循环所有可跨域的iframe进行处理
        for (i = 0; i < _frame.length; i++) {
            try {
                if (_a.hostname.indexOf(_frame[i].location.hostname) == 0) { //找到指定的跨域
                    return _frame[i].U.A.Request(url, params, cb ? function (data) { setTimeout(function () { cb.call(window, data) }); } : null, arg, header); //跨域获取
                }
            }
            catch (e) {
            }
        }
    }
    //完全跨域的情况,这里的要求是必须创建iframe id和name为U_Domain的
    else if (isdomain == 3) {
        //判断是否需要loading处理，如果需要loading处理，那么在第一个元素中添加loading
        if (params && U.UF.C.isElement(params[0])) {
            U.UF.DL.uploading(params[0]);
        }
        //跨域执行ajax处理 fun, issender, iframeid, url, id
        _newsinfo = new U.UF.EV.message(
            function (data, id, cookie) { //接受到跨域的ajax的回调处理 data[0]是执行ajax后台返回的值 data[1]是执行的cookie处理
                //后台设置了cookie 前台同时响应
                if (cookie == "") { //删除cookie的值
                    U.UF.Cookie.del(cookie);
                }
                //如果在和后台交互的过程设置了cookie，那么这里需要设置
                else {
                    U.UF.Cookie.set(cookie);
                }
                var _data = { //返回的ajax对象
                    httpRequest: null,  //xmlrequest对象
                    status: 200,  //服务器响应的状态 200成功，其他的都是失败
                    value: data, //服务器返回的值
                    context: arg //回调函数的参数
                };
                cb.call(cb, _data); //回调处理
            }, true, "domain", "U_Domain");
        //跨域传参
        _newsinfo.post([url, params], "domain");
    }
    return false; //如果开发者跨域了，也没有用跨域解决方案，也默认给他调用ajax的方法，因为在高版本的浏览器中已经支持xmlrequest跨域了
}

/**
* 判断用户是否连续发送ajax请求到后台，如果是我们视为攻击，返回false，否则是true
*/
U.A.Request.ifAttack = function () {
    var _isfor = U.A.allAjaxRequest.forrequest < 50; //获取是否循环进行ajax处理，如果超过50次我们认为是攻击ajax
    //如果为攻击ajax，那么就等待清楚攻击
    if (!_isfor) {
        setTimeout(function () { U.A.allAjaxRequest.forrequest = 0; })
    }
    return _isfor;
}

/**
* 请求时间差处理
* @param  {object} ajax对象
* @param  {object} 服务器返回值
*/
U.A.Request.timeSpan = function (ajaxobject, request) {
    var i,
        _timespan,
        _arr = U.A.allAjaxRequest.requestObject; //所有请求的ajax对象
    //循环数组的对象
    for (i = 0; i < _arr.length; i++) {
        try {
            //整个ajax的对象
            if (_arr[i].ajax == ajaxobject) {
                _timespan = new Date().getTime() - _arr[i].time; //请求时间差
                U.UF.C.console({ "timespan": _timespan, "request": request }); //控制台输出请求的时间差和值
            }
        } catch (e) { }
    }
}

//#endregion