/**
 * Created by Zhong on 2017/8/14.
 */
let pageOprObj = {
    gljLibName : null,
    stdGljLibId: null,
    userId: null,
    compilationId: null,
    initPage : function(container, containerComponent, containerC) {
        let me = pageOprObj;
        me.stdGljLibId = stdGljLibId;
        me.userId = userId;
        me.compilationId = compilationId;
        repositoryGljObj.buildSheet(container);
        gljComponentOprObj.buildSheet(containerComponent);
        componentOprObj.buildSheet(containerC);
        //获得定额库中引用此工料机库中的，所有被定额所套的工料机的ID
        //repositoryGljObj.getRationGljIds(gljLibId);
        repositoryGljObj.getGljDistType(function () {
            repositoryGljObj.currentRepositoryId = me.stdGljLibId;
            repositoryGljObj.getGljTree(stdGljLibId, function () {
                repositoryGljObj.getGljItems(me.stdGljLibId, me.userId, me.compilationId);
            });
            sheetOpr.shieldAllCells(repositoryGljObj.workBook.getSheet(0), repositoryGljObj.setting);
        });
    }
};

let repositoryGljObj = {
    treeObj : null,
    workBook: null,
    gljCurTypeId: -1,
    currentRepositoryId: -1,
    currentCache: null,
    parentNodeIds: {},
    gljList: [],
    stdGljList:[],
    complementaryGljList: [],
    allowComponent: [202, 203, 204, 301],//可带组成物类型：混凝土、砂浆、配合比、机械台班
    componentGljType: [201, 302, 303],//可成为组成物的工料机类型： 普通材料、 机械组成物、 机上人工
    distTypeTree: null,//add
    setting: {

        header:[
            {headerName:"编码",headerWidth:140,dataCode:"code", dataType: "String", formatter: "@", hAlign: "left", vAlign: "center"},
            {headerName:"名称",headerWidth:280,dataCode:"name", dataType: "String", hAlign: "left", vAlign: "center"},
            {headerName:"规格型号",headerWidth:180,dataCode:"specs", dataType: "String", hAlign: "left", vAlign: "center"},
            {headerName:"计量单位",headerWidth:120,dataCode:"unit", dataType: "String", hAlign: "center", vAlign: "center"},
            {headerName:"基价单价",headerWidth:120,dataCode:"basePrice", dataType: "Number", formatter: "0.00", hAlign: "right", vAlign: "center"},
            {headerName:"类型",headerWidth:120,dataCode:"gljType", dataType: "String", hAlign: "center", vAlign: "center"},
            {headerName:"是否新增",headerWidth:80,dataCode:"isComplementary", hAlign: "center", vAlign: "center"}
        ],
        view:{
            comboBox:[
                {row:-1,col:3,rowCount:-1,colCount:1}
            ],
            lockedCells:[
            ]
        }
    },
    getComboData: function (gljDistType) {
        let me = this;
        let distType;
        let distTypeTree = {
            prefix : 'gljType',
            distTypes: {},
            comboDatas: [],
            distTypesArr: []
        };
        gljDistType.forEach(function (typeData) {
            let typeObj = {
                data: typeData,
                children: [],
                parent: null
            }
            distTypeTree.distTypes[distTypeTree.prefix + typeData.ID] = typeObj;
            distTypeTree.distTypesArr.push(typeObj);
        });
        gljDistType.forEach(function (typeData) {
            distType = distTypeTree.distTypes[distTypeTree.prefix + typeData.ID];
            let parent = distTypeTree.distTypes[distTypeTree.prefix + typeData.ParentID];
            if(parent){
                distType.parent = parent;
                parent.children.push(distType);
            }
        });
        distTypeTree.distTypesArr.forEach(function (distTypeObj) {
           /* if(distTypeObj.children.length === 0 && distTypeObj.data.fullName !== '普通机械' &&distTypeObj.data.fullName !== '机械组成物'
                && distTypeObj.data.fullName !== '机上人工'){
                distTypeTree.comboDatas.push({text: distTypeObj.data.fullName, value: distTypeObj.data.ID});
            }*/
            if(distTypeObj.data.fullName !== '材料' && distTypeObj.data.fullName !== '机械'){
                distTypeTree.comboDatas.push({text: distTypeObj.data.fullName, value: distTypeObj.data.ID});
            }
        });
        return distTypeTree;
    },
    getGljDistType: function (callback) {
        let me = this;
        $.ajax({
            type: 'post',
            url: "complementartGlj/api/getGljDistType",
            dataType: 'json',
            success: function (result) {
                if(!result.error && callback){
                    me.distTypeTree = me.getComboData(result.data);
                    console.log(me.distTypeTree);
                    let combo = new GC.Spread.Sheets.CellTypes.ComboBox();
                    combo.items(me.distTypeTree.comboDatas).editorValueType(GC.Spread.Sheets.CellTypes.EditorValueType.text);
                    me.workBook.getSheet(0).getCell(-1, 5, GC.Spread.Sheets.SheetArea.viewport).cellType(combo).value(me.distTypeTree.comboDatas[0].text);
                    callback();
                }
            }
        })
    },

    getGljTree: function(gljLibId, callback) {
        let me = this;
        $.ajax({
            type:"POST",
            url:"complementartGlj/api/getGljTree",
            data:{"gljLibId": gljLibId},
            dataType:"json",
            cache:false,
            timeout:20000,
            success:function(result,textStatus,status){
                if(status.status == 200) {
                    zTreeHelper.createTree(result.data, gljSetting, "repositoryTree", me);
                    zTreeHelper.createTree(result.data, componentSetting, "componentTree", componentOprObj);
                    if (result.data && result.data.length > 0) {
                        me.gljCurTypeId = result.data[0].ID;
                    } else {
                        //重新创建库？
                        gljTypeTreeOprObj.addRootNode();
                    }
                    callback();
                }
            },
            error:function(err){
                alert(err.responseJSON.error);
            }
        })
    },
    getGljItems: function(stdGljLibId, userId, compilationId) {
        let me = this;
        $.ajax({
            type:"POST",
            url:"complementartGlj/api/getGljItems",
            data:{stdGljLibId: stdGljLibId, userId: userId, compilationId: compilationId},
            dataType:"json",
            cache:false,
            timeout:5000,
            success:function(result){
                if(!result.error) {
                    me.stdGljList = result.data.stdGljs;
                    me.complementaryGljList = result.data.complementaryGljs;
                    me.workBook.getSheet(0).setRowCount(me.stdGljList.length);
                    me.sortGlj(me.stdGljList);
                    me.sortGlj(me.complementaryGljList);
                    let rootNode = me.treeObj.getNodes()[0];
                    if(rootNode && rootNode.isParent && rootNode.isFirstNode){
                        componentOprObj.rootNode = rootNode;
                        me.treeObj.selectNode(rootNode);
                        gljTypeTreeOprObj.onClick(null, 'repositoryTree', rootNode);
                    }
                }
            },
            error:function(err){
                alert(err.responseJSON.error);
            }
        })
    },
    showGljItems: function(data, type) {
        let me = repositoryGljObj;
        if (me.workBook) {
            let cacheSection = [];
            let pArr = me.parentNodeIds["_pNodeId_" + type];
            for (let i = 0; i < data.length; i++) {
                if (pArr && pArr.indexOf(data[i].gljClass) >= 0) {
                    cacheSection.push(data[i]);
                } else if (type == data[i].gljClass) {
                    cacheSection.push(data[i]);
                }
            }
            sheetOpr.cleanSheet(me.workBook.getSheet(0), me.setting, -1);
            sheetOpr.showData(me.workBook.getSheet(0), me.setting, cacheSection, me.distTypeTree);

            cacheSection = null;
        }
    },
    buildSheet: function(container) {
        let me = repositoryGljObj;
        me.workBook = sheetOpr.buildSheet(container, me.setting, 30);
        me.repositoryGljDelOpr();
        me.workBook.getActiveSheet().bind(GC.Spread.Sheets.Events.ClipboardPasting, me.onClipboardPasting);
        me.workBook.getActiveSheet().bind(GC.Spread.Sheets.Events.ClipboardPasted, me.onClipboardPasted);
        me.workBook.getSheet(0).bind(GC.Spread.Sheets.Events.EditStarting, me.onCellEditStart);
        me.workBook.getSheet(0).bind(GC.Spread.Sheets.Events.EditEnded, me.onCellEditEnd);
        me.workBook.getSheet(0).bind(GC.Spread.Sheets.Events.EnterCell, me.onEnterCell);
        me.workBook.getSheet(0).bind(GC.Spread.Sheets.Events.SelectionChanged, me.onSelectionChanged);
    },
    getCurrentComponent: function (gljComponent) {
        let me = repositoryGljObj, rst = [];
        for(let i = 0; i < gljComponent.length; i++){
            let obj = {};
            for(let j = 0; j < me.complementaryGljList.length; j++){
                if(gljComponent[i].ID == me.complementaryGljList[j].ID){
                    obj.ID = me.complementaryGljList[j].ID;
                    obj.code = me.complementaryGljList[j].code;
                    obj.name = me.complementaryGljList[j].name;
                    obj.unit = me.complementaryGljList[j].unit;
                    obj.basePrice = me.complementaryGljList[j].basePrice;
                    obj.consumeAmt = gljComponent[i].consumeAmt;
                    rst.push(obj);
                }
            }
            for(let j = 0; j < me.stdGljList.length; j++){
                if(gljComponent[i].ID == me.stdGljList[j].ID){
                    obj.ID = me.stdGljList[j].ID;
                    obj.code = me.stdGljList[j].code;
                    obj.name = me.stdGljList[j].name;
                    obj.unit = me.stdGljList[j].unit;
                    obj.basePrice = me.stdGljList[j].basePrice;
                    obj.consumeAmt = gljComponent[i].consumeAmt;
                    rst.push(obj);
                }
            }
        }
        rst.sort(function (a, b) {
            let r = 0;
            if(a.code > b.code) r = 1;
            else if(a.code < b.code) r = -1;
            return r;
        });
        return rst;
    },
    //获得引用了组成物id为componentId的工料机，和重新变化组成物数组、重新计算单价
    getUpdateGljs: function (rObj, isDelete) {
        let me = repositoryGljObj, that = gljComponentOprObj,
            rst = {updateArr: [], updateBasePrcArr: []};
        //改变单价，以便reCalGljBasePrc方法可行
        if(!isDelete){
            for(let i = 0; i < me.complementaryGljList.length; i++){
                if(me.complementaryGljList[i].ID === rObj.ID){
                    me.complementaryGljList[i].basePrice = rObj.basePrice;
                    break;
                }
            }
        }
        for(let i = 0; i < me.complementaryGljList.length; i++){
            let thisComponent = me.complementaryGljList[i].component, isChange = false;
            for(let j = 0; j < thisComponent.length; j++){
                if(thisComponent[j].ID === rObj.ID){
                    //删除
                    isChange = true;
                    if(isDelete){
                        thisComponent.splice(j--, 1);
                    }
                    else {
                        break;
                    }
                }
            }
            if(isChange){//引用了此组成物
                let gljBasePrc = that.reCalGljBasePrc(me.getCurrentComponent(thisComponent));
                if(me.complementaryGljList[i].basePrice !== gljBasePrc){
                    me.complementaryGljList[i].basePrice = gljBasePrc;
                    rst.updateBasePrcArr.push({gljId: me.complementaryGljList[i].ID, gljType: me.complementaryGljList[i].gljType, basePrice: me.complementaryGljList[i].basePrice});
                }
                rst.updateArr.push(me.complementaryGljList[i]);
            }
        }
        return rst;
    },
    reshowGljBasePrc: function (glj) {
        let me = repositoryGljObj;
        let cacheSection = me.currentCache;
        for(let i = 0; i < cacheSection.length; i++){
            if(glj.ID === cacheSection[i].ID){
                cacheSection[i].basePrice = glj.basePrice;
                me.workBook.getSheet(0).setValue(i, 4, glj.basePrice);
                break;
            }
        }
    },
    onSelectionChanged: function (sender, info) {
        let me = repositoryGljObj, that = gljComponentOprObj;
        //混凝土202、砂浆203、配合比204、机械3
        if(typeof info.oldSelections || info.oldSelections.length === 0 && info.newSelections.length > 0 || info.oldSelections[0].row !== info.newSelections[0].row){
            let row = info.newSelections[0].row;
            sheetOpr.lockCells(that.workBook.getSheet(0), that.setting);
            that.workBook.getSheet(0).getRange(-1, 0 , -1, 1, GC.Spread.Sheets.SheetArea.viewport).locked(true);
            that.workBook.getSheet(0).getRange(-1, 4 , -1, 1, GC.Spread.Sheets.SheetArea.viewport).locked(true);
            that.isLocked = true;
            //that.workBook.getSheet(0).options.isProtected = true;
            sheetOpr.cleanSheet(that.workBook.getSheet(0), that.setting, -1);
            me.workBook.focus(true);
            me.currentComponent = [];
            if(row < me.currentCache.length){
                //标记当前工料机
                me.currentGlj = me.currentCache[row];
                if(me.allowComponent.indexOf(me.currentCache[row].gljType) !== -1){
                    //that.workBook.getSheet(0).getRange(-1, 0 , -1, 1, GC.Spread.Sheets.SheetArea.viewport).locked(false);
                    that.workBook.getSheet(0).getRange(-1, 4 , -1, 1, GC.Spread.Sheets.SheetArea.viewport).locked(false);
                    that.isLocked = false;
                    //展示数据
                    if(me.currentGlj.component.length > 0){
                        me.currentComponent = me.getCurrentComponent(me.currentGlj.component);
                        if(me.currentComponent.length > 0){
                            sheetOpr.showData(that.workBook.getSheet(0), that.setting, me.currentComponent);
                        }
                    }
                }
            }
            else{
                me.currentGlj = null;
            }
        }
    },
    onEnterCell: function (sender, args) {
        let me = repositoryGljObj;
        me.cellRowIdx = args.row;
        let isHasData = false;
        if(me.addGljObj){
            for(let i=0; i<me.setting.header.length; i++){
                if(me.addGljObj[me.setting.header[i].dataCode]){
                    isHasData = true;
                    break;
                }
            }
        }
        if(isHasData){
            if(me.editingRowIdx !== me.cellRowIdx) {
                let isComple = true;
                let focusToCol;
                function getFocusToCol (me){
                    if(!me.addGljObj[me.setting.header[0].dataCode]){
                        $('#alertGljTxt').text('编号不能为空，是否取消增加工料机?');
                        return 0;
                    }
                    else if(!me.addGljObj[me.setting.header[1].dataCode]){
                        $('#alertGljTxt').text('名称不能为空，是否取消增加工料机?');
                        return 1;
                    }
                    else if(!me.addGljObj[me.setting.header[3].dataCode]){
                        $('#alertGljTxt').text('计量单位不能为空，是否取消增加工料机?');
                        return 3;
                    }
                    else if(!me.addGljObj[me.setting.header[5].dataCode]){
                        $('#alertGljTxt').text('类型不能为空，是否取消增加工料机?');
                        return 5;
                    }
                    else {
                        return -1;
                    }
                }
                focusToCol = getFocusToCol(me);
                if(focusToCol === -1){

                }
                else {
                    $('#gljAlertBtn').click();
                    //me.workBook.getSheet(0).options.isProtected = true;
                    sheetOpr.lockAllCells(args.sheet);
                    $('#aleCanceBtn').click(function () {
                        // me.workBook.getSheet(0).options.isProtected = false;
                        sheetOpr.unLockAllCells(args.sheet);
                        sheetOpr.reLockSomeCodes(args.sheet, 0, repositoryGljObj.currentCache.length);
                        me.workBook.getSheet(0).setActiveCell(me.editingRowIdx, focusToCol);
                    });
                    $('#gljAleClose').click(function () {
                        // me.workBook.getSheet(0).options.isProtected = false;
                        sheetOpr.unLockAllCells(args.sheet);
                        sheetOpr.reLockSomeCodes(args.sheet, 0, repositoryGljObj.currentCache.length);
                        me.workBook.getSheet(0).setActiveCell(me.editingRowIdx, focusToCol);
                    });
                    $('#aleConfBtn').click(function () {
                        // me.workBook.getSheet(0).options.isProtected = false;
                        sheetOpr.unLockAllCells(args.sheet);
                        sheetOpr.reLockSomeCodes(args.sheet, 0, repositoryGljObj.currentCache.length);
                        me.addGljObj = null;
                        for(let col=0; col<me.setting.header.length; col++){
                            let field = me.setting.header[col].dataCode;
                            if(field === 'gljType'){
                                me.workBook.getSheet(0).getCell(me.editingRowIdx, col).value(
                                    typeof me.currentEditingGlj[field] !== 'undefined'?
                                    me.distTypeTree.distTypes[me.distTypeTree.prefix + me.currentEditingGlj[field]].data.fullName
                                    : '');
                            }
                            else{
                                me.workBook.getSheet(0).getCell(me.editingRowIdx, 0).formatter("@");
                                me.workBook.getSheet(0).getCell(me.editingRowIdx, col).value(me.currentEditingGlj[me.setting.header[col].dataCode]);
                            }
                        }
                        me.workBook.getSheet(0).setActiveCell(me.editingRowIdx, 0);
                    });
                }
            }
        }
    },
    onCellEditStart: function(sender, args) {
        let me = repositoryGljObj;
        let rObj = sheetOpr.combineRowData(me.workBook.getSheet(0), me.setting, args.row);
        me.currentEditingGlj = rObj;
        me.orgCode = me.workBook.getSheet(0).getValue(args.row, 0);
        let cacheSection = me.complementaryGljList;
        if (cacheSection) {
            for (let j = 0; j < cacheSection.length; j++) {
                if (cacheSection[j][me.setting.header[0].dataCode] && cacheSection[j][me.setting.header[0].dataCode] == rObj[me.setting.header[0].dataCode]) {
                    rObj["ID"] = cacheSection[j]["ID"];
                    rObj.gljClass = cacheSection[j].gljClass;
                    break;
                }
            }
        }
    },
    onCellEditEnd: function(sender, args) {
        let me = repositoryGljObj, that = gljComponentOprObj,
            rObj = sheetOpr.combineRowData(me.workBook.getSheet(0), me.setting, args.row, me),
            updateArr = [], addArr = [], updateBasePrcArr = [];
        me.editingRowIdx = args.row;
        rObj.basePrice = rObj.basePrice ? rObj.basePrice : 0;
        //更新
        if (me.currentEditingGlj["ID"]) {
            rObj["ID"] = me.currentEditingGlj["ID"];
            rObj.gljClass = me.currentEditingGlj.gljClass;
            //for(let col =0; col< me.setting.header.length; col++){
                if(me.currentEditingGlj[me.setting.header[args.col].dataCode] !== rObj[me.setting.header[args.col].dataCode]){
                    //me.addGljObj = rObj;
                    //编码、名称、单位、类型不可为空
                    if(rObj[me.setting.header[0].dataCode] && rObj[me.setting.header[1].dataCode] && rObj[me.setting.header[3].dataCode] && rObj[me.setting.header[5].dataCode]
                    &&rObj[me.setting.header[0].dataCode].toString().trim().length !== 0 && rObj[me.setting.header[1].dataCode].toString().trim().length !== 0 && rObj[me.setting.header[3].dataCode].toString().trim().length !== 0&&
                        rObj[me.setting.header[5].dataCode].toString().trim().length !== 0){
                        if(rObj.gljType !== me.currentEditingGlj.gljType){//修改了工料机类型
                                if(me.currentGlj){
                                    me.currentGlj.component = [];
                                }
                                if(me.allowComponent.indexOf(rObj.gljType) !== -1){
                                    rObj.basePrice = 0;
                                }
                                if(me.componentGljType.indexOf(me.currentEditingGlj.gljType) !== -1 &&
                                    !(me.currentEditingGlj.gljType === 302 && rObj.gljType === 303) && !(me.currentEditingGlj.gljType === 303 && rObj.gljType === 302)){//修改了原本是组成物的工料机
                                    //寻找所有引用了此组成物的工料机,并从组成物中删去此工料机,并重算单价
                                    let updateGljs = me.getUpdateGljs(rObj);
                                    if(updateGljs.updateArr.length > 0 || updateGljs.updateBasePrcArr.length > 0){
                                        for(let i = 0; i < updateGljs.updateArr.length; i++){
                                            updateArr.push(updateGljs.updateArr[i]);
                                        }
                                        for(let i = 0; i < updateGljs.updateBasePrcArr.length; i++){
                                            updateArr.push(updateGljs.updateBasePrcArr[i]);
                                        }
                                    }
                                }
                        }
                        else if(rObj.basePrice !== me.currentEditingGlj.basePrice){//修改了单价,可修改单价的必为可成为组成物的
                            //寻找所有引用了此组成物的工料机,并从组成物中删去此工料机,并重算单价
                            let updateGljs = me.getUpdateGljs(rObj);
                            if(updateGljs.updateArr.length > 0 || updateGljs.updateBasePrcArr.length > 0){
                                for(let i = 0; i < updateGljs.updateArr.length; i++){
                                    updateArr.push(updateGljs.updateArr[i]);
                                }
                                for(let i = 0; i < updateGljs.updateBasePrcArr.length; i++){
                                    updateArr.push(updateGljs.updateBasePrcArr[i]);
                                }
                            }
                            rObj.basePrice = !isNaN(parseFloat(rObj.basePrice)) && (rObj.basePrice && typeof rObj.basePrice !== 'undefined') ? that.round(parseFloat(rObj.basePrice), 2) : 0;
                        }
                        rObj.component = me.currentGlj.component;
                        updateArr.push(rObj);
                    }
                    else{
                        if(me.setting.header[args.col].dataCode === 'gljType'){
                            console.log(me.distTypeTree);
                            let distTypeVal =  me.distTypeTree.distTypes[me.distTypeTree.prefix + me.currentEditingGlj[me.setting.header[args.col].dataCode]].data.fullName;
                            args.sheet.setValue(args.row, args.col, distTypeVal);
                        }
                        else{
                            args.sheet.setValue(args.row, args.col, me.currentEditingGlj[me.setting.header[args.col].dataCode]);
                        }
                    }
                }
          //  }
            //--------------------------------------
            if(me.currentEditingGlj.basePrice !== rObj.basePrice){
                //update basePrice of ration when editting basePrice of glj
               /* let gljType = -1;
                let gljTypeParent = me.distTypeTree.distTypes[me.distTypeTree.prefix + me.currentEditingGlj.gljType].parent;
                if(gljTypeParent && gljTypeParent.data.ID <=3){
                    gljType = gljTypeParent.data.ID;
                }
                if(!gljTypeParent && me.currentEditingGlj.gljType <= 3){
                    gljType = me.currentEditingGlj.gljType;
                }
                let gljBasePrcObj = {gljId: me.currentEditingGlj.ID, gljType: gljType, basePrice: rObj.basePrice};
                if(gljBasePrcObj.gljType !== -1){
                    updateBasePrcArr.push(gljBasePrcObj);
                    if(me.rationLibs.length > 0){//重算定额单价
                        me.updateRationBasePrcRq(updateBasePrcArr);
                    }
                }*/
            }
            //update basePrice of ration when editting gljType of glj
            if(me.currentEditingGlj.gljType !== rObj.gljType){
                /*let gljTypeObj = {gljId: me.currentEditingGlj.ID, gljType: rObj.gljType, basePrice: rObj.basePrice};
                updateBasePrcArr.push(gljTypeObj);
                if(me.rationLibs.length > 0){
                    me.updateRationBasePrcRq(updateBasePrcArr);
                }*/
            }
            //-----------------------------------------------------------
        }
        //新增
        else {
            if(typeof rObj.code !== 'undefined'){
                me.addGljObj = rObj;
                let isCanSav = true;
                if(!rObj[me.setting.header[0].dataCode] || !rObj[me.setting.header[1].dataCode] || !rObj[me.setting.header[3].dataCode] || !rObj[me.setting.header[5].dataCode]){
                    isCanSav = false;
                }
                if(isCanSav){
                    me.addGljObj = null;
                    rObj.component = [];
                    //如果类型为混凝土、砂浆、配合比、机械台班时，添加时填写的单价清空
                    if(me.allowComponent.indexOf(rObj.gljType) !== -1){
                        rObj.basePrice = 0;
                    }
                    rObj.basePrice = !isNaN(parseFloat(rObj.basePrice)) && (rObj.basePrice && typeof rObj.basePrice !== 'undefined') ? parseFloat(rObj.basePrice) : 0;
                    addArr.push(rObj);
                }
            }
        }
        if(me.gljCurTypeId !== 732){
            rObj.gljClass = me.gljCurTypeId;
        }
        if(updateArr.length >0 || addArr.length >0){
            me.currentEditingGlj = null;
            //me.workBook.getSheet(0).setValue(11, 5, "人工");
            me.mixUpdateRequest(updateArr, addArr, []);
        }
    },
    repositoryGljDelOpr: function () {
        let me = repositoryGljObj;
        me.workBook.commandManager().register('repositoryGljDel', function () {
            let sheet = me.workBook.getSheet(0),
                updateArr = [], removeArr = [],
                tempRemoveArr= [],
                refGljCodes = [], //已被引用的工料机
                updateBasePrcArr = [],//删除基价单位后重新计算
                sels = sheet.getSelections(),
                canUpdate = false,
                cacheSection = me.currentCache;
            if(sels.length > 0 && cacheSection.length > 0){
                for(let i = 0; i < sels.length; i++){
                    if(sels[i].colCount === me.setting.header.length){
                        for(let j = 0; j < sels[i].rowCount; j++){
                            if(sels[i].row + j < cacheSection.length){
                                //删除了已被引用成组成物的工料机，重新计算所有引用此组成物的工料机的单价、组成物数组
                                let updateGljs = me.getUpdateGljs(cacheSection[sels[i].row + j], true);
                                if(updateGljs.updateArr.length > 0 || updateGljs.updateBasePrcArr.length > 0){
                                    for(let i = 0; i < updateGljs.updateArr.length; i++){
                                        updateArr.push(updateGljs.updateArr[i]);
                                    }
                                    for(let i = 0; i < updateGljs.updateBasePrcArr.length; i++){
                                        updateBasePrcArr.push(updateGljs.updateBasePrcArr[i]);
                                    }
                                }
                                removeArr.push(cacheSection[sels[i].row + j].ID);
                                //tempRemoveArr.push({ID: cacheSection[sels[i].row + j].ID, code: cacheSection[sels[i].row + j].code});
                                //删除后重新计算引用了此工料机的定额单价
                                updateBasePrcArr.push({gljId: cacheSection[sels[i].row + j].ID, gljType: cacheSection[sels[i].row + j].gljType, basePrice: 0, delete: 1});
                            }
                        }
                    }
                    else{
                        let maxCol = sels[i].col + sels[i].colCount - 1;
                        if(sels[i].col >= 2 && maxCol <= 4){
                            for(let j = 0; j < sels[i].rowCount; j++){
                                if(sels[i].row + j < cacheSection.length){
                                    let updateObj = cacheSection[sels[i].row + j];
                                    for(let col = sels[i].col; col <= maxCol; col++){
                                        if(me.setting.header[col].dataCode === 'basePrice'){
                                            //如果类型不为混凝土、砂浆、配合比、机械，才可删除单价 basePrice = 0
                                            if(me.allowComponent.indexOf(updateObj.gljType) === -1){
                                                canUpdate = true;
                                                updateObj[me.setting.header[col].dataCode] = 0;
                                                updateBasePrcArr.push({gljId: updateObj.ID, gljType: updateObj.gljType, basePrice: 0});
                                            }
                                        }
                                        else{
                                            canUpdate = true;
                                            updateObj[me.setting.header[col].dataCode] = '';
                                        }
                                    }
                                    if(canUpdate){
                                        updateArr.push(updateObj);
                                    }
                                }
                            }
                        }
                        //编号、名称、类型不可为空
                        else{
                            if(sels[i].row < cacheSection.length){
                                let text = '', cantNullStr =['编码', '名称', '类型'];
                                for(let col = sels[i].col; col <= sels[i].col + sels[i].colCount -1; col++){
                                    if(cantNullStr.indexOf(me.setting.header[col].headerName) !== -1){
                                        text += me.setting.header[col].headerName + " ";
                                    }
                                }
                                $('#alertText').text(text + "不可为空！");
                                $('#codeAlertBtn').click();
                                sheet.options.isProtected = true;
                                $('#codAleConfBtn').click(function () {
                                    sheetOpr.lockSomeCodes(sheet, 0, cacheSection.length);
                                });
                                $('#codAleClose').click(function () {
                                    sheetOpr.lockSomeCodes(sheet, 0, cacheSection.length);
                                });
                            }
                        }
                    }
                }
                if(removeArr.length > 0 || updateArr.length > 0){
                    //删除警告
                    $('#alertGljTxt').text('可能已有定额引用了当前工料机，导致定额查找不到此工料机。确定要删除吗？');
                    $('#gljAlertBtn').click();
                    //确认
                    $('#aleConfBtn').click(function () {
                        me.mixUpdateRequest(updateArr, [], removeArr);
                        /*if(updateBasePrcArr.length > 0 && me.rationLibs.length > 0){
                            me.updateRationBasePrcRq(updateBasePrcArr);
                        }*/
                    });
                }
            }

        });

        me.workBook.commandManager().setShortcutKey(null, GC.Spread.Commands.Key.del, false, false, false, false);
        me.workBook.commandManager().setShortcutKey('repositoryGljDel', GC.Spread.Commands.Key.del, false, false, false, false);
    },
    validUpdateObj: function (pasteObj, rowIdx) {
        let rst = {updateGlj: [], updateBasePrcArr: []}, backUpObj = {},
            me = repositoryGljObj,
            that = gljComponentOprObj,
            tempObj = me.currentCache[rowIdx],
            reCalBasePrc = false,
            isValid = true;
        //备份原始数据
        for(let atr in tempObj){
            backUpObj[atr] = tempObj[atr];
        }
        if(typeof pasteObj.code !== 'undefined'){
            if(pasteObj.code.trim().length !== 0){
                let isExist = false;
                for(let i = 0; i < me.stdGljList.length; i++){
                    if(me.stdGljList[i].code === pasteObj.code){
                        isExist = true;
                        break;
                    }
                }
                if(!isExist){
                    for(let i = 0; i < me.complementaryGljList.length; i++){
                        if(me.complementaryGljList[i].code === pasteObj.code){
                            isExist = true;
                            break;
                        }
                    }
                }
                if(!isExist){
                    tempObj.code = pasteObj.code;
                }
                else isValid = false;
            }
            else isValid = false;
        }
        if(typeof pasteObj.name !== 'undefined'){
            if(pasteObj.name.trim().length === 0) isValid = false;
            else tempObj.name = pasteObj.name;
        }
        if(typeof pasteObj.specs !== 'undefined'){
            tempObj.specs = pasteObj.specs;
        }
        if(typeof pasteObj.unit !== 'undefined'){
            tempObj.unit = pasteObj.unit;
        }
        if(typeof pasteObj.gljType !== 'undefined'){
            let isExsit = false;
            for(let i = 0; i < me.distTypeTree.comboDatas.length; i++){
                if(pasteObj.gljType === me.distTypeTree.comboDatas[i].text){
                    isExsit = true;
                    reCalBasePrc = true;
                    //
                    if(me.componentGljType.indexOf(tempObj.gljType) !== -1 &&
                        !(tempObj.gljType === 302 && pasteObj.gljType === 303) && !(tempObj.gljType === 303 && pasteObj.gljType === 302)){//修改了原本是组成物的工料机
                        //寻找所有引用了此组成物的工料机,并从组成物中删去此工料机,并重算单价
                        let updateGljs = me.getUpdateGljs(tempObj, true);
                        if(updateGljs.updateArr.length > 0 || updateGljs.updateBasePrcArr.length > 0){
                            for(let i = 0; i < updateGljs.updateArr.length; i++){
                                rst.updateGlj.push(updateGljs.updateArr[i]);
                            }
                            for(let i = 0; i < updateGljs.updateBasePrcArr.length; i++){
                                rst.updateBasePrcArr.push(updateGljs.updateBasePrcArr[i]);
                            }
                        }
                    }
                    tempObj.gljType = me.distTypeTree.comboDatas[i].value;
                    tempObj.shortName = me.distTypeTree.distTypes[me.distTypeTree.prefix + tempObj.gljType].data.shortName;
                    if(me.allowComponent.indexOf(tempObj.gljType) !== -1){
                        tempObj.basePrice = 0;
                    }
                    break;
                }
            }
            if(!isExsit) isValid = false;
        }
        //
        pasteObj.basePrice = !isNaN(parseFloat(pasteObj.basePrice)) && (pasteObj.basePrice && typeof pasteObj.basePrice !== 'undefined') ? that.round(parseFloat(pasteObj.basePrice), 2) :
            me.currentCache[rowIdx].basePrice;
        if(pasteObj.basePrice !== me.currentCache[rowIdx].basePrice){
            reCalBasePrc = true;
            tempObj.basePrice = pasteObj.basePrice;
            let updateGljs = me.getUpdateGljs(tempObj, false);
            if(updateGljs.updateArr.length > 0 || updateGljs.updateBasePrcArr.length > 0){
                for(let i = 0; i < updateGljs.updateArr.length; i++){
                    rst.updateGlj.push(updateGljs.updateArr[i]);
                }
                for(let i = 0; i < updateGljs.updateBasePrcArr.length; i++){
                    rst.updateBasePrcArr.push(updateGljs.updateBasePrcArr[i]);
                }
            }
        }
        if(isValid){
            rst.updateGlj.push(tempObj);
            if(reCalBasePrc){
                //重新计算定额基价对象
                //rst.updateBasePrc = {gljId: tempObj.ID, gljType: tempObj.gljType, basePrice: tempObj.basePrice};
                let newReObj = {gljId: tempObj.ID, gljType: tempObj.gljType, basePrice: tempObj.basePrice};
                rst.updateBasePrcArr.push(newReObj);
            }
        }
        else {
            for(let attr in backUpObj){
                tempObj[attr] = backUpObj[attr];
            }
        }
        return rst;
    },
    //粘贴的数据是否是可添加的数据,只有含有编号，名称，类型才可添加
    isValidObj: function(pasteObj) {
        let me = repositoryGljObj;
        if(!(pasteObj.code && typeof pasteObj.code !== 'undefined') || !(pasteObj.name && typeof pasteObj.name !== 'undefined') ||
            !(pasteObj.gljType && typeof pasteObj.gljType !== 'undefined')){
            return false;
        }
        if(pasteObj.gljType && typeof pasteObj.gljType !== 'undefined'){
            let isExist = false;
            for(let i = 0; i < me.distTypeTree.comboDatas.length; i++){
                if(me.distTypeTree.comboDatas[i].text === pasteObj.gljType){
                    isExist = true;
                    pasteObj.gljType = me.distTypeTree.comboDatas[i].value;
                    pasteObj.shortName = me.distTypeTree.distTypes[me.distTypeTree.prefix + pasteObj.gljType].data.shortName;
                    break;
                }
            }
            if(!isExist){
                return false;
            }
        }
        if(pasteObj.code && typeof pasteObj.code !== 'undefined'){
            for(let i = 0; i < me.stdGljList.length; i++){
                if(me.stdGljList[i].code === pasteObj.code){
                    return false;
                }
            }
            for(let i = 0; i < me.complementaryGljList.length; i++){
                if(me.complementaryGljList[i].code === pasteObj.code){
                    return false;
                }
            }

        }
        pasteObj.basePrice = !isNaN(parseFloat(pasteObj.basePrice)) && (pasteObj.basePrice && typeof pasteObj.basePrice !== 'undefined') ? parseFloat(pasteObj.basePrice) : 0;
        pasteObj.gljClass = me.gljCurTypeId;
        return true;
    },
    onClipboardPasting: function(sender, args) {
        let me = repositoryGljObj;
        let maxCol = args.cellRange.col + args.cellRange.colCount - 1;
        //复制的列数超过正确的列数，不可复制
        if (me.gljCurTypeId < 0 || maxCol >= me.setting.header.length -1) {
            args.cancel = true;
        }
    },
    onClipboardPasted: function(e, info) {
        if(info.pasteData.text.trim().length > 0){
            let me = repositoryGljObj;
            let updateArr = [], addArr = [];
            let items = sheetOpr.analyzePasteData(me.setting, info);
            let beginRow = info.cellRange.row, endRow = info.cellRange.row + info.cellRange.rowCount - 1,//复制的起始行数和结束行数
                maxRow = me.currentCache.length - 1,//当前数据最大行数
                updateBasePrcArr = [] ,
                updateCount, resumeArr = [];
            if(endRow <= maxRow){
                //updateItems = items;
                for(let i = 0; i < items.length; i++){
                    let updateObj = me.validUpdateObj(items[i], info.cellRange.row + i);
                    if(updateObj && typeof updateObj.updateGlj !== 'undefined'){
                        updateArr = updateObj.updateGlj;
                        /*if(typeof updateObj.updateBasePrcArr !== 'undefined'){
                         updateBasePrcArr = updateObj.updateBasePrcArr;
                         }*/
                    }
                    else{
                        resumeArr.push(info.cellRange.row + i);
                    }
                }
            }
            else if(beginRow <= maxRow && endRow > maxRow){
                updateCount = maxRow - beginRow + 1;
                for(let i = 0; i < updateCount; i++){
                    let updateObj = me.validUpdateObj(items[i], info.cellRange.row + i);
                    if(updateObj && typeof updateObj.updateGlj !== 'undefined'){
                        updateArr = updateObj.updateGlj;
                        /* if(typeof updateObj.updateBasePrcArr !== 'undefined'){
                         updateBasePrcArr = updateObj.updateBasePrcArr;
                         }*/
                    }
                    else{
                        resumeArr.push(info.cellRange.row + i);
                    }
                }
                if(info.cellRange.colCount === me.setting.header.length -1){
                    for(let i = updateCount ; i < items.length; i++){
                        if(me.isValidObj(items[i])){
                            items[i].component = [];
                            //类型为混凝土、砂浆、配合比、机械时，基价只能组成物计算
                            if(me.allowComponent.indexOf(items[i].gljType) !== -1){
                                items[i].basePrice = 0;
                            }
                            addArr.push(items[i]);
                        }
                        else{
                            resumeArr.push(info.cellRange.row + i);
                        }
                    }
                }
                else{
                    for(let i = updateCount ; i < items.length; i++){
                        resumeArr.push(info.cellRange.row + i);
                    }
                }
            }
            else{
                if(info.cellRange.colCount === me.setting.header.length -1){
                    for(let i = 0; i < items.length; i++){
                        if(me.isValidObj(items[i])){
                            items[i].component = [];
                            if(me.allowComponent.indexOf(items[i].gljType) !== -1){
                                items[i].basePrice = 0;
                            }
                            addArr.push(items[i]);
                        }
                        else{
                            resumeArr.push(info.cellRange.row + i);
                        }
                    }
                }
                else{
                    for(let i = 0; i < items.length; i++){
                        resumeArr.push(info.cellRange.row + i);
                    }
                }
            }
            //repaint
            if(resumeArr.length > 0){
                let sheet = me.workBook.getActiveSheet();
                sheet.suspendPaint();
                for(let i = 0; i < resumeArr.length ; i++){
                    if(resumeArr[i] < me.currentCache.length){
                        for(let col = 0; col < me.setting.header.length -1; col++){
                            if(me.setting.header[col].dataCode === 'gljType'){
                                let gljType = me.currentCache[resumeArr[i]][me.setting.header[col].dataCode];
                                sheet.setValue(resumeArr[i], col, me.distTypeTree.distTypes["gljType" + gljType].data.fullName);
                            }
                            else{
                                sheet.setValue(resumeArr[i], col, me.currentCache[resumeArr[i]][me.setting.header[col].dataCode]);
                            }
                        }
                    }
                    else{
                        for(let col = 0; col < me.setting.header.length - 1; col++){
                            sheet.setValue(resumeArr[i], col, '', GC.Spread.Sheets.SheetArea.viewport);
                        }
                    }
                }
                sheet.resumePaint();
            }
            if (updateArr.length > 0 || addArr.length > 0) {
                me.mixUpdateRequest(updateArr, addArr, []);
            }
            /*if(updateBasePrcArr.length > 0 && me.rationLibs.length > 0){
             me.updateRationBasePrcRq(updateBasePrcArr);
             }*/
        }
        else{//解决bug: 从原本的sheet复制一行数据，会两次调用粘贴事件函数..,todo:找出原因
            for(let i = 0, len = info.cellRange.rowCount; i < len; i++){
                for(let col = 0; col < 6; col++){
                    info.sheet.setValue(info.cellRange.row + i, col, '');
                }
            }
        }
    },
    updateRationBasePrcRq: function (basePrcArr) {
        $.ajax({
            type: 'post',
            url: 'complementartGlj/api/updateRationBasePrc',
            data:{basePrcArr: JSON.stringify(basePrcArr)},
            dataType: 'json',
            success: function (result) {
                if(result.error){
                    alert("计算定额基价失败");
                }
            }
        });
    },
  /*  getRationGljIds: function (repId) {
        let me = repositoryGljObj;
        $.ajax({
            type: 'post',
            url: 'api/getRationGljIds',
            data: {data: JSON.stringify({repId: repId})},
            dataType: 'json',
            success: function(result){
                if(!result.error){
                    me.rationGljIds = result.data;
                }
            }
        });
    },*/
    mixUpdateRequest: function(updateArr, addArr, removeIds) {
        let me = repositoryGljObj;
        $.ajax({
            type:"POST",
            url:"complementartGlj/api/mixUpdateGljItems",
            data:{userId: pageOprObj.userId, compilationId: pageOprObj.compilationId, updateItems: JSON.stringify(updateArr), addItems: JSON.stringify(addArr), removeIds: JSON.stringify(removeIds)},
            dataType:"json",
            cache:false,
            timeout:5000,
            success:function(result){
                if (result.error) {
                    alert(result.message);
                    me.getRationItems(me.currentRepositoryId);
                } else {
                    me.updateCache(addArr, updateArr, removeIds, result);
                    me.sortGlj(me.complementaryGljList);
                    if(me.currentOprParent === 1){
                        me.currentCache = me.getParentCache(me.parentNodeIds["_pNodeId_" + me.gljCurTypeId]);
                    }
                    else{
                        me.currentCache = me.getCache();
                        //sheetOpr.unLockAllCells(me.workBook.getSheet(0));
                        sheetOpr.reLockSomeCodes(me.workBook.getSheet(0), 0, me.currentCache.length);
                        //sheetOpr.lockSomeCodes(me.workBook.getSheet(0), 0, me.currentCache.length);
                    }
                    me.showGljItems(me.complementaryGljList, me.gljCurTypeId);
                }
            },
            error:function(err){
                alert("保存失败");
            }
        })
    },
    getParentCache: function (nodes) {
        let me = repositoryGljObj, rst = [];
        for(let i = 0; i < me.complementaryGljList.length; i++){
            if(nodes.indexOf(me.complementaryGljList[i].gljClass) !== -1){
                rst.push(me.complementaryGljList[i]);
            }
        }
        rst.sort(function (a, b) {
            let rst = 0;
            if(a.code > b.code) rst = 1;
            else if(a.code < b.code)rst = -1;
            return rst;
        });
        return rst;
    },
    getCache: function() {
        let me = this, rst = [];
        for (let i = 0; i < me.complementaryGljList.length; i++) {
            if (me.complementaryGljList[i].gljClass == me.gljCurTypeId) {
                rst.push(me.complementaryGljList[i]);
            }
        }
        return rst;
    },
    updateCache: function(addArr, updateArr, removeIds, result) {
        let me = this, cacheSection = me.complementaryGljList;
        if (addArr.length > 0) {
            me.complementaryGljList = me.complementaryGljList.concat(addArr);
            cacheSection = me.complementaryGljList;
        }
        for (let i = removeIds.length - 1; i >= 0; i--) {
            for (let j = cacheSection.length - 1; j >= 0 ; j--) {
                if (cacheSection[j]["ID"] == removeIds[i]) {
                    cacheSection.splice(j,1);
                }
            }
        }
        if (result && result.data && result.data.ops && result.data.ops.length > 0) {
            for (let i = 0; i < result.data.ops.length; i++) {
                for (let j = 0; j < cacheSection.length; j++) {
                    if (cacheSection[j][me.setting.header[0].dataCode] == result.data.ops[i][me.setting.header[0].dataCode]) {
                        cacheSection[j]["ID"] = result.data.ops[i]["ID"];
                    }
                }
            }
        }
        for (let i = 0; i < updateArr.length; i++) {
            for (let j = 0; j < cacheSection.length; j++) {
                if (updateArr[i]["ID"] && cacheSection[j]["ID"]) {
                    if (cacheSection[j]["ID"] == updateArr[i]["ID"]) {
                        cacheSection[j] = updateArr[i];
                    }
                } else {
                    if (cacheSection[j][me.setting.header[0].dataCode] == updateArr[i][me.setting.header[0].dataCode]) {
                        cacheSection[j] = updateArr[i];
                    }
                }
            }
        }
        //allgljs
    },
    sortGlj: function(gljList) {
        let me = this;
        gljList.sort(function(a, b){
            let rst = 0;
            if (a.code > b.code) rst = 1
            else if (a.code < b.code) rst = -1;
            return rst;
        });
    }
}

