//json综述。此类主要处理以下两种情况的数据。
//1、后台返回的数据形如：{"id":"1","name":"zhangsan"}  称为json数据，在js中称为对象。
//  元素Elements，包括div，a，input等在前端的表现形式是：{"tagname":"input","className":""}
//                                                        {"tagname":"div","className":""}
//2、[
//     {"id":"1","name":"zhangsan"}
//     {"id":"2","name":"lisi"}
//
//综上所述，前端元素，数据基本都是{}.所以本数据处理类是针对前端所有对象。

//#region 这里是json操作区域

//#region Json 操作兼容

//JSON类操作,如果不存在json类，则自己创建一个window.JSON。只有一个地方使用了此函数的parse方法
window.JSON = window.JSON || (function () {
    var JSON = function () { };
    U.Ut.AddObj(JSON, {
        stringify: function (UDE) {//转化成字符串
            return U.MS.jsonToStr(UDE);
        },
        parse: function (UDE) {//转化成实体
            return UDE.parseJSON();
        }
    });
    return JSON;
})();


//#endregion

//初始化json操作区域
//
U.Json = function () {
    var _um = U.M; //引用
    //初始化方法,类似Java中的构造函数，自动执行
    var _UME, _UFE = function (UDE, UPE) {
        //new的方式进入
        if (this.init == _UME.init) {
            this.init(UDE, UPE);
        }
        //直接以函数的方式进入
        else {
            return new _UME.init(UDE, UPE);
        }
    },
    cb = function (UTP) { //通过类型获取回调函数形式
        return function (UDE) {
            if (UTP == null) { return UDE; } //直接返回使用
            else if (U.Ut.isFunction(UTP)) { return UTP.apply(null, arguments); } //函数使用
            else if (U.Ut.isObject(UTP)) { return _UME.IfExists(UTP, UDE); } //判断对象的使用
            return UDE[UTP];  //字符串或者数字
        }
    },
    //
    maxAndmin = function (UDE, UCE, UII, UTP) {//最大最小统一使用区域
        if (UDE) {
            var _USE = -Infinity, _UNE = -Infinity, _UCB = cb(UCE);
            UDE.forEach(function (UVE, UI) {
                var _UKE = _UCB.call(UII, UVE, UI, UDE), _UTF = (UTP == "max" && _UKE > _UNE) || (UTP == "min" && _UKE < _UNE);
                if (_UTF || (_USE === _UNE && _UNE === -Infinity)) { _UNE = _UKE; _USE = UVE; } //设置值
            });
            return _USE;
        }
        else { throw new Error("数组异常"); }
    };




    //使用方法集
    _UFE.prototype = _UME = {
        init: function (UDE, UPE) { //初始化对象
            this.Value = UDE;
            this.Parent = UPE || window;
        },
        Clone: function (UDE) { //克隆对象 深克隆
            var i, _UCE; UDE = UDE || this.Value;
            if (U.Ut.isObject(UDE)) {
                _UCE = new UDE.constructor(); //通过源生成对象
                if (U.Ut.isArray(_UCE)) { for (i = 0; i < UDE.length; i++) { _UCE.push(arguments.callee(UDE[i])); } } //数组处理
                else { for (i in UDE) { if (UDE.hasOwnProperty(i)) { _UCE[i] = arguments.callee(UDE[i]); } } } //对象处理
                return _UCE;
            }
            return UDE;
        },
        Add: function (UCE) { //对象添加值
            var i;
            var _UDE = this.Value;
            //判断是对象或者数组，如为数组，采用集合添加模式
            if (!U.Ut.isArray(_UDE)) {
                for (i in UCE) {
                    if (UCE.hasOwnProperty(i)) {
                        _UDE[i] = UCE[i];
                    }
                }
            }
            //集合添加模式,但好像没有进入这一个分支,在上传时进入此分支。
            else {
                for (i = 0; i < _UDE.length; i++) {
                    U.Ut.AddObj(_UDE[i], UCE); //本身添加，太消耗了
                }
            } //数组方式为每一个都添加

            return this.Value;
        },

        FindOne: function (UCE, UKE) {//搜索一个(跨层次)
            return (this.Select(UCE, UKE, 1))[0];
        },
        invoke: function (UN, UDE) { //自动调用
            var _UT = this; (UDE) && (_UT = _$(UDE));
            if (_UT[UN]) { return _UT[UN](); } //直接运行
        },
        sort: function (UCE, UVE, UDE) { //排序
            UDE = UDE || this.Value; var _UKE, _UTF = U.M.GetType(UDE); (U.Ut.isString(UCE)) && (_UKE = {}, _UKE[UCE] = 1, UCE = _UKE);
            if (_UTF === "array") { //数组排序
                (UDE.sort(function (UO, UT) {
                    var i, _UIE, _UTF;
                    if (U.Ut.isFunction(_UTF)) { _UTF = UCE(UO, UT); } //函数回调查看
                    else if (U.Ut.isObject(UCE)) { //对象处理
                        for (i in UCE) { if (UCE.hasOwnProperty(i)) { _UTF = typeof (UO[i] || UT[i] || ""); _UTF = _um["ci" + _UTF.capitalizeFirstLetter()](UO[i], UT[i]); _UIE = UCE[i]; break; } } //排序
                    }
                    else { _UTF = UO > UT; } _UIE = _UIE || (UVE == -1 ? -1 : 1); return _UIE * ((_UTF == 1 || _UTF == true) ? 1 : -1);
                }));
                return UDE;
            }
            else { throw new Error(UDE + " is not an Array"); }
        },
        groupBy: function (UCE, UDE) {//分组查询
            var _USE = {}, _UCB = cb(UCE); UDE = UDE || this.Value;
            UDE.forEach(function (UVE, UI) { var _UKE = _UCB(UVE); (_USE[_UKE] == null) && (_USE[_UKE] = []); _USE[_UKE].push(UVE); });
            return _USE;
        },
        pluck: function (UCE, UDE) { //获取制定键的值
            var _USE = []; UDE = UDE || this.Value;
            if (!UDE.length) { _USE.push(UDE[UCE]); } else {
                UDE.forEach(function (UVE, UI) {
                    var _UCB = cb(UCE);
                    _USE.push(_UCB(UVE, UI, UDE));
                });
            }
            return _USE;
        },
        Where: function (UCE, UT, UDE, USE) { //条件选择 $gt(>) $lte(<=) $gt(>) $gte(>=) $ne(!=) $in(=) $nin(!=)
            UDE = UDE || this.Value; var i, j, k, z, _UGE, _UKE, _UFE, _UTE, _UTF = U.M.GetType(UDE); USE = USE || [];
            if (_UTF === "object") { //普通对象处理
                _UTF = []; for (i in UCE) {
                    if (UCE.hasOwnProperty(i)) {
                        _UGE = UCE;
                        _UTF = [];
                        _UTE = false;
                        switch (i) { case "$or": _UGE = UCE[i]; _UTE = true; break; } //or使用  
                        _UFE: for (j in _UGE) {
                            if (_UGE.hasOwnProperty(j)) {
                                _UKE: for (k in _UGE[j]) {
                                    if (_UGE[j].hasOwnProperty(k)) {
                                        switch (j) {
                                            case "$e": _UTF.push(UDE[k] == _UGE[j][k]); break; //=
                                            case "$ne": _UTF.push(UDE[k] != _UGE[j][k]); break; //!=
                                            case "$lt": _UTF.push(UDE[k] < _UGE[j][k]); break; //<
                                            case "$lte": _UTF.push(UDE[k] <= _UGE[j][k]); ; break; //<=
                                            case "$gt": _UTF.push(UDE[k] > _UGE[j][k]); break; //>
                                            case "$gte": _UTF.push(UDE[k] >= _UGE[j][k]); break; //>=
                                            case "$in": for (z = 0; z < _UGE[j][k].length; z++) { if (_UGE[j][k][z] == UDE[k]) { _UTF.push(true); break; } } _UTF = !_UTF; break; //in
                                            case "$nin": for (z = 0; z < _UGE[j][k]; z++) { if (_UGE[j][k][z] == UDE[k]) { continue _UKE; } } _UTF.push(true); break; //not in
                                            case "$all": for (z = 0; z < _UGE[j][k]; z++) { if (_UGE[j][k][z] != UDE[k]) { continue _UKE; } } _UTF.push(true); break; //匹配所有
                                            case "$exists": break; //存在文档
                                            case "$mod": break; //取模函数
                                            case "$not": break; //不匹配
                                        }
                                    }
                                }
                            }
                        }
                    }
                    if ((_UTE === true && _UTF.indexOf(true) > -1) || (_UTF.indexOf(false) == -1)) { USE.push(UDE); }
                }
            }
            else if (_UTF == "array") { //数组选择 
                for (i = 0; i < UDE.length; i++) { if (USE.length == UT) { break; } this.Where(UCE, UT, UDE[i], USE); }
            }
            return USE;
        },
        Select: function (UCE, UKE, UT, USE, UDE) {//条件获取
            var i, _UTF; USE = USE || []; UDE = arguments.length > 4 ? UDE : this.Value;
            if (U.Ut.isArray(UDE)) { for (i = 0; i < UDE.length; i++) { if (USE.length == UT) { break; } this.Select(UCE, UKE, UT, USE, UDE[i]); } }
            else {//对象添加处理
                if (this.IfExists(UCE, UDE)) { USE.push(UDE); } //确定本身是否为目标
                if (UKE === true) { for (i in UDE) { if (USE.length == UT) { break; }; if (U.M.GetType(UDE[i]) == "object") { _$(UDE[i], this).Select(UCE, UKE, UT, USE); } } } //全盘搜索
                else if (UKE) { if (USE.length != UT && UDE[UKE]) { _$(UDE[UKE], this).Select(UCE, UKE, UT, USE); }; } //条件搜索
            }
            return USE;
        },
        Change: function (UCE, UDE) {//修改值
            var i, _UDE = arguments.length > 1 ? UDE : this.Value, _UTF = U.M.GetType(_UDE);
            if (_UTF == "object") { for (i in UCE) { if (UCE.hasOwnProperty(i)) { _UDE[i] = UCE[i]; } } } //对象修改形式
            else if (_UTF == "array") { for (i = 0; i < _UDE.length; i++) { this.Change(UCE, _UDE[i]); } } //数组修改方式   _$(_UDE[i], this).Change(UCE); 
            return _UDE;
        },
        //obj 是一个object，是待删除的元素的关键字，在数组中删除含有该object的元素,digui是bool型
        //UKE 是  1、bool类型。如果为true，表示全递归查找数据,默认为false，不递归查找
        //        2、或者str   例如：{"directory":"C盘","children":[{"directory":"windows","children":[]},{"directory":"programfiles","children":[]}]} 中的"children"，根据此key去递归向下查找数据。找到数据后，匹配第一个参数，进行删除。
        //        3、是递归参数，外部不调用。                    
        Delete: function (obj, key, data) { //删除 允许递归


            var i, _deldata;
            data = data || this.Value; //传递进来的json数据

            var _type = U.M.GetType(data); //获取元素类型
            var _delarray = []; //返回的删除数据。


            if (_type == "object") { //对象删除
                if (this.IfExists(obj, data)) {
                    delete data;
                    _delarray.push(data);
                }
                else if (key === true) { //递归删除
                    for (i in data) {
                        _deldata = this.Delete(obj, key, data[i]); //递归删除该数据
                        _delarray = _delarray.concat(_deldata); //把删除的数据追加到变量中
                    }
                }
                else if (key && data[key]) { //根据指定的key进行递归删除
                    _deldata = this.Delete(obj, key, data[key]); //根据指定的key递归删除该数据
                    _delarray = data.concat(_deldata);
                }
            }
            //数组删除指定obj条件的元素
            else if (_type === "array") {
                for (i = 0; i < data.length; i++) {
                    //循环删除 获取移除的元素
                    _deldata = this.Delete(obj, key, data[i]);
                    if (_deldata.length) { //判断是否移除了元素，length大于0相当于移除超过一个元素。
                        data.splice(i, 1); //数组的系统移除方法
                        _delarray = _delarray.concat(_deldata); //把移除的元素添加到变量中
                        i--; //由于上面用了循环i++ 移除元素后 数组的下标减一了，所以这里用i--让i回到前面一个循环，这样即使数组删除了一个元素也不会直接跳过下一个元素的循环
                    }
                }
            } //数组使用
            return _delarray;
        },

        RecurD: function (UCE, UKE, UTP) { //数据递归
            var _UAE, _UGE, i = UCE ? (_UGE = [UCE], 0) : (_UGE = [], -1), _UDE = this.Value;
            if (U.Ut.isArray(_UDE)) {
                for (; i < _UGE.length; i++) {
                    if (i > -1) { for (j in UKE) { UKE[j] = _UGE[i][UTP]; } }
                    _UAE = _$(_UDE).Select(UKE)[0]; (_UAE) && (_UGE.push(_UAE));
                }
            }
            else {
                while (_UGE[4][UKE]) { _UDE.push(_UGE[4][_UPID]); _UPID = _UGE[4][i]["UserDirectoryParentID"] }
            }
            return _UGE;
        },
        NL: function (UCE, USE) { //通过数组生成集合
            var i, _UDE = this.Value;
            for (i = 0; i < UCE.length; i++) { _UDE[UCE[i]] = USE[i]; }
            return _UDE;
        },
        Reset: function (UCE) { //数组排序
            var i, _UDE = this.Value;
            for (i = 0; i < _UDE.length; i++) { if (this.IfExists(UCE, _UDE[i])) { _UDE.unshift(_UDE.splice(i, 1)[0]); } }
            return _UDE;
        },
        Like: function (UCE, UT, UKE, USE) { //like使用
            var i, _US, _UE, _UDE = this.Value, _UTF = U.M.GetType(_UDE); USE = USE || [];
            if (_UTF == "object") {
                for (i in UCE) {
                    if (UCE.hasOwnProperty(i)) {
                        if (_UDE[i] != UCE[i]) {
                            if (typeof _UDE[i] == "object" || typeof _UDE[i] == "object") { return; }
                            _US = (_UDE[i] + "").toLocaleLowerCase(); _UE = (UCE[i] + "").toLocaleLowerCase();
                            if (!(_US.indexOf(_UE) > -1 || _UE.indexOf(_US) > -1)) { return; }
                        }
                    }
                }
                USE.push(_UDE);
            }
            else if (_UTF === "array") { for (i = 0; i < _UDE.length; i++) { _$(_UDE[i], this).Like(UCE, UT - USE.length, UKE, USE); if (USE.length >= UT) { USE.splice(UT, USE.length); break; } } }
            return USE;
        },
        GZDL: function (UCE, UDE) {//选择指定字段的值
            var i, _UKE = {}, _UDE = this.Value;
            (U.Ut.isString(UCE)) && (UCE = [UCE]);
            for (i = 0; i < UCE.length; i++) { _UKE[UCE[i]] = _UDE[UCE[i]]; }
            return _UKE;
        },
        //UCE是一个object，UDE是json。判断json中的数据是否包含该object。
        //例：{name:张三,身高:1.8,体重:150}  查找{name:张三,身高:1.8},则符合条件,返回true，查找{name:张三,身高:1.5}，则不符合条件，返回false.
        IfExists: function (UCE, UDE) { //判断数据是否符合条件
            var i, _UTF;
            UDE = UDE || this.Value;
            //判断条件是否就是指定判断的元素，如果是直接返回true，
            if (UDE === UCE) {
                return true;
            }

            //循环条件，当条件中所有的条件都满足的时候，为true；否则为false
            for (i in UCE) {
                if (UCE.hasOwnProperty(i)) {
                    if (UDE[i] === UCE[i]) {
                        _UTF = true;
                    }
                    else {
                        _UTF = false;
                        break;
                    }
                }
            }
            return _UTF;
        },
        Merger: function (UDE) {//合并成数组分组
            UDE = UDE || this.Value; var i, _USE = [], _UTP = U.M.GetType(this.Value);
            if (_UTP == "object") { for (i in UDE) { if (UDE.hasOwnProperty(i)) { _USE = _USE.concat(UDE[i]); } } }
            else if (_UTP == "array") { for (i = 0; i < UDE.length; i++) { _USE = _USE.concat(UDE[i]); } }
            return _USE;
        },
        ToString: function () { return U.MS.jsonToStr(this.Value); }, //把json 数组变成string
        Each: function (UCB, UDE) { //数据遍历
            if (U.Ut.isFunction(UCB)) {
                UDE = UDE || this.Value;
                var i, _UTF = U.M.GetType(UDE);
                if (_UTF == "object") {
                    for (i in UDE) {
                        (UDE.hasOwnProperty(i)) && (UCB(UDE[i], i, UDE));
                    }
                }
                else if (_UTF === "array") {
                    Array.forEach(function () {
                        UCB.apply(UDE, arguments);
                    });
                }
            }
            return this;
        },
        //未使用   
        max: function (UCE, UTI, UDE) {//获取最大
            maxAndmin(UDE || this.Value, UCE, UTI, "max");
        },
        min: function () {//获取最小
            maxAndmin(UDE || this.Value, UCE, UTI, "min");
        },
        object: function (UCE, UDE) {//把数组转化成object
            var i, _USE = {}; UDE = UDE || this.Value;
            for (i = 0; i < UCE.length; i++) { return _USE[UCE[i]] = UDE[i]; }
            return _USE;
        },
        countBy: function (UFE, UDE) { //统计使用
            UDE = UDE || this.Value; var i, _UTF, _USE = {}, _UTP = U.M.GetType(UDE);
            if (_UTP == "array") { for (i = 0; i < UDE.length; i++) { _USE[UFE(UDE[i])] = (_USE[UFE(UDE[i])] || 0) + 1; } }
            else { throw new Error(UDE + " is not an Array"); }
        },
        where: function (UCE, UDE) { //获取制定的值
            var i = 0, _USE = []; UDE = UDE || this.Value;
            while (i++ < _UDE.length) { (this.IfExists(UCE, UDE)) && (_USE.push(UDE[i])); }
            return _USE;
        },
        count: function () {//统计返回的数
            return this.Value.length;
        },
        distinct: function () {//去除重复的数据

        },
        find: function () { //模拟数据库查询

        },
        each: function () { },
        has: function (UCE, UDE) {
            UDE = UDE || this.Value; var i;
            if (typeof UCE == "string") { if (UCE in UDE && UDE.hasOwnProperty(UCE)) { return true; } }
            else { for (i in UCE) { if (!(i in UDE && UDE.hasOwnProperty(i))) { return false; } } return true; } return false;
        },
        range: function (US, UE, UT) { //产生带编号的数组
            var _UDE = [], i = US || 0, _UL = (UE - US); UT = UT || (UE - US) > 0 ? 1 : -1;
            if (_UL) {
                _UL = Math.max(Math.ceil(_UL /= UT), 0);
                for (i = 0; i < _UL; i++) { US += UT; _UDE.push(US); }
            }
            return _UDE;
        },
        isEqual: function (UCE, UDE) { //两个值深度比较
            UDE = UDE || this.Value; var i, _UTP = U.M.GetType(UDE), _UFE = Object.prototype.toString.call;
            if (_UFE(UDE) === _UFE(UCE)) {
                if (_UTP == "object") { return (this.IfExists(UCE, UDE) && this.IsTF(UDE, UCE)); } //对象判断
                else if (_UTP == "array" && UDE.length == UCE.length) { i = UDE.length; while (i--) { if (!this.isEqual(UDE[i], UCE[i])) { return false; } } } //数组判断
                return true;
            }
            return false;
        },
        isMatch: function (UCE, UDE) { //判断指定的值是否存在
            UDE = UDE || this.Value; var i, _UTP = U.M.GetType(UDE);
            if (_UTP == "object") { return this.IfExists(UCE); } //集合使用
            throw new Error("参数必须为对象");
        }
    }
    _UME.IsTF = _UME.IfExists; //重载
    _UME.init.prototype = _UME;

    return _UFE; //返回的初始化方法，所以会自动执行java中的构造函数。

}


//#ednregion