/**
 * Phase 4c — Agent B tests for `diff.ts`.
 *
 * 20+ cases covering:
 *   - null-handling (first apply, never-null `next`)
 *   - cross-provider guard
 *   - every Change kind
 *   - deterministic cross-table ordering
 *   - deterministic within-table ordering
 *   - rename NEVER auto-detected — always drop + add
 *   - convenience `diffResources` wrapper
 */

import { describe, test, expect } from "bun:test";
import type {
  Change,
  DdlFieldDef,
  DdlIndex,
  DdlResource,
  Snapshot,
  SqlProvider,
} from "../types";
import type { ParsedResource } from "../../parser";
import type { ResourceDefinition } from "../../schema";
import { diffSnapshots, diffResources } from "../diff";

// --------------------------------------------------------------------
// Builders — tiny + explicit so each test reads like a spec
// --------------------------------------------------------------------

function field(
  name: string,
  overrides: Partial<DdlFieldDef> = {}
): DdlFieldDef {
  return {
    name,
    type: "string",
    nullable: false,
    primary: false,
    unique: false,
    indexed: false,
    ...overrides,
  };
}

function resource(
  name: string,
  fields: DdlFieldDef[] = [],
  indexes: DdlIndex[] = []
): DdlResource {
  return { name, fields, indexes };
}

function snapshot(
  resources: DdlResource[],
  provider: SqlProvider = "postgres"
): Snapshot {
  return {
    version: 1,
    provider,
    resources,
    generatedAt: "2026-04-17T00:00:00.000Z",
  };
}

const userPK: DdlFieldDef = field("id", { type: "uuid", primary: true });

// --------------------------------------------------------------------
// TC-1..3 — null handling
// --------------------------------------------------------------------

describe("diffSnapshots — null handling", () => {
  test("1. diffSnapshots(null, empty snapshot) → []", () => {
    expect(diffSnapshots(null, snapshot([]))).toEqual([]);
  });

  test("2. diffSnapshots(null, {A}) → [create-table A]", () => {
    const users = resource("users", [userPK]);
    const out = diffSnapshots(null, snapshot([users]));
    expect(out).toHaveLength(1);
    expect(out[0]).toEqual({ kind: "create-table", resource: users });
  });

  test("3. diffSnapshots({A}, null) → throws (next may not be null)", () => {
    const users = resource("users", [userPK]);
    // @ts-expect-error — deliberately violating the contract
    expect(() => diffSnapshots(snapshot([users]), null)).toThrow(
      /next.*must be a Snapshot/
    );
  });

  test("4. diffSnapshots({A}, empty) → [drop-table A]", () => {
    const users = resource("users", [userPK]);
    const out = diffSnapshots(snapshot([users]), snapshot([]));
    expect(out).toEqual([{ kind: "drop-table", resourceName: "users" }]);
  });
});

// --------------------------------------------------------------------
// TC-5 — cross-provider guard
// --------------------------------------------------------------------

describe("diffSnapshots — cross-provider guard", () => {
  test("5. postgres → mysql snapshot diff throws TypeError", () => {
    const pg = snapshot([resource("users", [userPK])], "postgres");
    const my = snapshot([resource("users", [userPK])], "mysql");
    expect(() => diffSnapshots(pg, my)).toThrow(/Cross-provider diff/);
  });
});

// --------------------------------------------------------------------
// TC-6..10 — single-dimension column changes
// --------------------------------------------------------------------

