export type TreeNode<T = any> = T & {
  id: number;
  parentId: number;
  children?: TreeNode<T>[];
};

export type ListNode<T extends object = any> = T & {
  id: number;
  parentId: number;
};

export function list2Tree<T extends ListNode[]>(
  items: T,
  parentId: number | null = null
): TreeNode<T[number]>[] {
  return items
    .filter(item => item.parentId === parentId)
    .map(item => {
      const children = list2Tree(items, item.id);
      return {
        ...item,
        ...(children.length ? { children } : null)
      };
    });
}

/**
 * 过滤树，返回列表数据
 * @param treeData
 * @param key 用于过滤的字段
 * @param value 用于过滤的值
 * @returns
 */
export function filterTree2List(treeData, key, value) {
  const filterChildrenTree = (resTree, treeItem) => {
    if (treeItem[key].includes(value)) {
      resTree.push(treeItem);
      return resTree;
    }
    if (Array.isArray(treeItem.children)) {
      const children = treeItem.children.reduce(filterChildrenTree, []);

      const data = { ...treeItem, children };

      if (children.length) resTree.push({ ...data });
    }
    return resTree;
  };
  return treeData.reduce(filterChildrenTree, []);
}

/**
 * 过滤树，并保留原有的结构
 * @param treeData
 * @param predicate
 * @returns
 */
export function filterTree<T extends TreeNode>(
  treeData: TreeNode<T>[],
  predicate: (data: T) => boolean
): TreeNode<T>[] {
  function filter(treeData: TreeNode<T>[]): TreeNode<T>[] {
    if (!treeData?.length) return treeData;

    return treeData.filter(data => {
      if (!predicate(data)) return false;

      data.children = filter(data.children);
      return true;
    });
  }

  return filter(treeData) || [];
}

export function deleteEmptyChildren(arr: any) {
  arr?.forEach(node => {
    if (node.children?.length === 0) delete node.children;
    else deleteEmptyChildren(node.children);
  });
}