// export function flattenToMultiLevelFormatWithRowSpanAdvanced(data) {
//   const result = [];
//   const rowSpanMap = new Map();
//   const firstIndexMap = new Map();

//   // 预处理：构建完整的层级关系
//   const organizeButtonsToPages = (nodes) => {
//     // 第一步：收集所有节点，建立ID到节点的映射
//     const allNodes = new Map();

//     const collectAllNodes = (nodeList, parentPath = []) => {
//       nodeList.forEach((node) => {
//         // 构建当前节点的完整路径
//         const currentPath = [
//           ...parentPath,
//           {
//             id: node.id,
//             name: node.name,
//             type: node.type,
//             icon: node.icon,
//           },
//         ];

//         // 存储节点信息，包含层级路径
//         allNodes.set(node.id, {
//           ...node,
//           path: currentPath,
//           level: currentPath.length,
//         });

//         if (node.children && node.children.length > 0) {
//           collectAllNodes(node.children, currentPath);
//         }
//       });
//     };

//     collectAllNodes(nodes);

//     // 第二步：为每个节点构建完整的层级字段
//     const processedNodes = Array.from(allNodes.values()).map((node) => {
//       const processedNode = { ...node };

//       // 添加层级字段 (name1, name2, name3, id1, id2, id3, parent_id1, parent_id2, ...)
//       node.path.forEach((pathNode, index) => {
//         const level = index + 1;
//         processedNode[`name${level}`] = pathNode.name;
//         processedNode[`id${level}`] = pathNode.id;
//         processedNode[`type${level}`] = pathNode.type;
//         processedNode[`icon${level}`] = pathNode.icon;

//         // 添加父级ID字段
//         if (index > 0) {
//           processedNode[`parent_id${level}`] = node.path[index - 1].id;
//         }
//       });

//       return processedNode;
//     });

//     // 第三步：根据parent_id构建children关系
//     const buildHierarchy = (nodeList) => {
//       const nodesById = new Map();
//       const rootNodes = [];

//       // 建立ID到节点的映射
//       nodeList.forEach((node) => {
//         nodesById.set(node.id, { ...node, children: [] });
//       });

//       // 构建父子关系
//       nodeList.forEach((node) => {
//         if (node.parent_id) {
//           const parentNode = nodesById.get(node.parent_id);
//           if (parentNode) {
//             parentNode.children.push(nodesById.get(node.id));
//           } else {
//             // 如果没有找到父节点，作为根节点
//             rootNodes.push(nodesById.get(node.id));
//           }
//         } else {
//           // 没有parent_id的作为根节点
//           rootNodes.push(nodesById.get(node.id));
//         }
//       });

//       return rootNodes;
//     };

//     return buildHierarchy(processedNodes);
//   };

//   // 预处理数据
//   const processedData = organizeButtonsToPages(data);
//   console.log('预处理后的数据:', processedData);

//   // 计算每个节点的叶子节点数量（按钮也算作叶子节点）
//   const calculateChildrenCount = (node) => {
//     let leafCount = 0;

//     if (node.children && node.children.length > 0) {
//       node.children.forEach((child) => {
//         if (
//           child.type === 'Button' ||
//           !child.children ||
//           child.children.length === 0
//         ) {
//           leafCount += 1;
//         } else {
//           leafCount += calculateChildrenCount(child);
//         }
//       });
//     }

//     rowSpanMap.set(node.id, leafCount);
//     return leafCount;
//   };

//   // 计算所有节点
//   processedData.forEach((root) => {
//     calculateChildrenCount(root);
//   });

//   console.log('跨行配置:', rowSpanMap);

//   // 扁平化并记录首次出现索引
//   const traverse = (node, currentPath = []) => {
//     const newPath = [
//       ...currentPath,
//       {
//         name: node.name,
//         id: node.id,
//         type: node.type,
//         icon: node.icon,
//       },
//     ];

//     // 记录每个节点第一次出现的索引
//     newPath.forEach((pathNode) => {
//       if (!firstIndexMap.has(pathNode.id)) {
//         firstIndexMap.set(pathNode.id, result.length);
//       }
//     });

//     // 生成数据的条件：叶子节点 或 按钮
//     const shouldGenerateData =
//       !node.children || node.children.length === 0 || node.type === 'Button';

//     if (shouldGenerateData) {
//       const item = {
//         id: node.id,
//         name: node.name,
//         guard_name: node.guard_name,
//         created_at: node.created_at,
//         updated_at: node.updated_at,
//         key: node.key,
//         icon: node.icon,
//         type: node.type,
//         backend_apis: node.backend_apis,
//         path: node.path,
//         _lft: node._lft,
//         _rgt: node._rgt,
//         parent_id: node.parent_id,
//         level: newPath.length,
//         is_leaf: true,
//         // 跨行配置
//         row_spans: {},
//       };

//       // 添加层级字段和跨行信息
//       newPath.forEach((pathNode, index) => {
//         const level = index + 1;
//         item[`name${level}`] = pathNode.name;
//         item[`id${level}`] = pathNode.id;
//         item[`type${level}`] = pathNode.type;
//         item[`icon${level}`] = pathNode.icon;