describe("diffSnapshots — column-level changes", () => {
  test("6. add a field → [add-column]", () => {
    const before = snapshot([resource("users", [userPK])]);
    const after = snapshot([resource("users", [userPK, field("email", { type: "email" })])]);
    const out = diffSnapshots(before, after);
    expect(out).toHaveLength(1);
    expect(out[0]).toMatchObject({
      kind: "add-column",
      resourceName: "users",
      field: { name: "email", type: "email" },
    });
  });

  test("7. drop a field → [drop-column]", () => {
    const before = snapshot([resource("users", [userPK, field("email", { type: "email" })])]);
    const after = snapshot([resource("users", [userPK])]);
    const out = diffSnapshots(before, after);
    expect(out).toHaveLength(1);
    expect(out[0]).toEqual({
      kind: "drop-column",
      resourceName: "users",
      fieldName: "email",
    });
  });

  test("8. change field type → [alter-column-type] with stub:true", () => {
    const before = snapshot([
      resource("users", [userPK, field("age", { type: "number" })]),
    ]);
    const after = snapshot([
      resource("users", [userPK, field("age", { type: "string" })]),
    ]);
    const out = diffSnapshots(before, after);
    expect(out).toHaveLength(1);
    expect(out[0]).toEqual({
      kind: "alter-column-type",
      resourceName: "users",
      fieldName: "age",
      fromType: "number",
      toType: "string",
      stub: true,
    });
  });

  test("9. flip nullable → [alter-column-nullable]", () => {
    const before = snapshot([
      resource("users", [userPK, field("bio", { type: "string", nullable: false })]),
    ]);
    const after = snapshot([
      resource("users", [userPK, field("bio", { type: "string", nullable: true })]),
    ]);
    const out = diffSnapshots(before, after);
    expect(out).toHaveLength(1);
    expect(out[0]).toEqual({
      kind: "alter-column-nullable",
      resourceName: "users",
      fieldName: "bio",
      nullable: true,
    });
  });

  test("10. change default → [alter-column-default]", () => {
    const before = snapshot([
      resource("users", [
        userPK,
        field("active", { type: "boolean", default: { kind: "literal", value: false } }),
      ]),
    ]);
    const after = snapshot([
      resource("users", [
        userPK,
        field("active", { type: "boolean", default: { kind: "literal", value: true } }),
      ]),
    ]);
    const out = diffSnapshots(before, after);
    expect(out).toHaveLength(1);
    expect(out[0]).toEqual({
      kind: "alter-column-default",
      resourceName: "users",
      fieldName: "active",
      default: { kind: "literal", value: true },
    });
  });

  test("removing default emits alter-column-default with no default", () => {
    const before = snapshot([
      resource("users", [
        userPK,
        field("active", { type: "boolean", default: { kind: "literal", value: true } }),
      ]),
    ]);
    const after = snapshot([
      resource("users", [userPK, field("active", { type: "boolean" })]),
    ]);
    const out = diffSnapshots(before, after);
    expect(out).toHaveLength(1);
    expect(out[0]).toMatchObject({
      kind: "alter-column-default",
      resourceName: "users",
      fieldName: "active",
    });
    // @ts-expect-error — discriminated narrow
    expect(out[0].default).toBeUndefined();
  });

  test("identical snapshot → []", () => {
    const s = snapshot([resource("users", [userPK, field("email", { type: "email" })])]);
    expect(diffSnapshots(s, s)).toEqual([]);
  });
});

// --------------------------------------------------------------------
// TC-11 — rename NEVER auto-detected
// --------------------------------------------------------------------

describe("diffSnapshots — rename policy", () => {
  test("11. renamed field surfaces as drop + add (never rename)", () => {
    const before = snapshot([
      resource("users", [userPK, field("userName", { type: "string" })]),
    ]);
    const after = snapshot([
      resource("users", [userPK, field("displayName", { type: "string" })]),
    ]);
    const out = diffSnapshots(before, after);
    const kinds = out.map((c) => c.kind);
    expect(kinds).toContain("drop-column");
    expect(kinds).toContain("add-column");
    expect(kinds).not.toContain("rename-column");
  });

  test("renamed table surfaces as drop + create (never rename)", () => {
    const before = snapshot([resource("users", [userPK])]);
    const after = snapshot([resource("accounts", [userPK])]);
    const out = diffSnapshots(before, after);
    const kinds = out.map((c) => c.kind);
    expect(kinds).toContain("drop-table");
    expect(kinds).toContain("create-table");
    expect(kinds).not.toContain("rename-table");
  });
});

// --------------------------------------------------------------------
// TC-12 — within-table order
// --------------------------------------------------------------------

