import { processWorkspacePermit } from '@/lib/data/permit-processing'
import { NextRequest, NextResponse } from 'next/server'
import { createAdminClient } from '@/lib/supabase/admin'
import { publicOrigin } from '@/lib/app-url'
import { isPurchaseCallback, isSynchronPermitUrl, synchronCallbackSchema, verifySynchronSignature, type SynchronPurchaseCallback } from '@/lib/integrations/synchron-contract'
import { applyVerifiedPaymentEvent } from '@/lib/data/purchases'
import type { PurchaseStatusReport } from '@/lib/integrations/synchron-payments'
import { syncTripToHha } from '@/lib/integrations/hha-trip-sync'
import type { Trip } from '@/types/db'

export const runtime = 'nodejs'
export const maxDuration = 300

export async function POST(req: NextRequest) {
  const secret = process.env.SYNCHRON_CALLBACK_SECRET?.trim() || ''
  if (Number(req.headers.get('content-length') || 0) > 64_000) {
    return NextResponse.json({ error: 'Callback too large' }, { status: 413 })
  }
  const raw = await req.text()
  if (raw.length > 64_000) return NextResponse.json({ error: 'Callback too large' }, { status: 413 })
  if (!verifySynchronSignature(raw, req.headers.get('x-synchron-timestamp'), req.headers.get('x-synchron-signature'), secret)) {
    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
  }
  let json: unknown
  try { json = JSON.parse(raw) } catch { return NextResponse.json({ error: 'Invalid JSON' }, { status: 400 }) }
  const parsed = synchronCallbackSchema.safeParse(json)
  if (!parsed.success) return NextResponse.json({ error: 'Invalid callback' }, { status: 400 })
  if (isPurchaseCallback(parsed.data)) return handlePurchaseCallback(parsed.data)
  const input = parsed.data
  const admin = createAdminClient()

  // The nine-digit Workspace reference is the authority. Never create a trip
  // from an unmatched callback or infer its identity from an eight-digit token.
  const { data: tripRow, error: tripError } = await admin.from('trips').select('*').eq('ref_code', input.workspace_trip_ref).maybeSingle()
  if (tripError) return NextResponse.json({ error: 'Trip lookup failed' }, { status: 500 })
  if (!tripRow) return NextResponse.json({ error: 'Workspace trip not found' }, { status: 404 })
  const trip = tripRow as Trip
  if (trip.source_system === 'synchron' ||
      (trip.synchron_order_token && trip.synchron_order_token !== input.synchron_order_token) ||
      (trip.synchron_order_id && input.synchron_order_id && trip.synchron_order_id !== input.synchron_order_id)) {
    return NextResponse.json({ error: 'Order is linked to another trip' }, { status: 409 })
  }
  const firstLink = !trip.synchron_order_token
  if (firstLink || (input.synchron_order_id && !trip.synchron_order_id)) {
    const { error } = await admin.from('trips').update({
      synchron_order_token: input.synchron_order_token,
      ...(input.synchron_order_id ? { synchron_order_id: input.synchron_order_id } : {}),
    }).eq('id', trip.id)
    if (error) return NextResponse.json({ error: 'Order link could not be saved' }, { status: error.code === '23505' ? 409 : 500 })
    await admin.from('service_requests').update({ vendor_order_id: input.synchron_order_token })
      .eq('trip_id', trip.id).eq('type', 'permit_request')
    await admin.from('service_requests').update({ status: 'in_progress' })
      .eq('trip_id', trip.id).eq('type', 'permit_request').eq('status', 'requested')
  }
  if (input.event === 'order.created') {
    if (firstLink) await admin.from('trip_events').insert({ trip_id: trip.id, actor_label: 'Synchron Permits', action: 'synchron_order_linked', detail: { synchron_order_token: input.synchron_order_token, synchron_order_id: input.synchron_order_id ?? null } })
    return NextResponse.json({ ok: true, trip_ref: trip.ref_code, synchron_order_token: input.synchron_order_token })
  }

  if (!isSynchronPermitUrl(input.permit_url)) return NextResponse.json({ error: 'Unapproved permit URL' }, { status: 400 })
  const documentKey = `item_file:${input.item_id}`
  const permitKey = `item:${input.item_id}`
  const { data: oldDocument } = await admin.from('documents').select('*').eq('source_system', 'synchron').eq('source_record_id', documentKey).maybeSingle()
  if (oldDocument && oldDocument.trip_id !== trip.id) return NextResponse.json({ error: 'Permit item belongs to another trip' }, { status: 409 })
  let document = oldDocument
  if (!document) {
    const { data, error } = await admin.from('documents').insert({
      trip_id: trip.id, kind: 'permit', storage_provider: 'external', storage_path: null,
      external_url: input.permit_url, file_name: `${input.state_code}-${input.item_id}.pdf`,
      uploader_label: 'Synchron Permits', source_system: 'synchron', source_record_id: documentKey,
    }).select('*').single()
    if (error || !data) return NextResponse.json({ error: 'Permit document could not be saved' }, { status: 500 })
    document = data
  } else if (document.external_url !== input.permit_url) {
    const { error } = await admin.from('documents').update({ external_url: input.permit_url }).eq('id', document.id)
    if (error) return NextResponse.json({ error: 'Permit document could not be updated' }, { status: 500 })
  }

  const { data: oldPermit } = await admin.from('permits').select('*').eq('source_system', 'synchron').eq('source_record_id', permitKey).maybeSingle()
  if (oldPermit && oldPermit.trip_id !== trip.id) return NextResponse.json({ error: 'Permit item belongs to another trip' }, { status: 409 })
  let permit = oldPermit
  if (!permit) {
    const { data, error } = await admin.from('permits').insert({
      trip_id: trip.id, document_id: document.id, state_code: input.state_code,
      permit_number: input.permit_number ?? null,
      effective_date: input.effective_date ?? null, expiration_date: input.expiration_date ?? null,
      extraction_status: 'pending', source_system: 'synchron', source_record_id: permitKey,
      source_status: 'Permit Attached', attached_at: new Date().toISOString(),
    }).select('*').single()
    if (error || !data) return NextResponse.json({ error: 'Permit could not be saved' }, { status: 500 })
    permit = data
  }

  const result = await processWorkspacePermit({ permitId: permit.id, origin: publicOrigin(req) })
  if (!result.ok || result.status === 'superseded') return NextResponse.json({ error: 'Permit processing pending; retry callback', detail: result.error }, { status: 503 })
  if (result.status === 'queued_or_already_processed') {
    const { data: job } = await admin.from('permit_processing_jobs').select('status').eq('permit_id', permit.id).single()
    const { data: saved } = await admin.from('permits').select('extraction_status,route_processing_status').eq('id', permit.id).single()
    const waitingForMap = saved?.extraction_status === 'processed' && saved?.route_processing_status === 'needs_preparation'
    if (job?.status !== 'done' && !waitingForMap) return NextResponse.json({ error: 'Permit is processing; retry callback' }, { status: 503 })
  }
  const { data: fulfilled } = await admin.from('service_requests').update({ status: 'fulfilled', vendor_order_id: input.synchron_order_token })
    .eq('trip_id', trip.id).eq('type', 'permit_request').eq('state_code', input.state_code)
    .in('status', ['requested', 'in_progress']).select('id')
  if (fulfilled?.length || !oldPermit) await admin.from('trip_events').insert({ trip_id: trip.id, actor_label: 'Synchron Permits', action: 'synchron_permit_attached', detail: { state_code: input.state_code, item_id: input.item_id, permit_number: permit.permit_number, synchron_order_token: input.synchron_order_token } })
  const sync = await syncTripToHha(trip.id)
  if (!sync.ok) console.error('Synchron permit trip sync failed:', sync.error)
  return NextResponse.json({ ok: true, trip_ref: trip.ref_code, permit_id: permit.id, route_status: result.status })
}

