/**
 * Created by Mai on 2017/4/1.
 */
var PROJECT = {
    createNew: function (projectID, userID) {
        // 定义private方法
        var tools = {
            _project: null,
            _ID: parseInt(projectID),
            _userID: userID,
            updateLock: 0,
            updateData: [],
            operation: '',
            modules: {},
            projCounter: 'projCounter',
            projSetting: 'proj_setting'
        };

        var me = tools;
        tools.doAfterUpdate = function(result){
            if (!result) { return }
            result.forEach(function(item){
                if(_.isArray(item)){
                    item.forEach(function (e) {
                        me.eachItem(e);
                    })
                }else {
                    me.eachItem(item)
                }
            });

        };
        tools.doAfterLoad = function(result, callback){
            var counter;
            //必须要先load ProjectInfo的信息
            let projectInfoModule = result.find(data => data.moduleName === ModuleNames.projectInfo);
            if (projectInfoModule) {
                me._project.projectInfo = projectInfoModule.data;
            }
            result.forEach(function(item){
                if (item.moduleName !== ModuleNames.projectInfo) {
                    if (me.modules[item.moduleName]){
                        me.modules[item.moduleName].loadData(item.data);
                    } else if (item.moduleName === me.projCounter) {
                        counter = item.data;
                    } else if (item.moduleName === me.projSetting) {
                        me._project.projSetting = item.data;
                        me._project.projSetting.moduleName = me.projSetting;
                    } else if(item.moduleName === ModuleNames.projectGLJ){
                        me._project.projectGLJ.loadToCache(item.data);
                    }
                }
            });
            for (module in counter) {
                if (me.modules[module]) {
                    me.modules[module].setMaxID(counter[module]);
                }
            }

            me._project.loadMainTree();
            //me.test(result[0].data[0]);
            callback(0);
        };
        tools.eachItem=function(item){
            if (me.modules[item.moduleName]){
                me.modules[item.moduleName].doAfterUpdate(item.err, item.data);
            }
        };

        /*tools.test = function(data){
            me._project.beginUpdate('修改名称');
            data.name = 'test';
            data['updateType'] = 'ut_update';
            me._project.push(ModuleNames.bills, [data]);
            me._project.endUpdate();
        };*/

        // 所有通过this访问的属性，都不应在此单元外部进行写入操作
        var project = function () {
            tools._project = this;
            this.mainTree = cacheTree.createNew(this);

            this.Bills = Bills.createNew(this);
            this.Ration = Ration.createNew(this);
            this.GLJ = GLJ.createNew(this);
            this.ration_glj = ration_glj.createNew(this);
            this.ration_coe = ration_coe.createNew(this);
            this.ration_ass = ration_ass.createNew(this);
            this.ration_installation = ration_installation.createNew(this);
            this.ration_template = ration_template.createNew(this);
            this.quantity_detail = quantity_detail.createNew(this);
            this.installation_fee = installation_fee.createNew(this);
            this.FeeRate = FeeRate.createNew(this);
            // this.VolumePrice = VolumePrice.createNew(this);
            this.projectGLJ = new ProjectGLJ();
           // this.projectGLJ.loadData();
            this.composition = new Composition();
            this.composition.loadData();
            this.labourCoe = new LabourCoe(this);
            this.calcProgram = new CalcProgram(this);
            this.calcBase = calcBase;

            // this.masterField = {ration: 'billsItemID', volumePrice: 'billsItemID'};
            this.masterField = {ration: 'billsItemID'};
        };

        // prototype用于定义public方法
        project.prototype.modify = function (modifyDatas, callback) {
            // To Do
        };

        // prototype用于定义public方法
        project.prototype.ID = function () {
            return tools._ID;
        };

        project.prototype.projCounter = function () {
            return tools.projCounter;
        };
        project.prototype.getDecimal = function (fullName) {
            let names = fullName.split('.'), decimal = this.Decimal;
            for (let name of names) {
                if (decimal[name]) {
                    decimal = decimal[name];
                } else {
                    return null;
                }
            }
            if (Object.prototype.toString.apply(decimal) === '[object Number]') {
                return decimal;
            } else {
                return null;
            }
        };

        project.prototype.loadMainTree = function () {
            var that = this;
            let loadRationGLJNode = function (cacheNode) {
                var newNode, bj = that.ration_glj.getMainAndEquGLJ(cacheNode.source.ID), i;
                for(i=0;i<bj.length;i++){
                    that.ration_glj.transferToNodeData(bj[i]);
                    newNode = that.mainTree.addNode(cacheNode, null, bj[i].ID);
                    newNode.source = bj[i];
                    newNode.sourceType = that.ration_glj.getSourceType();
                    newNode.data = bj[i];
                }
            };

            var loadRationNode = function (rations, cacheNode) {
                var newNode, br = that.Ration.getBillsSortRation(cacheNode.source.getID()), i;
                for (i = 0; i < br.length; i++) {
                    newNode = that.mainTree.addNode(cacheNode, null, br[i].ID);
                    if(br[i].type==rationType.gljRation){
                        br[i]=  that.ration_glj.combineRationAndGLJ(br[i]);
                    }
                    newNode.source = br[i];
                    newNode.sourceType = that.Ration.getSourceType();
                    newNode.data = br[i];
                    if(projectObj.project.projectInfo.property.displaySetting !== undefined &&
                        projectObj.project.projectInfo.property.displaySetting.disPlayMainMaterial==true){
                        loadRationGLJNode(newNode);
                    }
                }
            };
/*            let loadVolumePriceNode = function (cacheNode) {
                let newNode = null, bv = that.VolumePrice.getBillsSortVolumePrice(cacheNode.source.getID());
                for (let v of bv) {
                    newNode = that.mainTree.addNode(cacheNode);
                    newNode.source = v;
                    newNode.sourceType = that.VolumePrice.getSourceType();
                    newNode.data = v;
                }
            };*/

            var loadIdTreeNode = function (nodes, parent) {
                var newNode, i;
                for (i = 0; i < nodes.length; i++) {
                    newNode = that.mainTree.addNode(parent, null, nodes[i].data.ID);
                    newNode.source = nodes[i];
                    newNode.sourceType = that.Bills.getSourceType();
                    newNode.data = nodes[i].data;
                    that.FeeRate.loadFeeRateToBill(newNode);
                    if (nodes[i].children.length === 0) {
                        loadRationNode(that.Ration.datas, newNode);
                        // loadVolumePriceNode(newNode);
                    } else {
                        loadIdTreeNode(nodes[i].children, newNode);
                    }
                }
            };
            loadIdTreeNode(this.Bills.tree.roots, null);
            this.mainTree.sortTreeItems();
            this.mainTree.selected = this.mainTree.firstNode();
        };

        project.prototype.getParentTarget = function (node, targetField, targetValue) {
            var parent = node;
            while (parent && parent[targetField] !== targetValue) {
                parent = parent.parent;
            }
            return parent;
        };

        // 提供给各模块调用的统一从后台获取数据的方法
        /*project.prototype.pullData = function (url, data, successCallback, errorCallback) {
            $.ajax({
                type:"POST",
                url: url,
                data: {'data': JSON.stringify(data)},
                dataType: 'json',
                cache: false,
                timeout: 50000,
                success: function(result){
                    successCallback(result);
                },
                error: function(jqXHR, textStatus, errorThrown){
                    alert('error ' + textStatus + " " + errorThrown);
                    errorCallback();
                }
            });
        };*/

        // 所有模块在此从后台获取数据
        project.prototype.loadDatas = function (callback){
            $.ajax({
                type: "POST",
                url: '/project/getData',
                data: {'data': JSON.stringify({
                    "project_id": tools._ID,
                    "user_id": tools._userID
                })},
                dataType: 'json',
                cache: false,
                timeout: 50000,
                success: function (result) {
                    if (!result.error) {
                        tools.doAfterLoad(result.data, callback);
                        // for test calc
                        //tools.doAfterLoad([{moduleName: 'bills', data: BillsData}, {'moduleName': 'ration', data: DrawingData}], callback);
                    } else {
                        alert('error: ' + result.message);
                        callback(result.error);
                    }
                },
                error: function(jqXHR, textStatus, errorThrown){
                    alert('error ' + textStatus + " " + errorThrown);
                }
            });
        };

        project.prototype.beginUpdate = function(operation){
            if (tools.updateLock === 0){
                tools.operation = operation
            }
            tools.updateLock += 1;
        };

        project.prototype.endUpdate = function(){
            if (tools.updateLock === 0){
                throw "project can not endUpdate before beginUpdate";
            }
            tools.updateLock -= 1;
            if (tools.updateLock === 0) {
                $.ajax({
                    type: "POST",
                    url: '/project/save',
                    data: {'data': JSON.stringify({
                        "project_id": tools._ID,
                        "user_id": tools._userID,
                        "date": new Date,
                        "operation": tools.operation,
                        "update_data": tools.updateData
                    })},
                    dataType: 'json',
                    cache: false,
                    timeout: 50000,
                    success: function (result) {
                        if (!result.error) {
                            tools.doAfterUpdate(result.data);
                        } else {
                            alert('error: ' + result.message);
                        }
                        $.bootstrapLoading.end();
                    },
                    error: function(jqXHR, textStatus, errorThrown){
                        alert('error ' + textStatus + " " + errorThrown);
                        $.bootstrapLoading.end();
                    }
                });
                tools.updateData = [];
                tools.operation = "";
            }
        };

        project.prototype.push = function(moduleName, data){
            if (tools.updateLock === 0){
                throw "project can not push data before beginUpdate";
            }
            var moduleData = {
                moduleName: moduleName,
                data: data
            };
            tools.updateData.push(moduleData);
        };

        project.prototype.pushNow = function (operation, moduleName, data) {
            var that = this;
            this.beginUpdate(operation);
            if (Object.prototype.toString.apply(moduleName) === "[object Array]" && Object.prototype.toString.apply(data) === "[object Array]") {
                moduleName.forEach(function (name, index) {
                    if(name != 'projCounter'){
                        that.push(moduleName[index], data[index]);
                    }
                });
            } else {
                this.push(moduleName, data);
            }
            this.endUpdate();
        };
        project.prototype.registerModule = function(moduleName, obj){
            if (!tools.modules.hasOwnProperty(moduleName)){
                tools.modules[moduleName] = obj;
            }
        };
        project.prototype.markUpdateProject = function (data,type,callback) {
            CommonAjax.post("/project/markUpdateProject",{updateInfo:data,type:type},callback);
        };

        project.prototype.saveProperty = function (propertyName, propertyValue) {
            CommonAjax.post("/project/saveProperty", {projectID: this.ID(), propertyName: propertyName, propertyValue: propertyValue});
        };

        project.prototype.projectMarkChecking = function () {
            let me = this;
            let  changeMark = projectObj.project.projectInfo.changeMark;
            if(changeMark&&changeMark!=''){
                let totalNode = this.Bills.getTotalCostNode(projectObj.mainController);
                if(totalNode) totalNode.changed = true;
                this.calcProgram.calcAllNodesAndSave();
                CommonAjax.post("/project/removeProjectMark",{projectID:me.ID()},function (data) {
                    delete projectObj.project.projectInfo.changeMark;
                    if(socket.connected == true){//如果这时候socket已经连接成功，则发送删除标记广播
                        socket.emit('removeProjectMark',{projectID:me.ID(),userID:userID});
                    }else {//如果还没连接成功，则放入消息对象缓存，等socket连接成功后发送
                        socketObject.messages.push({message:'removeProjectMark',data:{projectID:me.ID(),userID:userID}});
                    }
                });
            }
        };
        project.prototype.updateLockBills = function (value,callback) {
            let mixDatas = {
                projectID: projectObj.project.ID(),
                updateType: 'update',
                properties: {
                    "property.lockBills":value
                },
                labourCoes: {},
                rations: [],
                bills: []
            };
            $.bootstrapLoading.start();
            CommonAjax.post('/pm/api/updateMixDatas', {user_id: userID, mixDataArr: mixDatas}, function (rstData) {
                projectObj.project.projectInfo.property.lockBills = value;
                if(callback){
                    callback();
                }
                $.bootstrapLoading.end();
            });
        };
        //返回清单是否被锁定
        project.prototype.isBillsLocked =function(){
            if(projectObj.project.projectInfo.property.lockBills == true){
                return true;
            }
            return false;
        };
        // 清单是否属于锁定范围(所有清单)
        project.prototype.withinBillsLocked = function (node) {
            return node && node.sourceType === commonConstants.SourceType.BILLS;
        };
        project.prototype.updateNodes = function (datas,callback) {
          /*  let datas = [
                {
                    type:'ration',
                    data:{
                        projectID:1605,
                        ID:"7b962fb0-1131-11e8-b3da-af725dadd7ae",
                        name:'testRation'
                    }
                },
                {
                    type:'bills',
                    data:{
                        projectID:1605,
                        ID:"af9f0081-1127-11e8-99a8-2fc02230b6e7",
                        name:'安全文明施工专项费用123'
                    }
                }
            ]*/
            CommonAjax.post("/project/updateNodes",datas,function (data) {
                if(callback){
                    callback(data);
                }
            })
        };

        project.prototype.updateNodesCache =function (datas) {
            let refreshNode = [];
            for(let d of datas){
                let temObj = null;
                if(d.type == ModuleNames.bills || d.type == ModuleNames.ration){//如果是树节点类型，直接取树节点更新
                    let temNode = this.mainTree.getNodeByID(d.data.ID);
                    if(temNode){
                        temObj = temNode.data;
                        refreshNode.push(temNode);
                    }
                }else {//其它类型，更新datas
                    temObj = _.find(this[d.type].datas,{"ID":d.data.ID});
                }
                if(temObj){
                    for(let key in d.data){
                        if(key == 'ID' || key == 'id'){
                            continue;
                        }
                        this.setValue(temObj,key,d.data[key])
                    }
                }
            }
            return refreshNode;
        };
        project.prototype.setValue=function (obj,key,value) {
            let keyArray = key.split('.');
            t_set(obj,value,keyArray,0);
            function t_set(obj,value,arr,index) {
                let nextIndex = index + 1;
                let tkey = arr[index];
                if(nextIndex < arr.length){
                    if(obj[tkey]==undefined){
                        obj[tkey] = {};
                    }
                    t_set(obj[tkey],value,arr,nextIndex)
                }else if(nextIndex == arr.length){
                    obj[tkey] = value;
                }
            }

        }
        project.prototype.updateEvalproject = function (evalProject,data,callback){
            let programID = null;
            if(evalProject ==1){//当打勾估价项目选项后，该定额取费专业读取计算程序名称为“估价项目”的计算程序，且为只读状态
                programID =  this.calcProgram.compiledTemplateMaps["估价项目"];
                if(callback) callback(programID);
            }else {//如果evalProject==0，则是去掉勾选估价项目选项，需要获取定额默认的取费专业。
                let libID = data.from == 'cpt'?"compleRationLib":data.libID;
                let query = {code:data.code,projectID:data.projectID,libID:libID};
                CommonAjax.post("/ration/getDefaultProgramID",query,function (result) {
                    if(callback) callback(result);
                })
            }
        };

        //判断项目是否安装工程
        project.prototype.isInstall = function () {
            return projectObj.project.projectInfo.property.isInstall?true:false;//如果是undefinded 就也返回false
        };

        /*        project.prototype.setBillsCalcMode = function (calcMode) {
                    this.property.billsCalcMode = calcMode;
                    this.initCalcFields();
                };*/

        /*project.prototype.initCalcFields = function () {
            // let settingConst = this.projSetting.settingConst;
            if (this.calcFields) {
                for (let field of this.calcFields) {
                    // unitFeeCalcFlag
                    if (field.type === 'zangu') {
                        field.unitFeeFlag = converseUnitFeeFlag;
                    } else {   
                        // if (this.projSetting.billsCalcMode === settingConst.billsCalcMode.rationContent) {
                        if (this.property.billsCalcMode === leafBillGetFeeType.rationContent) {
                            field.unitFeeFlag = rationContentUnitFeeFlag;
                        // } else if ( this.projSetting.billsCalcMode === settingConst.billsCalcMode.billsPrice) {
                        } else if ( this.property.billsCalcMode === leafBillGetFeeType.billsPrice) {
                            field.unitFeeFlag = billsPriceUnitFeeFlag;
                        } else {
                            field.unitFeeFlag = averageQtyUnitFeeFlag;
                        }
                    }
                    // totalFeeCalcFlag
                    if (field.type === 'common') {
                        // if (this.projSetting.billsCalcMode === settingConst.billsCalcMode.rationPriceConverse) {
                        if (this.property.billsCalcMode === leafBillGetFeeType.rationPriceConverse) {
                            field.totalFeeFlag = sumTotalFeeFlag;
                        } else {
                            field.totalFeeFlag = totalFeeFlag;
                        }
                    } else {
                        field.totalFeeFlag = sumTotalFeeFlag;
                    }
                }
            }
        }*/

        return new project();
    }
};
