/**
 * 将数组转换为表达式字符串
 * @param {Array} arr 输入的数组，包含不同类型的元素
 * @returns {string} 拼接后的表达式字符串
 */
export function convertArrayToExpression(arr) {
  const result = [];

  // 遍历输入数组的每个元素
  arr.forEach((item) => {
    switch (item.type) {
      case "Element":
        // 对于Element类型，提取tableElementKey并包裹在E[]中
        result.push(`E[${item.tableElementKey}]`);
        break;
      case "Operator":
        // 对于Operator类型，提取ft属性
        result.push(item.template.ft || item.ft || "");
        break;
      case "Text":
        // 对于Text类型，直接使用name属性
        result.push(item.name);
        break;
      case "Brackets":
        // 对于Text类型，直接使用name属性
        result.push(item.name);
        break;
      default:
        // 处理未知类型
        console.warn("未知类型:", item.type);
    }
  });

  // 将结果数组拼接成字符串并返回
  return result.join("");
}

export function formatArrayMore(inputArray) {
  console.log(inputArray, "inputArray");

  // 定义字段映射关系
  const fieldMappings = {
    tag2: "parameter1",
    tag3: "parameter2",
    symbol1: "symbol",
    logicSymbol: "groupTerm",
    tag4: "trueData",
    tag5: "falseData",
  };

  // 处理值的格式化，将特定格式字符串包裹在E[]中
  function formatValue(value) {
    // 检查是否是符合格式的字符串（包含:key_）
    if (typeof value === "string" && value.includes(":key_")) {
      return `E[${value}]`;
    }
    return value;
  }

  // 处理单个对象的函数
  function processObject(obj) {
    const result = {};

    // 处理formulaIfElse（如果存在）
    if (obj.formulaIfElse && Array.isArray(obj.formulaIfElse)) {
      result.formulaIfElse = obj.formulaIfElse.map((item) =>
        processObject(item)
      );
    }

    // 处理formula1和formula2，转换后赋值给trueData和falseData
    if (
      obj.formula1 &&
      Array.isArray(obj.formula1) &&
      obj.formula1.length > 0
    ) {
      result.trueData = convertArrayToExpression(obj.formula1);
      result.trueDataArray = obj.formula1;
    }

    if (
      obj.formula2 &&
      Array.isArray(obj.formula2) &&
      obj.formula2.length > 0
    ) {
      result.falseData = convertArrayToExpression(obj.formula2);
      result.falseDataArray = obj.formula2;
    }

    // 处理其他字段映射
    Object.keys(obj).forEach((key) => {
      // 特殊处理tags2、tags3、tags4和tags5
      if (key === "tags2" && Array.isArray(obj.tags2) && obj.tags2.length > 0) {
        const value = obj.tags2[0].tableElementKey || "";
        if (!result.parameter1) {
          result.parameter1 = formatValue(value);
        }
      } else if (
        key === "tags3" &&
        Array.isArray(obj.tags3) &&
        obj.tags3.length > 0
      ) {
        const value = obj.tags3[0].tableElementKey || "";
        if (!result.parameter2) {
          result.parameter2 = formatValue(value);
        }
      } else if (
        key === "tags4" &&
        Array.isArray(obj.tags4) &&
        obj.tags4.length > 0
      ) {
        const value = obj.tags4[0].tableElementKey || "";
        if (!result.trueData) {
          result.trueData = formatValue(value);
        }
      } else if (
        key === "tags5" &&
        Array.isArray(obj.tags5) &&
        obj.tags5.length > 0
      ) {
        const value = obj.tags5[0].tableElementKey || "";
        if (!result.falseData) {
          result.falseData = formatValue(value);
        }
      }
      // 处理其他映射字段
      else if (fieldMappings[key]) {
        if (
          (key === "tag2" && !result.parameter1) ||
          (key === "tag3" && !result.parameter2) ||
          (key === "tag4" && !result.trueData) ||
          (key === "tag5" && !result.falseData) ||
          !["tag2", "tag3", "tag4", "tag5"].includes(key)
        ) {
          result[fieldMappings[key]] = formatValue(obj[key]);
        }
      }
    });
    return result;
  }

  const resList = inputArray
    .map((item) => processObject(item))
    .map((item) => {
      const len = item.formulaIfElse.length;

      if (len) {
        for (let i = 0; i < len; i++) {
          if (i !== len - 1) {
            item.formulaIfElse[i].groupTerm =
              item.formulaIfElse[i + 1].groupTerm;
          } else {
            item.formulaIfElse[i].groupTerm = "";
          }
        }
      }
      return item;
    });

  // 处理整个数组
  return resList;
}

