import { beforeEach, describe, expect, it, vi } from 'vitest'
import { NextRequest } from 'next/server'

const mocks = vi.hoisted(() => ({ guard: vi.fn(), user: vi.fn(), db: vi.fn(), chat: vi.fn(), ask: vi.fn(), sync: vi.fn(), locations: vi.fn(), url: vi.fn() }))
vi.mock('@/lib/api-guard', () => ({ requireParticipant: mocks.guard }))
vi.mock('@/lib/auth', () => ({ getSessionUser: mocks.user }))
vi.mock('@/lib/supabase/admin', () => ({ createAdminClient: mocks.db }))
vi.mock('@/lib/data/chat', () => ({ loadVisibleChat: mocks.chat }))
vi.mock('@/lib/adapters/flask', () => ({ askTripAi: mocks.ask, isFlaskConfigured: () => true }))
vi.mock('@/lib/integrations/hha-trip-sync', () => ({ syncTripToHha: mocks.sync }))
vi.mock('@/lib/data/moderation', () => ({ openReviewTicket: vi.fn() }))
vi.mock('@/lib/observability/trip-ai-log', () => ({ logTripAiEvent: vi.fn(), tripAiRequestId: () => 'test-request' }))
vi.mock('@/lib/data/document-urls', () => ({ loadDocumentLocations: mocks.locations, resolveDocumentUrl: mocks.url }))
import { POST } from '@/app/api/trips/[id]/chat/route'
import { GET as documentGET } from '@/app/api/trips/[id]/permits/[permitId]/document/route'
import { GET as stateGET } from '@/app/api/state-info/[code]/route'
import { normalizeAgentEvidence } from '@/lib/domain/agent-evidence'

const permit = { id: '11111111-1111-4111-8111-111111111111', trip_id: 'trip', state_code: 'MD', permit_number: 'MD-123', document_id: 'doc', permit_width_in: 102, expiration_date: '2026-10-30', extraction: { restrictions: ['Daylight only'] } }
let inserts: Record<string, unknown>[]
let queries: Array<{table: string; filters: unknown[]}>
let results: Record<string, unknown>
let migrationMissing: boolean
beforeEach(() => {
  vi.clearAllMocks()
  inserts = []; queries = []; migrationMissing = false
  results = { permits: permit, documents: {id: 'doc'} }
  mocks.guard.mockResolvedValue({ ok: true, user: {id: 'user', email: 'test@example.test'}, participant: {name:'Test', role:'dispatcher', share_chat: false} })
  mocks.user.mockResolvedValue({ id: 'user' })
  mocks.chat.mockResolvedValue({ messages: [], failed: false })
  mocks.ask.mockResolvedValue({ok: true, data: {answer:'Daylight only.', confidence:'high', sources:['Permit Document-Maryland']} })
  mocks.sync.mockResolvedValue({ok: true})
  mocks.locations.mockResolvedValue([{id:'doc', storage_path:'private/permit.pdf'}])
  mocks.url.mockResolvedValue('https://files.example.test/signed.pdf')
  mocks.db.mockReturnValue({ from(table: string) {
    const query = {table, filters: [] as unknown[]}; queries.push(query)
    const chain = {
      select: vi.fn().mockReturnThis(), eq: vi.fn((...args: unknown[]) => {query.filters.push(args); return chain}),
      limit: vi.fn().mockReturnThis(),
      insert: vi.fn((row: Record<string, unknown>) => {inserts.push(row); return chain}),
      single: vi.fn(async () => migrationMissing && inserts.at(-1)?.agent_evidence !== undefined
        ? { data: null, error: { code: 'PGRST204', message: "Could not find the 'agent_evidence' column" } }
        : { data: {id: `msg-${inserts.length}`, ...inserts.at(-1)}, error: null }),
      maybeSingle: vi.fn(async () => ({data: results[table], error: null})),
      then: (resolve: (value: unknown) => unknown) => Promise.resolve({data: results[table] ? [results[table]] : [], error: null}).then(resolve),
    }
    return chain
  } })
})
const chatRequest = (body: object) => new NextRequest('https://workspace.test/api/trips/trip/chat', {method:'POST',body:JSON.stringify(body)})
const chatContext = {params: Promise.resolve({id:'trip'})}
const docContext = {params: Promise.resolve({id:'trip',permitId:permit.id})}

