// import type { AppRouteRecordRaw } from '/@/router/types';

export interface TreeNode {
  id: number;
  parentId: number;
  name: string;
  key?: string;
  level?: string;
  children?: TreeNode[];
}
export interface TreeMenuNode {
  menuId: number;
  parentId: number;
  name: string;
  type?: number;
  id: number;
  children?: TreeMenuNode[];
}

// function traverse(tree: TreeMenuNode[], rootId: number) {
//   tree.forEach((item) => {
//     if (item.parentId == rootId) {
//       console.log('name', item.name);
//       console.log('menuId', item.menuId);
//       console.log('rootId', rootId);
//       // temp.push(item.parentId);
//       // item.key = temp;
//     }
//     if (item.children?.length) {
//       traverse(item.children, item.menuId);
//     }
//   });
// }

export function makeTree(treeNodes: TreeNode[]): TreeNode[] {
  // 提前生成节点查找表。
  // 如果明确节点是顺序可以保证先父后子，可以省去这次遍历，在后面边遍历过程中填充查找表
  const nodesMap = new Map<number, TreeNode>(treeNodes.map((node) => [node.id, node]));

  // 引入虚拟根节点来统一实现 parent 始终有效，避免空判断
  const virtualRoot = {} as Partial<TreeNode>;
  treeNodes.forEach((node) => {
    const parent = nodesMap.get(node.parentId) ?? virtualRoot;
    (parent.children ??= []).push(node);
  });
  // if (virtualRoot.children?.length) {
  //   traverse(virtualRoot.children, virtualRoot.children[0].id);
  // }

  return virtualRoot.children ?? [];
}

export function getTreeId(treeNodes: TreeMenuNode[]): number[] {
  // 提前生成节点查找表。
  // 如果明确节点是顺序可以保证先父后子，可以省去这次遍历，在后面边遍历过程中填充查找表
  // const nodesMap = new Map<number, TreeNode>(treeNodes.map((node) => [node.id, node]));
  // 引入虚拟根节点来统一实现 parent 始终有效，避免空判断
  const TreeIdList: number[] = [];
  function getTreeIdList(list: TreeMenuNode[]) {
    return list.map((ele) => {
      if (ele.children && ele.children.length) {
        getTreeIdList(ele.children);
      } else {
        TreeIdList.push(ele.id);
      }
    });
  }
  getTreeIdList(treeNodes);
  console.log('TreeIdList', TreeIdList, treeNodes);
  return TreeIdList ?? [];
}

export function makeMenuTree(treeNodes: TreeMenuNode[]): TreeMenuNode[] {
  const nodesMap = new Map<number, TreeMenuNode>(treeNodes.map((node) => [node.menuId, node]));

  // 引入虚拟根节点来统一实现 parent 始终有效，避免空判断
  const virtualRoot = {} as Partial<TreeMenuNode>;
  treeNodes.forEach((node) => {
    const parent = nodesMap.get(node.parentId) ?? virtualRoot;
    (parent.children ??= []).push(node);
  });
  return virtualRoot.children ?? [];
}
/**
 * 递归修改文件树的字段名称
 * @param {Array|Object} tree - 文件树数据（数组/单个节点对象）
 * @param {Object} fieldMap - 字段名映射表 { 原字段名: 目标字段名 }
 * @returns {Array|Object} 修改后的文件树
 */
export function renameTreeFields(tree, fieldMap) {
  // 边界条件：空值直接返回
  if (tree === null || typeof tree !== 'object') {
    return tree;
  }

  // 如果是数组，递归处理每个元素
  if (Array.isArray(tree)) {
    return tree.map((item) => renameTreeFields(item, fieldMap));
  }

  // 如果是对象，遍历所有键并替换
  const newNode = {
    ...tree,
    label: tree.nameSn,
    value: tree.code,
    // 替换字段名（如果在映射表中）
    [fieldMap['childrenList']]: renameTreeFields(tree.childrenList, fieldMap),
    // [fieldMap['children']]: renameTreeFields(tree.children, fieldMap),
  };
  return newNode;
}