export function restoreArrayMore(processedArray, formulaDetailMap, remark) {
  // console.log(processedArray,formulaDetailMap, "restoreArrayMore");
  // 定义反转的字段映射关系（与原方法相反）
  const reverseMappings = {
    parameter1: "tag2",
    parameter2: "tag3",
    symbol: "symbol1",
    groupTerm: "logicSymbol",
    trueData: "tag4",
    falseData: "tag5",
  };

  // 从map获取完整元素信息并构建tags对象
  const getTagElement = (tableElementKey) => {
    try {
      const objTargetData =
        typeof formulaDetailMap === "string"
          ? JSON.parse(formulaDetailMap)
          : formulaDetailMap;
      const baseData = objTargetData[tableElementKey] || {};
      return {
        type: baseData.type || "Element",
        name: baseData.name || "",
        id: baseData.id || "",
        selected: false,
        tableElementKey: tableElementKey,
        children: [],
        text: baseData.name || "",
        style: "background-color: #409EFF",
      };
    } catch (error) {
      console.error("Error parsing formulaDetailMap:", error);
      return {
        type: "Element",
        name: "",
        id: "",
        selected: false,
        tableElementKey: tableElementKey,
        children: [],
        text: "",
        style: "background-color: #409EFF",
      };
    }
  };

  // 解析表达式字符串为公式数组
  function parseExpressionToFormula(expression) {
    if (typeof expression !== "string") return [];

    const formula = [];
    const len = expression.length;
    let currentPos = 0;

    // 定义所有运算符
    const operators = new Set([
      "+",
      "-",
      "*",
      "/",
      "%",
      "=",
      ">",
      "<",
      "!",
      "&",
      "|",
      "≥",
      "≤",
      "≠",
      "(",
      ")",
    ]);

    // 检查是否为运算符
    const isOperatorChar = (char) => operators.has(char);

    // 跳过空白字符
    const skipWhitespace = () => {
      while (currentPos < len && /\s/.test(expression[currentPos])) {
        currentPos++;
      }
    };

    while (currentPos < len) {
      skipWhitespace();
      if (currentPos >= len) break;

      const currentChar = expression[currentPos];

      // 处理元素 (E[...])
      if (
        currentChar === "E" &&
        currentPos + 1 < len &&
        expression[currentPos + 1] === "["
      ) {
        const endPos = expression.indexOf("]", currentPos + 2);
        if (endPos !== -1) {
          const key = expression.substring(currentPos + 2, endPos);
          formula.push(getTagElement(key));
          currentPos = endPos + 1;
        } else {
          // 无效格式，作为文本处理
          formula.push({
            type: "Text",
            name: expression.substring(currentPos),
          });
          break;
        }
      }
      // 处理运算符
      else if (isOperatorChar(currentChar)) {
        let operator = currentChar;
        currentPos++;

        // 处理多字符运算符 (如>=、<=、&&、||等)
        while (currentPos < len && isOperatorChar(expression[currentPos])) {
          operator += expression[currentPos];
          currentPos++;
        }

        formula.push({
          type: "Operator",
          ft: operator,
          template: { ft: operator },
          name: operator,
          selected: false,
        });
      }
      // 处理文本（数字或其他字符）
      else {
        let textEndPos = currentPos;

        // 收集所有非运算符、非元素的字符
        while (textEndPos < len) {
          const char = expression[textEndPos];
          // 遇到运算符或元素开始则停止
          if (
            isOperatorChar(char) ||
            (char === "E" &&
              textEndPos + 1 < len &&
              expression[textEndPos + 1] === "[")
          ) {
            break;
          }
          textEndPos++;
        }

        const text = expression.substring(currentPos, textEndPos).trim();
        if (text) {
          formula.push({
            type: "Text",
            name: text,
            selected: false,
          });
        }

        currentPos = textEndPos;
      }
    }

    console.log("解析后的公式数组：", formula);
    return formula;
  }

  // 还原值的格式化，去掉E[]包裹
  function restoreValue(value) {
    if (
      typeof value === "string" &&
      value.startsWith("E[") &&
      value.endsWith("]")
    ) {
      const innerValue = value.slice(2, -1);
      if (innerValue.includes(":key_")) {
        return innerValue;
      }
    }
    return value;
  }

  // 还原单个对象的函数
  // 还原单个对象的函数
  function restoreObject(obj) {
    const result = {};

    console.log("还原单个对象：", obj);

    // 递归还原formulaIfElse（如果存在）
    if (obj.formulaIfElse && Array.isArray(obj.formulaIfElse)) {
      result.formulaIfElse = obj.formulaIfElse.map((item) => {
        const formulaItem = {};
        // 处理parameter1
        if (item.parameter1) {
          const restoredValue = restoreValue(item.parameter1);
          // 判断是否为E[]包裹的原生格式
          if (item.parameter1.startsWith("E[")) {
            // 原生格式：设置tags2，清空tag2
            formulaItem.tags2 = [getTagElement(restoredValue)];
            formulaItem.tag2 = "";
          } else {
            // 非原生格式：设置tag2，清空tags2
            formulaItem.tag2 = restoredValue;
            formulaItem.tags2 = [];
          }
        } else {
          formulaItem.tags2 = [];
          formulaItem.tag2 = "";
        }

        // 处理parameter2
        if (item.parameter2) {
          const restoredValue = restoreValue(item.parameter2);
          // 判断是否为E[]包裹的原生格式
          if (item.parameter2.startsWith("E[")) {
            // 原生格式：设置tags3，清空tag3
            formulaItem.tags3 = [getTagElement(restoredValue)];
            formulaItem.tag3 = "";
          } else {
            // 非原生格式：设置tag3，清空tags3
            formulaItem.tag3 = restoredValue;
            formulaItem.tags3 = [];
          }
        } else {
          formulaItem.tags3 = [];
          formulaItem.tag3 = "";
        }

        // 处理其他字段（symbol、groupTerm等）
        if (item.symbol) {
          formulaItem.symbol1 = item.symbol;
        }
        if (item.groupTerm) {
          formulaItem.logicSymbol = item.groupTerm;
        }

        return formulaItem;
      });
    }

    // 根据remark值决定不同的还原逻辑
    if (remark == 2) {
      // 当remark等于2时：falseData/trueData还原成formula2/formula1
      if (obj.trueData) {
        result.formula1 = parseExpressionToFormula(obj.trueData);
        result.tag4 = ""; // 清空tag4
        result.tags4 = []; // 清空tags4数组
      }
      if (obj.falseData) {
        result.formula2 = parseExpressionToFormula(obj.falseData);
        result.tag5 = ""; // 清空tag5
        result.tags5 = []; // 清空tags5数组
      }
    } else {
      // 当remark不等于2时：falseData/trueData还原成tag4/tags4和tag5/tags5
      if (obj.trueData) {
        const restoredValue = restoreValue(obj.trueData);
        result.tag4 = restoredValue;
        result.tags4 = [getTagElement(restoredValue)];
      } else {
        result.tag4 = "";
        result.tags4 = [];
      }

      if (obj.falseData) {
        const restoredValue = restoreValue(obj.falseData);
        result.tag5 = restoredValue;
        result.tags5 = [getTagElement(restoredValue)];
      } else {
        result.tag5 = "";
        result.tags5 = [];
      }
    }

    return result;
  }
  // 还原整个数组
  return processedArray.map((item) => {
    const el = restoreObject(item);
    const len = el.formulaIfElse.length;

    if (len) {
      for (let i = len - 1; i >= 0; i--) {
        if (i !== 0) {
          el.formulaIfElse[i].logicSymbol = el.formulaIfElse[i - 1].logicSymbol;
        } else {
          el.formulaIfElse[i].logicSymbol = "";
        }
      }
    }
    return el;
  });
}

