import { beforeEach, describe, expect, it, vi } from 'vitest'
import { NextRequest } from 'next/server'
const mocks = vi.hoisted(() => ({ guard: vi.fn(), db: vi.fn(), voice: vi.fn() }))
vi.mock('server-only', () => ({}))
vi.mock('@/lib/api-guard', () => ({ requireParticipant: mocks.guard }))
vi.mock('@/lib/supabase/admin', () => ({ createAdminClient: mocks.db }))
vi.mock('@/lib/adapters/flask', async importOriginal => ({ ...await importOriginal<typeof import('@/lib/adapters/flask')>(), getVoiceAnswer: mocks.voice }))
vi.mock('@/lib/observability/trip-ai-log', () => ({ logTripAiEvent: vi.fn(), tripAiRequestId: () => 'test' }))
import { POST as save } from '@/app/api/trips/[id]/chat/voice-message/route'
import { POST as enrich } from '@/app/api/trips/[id]/chat/voice-evidence/route'

const backendId = '22222222-2222-4222-8222-222222222222'
const messageId = '33333333-3333-4333-8333-333333333333'
const context = { params: Promise.resolve({ id: 'trip' }) }
const request = (body: object) => new NextRequest('https://workspace.test', { method: 'POST', body: JSON.stringify(body) })
let inserts: Record<string, unknown>[]
let updates: Record<string, unknown>[]
let duplicate: boolean
let replies: { id: string; content: string }[]
let ownerFilters: string[]
beforeEach(() => {
  vi.clearAllMocks(); inserts = []; updates = []; duplicate = false; ownerFilters = []
  replies = [{ id: messageId, content: 'Verified answer, fee [amount hidden].' }]
  mocks.guard.mockResolvedValue({ ok: true, user: { id: 'user' }, participant: { name: 'Pilot', role: 'pilot', share_chat: false } })
  mocks.voice.mockResolvedValue({ ok: true, data: { content: 'Verified answer, fee $20.', metadata: { confidence: 95, source_citations: [{ source: 'permit', status: 'available', snippet: 'Issued fee USD 20', state: 'Virginia' }] } } })
  mocks.db.mockReturnValue({ from: () => {
    const query = {
      select: vi.fn().mockReturnThis(), eq: vi.fn().mockReturnThis(), in: vi.fn().mockReturnThis(), is: vi.fn().mockReturnThis(),
      like: vi.fn(function (this: unknown, _column: string, pattern: string) { ownerFilters.push(pattern); return this }),
      insert: vi.fn(function (this: unknown, row: Record<string, unknown>) { inserts.push(row); return this }),
      update: vi.fn(function (this: unknown, row: Record<string, unknown>) { updates.push(row); return this }),
      order: vi.fn(async () => ({ data: replies, error: null })),
      single: vi.fn(async () => duplicate ? { data: null, error: { code: '23505' } } : { data: { id: messageId, ...inserts.at(-1) }, error: null }),
      maybeSingle: vi.fn(async () => ({ data: { id: messageId, content: 'Existing reply', is_private: true, private_for_user_id: 'user' }, error: null })),
      then: (resolve: (value: unknown) => unknown) => Promise.resolve({ data: [{ id: messageId, content: replies[0]?.content, ...updates.at(-1) }], error: null }).then(resolve),
    }
    return query
  } })
})
describe('voice transcripts and optional source evidence', () => {
  it('saves normal assistant speech without calling the unavailable backend endpoint', async () => {
    mocks.voice.mockRejectedValue(new Error('Backend is down'))
    const response = await save(request({ role: 'assistant', content: 'Spoken reply, fee $20.', segment_id: 'segment', agent_evidence: { confidenceScore: 100 } }), context)
    expect(response.status).toBe(200)
    expect(mocks.voice).not.toHaveBeenCalled()
    expect(inserts[0]).toMatchObject({ content: 'Spoken reply, fee [amount hidden].', is_private: true, private_for_user_id: 'user', voice_backend_message_id: 'voice-transcript:user:assistant:segment', agent_evidence: null })
  })
  it('never creates a blank answer from a metadata packet', async () => {
    expect((await save(request({ role: 'assistant', backend_message_id: backendId }), context)).status).toBe(400)
    expect(inserts).toEqual([])
  })
  it('treats missing optional evidence as unavailable without creating another chat message', async () => {
    mocks.voice.mockResolvedValue({ ok: false, diagnostic: { httpStatus: 404 } })
    const response = await enrich(request({ backend_message_id: backendId, message_ids: [messageId] }), context)
    expect(response.status).toBe(200)
    expect(await response.json()).toEqual({ messages: [], unavailable: true })
    expect(inserts).toEqual([])
    expect(updates).toEqual([])
  })
  it('decorates only a matching saved reply owned by the requesting user, without changing content or timestamps', async () => {
    const response = await enrich(request({ backend_message_id: backendId, message_ids: [messageId], agent_evidence: { confidenceScore: 100 } }), context)
    expect(response.status).toBe(200)
    expect(mocks.voice).toHaveBeenCalledWith({ workspace_trip_id: 'trip', viewer_user_id: 'user', backend_message_id: backendId })
    expect(updates[0]).toMatchObject({ agent_evidence: { confidenceScore: 95 }, confidence: 'high' })
    expect(updates[0]).not.toHaveProperty('content')
    expect(updates[0]).not.toHaveProperty('created_at')
    expect(ownerFilters).toEqual(['voice-transcript:user:assistant:%', 'voice-transcript:user:assistant:%'])
    expect(JSON.stringify(await response.json())).not.toMatch(/USD 20|\$20/)
    expect(inserts).toEqual([])
  })
  it('does not attach evidence to a different answer', async () => {
    replies = [{ id: messageId, content: 'A different answer' }]
    expect((await enrich(request({ backend_message_id: backendId, message_ids: [messageId] }), context)).status).toBe(200)
    expect(updates).toEqual([])
  })
  it('deduplicates final transcript delivery and retains the saved reply', async () => {
    duplicate = true
    const response = await save(request({ role: 'assistant', content: 'Repeated reply', segment_id: 'segment' }), context)
    expect(response.status).toBe(200)
    expect((await response.json()).message.content).toBe('Existing reply')
  })
  it('requires membership for transcripts and evidence', async () => {
    mocks.guard.mockResolvedValue({ ok: false, response: new Response('Denied', { status: 403 }) })
    expect((await save(request({ role: 'user', content: 'Question' }), context)).status).toBe(403)
    expect((await enrich(request({ backend_message_id: backendId, message_ids: [messageId] }), context)).status).toBe(403)
    expect(mocks.voice).not.toHaveBeenCalled()
    expect(inserts).toEqual([])
  })
})