//         // 存储跨行信息
//         item.row_spans[`row_span${level}`] = rowSpanMap.get(pathNode.id) || 0;
//         item.row_spans[`first_index${level}`] = firstIndexMap.get(pathNode.id);
//       });

//       // 添加父级ID字段
//       for (let i = 2; i <= newPath.length; i++) {
//         item[`parent_id${i}`] = newPath[i - 2].id;
//       }

//       result.push(item);
//     }

//     // 递归处理子节点（按钮不继续递归）
//     if (node.children && node.children.length > 0 && node.type !== 'Button') {
//       node.children.forEach((child) => {
//         traverse(child, newPath);
//       });
//     }
//   };

//   processedData.forEach((item) => {
//     traverse(item, []);
//   });

//   console.log('最终处理后的数据:', result);
//   return result;
// }

// export function flattenToMultiLevelFormatWithRowSpanAdvancedNew(data: any[]) {
//   let result: any = [];
//   let length = 0;
//   data?.forEach((res: any, idx: number) => {
//     let row: any = {};
//     res?.children?.forEach((child: any, index: number) => {
//       row.id = `${res?.id}_${child.id}`;
//       row.name2 = child.name;
//       row.path2 = child.path;
//       row.icon2 = child.icon;
//       row.id1 = res.id;
//       row.id2 = child.id;
//       if (child.children?.length) {
//         row.buttonList = child.children;
//         child.children?.forEach((child2: any) => {
//           if (child2?.children?.length) {
//             row.buttonList = [...row.buttonList, ...child2?.children];
//           }
//         });
//       } else {
//         row.buttonList = null;
//       }
//       row.row_spans = {
//         rowSpan: !index ? res?.children?.length : 0,
//         firstIndex: idx > 0 && index === 0 ? length : 0,
//       };
//       result.push({ name: res?.name, path: res?.path, ...row });
//     });
//     length += res?.children?.length;
//   });
//   console.log('最终处理后的数据:', result);
//   return result;
// }

export function flattenToMultiLevelFormatWithRowSpanAdvancedNew(data: any) {
  if (!data || !Array.isArray(data)) {
    console.log('数据为空或不是数组');
    return [];
  }

  let result: any[] = [];
  let totalRows = 0; // 记录已处理的总行数

  data.forEach((res: any, parentIndex: number) => {
    // 检查父级数据是否有效
    if (!res || typeof res !== 'object') {
      console.warn(`第${parentIndex}个父级数据无效，跳过处理`);
      return;
    }

    const parentId = res?.id || `parent_${parentIndex}`;
    const parentName = res?.name || '';
    const parentPath = res?.path || '';

    // 获取子级数据
    const children = res?.children || [];
    const childrenLength = children.length;

    // 情况1: 如果没有子级，直接添加父级信息到结果
    if (!childrenLength) {
      const row = {
        id: parentId,
        name: parentName,
        path: parentPath,
        id1: parentId,
        buttonList: null,
        row_spans: {
          rowSpan: 1, // 没有子级，父级占一行
          firstIndex: parentIndex > 0 ? totalRows : 0,
        },
      };
      result.push(row);
      totalRows += 1; // 父级占据一行
      return;
    }

    // 情况2: 有子级，为每个子级创建一行
    children.forEach((child: any, childIndex: number) => {
      // 检查子级数据是否有效
      if (!child || typeof child !== 'object') {
        console.warn(`父级${parentId}的第${childIndex}个子级数据无效，跳过`);
        return;
      }

      const childId = child?.id || `${parentId}_child_${childIndex}`;

      // 收集所有按钮（第三级和更深层级的子级）
      let buttonList: any[] = [];

      // 处理直接子级的children（第三级）
      if (Array.isArray(child.children) && child.children.length > 0) {
        child.children.forEach((child2: any) => {
          if (child2 && typeof child2 === 'object') {
            // 添加第三级
            buttonList.push(child2);

            // 处理第四级及更深层级
            if (Array.isArray(child2.children) && child2.children.length > 0) {
              buttonList = buttonList.concat(
                child2.children.filter(
                  (item: any) => item && typeof item === 'object',
                ),
              );
            }
          }
        });
      }

      // 创建行数据
      const row: any = {
        id: `${parentId}_${childId}`,
        name: parentName, // 父级名称
        path: parentPath, // 父级路径
        name2: child.name || '', // 子级名称
        path2: child.path || '', // 子级路径
        icon2: child.icon || null, // 子级图标
        id1: parentId, // 父级ID
        id2: childId, // 子级ID
        buttonList: buttonList.length > 0 ? buttonList : null, // 按钮列表
        row_spans: {
          // 只有第一个子级显示rowSpan，其他子级为0
          rowSpan: childIndex === 0 ? childrenLength : 0,
          // 只有第一个子级需要设置firstIndex
          firstIndex: parentIndex > 0 && childIndex === 0 ? totalRows : 0,
        },
      };

      result.push(row);
    });

    totalRows += childrenLength; // 更新总行数
  });

  console.log('最终处理后的数据:', result);
  return result;
}
