// 多线程里面需要保存的数据
import Big from "big.js";

let code = "";
// 表格数据（渲染）
let tableList = null;
// 方法列表
let excelMethodList = [];
// excel坐标比较列表
let comparisonList = [];
// 当前样品信息
let currentSample = {};
// 当前项目：检测中心
let PROJECT = "";
// 套管
let bushing = "";
// 多线程传递到主线程的数据
let result = {
  method: "",
  value: null,
};

let modelType = "";

// 保存时传到后端参数
let param = null;
// 当前的模板
let currentTable = "";
// 当前模板的结构签名(行列坐标+占位符),用于判断模板内容是否被改过
let currentTemplateSig = "";
// 优化数采较多数据时-记录最后一个检验项的id
let getDataTypeId = null;
//当前检验项
let currentInsItem = null;
// 当前这次输入对应的原始检验项。计算过程中 pId 会切换到下游计算项，
// 保存时必须同时带回原始检验项，否则只会保存计算结果。
let sourceInsItemId = null;

/**
 * 生成模板结构签名
 * 只包含行列坐标与占位符,不含值,所以用户填值不会触发签名变化
 *
 * @param list 主线程传过来的表格数据
 * @returns 结构签名字符串
 */
function buildTemplateSig(list) {
  if (!list || !list.length) {
    return "";
  }
  return list
    .map((table) => {
      const tpl = table && table.template;
      if (!tpl || !tpl.length) {
        return `${table && table.templateId}:0`;
      }
      const cells = tpl
        .map((cell) => {
          const ps = cell.v && cell.v.ps ? cell.v.ps.value : "";
          return `${cell.r}-${cell.c}-${ps}`;
        })
        .join("|");
      return `${table.templateId}:${tpl.length}:${cells}`;
    })
    .join(";");
}

// 接收到主线程处理逻辑的消息
self.onmessage = function (event) {
  // 保存主线程传过来的值
  const data = JSON.parse(event.data);
  // 模板内容变了(不只是模板id变了)也要刷新表格,否则改完模版后 Worker 仍用旧模板计算并把旧版式回写页面
  const nextTemplateSig = buildTemplateSig(data.tableList);
  if (
    currentTable != data.currentTable ||
    (nextTemplateSig && nextTemplateSig != currentTemplateSig)
  ) {
    tableList = data.tableList;
  }
  currentTable = data.currentTable;
  if (nextTemplateSig) {
    currentTemplateSig = nextTemplateSig;
  }
  if (data.type && data.type == "saveData") {
    // 更新表格数据和传递到后端的参数
    tableList = data.tableList;
    param = data.param;
    return;
  }
  if (data.bushing && data.bushing != bushing && data.type == "saveData") {
    // 更新表格数据、传递到后端的参数和套管数据
    tableList = data.tableList;
    param = data.param;
    bushing = data.bushing;
    return;
  }
  modelType = data.modelType;
  code = data.code;
  const codeParts = typeof code === "string" ? code.split("-") : [];
  sourceInsItemId =
    data.currentInsItem && data.currentInsItem.i != null
      ? data.currentInsItem.i
      : codeParts[3];
  if (data.getDataTypeId) {
    // 记录 优化数采较多数据时-记录最后一个检验项的id
    getDataTypeId = data.getDataTypeId;
  } else {
    getDataTypeId = null;
  }
  if (tableList) {
    // 如果表格数据存在，则更新当前修改检验项的表格数据
    let str = code.split("-");
    let r = str[1];
    let c = str[2];
    tableList[0].arr.forEach((item, index) => {
      item.forEach((m, i) => {
        if (m.c == c && m.r == r) {
          tableList[0].arr[index] = data.tableList[0].arr[index];
        }
      });
    });
  } else {
    // 如果初始化表格数据不存在，直接赋值
    tableList = data.tableList;
  }
  if (param) {
    // 参数按“模板id + 单元格坐标”存,模板id即 code 的第一段
    let str = code.split("-");
    param[str[0]] = data.param[str[0]];
  } else {
    // 初始化传递到后端的参数
    param = data.param;
  }
  if (data.currentInsItem) {
    currentInsItem = data.currentInsItem;
  }
  // 更新方法列表、坐标比较列表、当前样品信息、项目
  excelMethodList = JSON.parse(JSON.stringify(data.excelMethodList));
  comparisonList = JSON.parse(JSON.stringify(data.comparisonList));
  currentSample = JSON.parse(JSON.stringify(data.currentSample));
  PROJECT = data.PROJECT;
  // 执行计算方法
  changeInput("", code);
};

