// @vitest-environment node
//
// Integration tests for scheduled sends, resumable sending, per-number
// delivery and phone sign-in. They run the real server code against an
// in-memory Postgres (PGlite) built from the project's own migrations, with
// Moolre replaced by a fake.
import { readFileSync, readdirSync } from 'node:fs'
import { join } from 'node:path'
import { and, eq, sql } from 'drizzle-orm'
import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'

vi.mock('../../db/index.js', async () => {
  const { PGlite } = await import('@electric-sql/pglite')
  const { drizzle } = await import('drizzle-orm/pglite')
  const schema = await import('../../db/schema')
  return { db: drizzle({ client: new PGlite(), schema }) }
})

const moolre = vi.hoisted(() => ({
  sent: [] as { senderId: string; messages: { recipient: string; message: string; ref: string }[] }[],
  // Return a non-OK result for a batch by its first ref.
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  respond: (_batch: { messages: { ref: string }[] }):
    | { ok: true }
    | { ok: false; code: string; reason: string }
    | Promise<{ ok: true }> => ({ ok: true }),
  statuses: new Map<string, number>(),
  statusCalls: 0,
}))

vi.mock('./moolre.server', async (importOriginal) => {
  const real = await importOriginal<typeof import('./moolre.server')>()
  return {
    ...real,
    getMoolreConfig: async () => ({ senderId: 'AKOTOSMS', environment: 'live' }),
    sendSmsBatch: async (input: { senderId: string; messages: { recipient: string; message: string; ref: string }[] }) => {
      moolre.sent.push(input)
      return moolre.respond(input)
    },
    getSmsStatuses: async (refs: string[]) => {
      moolre.statusCalls++
      return new Map(refs.filter((r) => moolre.statuses.has(r)).map((r) => [r, moolre.statuses.get(r)!]))
    },
  }
})

const { db } = await import('../../db/index.js')
const schema = await import('../../db/schema.js')
const { accounts, apiKeys, autoMessages, campaigns, loginCodes, senderIds } = schema
const messaging = await import('./messaging.server')
const delivery = await import('./delivery.server')
const phoneAuth = await import('./phone-auth.server')
const { authenticateApiKey } = await import('./api-keys.server')

const USER = 'user-1'
const phones = (n: number, start = 0) => Array.from({ length: n }, (_, i) => `23324${String(1000000 + start + i).padStart(7, '0')}`)
const sentRecipients = () => moolre.sent.flatMap((b) => b.messages.map((m) => m.recipient))
const credits = async () => (await db.select({ c: accounts.credits }).from(accounts).where(eq(accounts.userId, USER)))[0].c
const campaign = async (id: number) => (await db.select().from(campaigns).where(eq(campaigns.id, id)))[0]

beforeAll(async () => {
  const dir = join(process.cwd(), 'netlify/database/migrations')
  const client = (db as unknown as { $client: { exec: (q: string) => Promise<unknown> } }).$client
  for (const name of readdirSync(dir).sort()) {
    const text = readFileSync(join(dir, name, 'migration.sql'), 'utf8')
    for (const statement of text.split('--> statement-breakpoint')) if (statement.trim()) await client.exec(statement)
  }
})

afterAll(async () => {
  await (db as unknown as { $client: { close: () => Promise<void> } }).$client.close()
})

beforeEach(async () => {
  moolre.sent = []
  moolre.respond = () => ({ ok: true })
  moolre.statuses = new Map()
  moolre.statusCalls = 0
  await db.execute(sql`truncate login_codes, auto_messages, notifications, api_keys, campaigns, sender_ids, app_settings, accounts restart identity cascade`)
  await db.insert(accounts).values({ userId: USER, email: 'ama@example.com', credits: 10_000, phone: '233241112223', name: 'Ama Owusu' })
  await db.insert(senderIds).values({ userId: USER, senderId: 'UNITYBASIC', purpose: 'test', status: 'approved' })
})

const send = (recipients: string[], message = 'Hello parents') =>
  messaging.sendCampaign({ userId: USER, senderId: 'UNITYBASIC', message, recipients, source: 'api' })