export function generateResult(input) {
  // 检查输入是否有效
  if (!Array.isArray(input) || input.length === 0) {
    return null;
  }

  // 构建结果对象
  const result = {};

  // 处理标签的通用函数
  const processTags = (tags) => {
    if (tags && Array.isArray(tags)) {
      tags.forEach((tag) => {
        const key = tag.tableElementKey;
        if (key) {
          result[key] = {
            id: tag.id,
            name: tag.name,
            tableElementKey: key,
            type: tag.type,
          };
        }
      });
    }
  };

  // 处理公式数组(formula1和formula2)中的元素
  const processFormula = (formula) => {
    if (formula && Array.isArray(formula)) {
      formula.forEach((item) => {
        if (item.type === "Element" && item.tableElementKey) {
          const key = item.tableElementKey;
          result[key] = {
            id: item.id,
            name: item.name,
            tableElementKey: key,
            type: item.type,
          };
        }
      });
    }
  };

  // 遍历输入数组中的每一个对象元素
  input.forEach((data) => {
    if (data.formulaIfElse && Array.isArray(data.formulaIfElse)) {
      data.formulaIfElse.forEach((formulaItem) => {
        processTags(formulaItem.tags2);
        processTags(formulaItem.tags3);
      });
    }

    processTags(data.tags4);
    processTags(data.tags5);

    processFormula(data.formula1);
    processFormula(data.formula2);
  });

  if (Object.keys(result).length === 0) {
    return null;
  }

  return result;
}