/**
 * 判断公式是否为数值公式(含算术运算或 Excel 函数)
 * 这类公式必须走数值计算分支,否则只会把算式当文本原样显示
 *
 * @param f 公式字符串
 * @returns 是否按数值计算
 */
function isNumericFormula(f) {
  if (typeof f !== "string") {
    return false;
  }
  // 去掉双引号内的文本,避免把 "A-B" 这类文本字面量误判为算术
  const probe = f.replace(/"[^"]*"/g, "");
  // 只认支持的算术运算符和 Excel 函数,括号单独出现不视为数值公式,
  // 以免 IF 等不支持的函数被误判
  if (
    /[+\-*/^%]/.test(probe) ||
    /SUM|MAX|MIN|AVERAGE|ABS|MEDIAN/.test(probe)
  ) {
    return true;
  }
  // 纯单元格引用也是数值公式。模版里"最终值"常写成 =F4 这种形式,
  // 不认的话会掉进文本分支,把最终值变成带空格的字符串
  return /^[A-Za-z]{1,3}\d{1,7}$/.test(f.replace(/[=\s]/g, ""));
}

/**
 * 按检验项id取当前样品下的检验项信息,取不到时返回空对象,避免公式计算因缺项中断
 *
 * @param id 检验项id
 * @returns 检验项信息
 */
function findInsItem(id) {
  if (!currentSample || !currentSample.insProduct) {
    return {};
  }
  return currentSample.insProduct.find((m) => m.id == id) || {};
}

/**
 * 判断计算结果是否可以写回单元格
 *
 * @param r 计算结果
 * @returns 结果有效返回 true
 */
function isValidComputedResult(r) {
  if (r === "" || r === null || r === undefined) {
    return false;
  }
  return !(typeof r === "number" && isNaN(r));
}