describe('immediate sends', () => {
  it('sends in batches of 100 with message refs, and refunds a refused batch', async () => {
    moolre.respond = (b) => (b.messages[0].ref.endsWith('-100') ? { ok: false, code: 'X1', reason: 'Refused' } : { ok: true })
    const result = await send(phones(250))
    expect(result).toMatchObject({ status: 'partial', delivered: 150, total: 250, creditsUsed: 150 })
    expect(moolre.sent.map((b) => b.messages.length)).toEqual([100, 100, 50])
    expect(moolre.sent[0].messages[5].ref).toBe(`C${result.id}-5`)
    expect(await credits()).toBe(10_000 - 150)
    const row = await campaign(result.id)
    expect(row).toMatchObject({ status: 'partial', sentCount: 150, sendProgress: 250, lockedUntil: null })
    expect(row.delivery?.['100']).toBe(-1)
    expect(row.delivery?.['199']).toBe(-1)
    expect(row.delivery?.['99']).toBeUndefined()
  })

  it('stops at a sender ID refusal and refunds everything unsent', async () => {
    moolre.respond = () => ({ ok: false, code: 'ASMS07', reason: 'Sender ID refused' })
    const result = await send(phones(250))
    expect(result).toMatchObject({ status: 'failed', delivered: 0, creditsUsed: 0 })
    expect(moolre.sent).toHaveLength(1)
    expect(await credits()).toBe(10_000)
    expect(Object.keys((await campaign(result.id)).delivery ?? {})).toHaveLength(250)
  })

  it('refuses a send the balance cannot cover', async () => {
    await db.update(accounts).set({ credits: 5 }).where(eq(accounts.userId, USER))
    await expect(send(phones(10))).rejects.toMatchObject({ code: 'insufficient_credits' })
    expect(moolre.sent).toHaveLength(0)
  })
})

describe('scheduled sends', () => {
  const later = () => new Date(Date.now() + 10 * 60_000)
  const schedule = (n: number, at = later()) =>
    messaging.scheduleCampaign({ userId: USER, senderId: 'UNITYBASIC', message: 'Mid-term break', recipients: phones(n), source: 'api', scheduledFor: at })
  const makeDue = (id: number) => db.update(campaigns).set({ scheduledFor: new Date(Date.now() - 1000) }).where(eq(campaigns.id, id))

  it('reserves credits and sends nothing until due', async () => {
    const s = await schedule(30)
    expect(s).toMatchObject({ status: 'scheduled', creditsUsed: 30 })
    expect(await credits()).toBe(10_000 - 30)
    expect(await messaging.runDueCampaigns({ budgetMs: 5000 })).toEqual([])
    expect(moolre.sent).toHaveLength(0)
  })

  it('rejects times too soon or too far ahead', async () => {
    await expect(schedule(5, new Date(Date.now() + 30_000))).rejects.toMatchObject({ code: 'invalid_schedule' })
    await expect(schedule(5, new Date(Date.now() + 61 * 86_400_000))).rejects.toMatchObject({ code: 'invalid_schedule' })
    expect(await credits()).toBe(10_000)
  })

  it('sends when due', async () => {
    const s = await schedule(30)
    await makeDue(s.id)
    const [r] = await messaging.runDueCampaigns({ budgetMs: 5000 })
    expect(r).toMatchObject({ id: s.id, done: true, status: 'sent', delivered: 30 })
    expect(sentRecipients()).toHaveLength(30)
    expect((await campaign(s.id)).status).toBe('sent')
  })

  it('cancels with a full refund, once', async () => {
    const s = await schedule(40)
    expect(await messaging.cancelScheduledCampaign(USER, s.id)).toEqual({ id: s.id, creditsRefunded: 40 })
    expect(await credits()).toBe(10_000)
    expect(await campaign(s.id)).toMatchObject({ status: 'cancelled', creditsUsed: 0 })
    await expect(messaging.cancelScheduledCampaign(USER, s.id)).rejects.toMatchObject({ code: 'not_cancellable' })
    await expect(messaging.cancelScheduledCampaign('someone-else', s.id)).rejects.toMatchObject({ code: 'not_found' })
    await makeDue(s.id)
    expect(await messaging.runDueCampaigns({ budgetMs: 5000 })).toEqual([])
  })

  it('carries a large send across runs without sending anyone twice', async () => {
    const s = await schedule(450)
    await makeDue(s.id)
    // Each batch takes 50ms and each run may work for 60ms: one or two batches per run.
    moolre.respond = () => new Promise((resolve) => setTimeout(() => resolve({ ok: true }), 50))
    const [first] = await messaging.runDueCampaigns({ budgetMs: 60 })
    expect(first).toMatchObject({ done: false, status: 'sending' })
    expect(moolre.sent.length).toBeGreaterThanOrEqual(1)
    expect(moolre.sent.length).toBeLessThan(5)
    expect((await campaign(s.id)).lockedUntil!.getTime()).toBeLessThan(Date.now())
    let runs = 0
    while ((await campaign(s.id)).status === 'sending' && runs++ < 10) await messaging.runDueCampaigns({ budgetMs: 60 })
    expect(runs).toBeGreaterThan(0)
    const all = sentRecipients()
    expect(all).toHaveLength(450)
    expect(new Set(all).size).toBe(450)
    expect(await campaign(s.id)).toMatchObject({ status: 'sent', sentCount: 450, creditsUsed: 450 })
  })

  it('does not send if the sender ID was revoked after booking, and refunds', async () => {
    const s = await schedule(20)
    await db.update(senderIds).set({ status: 'rejected' }).where(eq(senderIds.userId, USER))
    await makeDue(s.id)
    const [r] = await messaging.runDueCampaigns({ budgetMs: 5000 })
    expect(r).toMatchObject({ status: 'failed', delivered: 0 })
    expect(moolre.sent).toHaveLength(0)
    expect(await credits()).toBe(10_000)
  })
})