describe("diffSnapshots — within-table order", () => {
  test("12. multiple column changes on one table: drops → alters → adds", () => {
    // Before: id, password, status (string)
    // After:  id, status (number), bio       — drop `password`, alter `status` type, add `bio`
    const before = snapshot([
      resource("users", [
        userPK,
        field("password", { type: "string" }),
        field("status", { type: "string" }),
      ]),
    ]);
    const after = snapshot([
      resource("users", [
        userPK,
        field("status", { type: "number" }),
        field("bio", { type: "string" }),
      ]),
    ]);
    const out = diffSnapshots(before, after);
    const kinds = out.map((c) => c.kind);
    // drop-column must precede alter-column-type; alter-column-type must precede add-column.
    const dropIdx = kinds.indexOf("drop-column");
    const alterIdx = kinds.indexOf("alter-column-type");
    const addIdx = kinds.indexOf("add-column");
    expect(dropIdx).toBeGreaterThanOrEqual(0);
    expect(alterIdx).toBeGreaterThan(dropIdx);
    expect(addIdx).toBeGreaterThan(alterIdx);
  });

  test("multiple drop-columns on the same table sort alphabetically", () => {
    const before = snapshot([
      resource("users", [
        userPK,
        field("zebra"),
        field("apple"),
        field("mango"),
      ]),
    ]);
    const after = snapshot([resource("users", [userPK])]);
    const out = diffSnapshots(before, after);
    const dropNames = out
      .filter((c) => c.kind === "drop-column")
      .map((c) => (c as { fieldName: string }).fieldName);
    expect(dropNames).toEqual(["apple", "mango", "zebra"]);
  });
});

// --------------------------------------------------------------------
// TC-13..14 — indexes + create-table inline indexes
// --------------------------------------------------------------------

describe("diffSnapshots — indexes", () => {
  test("13. drop table with index → [drop-index, drop-table] (drop-index first)", () => {
    const idx: DdlIndex = { name: "idx_users_email", fields: ["email"], unique: true };
    const before = snapshot([
      resource("users", [userPK, field("email", { type: "email" })], [idx]),
    ]);
    const after = snapshot([]);
    const out = diffSnapshots(before, after);
    expect(out.map((c) => c.kind)).toEqual(["drop-index", "drop-table"]);
  });

  test("14. create table with declared index → single [create-table] (no separate add-index)", () => {
    const idx: DdlIndex = { name: "idx_users_email", fields: ["email"], unique: true };
    const after = snapshot([
      resource("users", [userPK, field("email", { type: "email" })], [idx]),
    ]);
    const out = diffSnapshots(null, after);
    expect(out.map((c) => c.kind)).toEqual(["create-table"]);
    // The inline index lives on the CREATE TABLE's resource payload —
    // Agent A's emit is responsible for CREATE INDEX inside CREATE TABLE.
    expect((out[0] as { resource: DdlResource }).resource.indexes).toHaveLength(1);
  });

  test("20. adding indexed flag to an existing column via a new index → [add-index]", () => {
    const idx: DdlIndex = { name: "idx_users_email", fields: ["email"], unique: false };
    const before = snapshot([
      resource("users", [userPK, field("email", { type: "email" })], []),
    ]);
    const after = snapshot([
      resource("users", [userPK, field("email", { type: "email" })], [idx]),
    ]);
    const out = diffSnapshots(before, after);
    expect(out).toHaveLength(1);
    expect(out[0]).toEqual({ kind: "add-index", resourceName: "users", index: idx });
  });

  test("changing an index's shape (e.g. unique flip) → drop-index + add-index", () => {
    const before = snapshot([
      resource("users", [userPK, field("email", { type: "email" })], [
        { name: "idx_users_email", fields: ["email"], unique: false },
      ]),
    ]);
    const after = snapshot([
      resource("users", [userPK, field("email", { type: "email" })], [
        { name: "idx_users_email", fields: ["email"], unique: true },
      ]),
    ]);
    const out = diffSnapshots(before, after);
    const kinds = out.map((c) => c.kind);
    expect(kinds).toContain("drop-index");
    expect(kinds).toContain("add-index");
    // drop-index precedes add-index in the canonical order.
    expect(kinds.indexOf("drop-index")).toBeLessThan(kinds.indexOf("add-index"));
  });
});

// --------------------------------------------------------------------
// TC-15..16 — full-order determinism
// --------------------------------------------------------------------