function changeInput(m, code) {
  let str = code.split("-");
  let r = str[1]; //当前行
  let c = str[2]; //当前列
  let id = str[0];
  let pId = str[3]; //当前检验项id，用于计算完成后把结果写回该检验项所在行
  var list = []; //一个双层数组，里面保存有当前页面渲染的所有数据
  // 赋值当前模板的表格数据
  for (let a in tableList) {
    if (tableList[a].templateId == id) {
      list = tableList[a].arr;
      break;
    }
  }
  let isToExponential = ""; //是否为科学计数法
  let list2 = []; //一个数组，里面保存有当前检验项的所有参数值
  let isPoint = ""; //是否为小数点
  let inputType = null;
  let currentInsItemId = "";
  let isSave = "true";
  // 循环所有excel方法，找到当前行、列的检验项，如果此单元格（r,c）是某个excel方法里面的参数，则执行此方法
  const index = excelMethodList.findIndex((item) => item.r == r);
  excelMethodList.forEach((item) => {
    inputType =
      item.valueList &&
      item.valueList.length > 0 &&
      item.valueList.find((m) => m.r == r && m.c == c);
    // item.valueList  是当前excel方法的参数列表，找到当前填入的值是否是参数
    if (
      item.valueList &&
      item.valueList.length > 0 &&
      item.valueList.find((m) => m.r == r && m.c == c)
    ) {
      isSave = "false";
      // 如果是，则定义一个参数的对象集合，用于保存当前excel方法参数的值
      var comValue = {};
      item.valueList.forEach((a) => {
        list.forEach((b) => {
          if (b[0].r == a.r) {
            b.forEach((c) => {
              if (c.c == a.c) {
                // 获取当前参数的Execl行坐标(ABCD)等等
                var tableCode = "";
                for (var d in comparisonList) {
                  if (c.c == comparisonList[d].value) {
                    tableCode = comparisonList[d].label;
                    break;
                  }
                }
                list2.push(c.v.v);
                // 组装参数的对象集合并赋值，列如{A3:12,B4:15}
                if (
                  (getInspectionValueType(item.i) == 1 ||
                    isNumericFormula(item.v.f)) &&
                  !isNaN(parseFloat(c.v.v))
                ) {
                  // 如果是数字输入框
                  let n = String(c.v.v);
                  if (n.includes("/")) {
                    // 如果是分数，则赋值
                    comValue[tableCode + (c.r + 1)] = c.v.v;
                  } else {
                    comValue[tableCode + (c.r + 1)] = parseFloat(c.v.v);
                  }
                } else {
                  // 如果是文本、下拉框等等
                  comValue[tableCode + (c.r + 1)] = c.v.v;
                }
              }
            });
          }
        });
      });
        // 如果是函数方法，则执行此方法
        let comResult = ""; //初始化计算结果
        try {
          if (
            getInspectionValueType(item.i) == 1 ||
            isNumericFormula(item.v.f)
          ) {
            // 如果检验值类型是数字输入框,或公式本身含算术运算/Excel函数
            const itemInfo = findInsItem(item.i);
            let tell =
              typeof itemInfo.tell == "string" ? itemInfo.tell.split("&") : null;
            isPoint =
              tell &&
              tell.length > 0 &&
              typeof tell[0] == "string" &&
              tell[0].includes("/") &&
              tell[0] !== "/"; // 判断要求值是否为分数
            const inspectionItemClass = itemInfo.inspectionItemClass; // 检验项分类
            const inspectionItem = itemInfo.inspectionItem; // 检验项
            const inspectionItemSubclass = itemInfo.inspectionItemSubclass; // 检验子项
            let isHaveSymbol = false;
            let symbol = "";
            for (var a in comValue) {
              if (
                typeof comValue[a] == "string" &&
                (comValue[a].includes(">") ||
                  comValue[a].includes("≤") ||
                  comValue[a].includes("<") ||
                  comValue[a].includes("≥") ||
                  comValue[a].includes("＜") ||
                  comValue[a].includes("＞"))
              ) {
                if (comValue[a].includes(">")) {
                  symbol = ">";
                } else if (comValue[a].includes("≤")) {
                  symbol = "≤";
                } else if (comValue[a].includes("≥")) {
                  symbol = "≥";
                } else if (comValue[a].includes("＜")) {
                  symbol = "＜";
                } else if (comValue[a].includes("＞")) {
                  symbol = "＞";
                } else {
                  symbol = "<";
                }
                isHaveSymbol = true;
                break;
              }
            }
            // 根据输入的数值，进行计算
            comResult = compute(item.v.f.replace(/=/g, " "), comValue, isPoint);
            // 检验项为密度时，根据要求值的小数位改变最终值的小数位
            if (inspectionItem == "密度") {
              const str = "" + tell;
              const indexOfDecimal = str.indexOf(".");
              if (indexOfDecimal > -1) {
                const length = str.length - indexOfDecimal - 1;
                comResult = comResult.toFixed(length);
              }
            } else if (
              inspectionItemClass == "外护套机械物理性能" &&
              inspectionItem == "在IRM 902矿物油中浸泡后" &&
              (inspectionItemSubclass == "断裂伸长率变化率" ||
                inspectionItemSubclass == "抗张强度变化率")
            ) {
              comResult = Math.round(comResult).toFixed(0);
            } else if (
              typeof comResult == "string" &&
              (comResult.includes("断裂") || comResult.includes("脆化"))
            ) {
              comResult = comResult + "";
            }
            if (
              inspectionItem === "邵氏硬度" &&
              tell &&
              tell[0] &&
              tell[0].includes("A")
            ) {
              // 要求值如果有包含字母，最终结果要展示出字母
              comResult = comResult + "A";
            }
            if (
              inspectionItemClass === "绝缘机械物理性能" &&
              inspectionItem === "弯曲性能" &&
              inspectionItemSubclass === "最小弯曲半径" &&
              tell &&
              tell[0] &&
              tell[0].includes("D")
            ) {
              // 要求值如果有包含字母，最终结果要展示出字母
              comResult = comResult + "D";
            }
            if (isHaveSymbol) {
              comResult = symbol + comResult;
            }
            let list3 = list2.map((item) => item + "");
            // 判断填的检验值是否为科学计数法，如果为科学计数法，则进行转化
            isToExponential = list3.some(
              (val) => val.includes("e+") || val.includes("e-")
            );
            if (isToExponential) {
              let num2 = new Big(comResult);
              comResult = num2.toExponential(1);
            }
          } else {
            // 如果检验值类型是文本输入框、下拉框
            let valueList = [];
            // 处理excel函数参数列表
            item.valueList.forEach((a) => {
              valueList.push({
                name: `${comparisonList.find((e) => e.value == a.c).label}${
                  a.r + 1
                }`,
                value: 0,
              });
            });
            // 给excel函数参数赋文本值
            for (var a in comValue) {
              valueList.forEach((b) => {
                if (b.name == a) {
                  b.value = comValue[a];
                }
              });
            }
            // 计算公式，去掉excel函数的等号，并替换参数，列如：=A1  变成 A1 变成 ‘文本输入的值’
            let str = item.v.f.replace(/=/g, " ");
            valueList.forEach((b) => {
              str = str.replace(b.name, b.value);
            });
            // 计算结果赋值
            comResult = str;
          }
        } catch (error) {
          console.log("error---", error);
        }
        try {
          // 循环表格数据，给表格数据进行赋值
          list.forEach((a) => {
            if (a[0].r == item.r && isValidComputedResult(comResult)) {
              // 判断当前行是否为当前检验项所在行，如果为当前行，则给表格数据赋值
              for (var b in a) {
                if (a[b].c == item.c) {
                  try {
                    if (comResult == 0) {
                      // 判断计算结果是否为0，如果为0，则给表格数据赋值为0
                      a[b].v.v = 0;
                    } else if (
                      a[b].v.ct &&
                      a[b].v.ct.fa &&
                      typeof a[b].v.ct.fa == "string" &&
                      a[b].v.ct.fa.includes(".")
                    ) {
                      // 判断当前单元格是否保留小数点，如果为保留小数点，则给表格数据赋值为保留小数点，这个是根据模板配置小数点来的
                      let num = 0;
                      let str = a[b].v.ct.fa.split(".")[1];
                      num = str.length;
                      a[b].v.v = comResult
                        ? Number(comResult).toFixed(num)
                        : comResult;
                    } else if (
                      typeof comResult == "string" &&
                      (comResult.includes("e+") || comResult.includes("e-"))
                    ) {
                      // 判断计算结果是否为科学计数法，如果为科学计数法，则给表格数据赋值为科学计数法
                      a[b].v.v = comResult;
                    } else {
                      const inspectionItem = findInsItem(item.i).inspectionItem;
                      // 判断计算结果是否为数字，如果为数字，则给表格数据赋值为数字
                      if (inspectionItem == "铜线电阻率ρ20最大值") {
                        let val = parseFloat(Number(comResult).toFixed(5));
                        a[b].v.v = isNaN(val) ? comResult : val;
                      } else {
                        let val = parseFloat(Number(comResult).toFixed(3));
                        a[b].v.v = isNaN(val) ? comResult : val;
                      }
                    }
                  } catch (error) {
                    // 如果以上判断都不支持，则直接赋值
                    a[b].v.v = comResult;
                    console.log("error---", error);
                  }
                  break;
                }
              }
            }
          });
          // 如果此计算结果所属单元格，同时也是另一个excel函数的参数，那么就需要递归进行计算
          // 只有算出有效结果才继续向下游公式传递,避免把空值/NaN 传染给其它单元格
          if (isValidComputedResult(comResult)) {
            changeInput(comResult, `${id}-${item.r}-${item.c}-${pId}`); //改变最终值
          }
          currentInsItemId = item.i;
        } catch (error) {
          console.log("error---", error);
        }
    }
  });
  if (index === -1 || (inputType === undefined && isSave === "true")) {
    // 赋值传递到主线程的数据，method：saveInsContext表示此消息需要保存数据
    result = {
      method: "saveInsContext",
      value: {
        tableList, // 表格数据
        param: getParam(), //传给后端的参数
        getDataTypeId: getDataTypeId,
        currentInsItemId: currentInsItemId,
        sourceInsItemId: sourceInsItemId,
      },
    };
    // 发消息给主线程
    self.postMessage(JSON.stringify(result));
  }

  // 赋值多线程传输数据
  result = {
    method: "tableList",
    value: tableList,
  };
  // 发送主线程数据
  self.postMessage(JSON.stringify(result));
}
/**
 * 获取检测值类型
 *
 * @param id 检测值类型对应的id
 * @returns 返回检测值类型
 */
