function isFormulaItem(ele) {
  return ele.type == "Element" || ele.type == "ParamData";
}

//转换公式的参数
// function transformArguments(children,curEle,eleMap){
//   let fcReg = /(FC\.\S+\()(.+)\)/;
//   let fcText = '';
//   for (let i = (children.length-1); i >= 0; i--) {
//     let ele = children[i];

//     if(ele.isOn === false){
//       //点击了开关关闭的，跳过
//       continue;
//     }
//     //console.log(ele.name)
//     let tmpArr = fcReg.exec(ele.template.ft);
//     fcText = tmpArr[1] + fcText;//fc.XX( 左括号部分
//     let argList = tmpArr[2].split(",");//括号里面参数部分#1,#2..
//     let isNestEle = false;//是否有过嵌套的元素了
//     let isNestEle2 = false;
//     //console.log(argList)
//     //console.log(text)
//     argList.forEach((argText,index)=>{
//       if(argText.indexOf('#')>-1){
//         //#动态参数
//         let argIndex = index;
//         for (let j = 0; j < ele.template.args.length; j++) {
//           if(ele.template.args[j].key == argText){
//             //找到相同的#编码
//             argIndex = j;
//             break;
//           }
//         }
//         let arg = ele.arguments[argIndex];

//         if(arg && isFormulaItem(arg)){
//           if(!isNestEle && !isNestEle2 && i != (children.length-1) && curEle.id == arg.id){
//             //不是第一个嵌套的公式，且和当前挂载的是同一个元素
//             //认为这个参数是之前公式计算的结果，不再写入元素
//             isNestEle = true;
//           }else{
//             if(arg.type == 'Element'){
//               eleMap[arg.tableElementKey] = {
//                 id: arg.id,
//                 name: arg.name,
//                 tableElementKey: arg.tableElementKey,
//                 type: "Element",
//               };
//               fcText += `E[${arg.tableElementKey}]`;
//             }else if(arg.type == 'ParamData'){
//               eleMap[arg.k] = {
//                 id: arg.id,
//                 name: arg.name,
//                 v:arg.v,
//                 k:arg.k,
//                 type: "ParamData",
//               };
//               fcText += `WP[${arg.k}]`;
//             }

//           }
//         }else if(Array.isArray(arg)){
//           //ifsles方法会进来
//           arg.forEach((a)=>{
//             if(a && isFormulaItem(a)){
//               if(!isNestEle2 && i != (children.length-1) && curEle.id == a.id){
//                 //不是第一个嵌套的公式，且和当前挂载的是同一个元素
//                 //认为这个参数是之前公式计算的结果，不再写入元素
//                 isNestEle2 = true
//               }else{
//                 if(a.type == 'Element'){
//                   eleMap[a.tableElementKey] = {
//                     id: a.id,
//                     name: a.name,
//                     tableElementKey: a.tableElementKey,
//                     type: "Element",
//                   };
//                   fcText += `E[${a.tableElementKey}]`;
//                 }else if(a.type == 'ParamData'){
//                   eleMap[a.k] = {
//                     id: a.id,
//                     name: a.name,
//                     v:a.v,
//                     k:a.k,
//                     type: "ParamData",
//                   };
//                   fcText += `WP[${a.k}]`;
//                 }
//               }
//             }else if(a && a.type == 'Operator'){
//               //在运算符前后加上空格
//               fcText += ' '+a.name+' ';
//               //console.log(fcText)
//             }else if(a && a.type){
//               fcText += a.name;
//             }else{
//               fcText += a?a:"''";
//             }
//           })

//         }else{
//           fcText += arg?arg:"''";
//         }

//       }else{
//         //已有参数
//         fcText += argText?argText:'';
//       }
//       if(index != argList.length-1){
//         fcText += ',';
//       }
//     })
//     fcText += ')';
//   }