describe('permit chat action', () => {
  it('keeps the answer available when the evidence migration is pending', async () => {
    migrationMissing = true
    mocks.ask.mockResolvedValue({ ok: true, data: { answer: 'Daylight only.', confidence: 'high', sources: ['Permit Document'], evidence: normalizeAgentEvidence({ confidence: 93, source_citations: [{ source: 'permit', snippet: 'Sunrise to sunset.' }] }) } })
    const response = await POST(chatRequest({ question: 'Can I drive at night?' }), chatContext)
    expect(response.status).toBe(200)
    expect(inserts).toHaveLength(3)
    expect(inserts[2]).not.toHaveProperty('agent_evidence')
    expect((await response.json()).messages[1]).toMatchObject({ content: 'Daylight only.', agent_evidence: { confidenceScore: 93 } })
  })
  it('saves the full source panel with the private answer and filters pricing before persistence', async () => {
    mocks.guard.mockResolvedValue({ ok: true, user: { id: 'user' }, participant: { name: 'Pilot', role: 'pilot_driver', share_chat: false } })
    mocks.ask.mockResolvedValue({ ok: true, data: { answer: 'Daylight only. Fee $20', confidence: 'high', sources: ['Permit Document'], evidence: normalizeAgentEvidence({ confidence: 91, confidence_reason: 'Fee USD 20', reasoning_trace: [{ source: 'conclusion', indicated: 'The permit controls.' }], source_citations: [{ source: 'permit', snippet: 'Fee $20; sunrise to sunset.', state: 'Maryland', status: 'available', workspace_permit_ids: [permit.id] }] }) } })
    const response = await POST(chatRequest({ question: 'Can I drive at night?', permit_id: permit.id }), chatContext)
    expect(response.status).toBe(200)
    expect(inserts[1]).toMatchObject({ is_private: true, private_for_user_id: 'user', agent_evidence: { confidenceScore: 91, findings: [{ source: 'conclusion' }] } })
    expect(JSON.stringify(inserts[1])).not.toMatch(/\$20|USD 20/)
    expect((await response.json()).messages[1].agent_evidence.citations[0].permitIds).toEqual([permit.id])
  })
  it('validates the permit against the trip, forwards its identity and saves scope and privacy on both messages', async () => {
    const response = await POST(chatRequest({question:'Can I drive at night?',permit_id:permit.id,state_code:'VA'}),chatContext)
    expect(response.status).toBe(200)
    expect(queries.find((q) => q.table === 'permits')?.filters).toEqual([['id',permit.id],['trip_id','trip']])
    expect(mocks.ask.mock.calls[0][0].question).toContain('MD-123')
    expect(mocks.ask.mock.calls[0][0].question).toContain('Daylight only')
    expect(inserts).toHaveLength(2)
    for (const row of inserts) expect(row).toMatchObject({permit_id:permit.id,state_code:'MD',is_private:true,private_for_user_id:'user'})
    expect(inserts[0].content).toBe('Can I drive at night?')
  })
  it('rejects a permit from another trip before saving a message or calling the agent', async () => {
    results.permits = null
    const response = await POST(chatRequest({question:'Question',permit_id:permit.id}),chatContext)
    expect(response.status).toBe(400)
    expect(mocks.ask).not.toHaveBeenCalled(); expect(inserts).toEqual([])
  })
  it('sends whole-trip questions without a permit prompt', async () => {
    await POST(chatRequest({question:'Whole trip question'}),chatContext)
    expect(mocks.ask.mock.calls[0][0].question).toBe('Whole trip question')
    expect(inserts[0]).toMatchObject({permit_id:null,state_code:null})
  })
  it('keeps team messages outside the agent scope', async () => {
    await POST(chatRequest({question:'Team message',ask_ai:false,permit_id:permit.id}),chatContext)
    expect(mocks.ask).not.toHaveBeenCalled()
    expect(inserts[0]).toMatchObject({permit_id:null,state_code:null})
  })
})

describe('permit document action', () => {
  it('signs the file when opened and redirects, with no cached redirect', async () => {
    const response = await documentGET(new Request('https://workspace.test'),docContext)
    expect(response.status).toBe(307)
    expect(response.headers.get('location')).toBe('https://files.example.test/signed.pdf')
    expect(response.headers.get('cache-control')).toBe('private, no-store')
    expect(queries[0].filters).toContainEqual(['trip_id','trip'])
    expect(queries[1].filters).toContainEqual(['trip_id','trip'])
  })
  it('rejects a missing permit document', async () => {
    results.permits = {...permit,document_id:null}
    expect((await documentGET(new Request('https://workspace.test'),docContext)).status).toBe(404)
    expect(mocks.url).not.toHaveBeenCalled()
  })
  it('requires trip membership before signing a file', async () => {
    mocks.guard.mockResolvedValue({ok:false,response:new Response('Denied',{status:403})})
    expect((await documentGET(new Request('https://workspace.test'),docContext)).status).toBe(403)
    expect(mocks.db).not.toHaveBeenCalled()
  })
})

describe('state information action', () => {
  it('requires sign-in and only returns canonical source rules and provision documents', async () => {
    results.all_states = {state_code:'MD',state_name:'Maryland',details:{operating_time:'Daylight',provision:'https://files.example.test/provisions.pdf',username:'hidden'}}
    const response = await stateGET(new Request('https://workspace.test'),{params:Promise.resolve({code:'md'})})
    expect(response.status).toBe(200)
    const body = await response.json()
    expect(body.information.travel[0].items[0].detail).toBe('Daylight')
    expect(JSON.stringify(body)).not.toContain('hidden')
    expect(queries[0].filters).toContainEqual(['is_canonical',true])
    expect(queries[0].filters).toContainEqual(['source_present',true])
  })
  it('shows published pricing to dispatch and keeps pricing out of pilot responses', async () => {
    results.all_states = {state_code:'MD',state_name:'Maryland',details:{pricing:'$20',service_fee:'$5',superloads:'Review costs $100'}}
    const context = {params:Promise.resolve({code:'MD'})}
    mocks.user.mockResolvedValue({id:'user',role:'dispatcher'})
    const dispatch = await (await stateGET(new Request('https://workspace.test'),context)).json()
    expect(dispatch.information.pricing).toHaveLength(2)
    mocks.user.mockResolvedValue({id:'user',role:'pilot'})
    const pilot = await (await stateGET(new Request('https://workspace.test'),context)).json()
    expect(pilot.information.pricing).toEqual([])
    expect(JSON.stringify(pilot)).not.toMatch(/\$\d/)
  })
  it('denies anonymous catalog reads', async () => {
    mocks.user.mockResolvedValue(null)
    expect((await stateGET(new Request('https://workspace.test'),{params:Promise.resolve({code:'MD'})})).status).toBe(401)
    expect(mocks.db).not.toHaveBeenCalled()
  })
})
