// https://github.com/TypeScriptToLua/TypeScriptToLua/pull/1613
test("using transformer keeps parent chain for recursively transformed nested usings", () => {
    const code = `
        declare function disposable(): Disposable;

        function f() {
            using a = disposable();

            {
                using b = disposable();
            }
        }
    `;

    const program = createVirtualProgram({ "main.ts": code }, { target: ts.ScriptTarget.ESNext, lib: ["lib.esnext.d.ts"] });
    const sourceFile = program.getSourceFile("main.ts");
    util.assert(sourceFile);

    const context = new TransformationContext(program, sourceFile, createVisitorMap([]));
    const transformed = ts.transform(sourceFile, [usingTransformer(context)]).transformed[0];

    type NodeRelation = {
        id: number;
        kind: ts.SyntaxKind;
        text?: string;
        parent: string;
        children: number[];
    };

    const nodeToId = new Map<ts.Node, number>();
    const relations: NodeRelation[] = [];

    const visit = (node: ts.Node) => {
        const id = relations.length;
        nodeToId.set(node, id);
        relations.push({ id, kind: node.kind, text: ts.isIdentifier(node) ? node.text : undefined, parent: "-", children: [] });

        ts.forEachChild(node, child => {
            const childId = visit(child);
            relations[id].children.push(childId);
        });

        return id;
    };

    visit(transformed);

    for (const [node, id] of nodeToId.entries()) {
        if (!node.parent) {
            relations[id].parent = "-";
            continue;
        }

        const parentId = nodeToId.get(node.parent);
        relations[id].parent = parentId !== undefined ? String(parentId) : `outside:${ts.SyntaxKind[node.parent.kind]}`;
    }

    const usingIds = relations.filter(r => r.kind === ts.SyntaxKind.Identifier && r.text === "__TS__Using").map(r => r.id);
    expect(usingIds).toHaveLength(2);

    const functionId = relations.find(r => r.kind === ts.SyntaxKind.FunctionDeclaration && r.children.some(childId => relations[childId].kind === ts.SyntaxKind.Identifier && relations[childId].text === "f"))?.id;
    util.assert(functionId !== undefined);

    const functionBlockId = relations[functionId].children.find(childId => relations[childId].kind === ts.SyntaxKind.Block);
    util.assert(functionBlockId !== undefined);

    const formatNodeLine = (id: number, depth: number) => {
        const r = relations[id];
        const text = r.text ?? "-";
        return `${"  ".repeat(depth)}- ${r.id} ${ts.SyntaxKind[r.kind]} ${text} parent=${r.parent}`;
    };

    const renderTree = (id: number, depth: number): string[] => {
        const lines = [formatNodeLine(id, depth)];
        for (const childId of relations[id].children) {
            lines.push(...renderTree(childId, depth + 1));
        }
        return lines;
    };

    const subtreeIds = new Set<number>();
    const collectSubtree = (id: number) => {
        if (subtreeIds.has(id)) return;
        subtreeIds.add(id);
        for (const childId of relations[id].children) collectSubtree(childId);
    };
    collectSubtree(functionBlockId);

    const mismatchLines: string[] = [];
    for (const relation of relations) {
        if (!subtreeIds.has(relation.id)) continue;
        for (const childId of relation.children) {
            if (!subtreeIds.has(childId)) continue;
            const child = relations[childId];
            const expectedParent = String(relation.id);
            if (child.parent !== expectedParent) {
                mismatchLines.push(`- child ${child.id} ${ts.SyntaxKind[child.kind]} expectedParent=${expectedParent} actualParent=${child.parent}`);
            }
        }
    }

    const treeDump = renderTree(functionBlockId, 0).join("\n");
    const mismatchesDump = mismatchLines.length > 0 ? mismatchLines.join("\n") : "none";
    const dump = `tree:\n${treeDump}\nparentMismatches:\n${mismatchesDump}`;

    expect(dump).toBe(`...`)
});