function getInspectionValueType(id) {
  for (var a in currentSample.insProduct) {
    if (currentSample.insProduct[a].id == id) {
      return currentSample.insProduct[a].inspectionValueType;
    }
  }
}
/**
 * 处理分数或带有乘法和乘方的字符串
 *
 * @param str 字符串类型，表示要处理的分数或乘方表达式
 * @returns 返回一个数字或原字符串，如果字符串为有效的分数或乘方表达式，则返回计算结果；否则返回原字符串
 */
function handleFraction(str) {
  if (str && typeof str == "string" && str.includes("/")) {
    // 处理分数
    return eval(str.split("/")[0] / str.split("/")[1]);
  } else if (
    str &&
    typeof str == "string" &&
    str.includes("*") &&
    str.includes("^")
  ) {
    // 计算乘方
    const num1 = str.split("*");
    const num2 = num1[1].split("^");
    let num3 = new Big(num2[0]);
    let num4 = new Big(num2[1]);
    let num5 = Math.pow(num3, num4); // 计算次方
    return num1[0] * num5; // 最后计算乘法
  } else {
    return str;
  }
}

/**
 * 处理带有多个参数的函数
 *
 * @param res 字符串，需要被分割并处理的字符串
 * @param str 字符串，与res中的每一项进行比较的字符串，可能是分数或者带有比较符号的字符串
 * @param comp 字符串，表示比较类型的字符（如 '>'、'<'、'='、'≥'、'≤'、'±'、'~'、'-'）
 * @returns 返回布尔值，如果res中每一项都满足与str的比较条件，则返回true，否则返回false
 */