describe("diffSnapshots — determinism + cross-table order", () => {
  test("15. identical inputs → byte-identical Change[]", () => {
    const before = snapshot([
      resource("users", [userPK, field("email", { type: "email" })]),
      resource("posts", [userPK, field("title")]),
    ]);
    const after = snapshot([
      resource("users", [userPK, field("email", { type: "email" }), field("bio")]),
      resource("posts", [userPK, field("title"), field("published", { type: "boolean" })]),
    ]);
    const a = diffSnapshots(before, after);
    const b = diffSnapshots(before, after);
    expect(JSON.stringify(a)).toBe(JSON.stringify(b));
  });

  test("16. all 5 kinds in cross-table order: drop-index, drop-table, create-table, <per-table>, add-index", () => {
    // Scenario:
    //   old: zebra_table (drops, has an index), kept_table (has an index to drop, a column to alter)
    //   new: kept_table (altered, with new index), apple_table (new)
    const oldSnap = snapshot([
      resource("zebra_table", [userPK, field("z")], [
        { name: "idx_zebra_z", fields: ["z"], unique: false },
      ]),
      resource("kept_table", [
        userPK,
        field("active", {
          type: "boolean",
          default: { kind: "literal", value: false },
        }),
      ], [{ name: "idx_kept_old", fields: ["active"], unique: false }]),
    ]);
    const newSnap = snapshot([
      resource("apple_table", [userPK]),
      resource("kept_table", [
        userPK,
        field("active", {
          type: "boolean",
          default: { kind: "literal", value: true },
        }),
      ], [{ name: "idx_kept_new", fields: ["active"], unique: false }]),
    ]);
    const out = diffSnapshots(oldSnap, newSnap);
    const kinds = out.map((c) => c.kind);
    // Expected order (with specifics):
    //   drop-index idx_kept_old, drop-index idx_zebra_z,
    //   drop-table zebra_table,
    //   create-table apple_table,
    //   alter-column-default on kept_table.active,
    //   add-index idx_kept_new
    expect(kinds).toEqual([
      "drop-index",
      "drop-index",
      "drop-table",
      "create-table",
      "alter-column-default",
      "add-index",
    ]);
  });
});

// --------------------------------------------------------------------
// TC-17 — multiple alter kinds on the same column
// --------------------------------------------------------------------

describe("diffSnapshots — multi-kind alters", () => {
  test("17. nullable + default both change → both Changes emit in sub-order (type, nullable, default)", () => {
    const before = snapshot([
      resource("users", [
        userPK,
        field("bio", {
          type: "string",
          nullable: false,
          default: { kind: "literal", value: "" },
        }),
      ]),
    ]);
    const after = snapshot([
      resource("users", [
        userPK,
        field("bio", {
          type: "string",
          nullable: true,
          default: { kind: "null" },
        }),
      ]),
    ]);
    const out = diffSnapshots(before, after);
    const kinds = out.map((c) => c.kind);
    expect(kinds).toEqual(["alter-column-nullable", "alter-column-default"]);
  });

  test("type + nullable change → type precedes nullable", () => {
    const before = snapshot([
      resource("users", [userPK, field("x", { type: "string", nullable: false })]),
    ]);
    const after = snapshot([
      resource("users", [userPK, field("x", { type: "number", nullable: true })]),
    ]);
    const out = diffSnapshots(before, after);
    expect(out.map((c) => c.kind)).toEqual([
      "alter-column-type",
      "alter-column-nullable",
    ]);
  });
});

// --------------------------------------------------------------------
// TC-18 — add-column on new PK field
// --------------------------------------------------------------------

describe("diffSnapshots — primary-key fields in add-column", () => {
  test("18. new primary field → add-column carries primary:true on its field payload", () => {
    const before = snapshot([resource("users", [field("tmp", { type: "string" })])]);
    const after = snapshot([
      resource("users", [
        field("tmp", { type: "string" }),
        field("id", { type: "uuid", primary: true }),
      ]),
    ]);
    const out = diffSnapshots(before, after);
    const add = out.find((c) => c.kind === "add-column")! as Extract<
      Change,
      { kind: "add-column" }
    >;
    expect(add.field.primary).toBe(true);
  });
});

// --------------------------------------------------------------------
// TC-19 — unique flip policy
// --------------------------------------------------------------------

describe("diffSnapshots — unique flip policy (v1)", () => {
  test("19. flipping unique from false→true on a column emits alter-column-type stub (v1 workaround)", () => {
    // Policy: v1 cannot express "add UNIQUE constraint" as a first-class Change.
    // The correct future-facing response is an add-index with unique:true
    // — but that index has no stable name until the user provides one. So
    // v1 surfaces the flip as an alter-column-type stub so the user is
    // forced to edit the generated SQL manually.
    const before = snapshot([
      resource("users", [userPK, field("email", { type: "email", unique: false })]),
    ]);
    const after = snapshot([
      resource("users", [userPK, field("email", { type: "email", unique: true })]),
    ]);
    const out = diffSnapshots(before, after);
    // We accept either a stub (today's v1 behavior: ignore unique flip since
    // emit doesn't produce a UNIQUE constraint change) OR a dedicated Change.
    // Document the v1 reality: the diff engine does not emit a dedicated
    // Change for a unique flag flip. The user must add an explicit
    // persistence.indexes entry with unique:true to get a migration.
    const kinds = out.map((c) => c.kind);
    // v1 choice: diff engine is silent; user must opt in explicitly via an
    // indexes entry. This test documents that reality so it doesn't
    // regress silently.
    expect(kinds.includes("alter-column-type")).toBe(false);
    expect(out).toEqual([]);
  });
});