export function transformData(data) {
  // 辅助函数：获取值并根据类型决定是否用E[]包裹
  const getValue = (directValue, arrayValues) => {
    if (directValue) {
      return directValue;
    }

    // 检查数组中第一个元素
    if (arrayValues && arrayValues.length > 0) {
      const firstItem = arrayValues[0];
      // 如果类型是Element，用E[]包裹tableElementKey
      if (firstItem.type === "Element" && firstItem.tableElementKey) {
        return `E[${firstItem.tableElementKey}]`;
      }
      return firstItem.tableElementKey || "";
    }

    return "";
  };

  // 处理getDataList中的每个对象
  const conditions = data.getDataList.map((item) => {
    // 获取左侧值 a
    const leftValue = getValue(item.tagWhenLeft, item.tagsWhenLeft);
    // 获取条件符号
    const condition = item.condition || "";
    // 获取右侧值 x
    const rightValue = getValue(item.tagWhenRight, item.tagsWhenRight);
    // 获取结果左侧 b
    const thenLeft = getValue(item.tagThenLeft, item.tagsThenLeft);
    // 获取结果右侧
    const thenRight = getValue(item.tagThenRight, item.tagsThenRight);

    return `${leftValue}${condition}${rightValue},${thenLeft}=${thenRight}`;
  });

  // 处理else部分
  const elseLeft = getValue(data.elseTagLeft, data.elseTagsLeft);
  const elseRight = getValue(data.elseTagRight, data.elseTagsRight);
  const elsePart = `else,${elseLeft}=${elseRight}`;

  // 组合所有部分
  return [...conditions, elsePart].join(",");
}