function handleMoreParam(res, str, comp) {
  let arr = res.split("/");
  let arr0 = arr.every((item) => {
    switch (comp) {
      case ">":
        return item > handleFraction(str);
      case "<":
        return item < handleFraction(str);
      case "=":
        return item == handleFraction(str);
      case "≥":
        return item >= handleFraction(str);
      case "≤":
        return item <= handleFraction(str);
      case "±":
        let k = str.split("±");
        return (
          item >= eval(handleFraction(k[0]) - handleFraction(k[1])) &&
          item <=
            eval(Number(handleFraction(k[0])) + Number(handleFraction(k[1])))
        );
      case "~":
        let j = str.split("~");
        return (
          item >= eval(handleFraction(j[0])) &&
          item <= eval(handleFraction(j[1]))
        );
      case "-":
        let o = str.split("-");
        return (
          item >= eval(handleFraction(o[0])) &&
          item <= eval(handleFraction(o[1]))
        );
    }
  });
  if (arr0) {
    return true;
  } else {
    return false;
  }
}

/**
 * 获取参数
 *
 * @returns 返回处理后的参数对象
 */
function getParam() {
  // 按“模板id + 单元格坐标(r-c)”从当前模板快照出待保存参数
  const resultParam = {};
  tableList.forEach((t) => {
    resultParam[t.templateId] = {};
    (t.arr || []).forEach((a) => {
      a.forEach((b) => {
        const isEditable =
          b.v.ps != undefined &&
          typeof b.v.ps.value == "string" &&
          (b.v.ps.value.includes("检验值") ||
            b.v.ps.value === "计算值" ||
            b.v.ps.value === "最终值" ||
            b.v.ps.value === "设备名称");
        if (!isEditable) {
          return;
        }
        if (
          b.v.ps.value.includes("检验值") &&
          (b.v.v === "" || b.v.v === null || b.v.v === undefined)
        ) {
          return;
        }
        resultParam[t.templateId][`${b.r}-${b.c}`] = { v: b.v.v, u: b.u };
      });
    });
  });
  param = resultParam;
  return param;
}

/**
 * 计算多个数值的和
 *
 * @param val 数值型参数，可变长参数列表
 * @returns 返回所有参数的和，如果参数列表为空或参数类型非数值型，则返回null
 */
