import type { MaybePromise } from './typed.js'

export type Tree<T extends {}> = Omit<T, 'children'> & {
    children?: T[] | undefined
}

/** Options for {@link flattenTree} */
export interface FlattenTreeOptions<T extends {}> {
    /** children 字段 */
    childrenKey?: keyof T
}

/**
 * 平铺树节点
 * @param tree - 树
 * @param options - 配置
 */
export declare function flattenTree<T extends {}>(tree: T[], options?: FlattenTreeOptions<T>): T[]

/**
 * 数组转成树的配置
 */
export interface Array2TreeOptions<T extends {}> {
    /**
     * 根节点ID，默认自动计算
     */
    rootId?: string
    /**
     * 数据的ID字段名
     * @defaultValue 'id'
     */
    idKey?: keyof T
    /**
     * 数据的父节点ID字段名
     * @defaultValue 'parentId'
     */
    parentKey?: keyof T
    /**
     * 数据的下级节点字段名
     * @defaultValue 'children'
     */
    childrenKey?: keyof T
    /**
     * 数据的排序字段名
     */
    sortKey?: keyof T
    /**
     * 是否覆盖原 children
     */
    overwriteChildren?: boolean
}
/**
 * 数组转成树

 *
 * @param data - 源数组
 * @param options - 转换配置
 * @returns 树
 */
export declare function array2Tree<T extends {}>(data: T[], options?: Array2TreeOptions<T>): T[]

/**
 * 遍历树节点的配置
 */
export interface WalkTreeOptions<T extends {}> {
    /**
     * 是否异步等待 each 的返回结果
     */
    async?: boolean

    /**
     * 是否返回所有祖先节点
     */
    path?: boolean

    /**
     * 数据的下级节点字段名
     * @defaultValue 'children'
     */
    childrenKey?: keyof T

    /**
     * 遍历顺序
     * - pre 节点在子节点之前遍历
     * - post 节点在子节点之后遍历
     * @defaultValue 'pre'
     */
    order?: 'pre' | 'post'
}
/**
 * 遍历树节点
 *
 * @param data - 源数组
 * @param each - 遍历方法，返回 false 结束遍历
 * @param options - 转换配置
 * @returns false 异常结束；true 正常结束
 */
export declare function walkTree<T extends {}>(
    data: T[],
    each: (item: T, index: number, parent: T | undefined, children: T[] | undefined) => MaybePromise<boolean | void>,
    options?: WalkTreeOptions<T> & {
        async: true
        path?: false
    },
): Promise<boolean>

export declare function walkTree<T extends {}>(
    data: T[],
    each: (item: T, index: number, parents: T[], children: T[] | undefined) => MaybePromise<boolean | void>,
    options?: WalkTreeOptions<T> & {
        async: true
        path: true
    },
): Promise<boolean>

export declare function walkTree<T extends {}>(
    data: T[],
    each: (item: T, index: number, parent: T | undefined, children: T[] | undefined) => boolean | void,
    options?: WalkTreeOptions<T> & {
        async?: false
        path?: false
    },
): boolean

export declare function walkTree<T extends {}>(
    data: T[],
    each: (item: T, index: number, parents: T[], children: T[] | undefined) => boolean | void,
    options?: WalkTreeOptions<T> & {
        async?: false
        path: true
    },
): boolean

/**
 * 遍历树节点的配置
 */
export interface FilterTreeOptions<T extends {}> {
    /**
     * 数据的下级节点字段名
     * @defaultValue 'children'
     */
    childrenKey?: keyof T
}
/**
 * 过滤树节点
 *
 * - filter 返回 truthy 或子孙节点留存的节点会被保留
 * - 注意：在原始数据上操作，如需要保留原始数据，需克隆后操作
 *
 * @param data - 源数组
 * @param filter - 过滤方法
 * @param multiple - 是否查找多个
 * @returns 过滤后的节点
 */
export declare function filterTree<T extends {}>(
    data: T[],
    filter: (item: T, index: number, parent: T | undefined, children: T[] | undefined) => unknown,
    options?: FilterTreeOptions<T>,
): T[]

/**
 * 查找树节点
 * @param data - 源数组
 * @param finder - 查找方法
 * @param multiple - 是否查找多个
 * @returns 找到的节点
 */
export declare function findInTree<T extends {}>(
    data: T[],
    finder: (item: T, index: number, parent: T | undefined, children: T[] | undefined) => boolean,
    multiple?: false,
): T | undefined
export declare function findInTree<T extends {}>(
    data: T[],
    finder: (item: T, index: number, parent: T | undefined, children: T[] | undefined) => boolean,
    multiple: true,
): T[]