export function generateElementMap(originalData) {
  const elementMap = {};

  // 提取Element的工具函数
  const extractElements = (elements) => {
    if (elements && Array.isArray(elements)) {
      elements.forEach((element) => {
        if (element.type === "Element" && element.tableElementKey) {
          elementMap[element.tableElementKey] = {
            id: element.id,
            name: element.name,
            tableElementKey: element.tableElementKey,
            type: element.type,
          };
        }
      });
    }
  };

  // 处理getDataList中的元素
  if (originalData.getDataList && Array.isArray(originalData.getDataList)) {
    originalData.getDataList.forEach((item) => {
      // 处理tagsWhenLeft（新增）
      extractElements(item.tagsWhenLeft);
      // 处理tagsWhenRight
      extractElements(item.tagsWhenRight);
      // 处理tagsThenLeft（新增）
      extractElements(item.tagsThenLeft);
      // 处理tagsThenRight（新增）
      extractElements(item.tagsThenRight);
    });
  }

  // 处理elseTagsLeft中的元素
  extractElements(originalData.elseTagsLeft);

  // 处理elseTagsRight中的元素
  extractElements(originalData.elseTagsRight);

  return elementMap;
}
export function restoreData(str, map) {
  // 辅助函数：创建元素对象
  const createElement = (tableElementKey, text) => ({
    type: "Element",
    name: text, // 确保name是字符串
    id: Date.now().toString() + Math.random().toString(36).substr(2, 9),
    selected: false,
    tableElementKey: tableElementKey,
    children: [],
    text: text, // 确保text是字符串
    style: "background-color: #409EFF",
  });

  // 辅助函数：解析值并决定是直接值还是元素数组
  const parseValue = (value) => {
    // 检查是否是E[]包裹的元素
    const elementMatch = value.match(/^E\[(.+)\]$/);
    if (elementMatch) {
      const tableElementKey = elementMatch[1];
      // 映射tableElementKey到对应的text
      const textMap = map;
      const text = textMap[tableElementKey].name || tableElementKey;
      return {
        directValue: "",
        arrayValues: [createElement(tableElementKey, text)],
      };
    }

    // 普通值
    return {
      directValue: value,
      arrayValues: [],
    };
  };

  // 分割字符串为各个部分
  const parts = str.split(",");
  const elseIndex = parts.findIndex((part) => part === "else");

  if (elseIndex === -1) {
    // 如果没有else部分，返回合理的默认结构
    return {
      getDataList: [],
      elseTagLeft: "",
      elseTagsLeft: [],
      elseTagRight: "",
      elseTagsRight: [],
    };
  }

  // 提取条件部分和else部分
  const conditionParts = parts.slice(0, elseIndex);
  const elseParts = parts.slice(elseIndex + 1);

  // 处理条件部分
  const getDataList = [];
  for (let i = 0; i < conditionParts.length; i += 2) {
    const conditionStr = conditionParts[i];
    const resultStr = conditionParts[i + 1];

    if (!resultStr) continue; // 跳过无效条目

    // 解析条件部分 (a[condition]x)
    let leftValue, condition, rightValue;

    // 查找条件符号，按长度排序避免"=="被误解析为"="
    const conditions = ["!=", ">=", "<=", "=", ">", "<"];
    let foundCondition = null;

    for (const cond of conditions) {
      if (conditionStr.includes(cond) && conditionStr.indexOf(cond) > 0) {
        foundCondition = cond;
        break;
      }
    }

    if (foundCondition) {
      const conditionIndex = conditionStr.indexOf(foundCondition);
      leftValue = conditionStr.substring(0, conditionIndex);
      condition = foundCondition;
      rightValue = conditionStr.substring(
        conditionIndex + foundCondition.length
      );
    } else {
      // 如果没有找到条件符号，默认使用=
      leftValue = conditionStr;
      condition = "=";
      rightValue = "";
    }

    // 解析结果部分 (b=y)
    const [thenLeftStr, thenRightStr = ""] = resultStr.split("=");

    // 解析各个值
    const leftParsed = parseValue(leftValue);
    const rightParsed = parseValue(rightValue);
    const thenLeftParsed = parseValue(thenLeftStr);
    const thenRightParsed = parseValue(thenRightStr);

    // 添加到getDataList
    getDataList.push({
      tagWhenLeft: leftParsed.directValue,
      tagsWhenLeft: leftParsed.arrayValues,
      condition: condition,
      tagWhenRight: rightParsed.directValue,
      tagsWhenRight: rightParsed.arrayValues,
      tagThenLeft: thenLeftParsed.directValue,
      tagsThenLeft: thenLeftParsed.arrayValues,
      tagThenRight: thenRightParsed.directValue,
      tagsThenRight: thenRightParsed.arrayValues,
    });
  }

  // 处理else部分 - 修复主要问题点
  const elseKeyValue = elseParts[0] || "";
  const [elseLeftStr, elseRightStr = ""] = elseKeyValue.split("=");

  const elseLeftParsed = parseValue(elseLeftStr);
  const elseRightParsed = parseValue(elseRightStr);

  // 构建并返回原始对象结构
  return {
    getDataList: getDataList,
    elseTagLeft: elseLeftParsed.directValue,
    elseTagsLeft: elseLeftParsed.arrayValues,
    elseTagRight: elseRightParsed.directValue,
    elseTagsRight: elseRightParsed.arrayValues,
  };
}
export function convertToFCDataChange(data) {
  // 1. 元素：取arguments[0].tableElementKey（非空则用E[]包裹）
  let element = "";
  // 传统判断：先确保data、arguments、arguments[0]存在，再取tableElementKey
  if (
    data &&
    data.arguments &&
    data.arguments[0] &&
    data.arguments[0].tableElementKey
  ) {
    element = `E[${data.arguments[0].tableElementKey}]`;
  }

  // 2. 变化方式：取changeMethod（默认空字符串）
  const changeMethod = data && data.changeMethod ? data.changeMethod : "";

  // 3. 数据格式：取dataFormat（默认空字符串）
  const dataFormat = data && data.dataFormat ? data.dataFormat : "";

  // 4. 协同元素：优先coordinationTags数组 → 再fallback到coordinationTag单个标签
  let coordinationElement = "";
  // 先判断coordinationTags数组是否有有效数据
  if (
    data &&
    data.coordinationTags &&
    data.coordinationTags.length > 0 &&
    data.coordinationTags[0].tableElementKey
  ) {
    coordinationElement = `E[${data.coordinationTags[0].tableElementKey}]`;
  }
  // 数组无值时，取coordinationTag单个标签（需非空）
  else if (data && data.coordinationTag && data.coordinationTag.trim() !== "") {
    coordinationElement = data.coordinationTag;
  }

  // 5. 频率：优先frequencyTags数组 → 再fallback到frequencyTag单个标签
  let frequency = "";
  // 先判断frequencyTags数组是否有有效数据
  if (
    data &&
    data.frequencyTags &&
    data.frequencyTags.length > 0 &&
    data.frequencyTags[0].tableElementKey
  ) {
    frequency = `E[${data.frequencyTags[0].tableElementKey}]`;
  }
  // 数组无值时，取frequencyTag单个标签（需非空）
  else if (data && data.frequencyTag && data.frequencyTag.trim() !== "") {
    frequency = data.frequencyTag;
  }

  // 6. 单位：取frequencyUnit（默认空字符串）
  const unit = data && data.frequencyUnit ? data.frequencyUnit : "";

  // 7. stopConditionParamTags → 再stopConditionParamTags数组 → 最后fallback到stopConditionParamTag单个标签
  let stopElement = "";
  // stopConditionParamTags
  if (
    data &&
    data.stopConditionParamTags &&
    data.stopConditionParamTags.length > 0 &&
    data.stopConditionParamTags[0].tableElementKey
  ) {
    stopElement = `E[${data.stopConditionParamTags[0].tableElementKey}]`;
  }

  // 两个数组都无值时，取stopConditionParamTag单个标签（需非空）
  else if (
    data &&
    data.stopConditionParamTag &&
    data.stopConditionParamTag.trim() !== ""
  ) {
    stopElement = data.stopConditionParamTag;
  }

  // 8. 判断条件：取stopConditionOperator（默认空字符串）
  const conditionOperator =
    data && data.stopConditionOperator ? data.stopConditionOperator : "";

  // 9. 值：优先stopConditionValueTags数组 → 再fallback到stopConditionValueTag单个标签
  let value = "";
  // 先判断stopConditionValueTags数组是否有有效数据
  if (
    data &&
    data.stopConditionValueTags &&
    data.stopConditionValueTags.length > 0 &&
    data.stopConditionValueTags[0].tableElementKey
  ) {
    value = `E[${data.stopConditionValueTags[0].tableElementKey}]`;
  }
  // 数组无值时，取stopConditionValueTag单个标签（需非空）
  else if (
    data &&
    data.stopConditionValueTag &&
    data.stopConditionValueTag.trim() !== ""
  ) {
    value = data.stopConditionValueTag;
  }

  // 组合成最终的FC.dataChange格式
  return `FC.dataChange(${element},${changeMethod},${dataFormat},${coordinationElement},${frequency},${unit},${stopElement},${conditionOperator},${value})`;
}

