import { describe, expect, test } from "bun:test";
import { readFileSync } from "node:fs";
import { join } from "node:path";
import { EMBEDDED_MIGRATIONS } from "../migrations-embedded";

const DESKTOP_MIGRATIONS_DIR = join(
  import.meta.dir,
  "..",
  "..",
  "..",
  "..",
  "..",
  "apps",
  "desktop",
  "drizzle",
);
const CORE_MIGRATIONS_DIR = join(import.meta.dir, "..", "migrations");

type DiskJournalEntry = {
  idx: number;
  version: string;
  when: number;
  tag: string;
  breakpoints: boolean;
};

type DiskJournal = {
  version: string;
  dialect: string;
  entries: DiskJournalEntry[];
};

function readJournal(directory: string): DiskJournal {
  return JSON.parse(
    readFileSync(join(directory, "meta", "_journal.json"), "utf8"),
  );
}

const desktopJournal = readJournal(DESKTOP_MIGRATIONS_DIR);
const coreJournal = readJournal(CORE_MIGRATIONS_DIR);
const diskEntries = [...desktopJournal.entries, ...coreJournal.entries];

describe("embedded migrations sync with their disk sources", () => {
  test("journal metadata matches (version, dialect, entry count)", () => {
    expect(EMBEDDED_MIGRATIONS.version).toBe(desktopJournal.version);
    expect(EMBEDDED_MIGRATIONS.dialect).toBe(desktopJournal.dialect);
    expect(coreJournal.dialect).toBe(desktopJournal.dialect);
    expect(EMBEDDED_MIGRATIONS.entries.length).toBe(diskEntries.length);
  });

  test("entry ordering matches disk exactly (reconcile applies in array order)", () => {
    // Order-sensitive: reconcile walks `entries` in declared order. If the
    // generated file were reordered or resorted, a fresh DB could apply
    // dependent migrations in the wrong order. Assert tags AND indices line up.
    expect(EMBEDDED_MIGRATIONS.entries.map((e) => e.tag)).toEqual(
      diskEntries.map((e) => e.tag),
    );
    expect(EMBEDDED_MIGRATIONS.entries.map((e) => e.idx)).toEqual(
      diskEntries.map((e) => e.idx),
    );
  });

  for (const diskEntry of diskEntries) {
    test(`entry ${diskEntry.tag} matches (fields + SQL contents)`, () => {
      const embedded = EMBEDDED_MIGRATIONS.entries.find(
        (e) => e.tag === diskEntry.tag,
      );
      expect(embedded).toBeDefined();
      if (!embedded) throw new Error("unreachable after toBeDefined");

      expect(embedded.idx).toBe(diskEntry.idx);
      expect(embedded.version).toBe(diskEntry.version);
      expect(embedded.when).toBe(diskEntry.when);
      expect(embedded.breakpoints).toBe(diskEntry.breakpoints);

      const sourceDir = coreJournal.entries.some(
        (entry) => entry.tag === diskEntry.tag,
      )
        ? CORE_MIGRATIONS_DIR
        : DESKTOP_MIGRATIONS_DIR;
      const diskSql = readFileSync(
        join(sourceDir, `${diskEntry.tag}.sql`),
        "utf8",
      );
      expect(embedded.sql).toBe(diskSql);
    });
  }
});