//   return fcText;
// }
function transformArguments(children, curEle, eleMap) {
  // debugger;
  let fcReg = /(FC\.\S+\()(.+)\)/;
  let fcText = "";
  for (let i = children.length - 1; i >= 0; i--) {
    let ele = children[i];

    console.log("transformArguments==ele", ele);

    if (ele.isOn === false) {
      //点击了开关关闭的，跳过
      continue;
    }
    if (ele.template != null && ele.template != undefined) {
      let tmpArr = fcReg.exec(ele.template.ft);
      fcText = tmpArr[1] + fcText; //fc.XX( 左括号部分
      let argList = tmpArr[2].split(","); //括号里面参数部分#1,#2..
      let isNestEle = false; //是否有过嵌套的元素了
      let isNestEle2 = false;
      //console.log(argList)
      //console.log(text)
      argList.forEach((argText, index) => {
        if (argText.indexOf("#") > -1) {
          //#动态参数
          let argIndex = index;
          for (let j = 0; j < ele.template.args.length; j++) {
            if (ele.template.args[j].key == argText) {
              //找到相同的#编码
              argIndex = j;
              break;
            }
          }
          let arg = ele.arguments[argIndex];

          if (arg && isFormulaItem(arg)) {
            if (
              !isNestEle &&
              !isNestEle2 &&
              i != children.length - 1 &&
              curEle.id == arg.id
            ) {
              //不是第一个嵌套的公式，且和当前挂载的是同一个元素
              //认为这个参数是之前公式计算的结果，不再写入元素
              isNestEle = true;
            } else {
              // let atbkey=arg.tableElementKey.replace('_key',':key')
              if (arg.type == "Element") {
                eleMap[arg.tableElementKey] = {
                  id: arg.id,
                  name: arg.name,
                  tableElementKey: arg.tableElementKey,
                  type: "Element",
                };
                fcText += `E[${arg.tableElementKey}]`;
              } else if (arg.type == "ParamData") {
                eleMap[arg.k] = {
                  id: arg.id,
                  name: arg.name,
                  v: arg.v,
                  k: arg.k,
                  type: "ParamData",
                };
                fcText += `WP[${arg.k}]`;
              }
            }
          } else if (Array.isArray(arg)) {
            //ifsles方法会进来
            arg.forEach((a) => {
              if (a && isFormulaItem(a)) {
                if (
                  !isNestEle2 &&
                  i != children.length - 1 &&
                  curEle.id == a.id
                ) {
                  //不是第一个嵌套的公式，且和当前挂载的是同一个元素
                  //认为这个参数是之前公式计算的结果，不再写入元素
                  isNestEle2 = true;
                } else {
                  if (a.type == "Element") {
                    eleMap[a.tableElementKey] = {
                      id: a.id,
                      name: a.name,
                      tableElementKey: a.tableElementKey,
                      type: "Element",
                    };
                    fcText += `E[${a.tableElementKey}]`;
                  } else if (a.type == "ParamData") {
                    eleMap[a.k] = {
                      id: a.id,
                      name: a.name,
                      v: a.v,
                      k: a.k,
                      type: "ParamData",
                    };
                    fcText += `WP[${a.k}]`;
                  }
                }
              } else if (a && a.type == "Operator") {
                //在运算符前后加上空格
                fcText += " " + a.name + " ";
                //console.log(fcText)
              } else if (a && a.type) {
                fcText += a.name;
              } else {
                fcText += a ? a : "''";
              }
            });
          } else {
            fcText += arg ? arg : "''";
          }
        } else {
          //已有参数
          fcText += argText ? argText : "";
        }
        if (index != argList.length - 1) {
          fcText += ",";
        }
      });

      fcText += ")";
    }
    console.log(fcText, "ele.name");
  }

  return fcText;
}
export const formulaArrayToString = (processFormula, resultFormula) => {
  let text = "";
  let eleMap = {}; //元素字典，为了回显的时候查询信息
  let preIsOp = false; //前一个参数是否是四则运算（+-*/）
  // debugger

  console.log("processFormula", processFormula);
  processFormula.forEach((item) => {
    if (isFormulaItem(item)) {
      //item.type == "Element" || item.type == "ParamData";
      //console.log(item)
      if (item.children.length < 1) {
        if (item.type == "Element") {
          eleMap[item.tableElementKey] = {
            id: item.id,
            name: item.name,
            tableElementKey: item.tableElementKey,
            type: "Element",
          };
          text += `${
            isStrictNumber(item.argIndex) ? "#" + item.argIndex + "~" : ""
          }E[${item.tableElementKey}],`;
        } else if (item.type == "ParamData") {
          eleMap[item.k] = {
            id: item.id,
            name: item.name,
            v: item.v,
            k: item.k,
            type: "ParamData",
          };
          text += `WP[${item.k}]`;
        }
      } else {
        text += `${
          isStrictNumber(item.argIndex) ? "#" + item.argIndex + "~" : ""
        }${transformArguments(item.children, item, eleMap)},`;
        // text += `${index > 0 && !preIsOp ? "," : ""}${
        //   item.argIndex || item.argIndex === 0 ? "#" + item.argIndex + "-" : ""
        // }${transformArguments(item.children, item, eleMap)},`;
        // (index > 0 && !preIsOp ? "," : "") +
        // "#" +
        // item.argIndex +
        // "-" +
        // transformArguments(item.children, item, eleMap) +
        // ",";
        console.log(text, "中间1111111");

        preIsOp = false;
      }
    } else if (item.type == "Element") {
      text += item.template.ft;
    } else if (item.type == "Operator") {
      //在运算符前后加上空格
      preIsOp = true;
      text += `${item.name},`;
      // text += item.name + ",";
      //console.log(fcText)
    } else {
      text += item.name + ",";
    }
  });

  console.log("sssssss", text, resultFormula);
  const fcReg = /(FC\.\S+\()(.+)\)/;
  if (resultFormula[0].children.length) {
    //等号左侧部分
    let resText = transformArguments(
      resultFormula[0].children,
      resultFormula[0],
      eleMap
    );
    console.log(resText, "等号左侧");

    //等号左侧元素不需要，左侧的公式嵌套右侧所有结果
    let leftArr = fcReg.exec(resText);
    console.log("左侧匹配", leftArr, resText);

    if (!!text && !resText.includes(text) && !!leftArr) {
      let reg = leftArr[2].replace("OPTION,", "");

      console.log("resultFormula替换111", reg, "processFormula替换222", text);

      const textArr = splitSharpSegments(text);
      console.log("resultFormula替换333", textArr);
      const map = reg.split(",").map((el, index) => {
        const idx = textArr.findIndex((item) => item.idx === index);
        if (idx > -1) {
          return textArr[idx].after;
        } else {
          return el;
        }
      });
      console.log("resultFormula替换444", map);
      text = leftArr[1] + map.join(",") + ")";
    } else {
      text = resText;
    }
  } else {
    // 判断字符串是否以 FC.xxx(...) 开头
    const textArr = splitSharpSegments(text);
    console.log("resultFormula替换555", textArr);
    const fcRegStart = /^FC\.\w+\([^)]*\)/;
    if (!fcRegStart.test(text)) {
      text = cleanExpr(text).replace(/#\d+~/g, "");
    }
  }
  text = text.replace(
    /(FC\.\w+)(\(([^]*?)\))(?=[^()]*$)/,
    (_, fn, __, inner) => fn + "(" + inner.replace(/,\s*$/, "") + ")"
  );
  console.log(text, eleMap, "最终");
  return { text, eleMap };
};