// 从data中提取所有type为Element的对象，生成以tableElementKey为键的映射
export function extractElementMap(data) {
  const elementMap = {};

  // 需要检查的包含Element对象的数组字段
  const elementArrays = [
    "arguments",
    "coordinationTags",
    "frequencyTags",
    "stopConditionParamTags",
    "stopConditionValueTags",
  ];

  // 遍历所有可能包含Element对象的数组
  elementArrays.forEach((field) => {
    if (data && data[field] && Array.isArray(data[field])) {
      data[field].forEach((item) => {
        // 检查是否是有效的Element对象
        if (item && item.type === "Element" && item.tableElementKey) {
          // 以tableElementKey为键，存储对象的关键信息
          elementMap[item.tableElementKey] = {
            id: item.id,
            name: item.name,
            tableElementKey: item.tableElementKey,
            type: item.type,
            // 可根据需要添加其他属性
          };
        }
      });
    }
  });

  // 如果你提供的示例中"deviationRangeJson"是固定需要添加的字段，可以在这里补充
  // elementMap.deviationRangeJson = "{\"symbol\":\"【min,max】\",\"model\":\"1\",\"arguments1\":\"\",\"arguments2\":\"\"}";

  return elementMap;
}

export function restoreOriginalData(fcString, mapObj) {
  // 提取括号内的参数部分
  const paramsStr = fcString.replace(/^FC\.dataChange\((.*)\)$/, "$1");

  // 分割参数（处理可能包含逗号的情况）
  const params = [];
  let currentParam = "";
  let bracketCount = 0;

  for (let char of paramsStr) {
    if (char === "," && bracketCount === 0) {
      params.push(currentParam.trim());
      currentParam = "";
    } else {
      if (char === "[") bracketCount++;
      if (char === "]") bracketCount--;
      currentParam += char;
    }
  }
  params.push(currentParam.trim());

  // 创建结果对象
  const result = {
    changeMethod: "",
    dataFormat: "",
    frequencyUnit: "",
    stopConditionOperator: "",
    name: "数据自变", // 保持原始名称
    template: {
      ft: "FC.dataChange(#1,#2,#3,#4,#5,#6,#7,#8,#9)",
      args: [
        { key: "#1", m: "元素" },
        { key: "#2", m: "变化方式" },
        { key: "#3", m: "数据格式" },
        { key: "#4", m: "协同元素" },
        { key: "#5", m: "频率" },
        { key: "#6", m: "单位(1-年,2-月,3-日,4-时,5-分,6-秒)" },
        { key: "#7", m: "停止元素" },
        { key: "#8", m: "判断条件" },
        { key: "#9", m: "值" },
      ],
    },
    type: 0,
    example: "对时间元素进行自增或自减",
    number: null,
    arguments: [null, null, null, null, null, null, null, null, null],
    coordinationTag: "",
    coordinationTags: [],
    frequencyTags: [],
    frequencyTag: "",
    stopConditionParamTags: [],
    stopConditionParamTag: "",
    stopConditionValueTags: [],
    stopConditionValueTag: "",
  };

  // 解析参数并填充结果对象
  // 参数0: 元素
  if (params[0].startsWith("E[")) {
    const key = params[0].replace(/^E\[([^\]]+)\]$/, "$1");
    result.arguments[0] = mapObj[key]
      ? { ...mapObj[key], selected: false }
      : null;
  }

  // 参数1: 变化方式
  result.changeMethod = params[1] || "";

  // 参数2: 数据格式
  result.dataFormat = params[2] || "";

  // 参数3: 协同元素
  if (params[3].startsWith("E[")) {
    const key = params[3].replace(/^E\[([^\]]+)\]$/, "$1");
    if (mapObj[key]) {
      result.coordinationTags = [
        {
          ...mapObj[key],
          selected: false,
          children: [],
          text: mapObj[key].name,
          style: "background-color: #409EFF",
        },
      ];
    }
  } else if (params[3]) {
    result.coordinationTag = params[3];
  }

  // 参数4: 频率
  if (params[4].startsWith("E[")) {
    const key = params[4].replace(/^E\[([^\]]+)\]$/, "$1");
    if (mapObj[key]) {
      result.frequencyTags = [
        {
          ...mapObj[key],
          selected: false,
          children: [],
          text: mapObj[key].name,
          style: "background-color: #409EFF",
        },
      ];
    }
  } else if (params[4]) {
    result.frequencyTag = params[4];
  }

  // 参数5: 单位
  result.frequencyUnit = params[5] || "";

  // 参数6: 停止元素
  if (params[6].startsWith("E[")) {
    const key = params[6].replace(/^E\[([^\]]+)\]$/, "$1");
    if (mapObj[key]) {
      result.stopConditionParamTags = [
        {
          ...mapObj[key],
          selected: false,
          children: [],
          text: mapObj[key].name,
          style: "background-color: #409EFF",
        },
      ];
    }
  } else if (params[6]) {
    result.stopConditionParamTag = params[6];
  }

  // 参数7: 判断条件
  result.stopConditionOperator = params[7] || "";

  // 参数8: 值
  if (params[8].startsWith("E[")) {
    const key = params[8].replace(/^E\[([^\]]+)\]$/, "$1");
    if (mapObj[key]) {
      result.stopConditionValueTags = [
        {
          ...mapObj[key],
          selected: false,
          children: [],
          text: mapObj[key].name,
          style: "background-color: #409EFF",
        },
      ];
    }
  } else if (params[8]) {
    result.stopConditionValueTag = params[8];
  }

  return result;
}