describe('resuming stopped sends', () => {
  it('finishes a send whose sender stopped part-way (lease expired)', async () => {
    const [c] = await db
      .insert(campaigns)
      .values({
        userId: USER, senderId: 'UNITYBASIC', message: 'Hi', recipients: phones(150), recipientCount: 150, segments: 1, creditsUsed: 150,
        status: 'sending', sendProgress: 100, sentCount: 100, lockedUntil: new Date(Date.now() - 1000),
      })
      .returning({ id: campaigns.id })
    const [r] = await messaging.runDueCampaigns({ budgetMs: 5000 })
    expect(r).toMatchObject({ id: c.id, done: true, status: 'sent', delivered: 150 })
    expect(sentRecipients()).toEqual(phones(50, 100))
  })

  it('never touches a send still inside its lease, or one from before resumable sending', async () => {
    await db.insert(campaigns).values([
      { userId: USER, senderId: 'UNITYBASIC', message: 'Old', recipients: phones(10), recipientCount: 10, segments: 1, creditsUsed: 10, status: 'sending' },
      {
        userId: USER, senderId: 'UNITYBASIC', message: 'Busy', recipients: phones(10), recipientCount: 10, segments: 1, creditsUsed: 10,
        status: 'sending', lockedUntil: new Date(Date.now() + 60_000),
      },
    ])
    expect(await messaging.runDueCampaigns({ budgetMs: 5000 })).toEqual([])
    expect(moolre.sent).toHaveLength(0)
  })

  it('leaves voice sends alone', async () => {
    await db.insert(campaigns).values({
      userId: USER, senderId: '+233302000000', message: 'Voice', recipients: phones(3), recipientCount: 3, segments: 1, creditsUsed: 15,
      status: 'sending', channel: 'voice', lockedUntil: new Date(Date.now() - 1000),
    })
    expect(await messaging.runDueCampaigns({ budgetMs: 5000 })).toEqual([])
  })
})

describe('per-number delivery', () => {
  it('shows Moolre statuses through admin labels, and re-checks at most every 20 seconds', async () => {
    moolre.respond = (b) => (b.messages[0].ref.endsWith('-2') ? { ok: false, code: 'X', reason: 'no' } : { ok: true })
    // Two batches of 2 would be nicer; with 100 per batch, refuse a later send instead.
    const r = await send(phones(3))
    moolre.statuses.set(`C${r.id}-0`, 1).set(`C${r.id}-1`, 3)

    let page = await delivery.recipientsPage(USER, r.id, 1, 500)
    expect(page!.recipients.map((x) => x.state)).toEqual(['sent', 'sent', 'sent'])
    expect(page!.recipients[0].providerStatus).toBe(1)
    expect(moolre.statusCalls).toBe(1)

    await delivery.saveDeliveryLabels({ 1: 'delivered', 3: 'failed' }, 'admin@example.com')
    page = await delivery.recipientsPage(USER, r.id, 1, 500)
    expect(moolre.statusCalls).toBe(1) // throttled
    expect(page!.recipients.map((x) => x.state)).toEqual(['delivered', 'failed', 'sent'])
    expect(page!.counts).toMatchObject({ delivered: 1, failed: 1, sent: 1 })

    expect(await delivery.recipientsPage('someone-else', r.id, 1, 500)).toBeNull()
    expect(await delivery.recentDeliveryCodes()).toEqual(expect.arrayContaining([{ code: 1, count: 1 }, { code: 3, count: 1 }]))
  })

  it('marks numbers from a refused batch as not sent and never asks Moolre about them', async () => {
    moolre.respond = () => ({ ok: false, code: 'X', reason: 'no' })
    const r = await send(phones(2))
    const page = await delivery.recipientsPage(USER, r.id, 1, 500)
    expect(page!.recipients.map((x) => x.state)).toEqual(['not_sent', 'not_sent'])
    expect(moolre.statusCalls).toBe(0)
  })

  it('shows a scheduled send as scheduled without asking Moolre', async () => {
    const s = await messaging.scheduleCampaign({
      userId: USER, senderId: 'UNITYBASIC', message: 'Later', recipients: phones(2), source: 'api', scheduledFor: new Date(Date.now() + 600_000),
    })
    const page = await delivery.recipientsPage(USER, s.id, 1, 500)
    expect(page!.counts.scheduled).toBe(2)
    expect(moolre.statusCalls).toBe(0)
  })
})