const isStrictNumber = (v) => typeof v === "number" && !Number.isNaN(v);
/**
 * 按规则拆分，并保留 #数字- 前缀
 * @param {string} str 原始字符串
 * @returns {string[]} 形如 ["#1- FC.quantity(...)", "#2- E[...]", ...]
 */
function splitSharpSegments(str) {
  const re = /(#(\d+)~)([^#]*?)(?=,#\d+|$)/g;
  const res = [];
  let m;

  while ((m = re.exec(str)) !== null) {
    const idx = Number(m[2]); // 数字部分
    let raw = m[3]; // "#数字-" 后面的原始片段

    if (raw.includes("(")) {
      const close = raw.lastIndexOf(")");
      res.push({ idx, after: raw.slice(0, close + 1) });
    } else {
      const close = raw.lastIndexOf("]");
      res.push({ idx, after: raw.slice(0, close + 1) });
    }
  }
  return res;
}

/**
 * 清洗表达式
 * @param {string} raw 原始字符串
 * @returns {string} 清洗后的字符串
 */
function cleanExpr(raw) {

  raw = raw.replace(/\s+/g, ''); // 去掉所有空格

  // 1. 把 FC.xx(...) 整体保护起来
  const bucket = [];
  const protected_ = raw.replace(
    /FC\.[^(]+\([^)]*\)/g,          // 匹配 FC.xx(任意非右括号)
    m => (bucket.push(m), `__${bucket.length - 1}__`)  // 占位符
  );

  // 2. 在“非函数区”做逗号清理
  let cleaned = protected_.replace(/,([#+\-*/()\d])/g, '$1');

  // 3. 还原占位符
  cleaned = cleaned.replace(/__(\d+)__/g, (_, i) => bucket[i]);

  // 去掉末尾逗号
  cleaned = cleaned.replace(/,$/, '');

  // 3. 保证运算符左右各有一个空格
  //    先给所有运算符前后强制插入一个空格
  cleaned = cleaned.replace(/([+\-*/])/g, ' $1 ');
  //    再把连续空格压成一个
  cleaned = cleaned.replace(/\s+/g, ' ');
  //    去掉行首行尾空格
  return cleaned.trim();
}