function SUM(...val) {
  try {
    let num = null;
    if (
      val != null &&
      val != undefined &&
      val != "undefined" &&
      val != "NaN" &&
      val.length > 0
    ) {
      val.forEach((item) => {
        num += item;
      });
    }
    return num;
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * 计算传入参数中的最大值
 *
 * @param ...val 可变参数列表，用于计算最大值的数值或可转换为数值的类型
 * @returns 返回最大值，如果参数列表为空或为null/undefined/''，则返回null
 */
function MAX(...val) {
  try {
    let max = null;
    if (
      val != null &&
      val != undefined &&
      val != "undefined" &&
      val != "NaN" &&
      val.length > 0
    ) {
      val = val.filter((item) => item != null && item !== "");
      if (val.length > 0) {
        max = Math.max(...val);
      } else {
        max = null;
      }
    }
    return max;
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * IF判断
 *
 *
 *
 */
function IF(...val) {
  try {
    let ifNUm = null;
    if (
      val != null &&
      val != undefined &&
      val != "undefined" &&
      val != "NaN" &&
      val.length > 0
    ) {
      if (val[0] === "" || val[0] == 0 || val[0] === " ") {
        ifNUm = val[1];
      } else {
        ifNUm = val[0];
      }
    }
    return ifNUm;
  } catch (error) {
    console.log("IFerror---", error);
  }
}
/**
 * 计算传入参数中的最小值
 *
 * @param val 可变参数，用于计算最小值的数值数组
 * @returns 返回传入参数中的最小值，如果传入参数为空或所有值均为null或空字符串，则返回null
 */
function MIN(...val) {
  try {
    let min = null;
    if (
      val != null &&
      val != undefined &&
      val != "undefined" &&
      val != "NaN" &&
      val.length > 0
    ) {
      val = val.filter((item) => item != null && item !== "");
      if (val.length > 0) {
        min = Math.min(...val);
      }
    }
    return min;
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * 计算给定数值的平均值
 *
 * @param val 数值列表，可包含任意个参数
 * @returns 返回平均值，如果数值列表为空或包含非数值项，则返回null
 */
function AVERAGE(...val) {
  try {
    let num = null;
    let arr = [];
    if (
      val != null &&
      val != undefined &&
      val != "undefined" &&
      val != "NaN" &&
      val.length > 0
    ) {
      arr = val.filter(
        (item) => item !== null && item !== "" && item != undefined
      );
      arr.forEach((item) => {
        num += item;
      });
      if (arr.length > 0) {
        return num / arr.length;
      } else {
        return null;
      }
    } else {
      return null;
    }
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * 取整数
 *
 * @param val 任意数值
 * @returns 返回该数值的整数
 */
function INT(val) {
  try {
    return Math.round(val);
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * 计算一个数的绝对值
 *
 * @param val 任意数值
 * @returns 返回该数值的绝对值
 */
function ABS(val) {
  try {
    return Math.abs(val);
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * 计算一组数字的中位数
 *
 * @param val 任意个参数，需要计算中位数的数字
 * @returns 如果参数中有有效的数字，则返回计算出的中位数；否则返回null
 */
function MEDIAN(...val) {
  try {
    let arr = [];
    if (val && val.length > 0) {
      arr = val.filter((item) => item != null && item !== "");
      const sortedArr = arr.sort((a, b) => a - b);
      // 计算中位数
      const half = Math.floor(sortedArr.length / 2);
      if (arr.length > 0) {
        // 如果数组长度是奇数，直接取中间的元素
        if (sortedArr.length % 2 === 1) {
          return sortedArr[half];
        } else {
          // 如果数组长度是偶数，取中间两个元素的平均值
          return (sortedArr[half - 1] + sortedArr[half]) / 2;
        }
      } else {
        return null;
      }
    } else {
      return null;
    }
  } catch (error) {
    console.log("error---", error);
  }
}

/**
 * 计算幂
 *
 * @param str 字符串形式的幂表达式，例如"2^3"
 * @returns 返回计算后的幂值，如果表达式无效则返回null
 */
function CalculatePower(str) {
  try {
    if (str && str.includes("^")) {
      let arr = str.split("^");
      if (arr && arr.length > 1) {
        return Math.pow(arr[0], arr[1]);
      } else {
        return null;
      }
    }
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * 转换π
 *
 *
 *
 */
function PI() {
  try {
    return 3.1415926;
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * 计算LOG
 *
 *
 *
 */
function LOG(...val) {
  try {
    let LOGNUm = null;
    if (
      val != null &&
      val != undefined &&
      val != "undefined" &&
      val != "NaN" &&
      val.length > 0
    ) {
      val = val.filter((item) => item != null && item !== "");
      if (val.length > 0) {
        LOGNUm = Math.log(val[0]);
      }
    }
    // console.log(LOGNUm);
    return LOGNUm;
  } catch (error) {
    console.log("error---", error);
  }
}

/**
 * 根据坐标获取列名
 * @param {Object} cellId
 */
function getColumnNameFromId(cellId) {
  try {
    if (!Array.isArray(cellId)) {
      cellId = cellId.split("-");
    }
    var i = cellId[0];
    var letter = "";
    if (i > 701) {
      letter += String.fromCharCode(64 + parseInt(i / 676));
      letter += String.fromCharCode(64 + parseInt((i % 676) / 26));
    } else if (i > 25) {
      letter += String.fromCharCode(64 + parseInt(i / 26));
    }
    letter += String.fromCharCode(65 + (i % 26));
    return letter + (parseInt(cellId[1]) + 1);
  } catch (e) {
    console.log("error", e);
  }
}
/**
 * 根据列名获取坐标
 * @param {Object} id
 * @param {Object} arr
 */
function getIdFromColumnName(id, arr) {
  try {
    id = String(id).replace(/\$/g, "");
    // Get the letters
    var t = /^[a-zA-Z]+/.exec(id);
    if (t) {
      // Base 26 calculation
      var code = 0;
      for (var i = 0; i < t[0].length; i++) {
        code +=
          parseInt(t[0].charCodeAt(i) - 64) * Math.pow(26, t[0].length - 1 - i);
      }
      code--;
      // Make sure jexcel starts on zero
      if (code < 0) {
        code = 0;
      }

      // Number
      var number = parseInt(/[0-9]+$/.exec(id));
      if (number > 0) {
        number--;
      }

      if (arr == true) {
        id = [code, number];
      } else {
        // id = code + '-' + number;
        id = {
          c: code,
          r: number,
        };
      }
    }
    return id;
  } catch (e) {
    console.log("error", e);
  }
}

/**
 * 更改参数
 *
 * @param f 参数列表
 * @returns 返回一个包含坐标信息的数组
 */
function changeParameter(f) {
  try {
    let arr = getABCList(f);
    let arr2 = [];
    arr.forEach((item) => {
      // 判断是否为范围，列如MAX(A1:B2)
      if (item.includes(":")) {
        let r0 = getIdFromColumnName(item.split(":")[0]).r;
        let c0 = getIdFromColumnName(item.split(":")[0]).c;
        let r1 = getIdFromColumnName(item.split(":")[1]).r;
        let c1 = getIdFromColumnName(item.split(":")[1]).c;
        for (let i = Number(r0); i <= Number(r1); i++) {
          for (let u = Number(c0); u <= Number(c1); u++) {
            arr2.push({
              r: i,
              c: u,
            });
          }
        }
      } else {
        // 没有则直接获取
        arr2.push(getIdFromColumnName(item));
      }
    });
    return arr2;
  } catch (error) {
    console.log("error", error);
  }
}
/**
 * 获取包含 ABC 字符的列表
 *
 * @param f 字符串，包含需要解析的公式或表达式
 * @returns 包含 ABC 字符的数组列表
 */
function getABCList(f) {
  try {
    if (typeof f !== "string") {
      return [];
    }
    let regex = /[=\+\-\*\%\(\)\/\^\s]/g;
    // 上面计算函数新增后，这里也要同步增加
    let fouList = [
      "SUM",
      "MAX",
      "MIN",
      "AVERAGE",
      "ABS",
      "PI",
      "INT",
      "IF",
      "LOG",
    ];
    // 替换特殊字符,去掉 Excel 绝对引用符号($D$14 与 D14 等价)
    f = f
      .replace(/\$/g, "")
      // 区间写法里的空格(AVERAGE( D14 : D15 ))会被下面的空白替换吃掉冒号,
      // 导致区间被拆成两个独立单元格,先把区间规整成 D14:D15
      .replace(/\s*:\s*/g, ":")
      .replace(regex, ",")
      .replace(new RegExp('"&', "g"), "")
      .replace(new RegExp('&"', "g"), "");
    fouList.forEach((item) => {
      f = f.replace(new RegExp(item, "g"), ",");
    });
    let arr = f.split(",").filter((item) => {
      return (
        item && /[a-zA-Z]/.test(item) && item != "undefined" && item != "null"
      );
    });
    return arr;
  } catch (error) {
    console.log("error", error);
  }
}
/**
 * 获取所有单元格
 *
 * @param f 表格数据或相关参数
 * @returns 返回一个对象，其键为单元格的唯一标识符（由列和行ID拼接而成），值为null
 */
function getAllCell(f) {
  try {
    let arr = changeParameter(f);
    let arr0 = {};
    arr.forEach((item) => {
      arr0[getColumnNameFromId(`${item.c}` + "-" + `${item.r}`)] = null;
    });
    return arr0;
  } catch (error) {
    console.log("error", error);
  }
}

/**
 * 把单元格值转成可参与 eval 的字面量,空白单元格按 0 处理(与 Excel 一致)
 *
 * @param value 单元格的值
 * @returns 数值/原始值,空值返回 0
 */
function toNumberLiteral(value) {
  if (value === null || value === undefined) {
    return 0;
  }
  if (typeof value === "string" && value.trim() === "") {
    return 0;
  }
  return value;
}

/**
 * 计算函数
 *
 * @param f 字符串类型，表示待计算的公式
 * @param comValue 对象类型，表示要替换的单元格值，键为单元格名称，值为替换后的值
 * @returns 返回计算后的结果，如果计算失败则返回0
 */
function compute(f, comValue, isPoint) {
  try {
    // 去掉 Excel 绝对引用符号,$D$14 与 D14 等价;
    // 区间里的空格也要一并去掉,否则下面把 ":" 换成 "-" 后 D14-D15 会因空格匹配不上而展开失败
    let str = f.replace(/\$/g, "").replace(/\s*:\s*/g, ":");
    // 获取单元格对应值
    let arr = getAllCell(f);
    for (var a in comValue) {
      if (typeof comValue[a] == "string" && comValue[a].includes(">")) {
        comValue[a] = comValue[a].replace(">", "");
      }
      if (typeof comValue[a] == "string" && comValue[a].includes("≤")) {
        comValue[a] = comValue[a].replace("≤", "");
      }
      if (typeof comValue[a] == "string" && comValue[a].includes("≥")) {
        comValue[a] = comValue[a].replace("≥", "");
      }
      if (typeof comValue[a] == "string" && comValue[a].includes("<")) {
        comValue[a] = comValue[a].replace("<", "");
      }
      if (typeof comValue[a] == "string" && comValue[a].includes("＜")) {
        comValue[a] = comValue[a].replace("＜", "");
      }
      if (typeof comValue[a] == "string" && comValue[a].includes("＞")) {
        comValue[a] = comValue[a].replace("＞", "");
      }
      if (
        comValue[a] !== "undefined" &&
        comValue[a] !== "null" &&
        comValue[a] !== undefined
      ) {
        if (typeof comValue[a] == "string" && comValue[a].includes("^")) {
          // 计算幂次
          arr[a] = CalculatePower(comValue[a]);
        } else {
          arr[a] = comValue[a];
        }
      }
    }
    // 解析公式参数，特别是带：的
    let arr0 = getABCList(f);
    let obj = {};
    arr0.forEach((item) => {
      if (item.includes(":")) {
        let arr1 = [];
        let r0 = getIdFromColumnName(item.split(":")[0]).r;
        let c0 = getIdFromColumnName(item.split(":")[0]).c;
        let r1 = getIdFromColumnName(item.split(":")[1]).r;
        let c1 = getIdFromColumnName(item.split(":")[1]).c;
        for (let i = Number(r0); i <= Number(r1); i++) {
          for (let u = Number(c0); u <= Number(c1); u++) {
            arr1.push({
              r: i,
              c: u,
            });
          }
        }
        let arr2 = [];
        arr1.forEach((m) => {
          arr2.push(getColumnNameFromId(`${m.c}` + "-" + `${m.r}`));
        });
        obj[item.split(":").join("-")] = arr2.join(",");
      } else {
        obj[item] = item;
      }
    });
    str = str.replace(new RegExp(":", "g"), "-");
    // 替换参数
    for (var a in obj) {
      str = str.replace(new RegExp(a, "g"), obj[a]);
    }
    // 计算:一次性替换所有参数,避免 D1 与 D14 这类前缀互相污染;
    // 空白单元格按 0 处理,避免把 null/undefined 带进表达式导致整条公式算不出来
    const cellKeys = Object.keys(arr);
    if (cellKeys.length > 0) {
      const pattern = new RegExp(
        cellKeys
          .sort((x, y) => y.length - x.length)
          .map((k) => k.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
          .join("|"),
        "g"
      );
      str = str.replace(pattern, (m) => String(toNumberLiteral(arr[m])));
    }
    if (str.includes(",,")) {
      str = str.replace(new RegExp(",,", "g"), ",");
    }
    if (str.includes(",,")) {
      str = str.replace(new RegExp(",,", "g"), ",");
    }
    if (str.includes(",,")) {
      str = str.replace(new RegExp(",,", "g"), ",");
    }
    if (str.includes(",,")) {
      str = str.replace(new RegExp(",,", "g"), ",");
    }
    if (str.includes(",,")) {
      str = str.replace(new RegExp(",,", "g"), ",");
    }
    if (str.includes('&"/"&')) {
      // 计算带斜杠的
      return str
        .replace(new RegExp('&"/"&', "g"), "/")
        .replace(new RegExp("//", "g"), "");
    } else if (isPoint && !/SUM|MAX|MIN|AVERAGE|ABS|MEDIAN/.test(str)) {
      // 分数形式的输入(如 3/4)按原文返回展示;
      // 但含 Excel 函数名的公式不能走这里,否则会把 "AVERAGE(...)" 这种算式文本当成结果写回单元格
      return str.replace("ABS", "").replace(/\(|\)/g, "");
    } else {
      if (str.includes("IF")) {
        str = str.replace("IF", "").replace(/\(|\)/g, "");
        const str1 = str.split(",");
        if (str1[0] === " " || str1[0] === "") {
          str1[0] = 0;
        }
        if (str1[2] === " " || str1[2] === "") {
          str1[2] = 0;
        }
        const str2 = str1.join(",");
        str = "IF(" + str2 + ")";
      }
      // console.log('str---', str)
      if (str.includes("断裂") || str.includes("脆化")) {
        const result = str.replace(/[^\u4e00-\u9fa5]/g, "");
        if (result.includes("断裂") && !result.includes("脆化")) {
          return "断裂";
        } else if (!result.includes("断裂") && result.includes("脆化")) {
          return "脆化";
        } else if (result.includes("断裂") && result.includes("脆化")) {
          return "断裂脆化";
        }
      }
      // 计算常规的
      const value = eval(str);
      // 除零等非有限结果不写回单元格(与 Excel 的 #DIV/0! 一致:不出值)
      if (typeof value === "number" && !isFinite(value)) {
        return undefined;
      }
      return value;
    }
  } catch (error) {
    console.log("error", error);
  }
}