/* 建设其他费表格相关 */
const budgetSummaryObj = (() => {

  const { isEmptyVal, isDef, isNumber } = window.commonUtil;
  const { fixedFlag, BudgetArea } = window.commonConstants;

  // 原始数据
  let rawData = [];
  // ID与原始数据映射表（主要是恢复用）
  const orgMap = {};
  // 建设其他费表格对象
  let spread = null;
  // 建设其他费树
  let tree = null;
  // 计算相关
  const calcSetting = {
    costGrowthRate: 0,
    growthPeriod: 0,
  };

  // 单位设置下拉框
  const setUnitCombo = (sheet, data) => {
    const unitCol = budgetSummaryTreeSetting.cols.findIndex(item => item.data.field === 'unit');
    if (unitCol >= 0) {
      TREE_SHEET_HELPER.massOperationSheet(sheet, () => {
        const comboBox = sheetCommonObj.getDynamicCombo();
        comboBox
          .itemHeight(10)
          .items(['m', 'm2', 'm3', 'km', 't', 'kg', '台班', '工日', '昼夜', '元', '项', '处', '个', '件',
            '根', '组', '系统', '台', '套', '株', '丛', '缸', '支', '只', '块', '座', '对', '份', '樘', '攒', '榀'])
          .editable(true);
        data.forEach((item, index) => {
          sheet.getCell(index, unitCol).cellType(comboBox);
        })
      });
    }
  }

  const getFieldByCol = (col) => {
    const item = budgetSummaryTreeSetting.cols[col];
    return item && item.data && item.data.field || null;
  }

  // 单元格值验证器
  const validator = {
    text() {
      return true
    },
    number(val) {
      return !isDef(val) || isNumber(val);
    },
  };
  const getValidator = (col) => {
    const item = budgetSummaryTreeSetting.cols[col];
    if (!item) {
      return 'text';
    }
    return validator[item.data.type || 'text'];
  }

  // 单元格文本转换处理
  const textFactory = {
    calcBase(node) {
      if (node.data.calcBase && node.data.calcBase !== "") {
        return cbParser.toFExpr(node.data.calcBase);
      }
    },
    'feesIndex.common.unitFee': (node) => {
      return _.get(node, 'data.feesIndex.common.unitFee', '') || '';
    },
    'feesIndex.common.totalFee': (node) => {
      return _.get(node, 'data.feesIndex.common.totalFee', '') || '';
    },
    'feesIndex.building.totalFee': (node) => {
      return _.get(node, 'data.feesIndex.building.totalFee', '') || '';
    },
    'feesIndex.installation.totalFee': (node) => {
      return _.get(node, 'data.feesIndex.installation.totalFee', '') || '';
    },
    'feesIndex.equipment.totalFee': (node) => {
      return _.get(node, 'data.feesIndex.equipment.totalFee', '') || '';
    },
    'feesIndex.other.totalFee': (node) => {
      return _.get(node, 'data.feesIndex.other.totalFee', '') || '';
    },
  };

  /* 表格事件相关 */
  // 根据节点数据刷新表格数据
  const refreshData = (sheet, changedCells) => {
    if (!tree) {
      return;
    }
    TREE_SHEET_HELPER.massOperationSheet(sheet, () => {
      changedCells.forEach(({ row, col }) => {
        const node = tree.items[row];
        const field = getFieldByCol(col);
        if (!field || !node) {
          return;
        }
        const textFunc = textFactory[field];
        const val = textFunc ? textFunc(node) : node.data[field];
        sheet.setValue(row, col, val);
      });
    });
  }

  // 刷新整个表格
  const refreshAll = (sheet) => {
    const changedCells = [];
    const colCount = budgetSummaryTreeSetting.cols.length;
    for (let row = 0; row < tree.items.length; row++) {
      for (let col = 0; col < colCount; col++) {
        changedCells.push({ row, col })
      }
    }
    refreshData(sheet, changedCells);
  }

  // 更新数据
  const bulkOperation = async (bulkData) => {
    if (bulkData.length) {
      await ajaxPost('/bills/bulkOperation', { bulkData });
    }
  };

  // 编辑相关
  const edit = async (sheet, changedCells, calcNodes = null) => {
    if (!changedCells.length && !calcNodes) {
      return;
    }
    if (changedCells.length) {
      // 单元格值验证
      const isValid = changedCells.every(({ row, col }) => {
        const val = sheet.getValue(row, col);
        return getValidator(col)(val);
      });
      // 验证不通过，恢复
      if (!isValid) {
        refreshData(sheet, changedCells);
      }
    }
    let needCalc = false;
    const nodes = [];
    try {
      $.bootstrapLoading.start();
      const IDMap = {};
      const bulkData = [];
      changedCells.forEach(({ row, col }) => {
        const node = tree.items[row];
        if (!node) {
          return;
        }
        if (!nodes.find(n => n.data.ID !== node.data.ID)) {
          nodes.push(node);
        }
        const field = getFieldByCol(col);
        const value = sheet.getValue(row, col) || '';
        const data = (IDMap[node.data.ID] || (IDMap[node.data.ID] = {}));
        if (['feesIndex.common.unitFee'].includes(field)) {
          const fees = node.data.fees || [];
          const feeItem = fees.find(item => item.fieldName === 'common');
          if (feeItem) {
            feeItem.unitFee = value;
          } else {
            fees.push({ fieldName: 'common', totalFee: 0, unitFee: +value });
          }
          data[field] = fees;
          node.data[field] = fees;
          node.data.feesIndex = getFeeIndex(node.data.fees);
        } else {
          data[field] = value;
          node.data[field] = value;
        }
        if (field === 'calcBase') {
          node.data.userCalcBase = value;
          projectObj.project.calcBase.calculate(node, null, false);
          if (!projectObj.project.calcBase.success) {
            throw projectObj.project.calcBase.errMsg;
          } else if (isEmptyVal(value)) {
            // 删除清单基数，单价要清空
            calcTools.setFieldValue(node, 'feesIndex.common.unitFee', 0);
          }
          data.calcBase = node.data.calcBase;
          data.calcBaseValue = node.data.calcBaseValue;
          data.tenderCalcBaseValue = node.data.tenderCalcBaseValue;
        }
        if (['quantity', 'feesIndex.common.unitFee', 'calcBase', 'feeRate'].includes(field)) {
          needCalc = true;
        }
      });
      calcNodes = calcNodes ? calcNodes : nodes;
      // 重算节点
      const dataArr = [];
      if ((needCalc && nodes.length) || (calcNodes && calcNodes.length)) {
        const changedNodes = projectObj.project.calcProgram.calcNodes(calcNodes, false, tree);
        for (const node of changedNodes) {
          nodes.push(node);
          if (node.changed) {
            const data = calcTools.cutNodeForSave(node);
            dataArr.push(data);
          }
        }
      }
      dataArr.forEach(item => {
        delete item.projectID;
        const data = IDMap[item.ID];
        if (data) {
          Object.assign(data, item);
        } else {
          IDMap[item.ID] = item;
        }
      });
      // 保存节点
      Object
        .entries(IDMap)
        .forEach(([ID, data]) => {
          const node = tree.findNode(ID);
          if (!node) {
            return;
          }
          // 处理其他费用
          if (node.isBelongToFlags([fixedFlag.CONSTRUCTION_OTHER_FEE])) {
            const fees = data.fees || [];
            const commonFeeItem = fees.find(item => item.fieldName === 'common');
            const otherFeeItem = fees.find(item => item.fieldName === 'other');
            if (otherFeeItem) {
              otherFeeItem.totalFee = commonFeeItem && commonFeeItem.totalFee || 0;
            } else {
              fees.push({ fieldName: 'other', totalFee: commonFeeItem && commonFeeItem.totalFee || 0 });
            }
          }
          bulkData.push({ type: 'update', data: { ID, ...data } });
        });
      await bulkOperation(bulkData);
      Object
        .entries(IDMap)
        .forEach(([ID, data]) => {
          const node = tree.findNode(ID);
          if (node) {
            Object.assign(node.data, data);
            node.data.feesIndex = getFeeIndex(node.data.fees);
            orgMap[ID] = _.cloneDeep(node.data);
          }
        });
      refreshAll(sheet);
    } catch (err) {
      console.log(err);
      nodes.forEach(node => {
        const orgItem = orgMap[node.data.ID];
        if (orgItem) {
          Object.assign(node.data, orgItem);
        }
      });
      refreshData(sheet, changedCells);
      alert(err);
    } finally {
      $.bootstrapLoading.end();
    }
  }
  // 是否是属于工程费用区域的节点
  const isConstructionFeeArea = (node) => {
    return node && node.data && node.data.area === BudgetArea.CONSTRUCTION_FEE;
  }
  // 工具栏可操作性
  let upLevelDisabled = false;
  let downLevelDisabled = false;
  let upMoveDisabled = false;
  let downMoveDisabled = false;
  const refreshToolsBar = (node) => {
    upLevelDisabled = !node || !node.canUpLevel() || isConstructionFeeArea(node) || (node.nextSibling && node.data.calcBase);
    downLevelDisabled = !node || !node.canDownLevel() || isConstructionFeeArea(node) || isConstructionFeeArea(node.preSibling) || (node.preSibling && node.preSibling.data.calcBase);
    upMoveDisabled = !node || !node.canUpMove() || isConstructionFeeArea(node) || isConstructionFeeArea(node.preSibling);
    downMoveDisabled = !node || !node.canDownMove() || isConstructionFeeArea(node) || isConstructionFeeArea(node.nextSibling);
    if (upLevelDisabled) {
      $('#budget-upLevel').addClass('disabled');
    } else {
      $('#budget-upLevel').removeClass('disabled');
    }
    if (downLevelDisabled) {
      $('#budget-downLevel').addClass('disabled');
    } else {
      $('#budget-downLevel').removeClass('disabled');
    }
    if (upMoveDisabled) {
      $('#budget-upMove').addClass('disabled');
    } else {
      $('#budget-upMove').removeClass('disabled');
    }
    if (downMoveDisabled) {
      $('#budget-downMove').addClass('disabled');
    } else {
      $('#budget-downMove').removeClass('disabled');
    }
  };
  // 表格选中相关
  const selectCell = (row, col, setCell = false) => {
    const node = tree.items[row];
    refreshToolsBar(node);
    tree.selected = node;
    console.log(node);
    const sheet = spread.getSheet(0);
    if (setCell) {
      sheet.setActiveCell(row, col);
    }
    //设置选中行底色和恢复前选中行底色
    const refreshNodes = [node];
    if (!tree.preSelected) {
      refreshNodes.push(tree.items[0]);
    } else {
      refreshNodes.push(tree.preSelected);
    }
    tree.preSelected = node;
    projectObj.setNodesStyle(sheet, refreshNodes, tree);
  };
  // 事件列表
  const events = {
    EnterCell(sender, args) {
      args.sheet.repaint();
    },
    SelectionChanged(sender, args) {
      const newSel = args.newSelections[0] ? { row: args.newSelections[0].row, col: args.newSelections[0].col } : { row: 0, col: 0 };
      selectCell(newSel.row, newSel.col);
    },
    ValueChanged(sender, args) {
      if (isEmptyVal(args.oldValue) && isEmptyVal(args.newValue)) {
        return;
      }
      edit(args.sheet, [{ row: args.row, col: args.col }]);
    },
    RangeChanged(sender, args) {
      edit(args.sheet, args.changedCells);
    }
  }
  const bindEvents = (sheet) => {
    Object.entries(events).forEach(([ev, evFunc]) => {
      sheet.bind(GC.Spread.Sheets.Events[ev], evFunc);
    });
  }

  /* 只读相关 */
  // 单元格锁定判断
  const lockFactory = {
    code(node) {
      return !!(node && node.getFlag());
    },
    name(node) {
      return !!(node && node.getFlag());
    },
    calcBase(node) {
      return !!(node && node.children.length);
    },
    feeRate(node) {
      return !!(node && node.children.length);
    }
  };
  const lockData = (sheet, nodes, isMass = true) => {
    const lock = () => {
      if (projectReadOnly) {
        sheet.getRange(0, 0, nodes.length, budgetSummaryTreeSetting.cols.length, GC.Spread.Sheets.SheetArea.viewport).locked(true);
        return 0;
      }
      // 工程费用区域，只读
      const equipmentNode = nodes.find(node => node.getFlag() === fixedFlag.CONSTRUCTION_EQUIPMENT_FEE);
      if (!equipmentNode) {
        return 0;
      }
      sheet.getRange(0, 0, equipmentNode.serialNo() + 1, budgetSummaryTreeSetting.cols.length, GC.Spread.Sheets.SheetArea.viewport).locked(true);
      return equipmentNode.serialNo() + 1;
    }
    if (isMass) {
      TREE_SHEET_HELPER.massOperationSheet(sheet, () => {
        return lock();
      });
    } else {
      return lock();
    }
  }

  /* 单元格类型 */
  const calcBaseButtonCallback = (hitInfo) => {
    calcBaseView.onCalcBaseButtonClick(hitInfo, 'budget');
  };
  const cellTypeFactory = {
    calcBase(node) {
      const locked = lockFactory.calcBase(node);
      return sheetCommonObj.getCusButtonCellType(calcBaseButtonCallback, locked);
    }
  }

  /* 设置可编辑区域节点的只读性和单元格类型 */
  const setCells = (sheet, startRow, nodes) => {
    for (let row = startRow; row < nodes.length; row++) {
      const node = nodes[row];
      budgetSummaryTreeSetting.cols.forEach((item, col) => {
        const field = item.data.field;
        // 锁定单元格
        const lockFunc = lockFactory[field];
        if (lockFunc) {
          const isLocked = lockFunc(node);
          sheet.getCell(row, col).locked(isLocked);
        }
        // 设置单元格类型
        const cellTypeFunc = cellTypeFactory[field];
        if (cellTypeFunc) {
          const cellType = cellTypeFunc(node);
          sheet.getCell(row, col).cellType(cellType);
        }
        // 单元格文本转换
        const textFunc = textFactory[field];
        if (textFunc) {
          sheet.setValue(row, col, textFunc(node));
        }
      });
    }
  }
  /* 初始化表格 */
  const initSpread = () => {
    if (!spread) {
      // spread = sheetCommonObj.createSpread($('#budget-summary-sheet')[0], 1);
      spread = SheetDataHelper.createNewSpread($('#budget-summary-sheet')[0]);
      sheetCommonObj.spreadDefaultStyle(spread);
      // 设置表头
      const sheet = spread.getSheet(0);
      bindEvents(sheet);
      const headers = sheetCommonObj.getHeadersFromTreeSetting(budgetSummaryTreeSetting);
      sheetCommonObj.setHeader(sheet, headers);
      // 右键菜单
      initContextMenu();
    } else {
      spread.refresh();
    }
    return spread;
  }

  // 初始化树
  const initTree = (data, sheet, setting) => {
    tree = idTree.createNew({ id: 'ID', pid: 'ParentID', nid: 'NextSiblingID', rootId: -1, autoUpdate: true });
    const controller = TREE_SHEET_CONTROLLER.createNew(tree, sheet, setting, false, true);
    tree.loadDatas(data);
    tree.items.forEach(node => {
      node.source = node;
      node.sourceType = ModuleNames.bills;
    });
    controller.showTreeData();
    sheet.setRowCount(data.length);
    setUnitCombo(sheet, data);
    TREE_SHEET_HELPER.massOperationSheet(sheet, () => {
      const startRow = lockData(sheet, tree.items, false);
      setCells(sheet, startRow, tree.items);
      // 表格格式化
      budgetSummaryTreeSetting.cols.forEach((item, index) => {
        sheet.setFormatter(-1, index, item.formatter || '@', GC.Spread.Sheets.SheetArea.viewport);
      });
    });
    selectCell(sheet.getActiveRowIndex(), sheet.getActiveColumnIndex());
  }

  /* 右键菜单 */
  // 更新树结构数据
  const updateTree = (sheet, updateData) => {
    // 更新数据
    updateData.forEach(item => {
      if (item.type === 'new') {
        orgMap[item.data.ID] = _.cloneDeep(item.data);
        rawData.push(item.data)
      } else if (item.type === 'update') {
        if (orgMap[item.data.ID]) {
          Object.assign(orgMap[item.data.ID], item.data);
        }
        const node = tree.findNode(item.data.ID);
        if (node) {
          Object.assign(node.data, item.data);
        }
      } else {
        delete orgMap[item.data.ID];
        const removeIndex = rawData.findIndex(d => d.ID === item.data.ID);
        if (removeIndex > -1) {
          rawData.splice(removeIndex, 1);
        }
      }
    });
    // 重新初始化树
    initTree(rawData, sheet, budgetSummaryTreeSetting);
  }
  let loading = false;
  // 插入
  const insert = async (sheet, selected) => {
    try {
      if (loading) {
        return;
      }
      loading = true;
      $.bootstrapLoading.start();
      const updateData = tree.getInsertData(selected.data.ParentID, selected.data.NextSiblingID, uuid.v1());
      const newData = updateData.filter(item => item.type === 'new');
      newData.forEach(item => {
        item.data.fees = [];
        item.data.flags = [];
        item.feesIndex = {};
        item.flagsIndex = {};
        item.data.type = selected.data.type;
        item.data.projectID = projectObj.project.property.rootProjectID;
      });
      await bulkOperation(updateData);
      updateTree(sheet, updateData);
      selectCell(sheet.getActiveRowIndex() + selected.posterityCount() + 1, sheet.getActiveColumnIndex(), true);
    } catch (err) {
      alert(err);
    } finally {
      $.bootstrapLoading.end();
      loading = false;
    }
  }
  // 删除
  const remove = async (sheet, selected) => {
    try {
      if (loading) {
        return;
      }
      loading = true;
      $.bootstrapLoading.start();
      const updateData = tree.getDeleteData(selected);
      await bulkOperation(updateData);
      updateTree(sheet, updateData);
    } catch (err) {
      alert(err);
    } finally {
      $.bootstrapLoading.end();
      loading = false;
    }
  }
  // 升级
  const upLevel = async (selected) => {
    if (!spread || !tree) {
      return;
    }
    const sheet = spread.getSheet(0);
    selected = selected ? selected : tree.selected;
    try {
      if (loading || upLevelDisabled) {
        return;
      }
      loading = true;
      $.bootstrapLoading.start();
      const updateData = selected.getUpLevelData();
      await bulkOperation(updateData);
      updateTree(sheet, updateData);
    } catch (err) {
      alert(err);
    } finally {
      $.bootstrapLoading.end();
      loading = false;
    }
  }
  // 降级
  const downLevel = async (selected) => {
    if (!spread || !tree) {
      return;
    }
    const sheet = spread.getSheet(0);
    selected = selected ? selected : tree.selected;
    try {
      if (loading || downLevelDisabled) {
        return;
      }
      loading = true;
      $.bootstrapLoading.start();
      const updateData = selected.getDownLevelData();
      await bulkOperation(updateData);
      updateTree(sheet, updateData);
    } catch (err) {
      alert(err);
    } finally {
      $.bootstrapLoading.end();
      loading = false;
    }
  }
  // 上移
  const upMove = async (selected) => {
    if (!spread || !tree) {
      return;
    }
    const sheet = spread.getSheet(0);
    selected = selected ? selected : tree.selected;
    try {
      if (loading || upMoveDisabled) {
        return;
      }
      loading = true;
      $.bootstrapLoading.start();
      const updateData = selected.getUpMoveData();
      await bulkOperation(updateData);
      updateTree(sheet, updateData);
      const prev = selected.preSibling;
      const row = sheet.getActiveRowIndex() - prev.posterityCount() - 1;
      selectCell(row, sheet.getActiveColumnIndex(), true);
      sheet.showRow(row, GC.Spread.Sheets.VerticalPosition.center);
    } catch (err) {
      alert(err);
    } finally {
      $.bootstrapLoading.end();
      loading = false;
    }
  }
  // 下移
  const downMove = async (selected) => {
    if (!spread || !tree) {
      return;
    }
    const sheet = spread.getSheet(0);
    selected = selected ? selected : tree.selected;
    try {
      if (loading || downMoveDisabled) {
        return;
      }
      loading = true;
      $.bootstrapLoading.start();
      const updateData = selected.getDownMoveData();
      await bulkOperation(updateData);
      updateTree(sheet, updateData);
      const next = selected.nextSibling;
      const row = sheet.getActiveRowIndex() + next.posterityCount() + 1;
      selectCell(row, sheet.getActiveColumnIndex(), true);
      sheet.showRow(row, GC.Spread.Sheets.VerticalPosition.center);
    } catch (err) {
      alert(err);
    } finally {
      $.bootstrapLoading.end();
      loading = false;
    }

  }
  // 初始化右键菜单
  const initContextMenu = () => {
    if (!spread) {
      return;
    }
    let curRow;
    let curNode;
    const sheet = spread.getSheet(0);
    $.contextMenu({
      selector: '#budget-summary-sheet',
      build: function ($trigger, e) {
        const target = SheetDataHelper.safeRightClickSelection($trigger, e, spread);
        curRow = target.row;
        curNode = tree && tree.items[curRow] || null;
        selectCell(target.row, target.col, true);
        return target.hitTestType === GC.Spread.Sheets.SheetArea.viewport || target.hitTestType === GC.Spread.Sheets.SheetArea.rowHeader;
      },
      items: {
        insert: {
          name: '插入行',
          icon: 'fa-sign-in',
          disabled() {
            return !curNode || (curNode.data.area === BudgetArea.CONSTRUCTION_FEE && curNode.getFlag() !== fixedFlag.CONSTRUCTION_FEE);
          },
          callback() {
            insert(sheet, curNode);
          }
        },
        remove: {
          name: '删除行',
          icon: 'fa-remove',
          disabled() {
            return !curNode || isConstructionFeeArea(curNode) || curNode.getFlag();
          },
          callback() {
            remove(sheet, curNode);
          }
        },
        refresh: {
          name: '刷新数据',
          icon: 'fa-refresh',
          callback() {
            init(projectObj.project.property.rootProjectID);
          }
        },
      }
    });
  }

  // 初始化
  const init = async (constructionID) => {
    try {
      $.bootstrapLoading.start();
      const { treeData, costGrowthRate, growthPeriod } = await ajaxPost('/bills/initialBudgetSummary', { constructionID });
      calcSetting.costGrowthRate = costGrowthRate;
      calcSetting.growthPeriod = growthPeriod;
      $('#costGrowthRate').val(costGrowthRate);
      $('#growthPeriod').val(growthPeriod);
      rawData = treeData;
      rawData.forEach((item) => {
        if (item.quantity) {
          item.quantity = parseFloat(item.quantity);
        }
        item.feesIndex = getFeeIndex(item.fees);
        item.flagsIndex = {};
        if (item.flags) {
          item.flags.forEach((flag) => {
            item.flagsIndex[flag.fieldName] = flag;
          });
        }
      });
      const spread = initSpread();
      const sheet = spread.getSheet(0);
      rawData.forEach(item => {
        orgMap[item.ID] = _.cloneDeep(item);
      });
      initTree(rawData, sheet, budgetSummaryTreeSetting);
      calcBase.initBudget();
      // 造价计算
      await edit(sheet, [], tree.roots.slice(1));
    } catch (err) {
      console.log(err);
      alert(err);
    } finally {
      $.bootstrapLoading.end();
    }
  }

  // 点击tab，重新初始化
  $('#tab-budget-summary').click(function () {
    if (!$(this).hasClass('active')) {
      init(projectObj.project.property.rootProjectID);
    }
  });
  $('#budget-upLevel').click(() => {
    upLevel();
  });
  $('#budget-downLevel').click(() => {
    downLevel();
  });
  $('#budget-upMove').click(() => {
    upMove();
  });
  $('#budget-downMove').click(() => {
    downMove();
  });

  /* 建设项目设置 */
  $('#openConstructionSet').click(() => {
    $('#constructionSet').modal('show');
  });
  function isKeyNumber(keyCode) {
    // 数字
    if (keyCode >= 48 && keyCode <= 57) {
      return true;
    } else if (keyCode >= 96 && keyCode <= 105) { //小键盘数字
      return true;
    } else if (keyCode == 8 || keyCode == 46 || keyCode == 37 || keyCode == 39 || keyCode == 108 || keyCode == 110) {  // Backspace, del, 左右方向键
      return true;
    } else if (keyCode >= 112 && keyCode <= 123) { //F1 -F12
      return true;
    }
    return false;
  }

  //年造价增涨率
  $('#costGrowthRate').keydown(function (e) {
    return isKeyNumber(e.keyCode);
  });
  //计费年限
  $("#growthPeriod").keydown(function (e) {
    return isKeyNumber(e.keyCode);
  });
  // 确认设置
  $('#construction-set-ok').click(async () => {
    try {
      $.bootstrapLoading.start();
      const curCostGrowthRate = $('#costGrowthRate').val();
      const curGrowthPeriod = $('#growthPeriod').val();
      const bulkData = [
        {
          type: 'updateProject',
          data: {
            ID: projectObj.project.property.rootProjectID,
            'property.costGrowthRate': curCostGrowthRate,
            'property.growthPeriod': curGrowthPeriod,
          }
        }
      ];
      await bulkOperation(bulkData);
      calcSetting.costGrowthRate = curCostGrowthRate;
      calcSetting.growthPeriod = curGrowthPeriod;
    } catch (err) {
      alert(err);
      $('#costGrowthRate').val(calcSetting.costGrowthRate);
      $('#growthPeriod').val(calcSetting.growthPeriod);
    } finally {
      $.bootstrapLoading.end();
    }
  });


  // 对外暴露
  return {
    getTree: () => tree,
    getSheet: () => spread.getSheet(0),
    calcSetting,
    edit,
  };

})();