let gljTypeTreeOprObj = {
    onClick: function(event,treeId,treeNode) {
        let me = repositoryGljObj,
            that = gljComponentOprObj,
            gljTypeId = treeNode.ID;
        me.gljCurTypeId = treeNode.ID;
        that.isLocked = true;
        //消除新增到一半的数据
        me.addGljObj = null;
        //me.currentCache = me.getCache();
        sheetOpr.cleanSheet(that.workBook.getSheet(0), that.setting, 5);
        that.workBook.getSheet(0).getRange(-1, 0 , -1, 1, GC.Spread.Sheets.SheetArea.viewport).locked(true);
        that.workBook.getSheet(0).getRange(-1, 4 , -1, 1, GC.Spread.Sheets.SheetArea.viewport).locked(true);
        me.workBook.getSheet(0).getRange(-1, 6 , -1, 1, GC.Spread.Sheets.SheetArea.viewport).locked(true);
        //that.workBook.getSheet(0).options.isProtected = true;
        if (me.parentNodeIds["_pNodeId_" + treeNode.ID]) {
            me.currentOprParent = 1;
            me.currentCache = me.getParentCache(me.parentNodeIds["_pNodeId_" + treeNode.ID]);
            sheetOpr.lockCodeCells(me.workBook.getSheet(0), me.currentCache.length);
            me.workBook.getSheet(0).setRowCount(me.currentCache.length);
        } else {
            me.currentOprParent = 0;
            me.currentCache = me.getCache();
            sheetOpr.unLockAllCells(me.workBook.getSheet(0));
            sheetOpr.reLockSomeCodes(me.workBook.getSheet(0), 0, me.currentCache.length);
        }
        me.showGljItems(me.complementaryGljList, gljTypeId);
    }
}
