import { createServer, type IncomingMessage } from 'node:http'
import { chromium, type Browser } from 'playwright'

/**
 * Rendert die Druckansicht einer Akte zu PDF. Kein PDF-Layout von Hand, die
 * Gestaltung kommt aus `@media print` der Seite selbst. Siehe docs/08-suche-und-export.md.
 *
 * Der Dienst ist nur im Stack-Netz erreichbar und kennt keine Rechte. Wer darf,
 * entscheidet die Web-App, bevor sie hier anfragt; sie schickt das Sitzungs-Cookie
 * des Abrufers mit, damit die gerenderte Seite dessen Freigabestufe sieht.
 */
const PORT = Number(process.env.PORT ?? 3000)
const RENDER_TIMEOUT_MS = Number(process.env.RENDER_TIMEOUT_MS ?? 30_000)

let browser: Browser | null = null

async function getBrowser(): Promise<Browser> {
  if (browser?.isConnected()) return browser
  browser = await chromium.launch({ args: ['--no-sandbox', '--disable-dev-shm-usage'] })
  return browser
}

type RenderRequest = {
  url: string
  cookies?: { name: string; value: string; domain: string; path: string }[]
  /** Wasserzeichen: Name des Abrufers, Zeitstempel, Freigabestufe. */
  headerHtml?: string
  footerHtml?: string
}

function readBody(request: IncomingMessage): Promise<string> {
  return new Promise((resolve, reject) => {
    const chunks: Buffer[] = []
    let size = 0
    request.on('data', (chunk: Buffer) => {
      size += chunk.length
      if (size > 1_000_000) {
        reject(new Error('Anfrage zu groß'))
        request.destroy()
        return
      }
      chunks.push(chunk)
    })
    request.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')))
    request.on('error', reject)
  })
}

async function render(spec: RenderRequest): Promise<Buffer> {
  const context = await (await getBrowser()).newContext({ locale: 'de-DE', timezoneId: 'Europe/Berlin' })
  try {
    if (spec.cookies?.length) await context.addCookies(spec.cookies)
    const page = await context.newPage()
    await page.goto(spec.url, { waitUntil: 'networkidle', timeout: RENDER_TIMEOUT_MS })
    await page.emulateMedia({ media: 'print' })
    return await page.pdf({
      format: 'A4',
      printBackground: true,
      displayHeaderFooter: Boolean(spec.headerHtml || spec.footerHtml),
      headerTemplate: spec.headerHtml ?? '<span></span>',
      footerTemplate: spec.footerHtml ?? '<span></span>',
      margin: { top: '18mm', bottom: '18mm', left: '16mm', right: '16mm' },
    })
  } finally {
    await context.close()
  }
}

const server = createServer((request, response) => {
  void (async () => {
    if (request.url === '/health') {
      const healthy = browser === null || browser.isConnected()
      response.writeHead(healthy ? 200 : 503, { 'content-type': 'application/json' })
      response.end(JSON.stringify({ status: healthy ? 'up' : 'down' }))
      return
    }

    if (request.method === 'POST' && request.url === '/render') {
      try {
        const spec = JSON.parse(await readBody(request)) as RenderRequest
        if (typeof spec.url !== 'string') throw new Error('url fehlt')
        const pdf = await render(spec)
        response.writeHead(200, {
          'content-type': 'application/pdf',
          'content-length': String(pdf.byteLength),
        })
        response.end(pdf)
      } catch (error) {
        console.error('[pdf] Rendern fehlgeschlagen', error)
        response.writeHead(500, { 'content-type': 'application/json' })
        response.end(JSON.stringify({ error: error instanceof Error ? error.message : 'unbekannt' }))
      }
      return
    }

    response.writeHead(404)
    response.end()
  })()
})

server.listen(PORT, () => console.log(`[pdf] hört auf Port ${PORT}`))

async function shutdown(): Promise<void> {
  server.close()
  await browser?.close().catch(() => undefined)
  process.exit(0)
}
process.on('SIGTERM', () => void shutdown())
process.on('SIGINT', () => void shutdown())