// --------------------------------------------------------------------
// TC-21 — convenience wrapper
// --------------------------------------------------------------------

describe("diffResources convenience wrapper", () => {
  test("21. diffResources(parsed, null) computes next snapshot + create-table changes", () => {
    const def: ResourceDefinition = {
      name: "user",
      fields: { id: { type: "uuid", required: true, primary: true } as any },
      options: { persistence: { provider: "postgres" } } as any,
    };
    const parsed: ParsedResource = {
      definition: def,
      filePath: "/virtual/user.resource.ts",
      fileName: "user",
      resourceName: "user",
    };
    const { snapshot: snap, changes } = diffResources([parsed], null);
    expect(snap.resources).toHaveLength(1);
    expect(snap.resources[0].name).toBe("users");
    expect(changes).toHaveLength(1);
    expect(changes[0].kind).toBe("create-table");
  });

  test("diffResources roundtrips through an applied snapshot", () => {
    const def: ResourceDefinition = {
      name: "user",
      fields: {
        id: { type: "uuid", required: true, primary: true } as any,
        email: { type: "email", required: true },
      },
      options: { persistence: { provider: "postgres" } } as any,
    };
    const parsed: ParsedResource = {
      definition: def,
      filePath: "/virtual/user.resource.ts",
      fileName: "user",
      resourceName: "user",
    };
    // First run: applied=null → create-table.
    const r1 = diffResources([parsed], null);
    expect(r1.changes[0].kind).toBe("create-table");
    // Second run: applied=r1.snapshot → no change.
    const r2 = diffResources([parsed], r1.snapshot);
    expect(r2.changes).toEqual([]);
  });

  test("diffResources propagates snapshot errors (e.g. missing PK)", () => {
    const def: ResourceDefinition = {
      name: "user",
      fields: { name: { type: "string", required: true } },
      options: { persistence: { provider: "postgres" } } as any,
    };
    const parsed: ParsedResource = {
      definition: def,
      filePath: "/virtual/user.resource.ts",
      fileName: "user",
      resourceName: "user",
    };
    expect(() => diffResources([parsed], null)).toThrow(/exactly one primary key/);
  });
});

// --------------------------------------------------------------------
// Stress — many changes at once
// --------------------------------------------------------------------

describe("diffSnapshots — stress ordering", () => {
  test("cross-table: drop-index always first, add-index always last", () => {
    const before = snapshot([
      resource(
        "users",
        [userPK, field("a"), field("b")],
        [{ name: "idx_users_a", fields: ["a"], unique: false }]
      ),
      resource("posts", [userPK, field("title")]),
    ]);
    const after = snapshot([
      resource(
        "users",
        [userPK, field("c"), field("b")],
        [
          { name: "idx_users_b", fields: ["b"], unique: false },
        ]
      ),
      resource(
        "posts",
        [userPK, field("title"), field("slug")],
        [{ name: "idx_posts_slug", fields: ["slug"], unique: true }]
      ),
    ]);
    const out = diffSnapshots(before, after);
    const kinds = out.map((c) => c.kind);

    const firstDropIdx = kinds.indexOf("drop-index");
    const lastDropIdx = kinds.lastIndexOf("drop-index");
    const firstAddIdx = kinds.indexOf("add-index");
    const lastAddIdx = kinds.lastIndexOf("add-index");

    expect(firstDropIdx).toBe(0);
    // All drop-indexes precede any other kind.
    expect(lastDropIdx).toBeLessThan(
      kinds.findIndex((k, i) => i > lastDropIdx && k !== "drop-index")
    );
    // All add-indexes are at the end — last index equals array length - 1.
    expect(lastAddIdx).toBe(kinds.length - 1);
    expect(firstAddIdx).toBeGreaterThan(firstDropIdx);
  });
});