describe('phone sign-in', () => {
  const codeFromText = () => moolre.sent.at(-1)!.messages[0].message.match(/\b(\d{6})\b/)![1]

  it('texts a code to the saved number, logs it hidden, and swaps it for a working API key once', async () => {
    expect(await phoneAuth.requestLoginCode('024 111 2223', '1.2.3.4')).toEqual({ expiresInSeconds: 600 })
    expect(moolre.sent).toHaveLength(1)
    expect(moolre.sent[0]).toMatchObject({ senderId: 'AKOTOSMS', messages: [{ recipient: '233241112223' }] })
    const code = codeFromText()
    const [log] = await db.select().from(autoMessages)
    expect(log.message).not.toContain(code)
    expect(log).toMatchObject({ event: 'login_code', status: 'sent' })

    const wrong = code === '000000' ? '111111' : '000000'
    await expect(phoneAuth.verifyLoginCode('0241112223', wrong, null)).rejects.toMatchObject({ code: 'invalid_code' })
    const result = await phoneAuth.verifyLoginCode('+233 24 111 2223', code, 'Mozilla/5.0 (Linux; Android 14) Chrome/130')
    expect(result.key).toMatch(/^akc_live_/)
    expect(result.keyName).toBe('Phone app (Chrome on Android)')

    const authed = await authenticateApiKey(new Request('https://x/', { headers: { Authorization: `Bearer ${result.key}` } }))
    expect(authed?.userId).toBe(USER)
    await expect(phoneAuth.verifyLoginCode('0241112223', code, null)).rejects.toMatchObject({ code: 'invalid_code' })
  })

  it('locks a code after 5 wrong tries', async () => {
    await phoneAuth.requestLoginCode('0241112223', null)
    const code = codeFromText()
    const wrong = code === '000000' ? '111111' : '000000'
    for (let i = 0; i < 5; i++) await expect(phoneAuth.verifyLoginCode('0241112223', wrong, null)).rejects.toMatchObject({ code: 'invalid_code' })
    await expect(phoneAuth.verifyLoginCode('0241112223', code, null)).rejects.toMatchObject({ code: 'invalid_code' })
  })

  it('answers the same for a number on no account, without texting it', async () => {
    expect(await phoneAuth.requestLoginCode('0559998887', null)).toEqual({ expiresInSeconds: 600 })
    expect(moolre.sent).toHaveLength(0)
    await expect(phoneAuth.verifyLoginCode('0559998887', '123456', null)).rejects.toMatchObject({ code: 'invalid_code' })
  })

  it('does not sign in when two accounts share the number', async () => {
    await db.insert(accounts).values({ userId: 'user-2', email: 'kofi@example.com', phone: '233241112223' })
    await phoneAuth.requestLoginCode('0241112223', null)
    expect(moolre.sent).toHaveLength(0)
  })

  it('limits codes per number and per network', async () => {
    for (let i = 0; i < 3; i++) await phoneAuth.requestLoginCode('0241112223', '9.9.9.9')
    await expect(phoneAuth.requestLoginCode('0241112223', '9.9.9.9')).rejects.toMatchObject({ code: 'too_many_requests' })
    for (let i = 0; i < 7; i++) await phoneAuth.requestLoginCode(`05000000${String(i).padStart(2, '0')}`, '9.9.9.9')
    await expect(phoneAuth.requestLoginCode('0509999999', '9.9.9.9')).rejects.toMatchObject({ code: 'too_many_requests' })
  })

  it('rejects numbers that are not Ghana mobile numbers', async () => {
    await expect(phoneAuth.requestLoginCode('12345', null)).rejects.toMatchObject({ code: 'invalid_phone' })
  })

  it('retires the oldest phone-app key when the account is at its key limit', async () => {
    for (let i = 0; i < 9; i++) await db.insert(apiKeys).values({ userId: USER, name: `Website ${i}`, prefix: 'akc_live_x', keyHash: `h${i}` })
    await db.insert(apiKeys).values({ userId: USER, name: 'Phone app (old)', prefix: 'akc_live_y', keyHash: 'old' })
    await phoneAuth.requestLoginCode('0241112223', null)
    await phoneAuth.verifyLoginCode('0241112223', codeFromText(), null)
    const [old] = await db.select().from(apiKeys).where(eq(apiKeys.keyHash, 'old'))
    expect(old.revokedAt).not.toBeNull()
    const active = await db.select().from(apiKeys).where(and(eq(apiKeys.userId, USER), sql`${apiKeys.revokedAt} is null`))
    expect(active).toHaveLength(10)
  })

  it('stores only hashes of codes', async () => {
    await phoneAuth.requestLoginCode('0241112223', null)
    const code = codeFromText()
    const rows = await db.select().from(loginCodes)
    expect(JSON.stringify(rows)).not.toContain(code)
  })
})
