import { afterAll, beforeAll, describe, expect, it } from 'vitest'
import { createOrder } from '@platform-modules/commerce-orders'
import type { TransactionalDatabase } from '@platform-modules/db'
import { isOrderNotFoundError } from './errors.js'
import { startPg } from './pg-harness.js'
import { checkoutSession, type CheckoutDbSchema } from './schema.js'
import { getCheckoutStatus } from './status.js'
import {
  buildCheckoutDeps,
  BUYER_ID,
  OTHER_USER_ID,
  seedDigitalVariant,
  setOrderStatus,
  VARIANT_DIGITAL,
} from './test-fixtures.js'

describe('getCheckoutStatus (real Postgres)', () => {
  let db: TransactionalDatabase<CheckoutDbSchema>
  let stop: (() => Promise<void>) | undefined

  beforeAll(async () => {
    const pg = await startPg()
    db = pg.db
    stop = pg.stop
    await seedDigitalVariant(db, { variantId: VARIANT_DIGITAL, amount: 1000n })
  }, 120_000)

  afterAll(async () => {
    await stop?.()
  }, 30_000)

  async function createOwnedOrder() {
    return db.transaction((tx) =>
      createOrder(tx, {
        idempotencyKey: crypto.randomUUID(),
        buyerRef: { userId: BUYER_ID },
        currency: 'USD',
        priceMode: 'exclusive',
        subtotal: 1000n,
        tax: 0n,
        discount: 0n,
        total: 1000n,
        lines: [
          {
            variantId: VARIANT_DIGITAL,
            kind: 'digital',
            qty: 1,
            unitPrice: 1000n,
            lineTotal: 1000n,
            currency: 'USD',
          },
        ],
        splits: [{ vendorId: null, amount: 1000n, funder: 'platform' }],
      }),
    )
  }

  it('status-charging-returns-secret — charging order returns clientSecret', async () => {
    const created = await createOwnedOrder()
    await setOrderStatus(db, created.id, 'charging')
    await db.insert(checkoutSession).values({
      orderId: created.id,
      clientSecret: 'sec_status',
    })

    const deps = buildCheckoutDeps(db)
    const status = await getCheckoutStatus(deps, created.id, { userId: BUYER_ID })

    expect(status).toEqual({ status: 'charging', clientSecret: 'sec_status' })
  })

  it('status-paid-no-secret — paid order omits clientSecret even with stale session', async () => {
    const created = await createOwnedOrder()
    await setOrderStatus(db, created.id, 'paid', 'pi_paid')
    await db.insert(checkoutSession).values({
      orderId: created.id,
      clientSecret: 'sec_stale',
    })

    const deps = buildCheckoutDeps(db)
    const status = await getCheckoutStatus(deps, created.id, { userId: BUYER_ID })

    expect(status).toEqual({ status: 'paid' })
    expect(status.clientSecret).toBeUndefined()
  })

  it('status-not-owned-404 — non-owner and missing order both throw OrderNotFoundError', async () => {
    const created = await createOwnedOrder()
    const deps = buildCheckoutDeps(db)
    const missingId = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa'

    const nonOwner = await getCheckoutStatus(deps, created.id, {
      userId: OTHER_USER_ID,
    }).catch((e) => e)
    const missing = await getCheckoutStatus(deps, missingId, { userId: BUYER_ID }).catch((e) => e)

    expect(isOrderNotFoundError(nonOwner)).toBe(true)
    expect(isOrderNotFoundError(missing)).toBe(true)
    expect(nonOwner.httpStatus).toBe(missing.httpStatus)
  })
})