import { afterEach, describe, expect, mock, spyOn, test } from "bun:test"
import { Effect } from "effect"
import { Flag } from "@saeeol/core/flag/flag"
import { Instance } from "../../src/project/instance"
import { Server } from "../../src/server/server"
import { SyncPaths } from "../../src/server/routes/instance/httpapi/groups/sync"
import { Session } from "@/session/session"
import * as Log from "@saeeol/core/util/log"
import { resetDatabase } from "../fixture/db"
import { disposeAllInstances, tmpdir } from "../fixture/fixture"

void Log.init({ print: false })

const originalHttpApi = Flag.SAEEOL_EXPERIMENTAL_HTTPAPI
const originalWorkspaces = Flag.SAEEOL_EXPERIMENTAL_WORKSPACES

function app(httpapi = true) {
  Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = httpapi
  return httpapi ? Server.Default().app : Server.Legacy().app
}

function runSession<A, E>(fx: Effect.Effect<A, E, Session.Service>) {
  return Effect.runPromise(fx.pipe(Effect.provide(Session.defaultLayer)))
}

afterEach(async () => {
  mock.restore()
  Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = originalHttpApi
  Flag.SAEEOL_EXPERIMENTAL_WORKSPACES = originalWorkspaces
  await disposeAllInstances()
  await resetDatabase()
})

describe("sync HttpApi", () => {
  test("serves sync routes through Hono bridge", async () => {
    Flag.SAEEOL_EXPERIMENTAL_WORKSPACES = true
    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
    const headers = { "x-saeeol-directory": tmp.path, "content-type": "application/json" }
    const info = spyOn(Log.create({ service: "server.sync" }), "info")

    const session = await Instance.provide({
      directory: tmp.path,
      fn: async () => runSession(Session.Service.use((svc) => svc.create({ title: "sync" }))),
    })

    const started = await app().request(SyncPaths.start, { method: "POST", headers })
    expect(started.status).toBe(200)
    expect(await started.json()).toBe(true)

    const history = await app().request(SyncPaths.history, {
      method: "POST",
      headers,
      body: JSON.stringify({}),
    })
    expect(history.status).toBe(200)
    const rows = (await history.json()) as Array<{
      id: string
      aggregate_id: string
      seq: number
      type: string
      data: Record<string, unknown>
    }>
    expect(rows.map((row) => row.aggregate_id)).toContain(session.id)

    const replayed = await app().request(SyncPaths.replay, {
      method: "POST",
      headers,
      body: JSON.stringify({
        directory: tmp.path,
        events: rows
          .filter((row) => row.aggregate_id === session.id)
          .map((row) => ({
            id: row.id,
            aggregateID: row.aggregate_id,
            seq: row.seq,
            type: row.type,
            data: row.data,
          })),
      }),
    })
    expect(replayed.status).toBe(200)
    expect(await replayed.json()).toEqual({ sessionID: session.id })
    expect(info.mock.calls.some(([message]) => message === "sync replay requested")).toBe(true)
    expect(info.mock.calls.some(([message]) => message === "sync replay complete")).toBe(true)
  })

  test("matches legacy seq validation", async () => {
    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
    const headers = { "x-saeeol-directory": tmp.path, "content-type": "application/json" }
    const cases = [
      {
        path: SyncPaths.history,
        body: { aggregate: -1 },
      },
      {
        path: SyncPaths.history,
        body: { aggregate: 1.5 },
      },
      {
        path: SyncPaths.replay,
        body: {
          directory: tmp.path,
          events: [{ id: "event", aggregateID: "session", seq: -1, type: "session.created", data: {} }],
        },
      },
      {
        path: SyncPaths.replay,
        body: {
          directory: tmp.path,
          events: [{ id: "event", aggregateID: "session", seq: 1.5, type: "session.created", data: {} }],
        },
      },
    ]

    for (const item of cases) {
      const legacy = await app(false).request(item.path, {
        method: "POST",
        headers,
        body: JSON.stringify(item.body),
      })
      const httpapi = await app(true).request(item.path, {
        method: "POST",
        headers,
        body: JSON.stringify(item.body),
      })
      expect(httpapi.status).toBe(legacy.status)
      expect(httpapi.status).toBe(400)
    }
  })
})