/**
 * Route purchase payment events (task §6.4). The signed callback is the
 * trusted source; it is mapped to a status report and applied through the
 * single verified path. 200 on duplicates so Synchron stops retrying.
 */
async function handlePurchaseCallback(input: SynchronPurchaseCallback) {
  const paymentStatus: PurchaseStatusReport['paymentStatus'] =
    input.event === 'purchase.payment_confirmed' ? 'paid' : input.event === 'purchase.payment_failed' ? 'failed' : 'refunded'
  const report: PurchaseStatusReport = {
    purchaseReference: input.purchase_reference,
    paymentStatus,
    synchronPurchaseToken: input.synchron_purchase_token ?? null,
    stripeCheckoutSessionId: input.stripe_checkout_session_id ?? null,
    stripePaymentIntentId: input.stripe_payment_intent_id ?? null,
    stripeChargeId: input.stripe_charge_id ?? null,
    paymentConfirmedAt: paymentStatus === 'paid' ? (input.paid_at ?? new Date().toISOString()) : null,
    externalEventId: input.event_id,
  }
  const result = await applyVerifiedPaymentEvent({ source: 'synchron', report, via: 'callback' })
  if (!result.ok && result.reason === 'unknown_purchase') return NextResponse.json({ error: 'Purchase not found', result }, { status: 404 })
  if (!result.ok && result.reason === 'error') return NextResponse.json({ error: 'Purchase update failed; retry callback', result }, { status: 503 })
  return NextResponse.json({ ok: true, result })
}