// SPDX-License-Identifier: LicenseRef-ConusAI-Template-1.0

import { readFileSync } from "node:fs"
import { buildRegistry } from "@conusai-kit/core"
import { entitiesOf } from "@conusai-kit/data"
import { createTable } from "@conusai-kit/data-kysely"
import { createMysqlTable } from "@conusai-kit/data-kysely/mysql"
import { createMongoCollection } from "@conusai-kit/data-mongo"
import { appUserIdentities, tenancyModule } from "@conusai-kit/tenancy"
import { describe, expect, it } from "vitest"

const read = (path: string) => readFileSync(new URL(`../${path}`, import.meta.url), "utf8")

describe("app_user_identity profile contracts", () => {
  it.each(["postgres", "mariadb", "mongodb", "convex"] as const)("is registered for %s", (profile) => {
    const entities = entitiesOf(buildRegistry([tenancyModule]), profile)
    expect(entities.filter((entity) => entity.table === appUserIdentities.table)).toHaveLength(1)
  })

  it("creates and eagerly backfills the Postgres alias table in a forward migration", () => {
    const sql = read("migrations/postgres/0006_app-user-identity.sql")
    for (const statement of createTable(appUserIdentities)) expect(sql).toContain(`${statement};`)
    expect(sql).toContain('insert into "app_user_identity"')
    expect(sql).toContain('from "users"')
    expect(sql).toContain('"user_id",\n  "migration_id"\n)\nselect\n  "id",')
    expect(read("migrations/postgres/0001_kernel.sql")).not.toContain('create table "app_user_identity"')
  })

  it("uses bounded MariaDB unique-key columns and preserves user IDs during backfill", () => {
    const sql = read("profiles/mariadb/migrations/0006_app-user-identity.sql")
    expect(sql).toContain("`issuer` varchar(255) not null")
    expect(sql).toContain("`subject` varchar(255) not null")
    expect(sql).toContain("unique (`issuer`, `subject`)")
    expect(sql).toContain("insert into `app_user_identity`")
    expect(sql).toContain("from `users`")
    // The generated table contract has the same fields, constraints and indexes; the migration
    // deliberately narrows the two string columns so InnoDB can index their full values.
    const generated = createMysqlTable(appUserIdentities).join(";\n")
    for (const fragment of [
      "create table `app_user_identity`",
      "`user_id` char(36) not null",
      "`app_user_identity_user_id_idx`",
    ]) {
      expect(generated).toContain(fragment)
      expect(sql).toContain(fragment)
    }
  })

  it("commits the generated MongoDB collection and unique/user indexes", () => {
    const commands = JSON.parse(read("profiles/mongodb/migrations/0006_app-user-identity.json"))
    expect(commands).toEqual(JSON.parse(JSON.stringify(createMongoCollection(appUserIdentities))))
    expect(commands[1]).toMatchObject({ createIndex: { unique: true, keys: { issuer: 1, subject: 1 } } })
  })

  it("generates the Convex table and routes resolution through one internal mutation", () => {
    const schema = read("convex/schema.ts")
    expect(schema).toContain('"app_user_identity": defineTable')
    expect(schema).toContain('.index("by_unique_issuer_subject", ["issuer", "subject"])')
    expect(schema).toContain('.index("by_userId", ["userId"])')
    const system = read("convex/system.ts")
    expect(system).toContain("export const appUserResolve = internalMutation")
    expect(system).toContain("resolveAppUser(data(ctx)")
    expect(system).not.toContain("export const userInsert")
    expect(system).not.toContain("export const userByIdentity")
  })
})