// ST-1004: Server-Sent Events stream voor de QR-pairing-flow (M10).
//
// De desktop opent deze stream direct na pair/start. Auth is via de HttpOnly
// `s4m_pair`-cookie die diezelfde start-call zette — geen iron-session nodig
// (de gebruiker is op dit punt nog niet geauthenticeerd) en geen secret in
// query-parameters. De pairingId in het pad is niet vertrouwelijk.
//
// Bouwt voort op het LISTEN/NOTIFY-patroon uit ST-802
// (app/api/realtime/solo/route.ts) maar op channel `scrum4me_pairing`.
//
// Output: text/event-stream met
//   - één `state`-event direct na connect met de huidige pairing-status (zo
//     mist de desktop geen approve die net vóór de SSE-open landde)
//   - `message`-events met de volledige notify-payload bij elke status-wijziging
//   - heartbeat-comments elke 25s om proxy-timeouts te voorkomen
//
// Sluit zelf na 240s als safety-net (Vercel kapt na maxDuration), of zodra
// status `consumed` of `cancelled` doorkomt — desktop heeft dan geen reden
// meer om te luisteren.

import { NextRequest } from 'next/server'
import { Client } from 'pg'
import { prisma } from '@/lib/prisma'
import { verifyToken } from '@/lib/auth/pairing'
import { readPairCookie } from '@/lib/auth/pair-cookie'

export const runtime = 'nodejs'
export const dynamic = 'force-dynamic'
export const maxDuration = 300

const CHANNEL = 'scrum4me_pairing'
const HEARTBEAT_MS = 25_000
const HARD_CLOSE_MS = 240_000

interface NotifyPayload {
  op: 'I' | 'U'
  pairing_id: string
  status: 'pending' | 'approved' | 'consumed' | 'cancelled'
}

const TERMINAL_STATUSES = new Set(['consumed', 'cancelled'])

export async function GET(
  request: NextRequest,
  { params }: { params: Promise<{ pairingId: string }> },
) {
  const { pairingId } = await params

  const desktopToken = await readPairCookie()
  if (!desktopToken) {
    return Response.json({ error: 'Geen pairing-cookie' }, { status: 401 })
  }

  const pairing = await prisma.loginPairing.findUnique({
    where: { id: pairingId },
    select: { desktop_token_hash: true, status: true, expires_at: true },
  })
  if (!pairing) {
    return Response.json({ error: 'Pairing niet gevonden' }, { status: 404 })
  }
  if (pairing.expires_at < new Date()) {
    return Response.json({ error: 'Pairing verlopen' }, { status: 410 })
  }
  if (!verifyToken(desktopToken, pairing.desktop_token_hash)) {
    return Response.json({ error: 'Ongeldige cookie' }, { status: 401 })
  }

  const directUrl = process.env.DIRECT_URL ?? process.env.DATABASE_URL
  if (!directUrl || !directUrl.startsWith('postgres')) {
    // .env.local heeft DIRECT_URL=http://localhost:3000 (placeholder); dan
    // valt fallback ook nog terug op DATABASE_URL.
    const fallback = process.env.DATABASE_URL
    if (!fallback) {
      return Response.json(
        { error: 'DATABASE_URL niet geconfigureerd' },
        { status: 500 },
      )
    }
  }
  const connectionString =
    directUrl && directUrl.startsWith('postgres')
      ? directUrl
      : process.env.DATABASE_URL!

  const encoder = new TextEncoder()
  const pgClient = new Client({ connectionString })

  let heartbeatTimer: ReturnType<typeof setInterval> | null = null
  let hardCloseTimer: ReturnType<typeof setTimeout> | null = null
  let closed = false

  const stream = new ReadableStream({
    async start(controller) {
      const enqueue = (chunk: string) => {
        if (closed) return
        try {
          controller.enqueue(encoder.encode(chunk))
        } catch {
          // controller al gesloten — negeren
        }
      }

      const cleanup = async (reason: string) => {
        if (closed) return
        closed = true
        if (heartbeatTimer) clearInterval(heartbeatTimer)
        if (hardCloseTimer) clearTimeout(hardCloseTimer)
        try {
          await pgClient.end()
        } catch {
          // ignore
        }
        try {
          controller.close()
        } catch {
          // already closed
        }
        if (process.env.NODE_ENV !== 'production') {
          console.log(`[pair/stream ${pairingId}] closed: ${reason}`)
        }
      }

      try {
        await pgClient.connect()
        await pgClient.query(`LISTEN ${CHANNEL}`)
      } catch (err) {
        console.error('[pair/stream] pg connect/listen failed:', err)
        enqueue(
          `event: error\ndata: ${JSON.stringify({ message: 'pg connect failed' })}\n\n`,
        )
        await cleanup('pg connect failed')
        return
      }

      pgClient.on('notification', (msg) => {
        if (!msg.payload) return
        let payload: NotifyPayload
        try {
          payload = JSON.parse(msg.payload) as NotifyPayload
        } catch {
          return
        }
        if (payload.pairing_id !== pairingId) return
        enqueue(`data: ${msg.payload}\n\n`)
        if (TERMINAL_STATUSES.has(payload.status)) {
          cleanup(`terminal status: ${payload.status}`)
        }
      })

      pgClient.on('error', (err) => {
        console.error('[pair/stream] pg client error:', err)
        cleanup('pg error')
      })

      // Initial state — dicht de race tussen pair/start en SSE-open. De
      // *eerste* findUnique (voor cookie-validatie) gebeurde vóór LISTEN
      // actief was; als de mobiel tussen die query en LISTEN approvet is
      // de pg_notify verloren (Postgres queuet niet) én is de eerder
      // gelezen status stale. Lees daarom de status hier opnieuw — nu LISTEN
      // wel actief is, dus alle approvals na dit punt komen via de notify-
      // handler door.
      const fresh = await prisma.loginPairing.findUnique({
        where: { id: pairingId },
        select: { status: true },
      })
      const currentStatus = fresh?.status ?? pairing.status

      enqueue(
        `event: state\ndata: ${JSON.stringify({
          pairing_id: pairingId,
          status: currentStatus,
        })}\n\n`,
      )
      if (TERMINAL_STATUSES.has(currentStatus)) {
        await cleanup(`already-${currentStatus}`)
        return
      }

      heartbeatTimer = setInterval(() => {
        enqueue(`: heartbeat\n\n`)
      }, HEARTBEAT_MS)

      hardCloseTimer = setTimeout(() => {
        cleanup('hard close 240s')
      }, HARD_CLOSE_MS)

      request.signal.addEventListener('abort', () => {
        cleanup('client aborted')
      })
    },
  })

  return new Response(stream, {
    headers: {
      'Content-Type': 'text/event-stream; charset=utf-8',
      'Cache-Control': 'no-cache, no-transform',
      Connection: 'keep-alive',
      'X-Accel-Buffering': 'no',
    },
  })
}
