// Reverse-Proxy für Dev-Previews: Host <sub>.<baseHost> ⇒ laufender Dev-Container (R5: Docker-DNS im Netz preview-sandbox).
// Keine Authentifizierung hier: die Hosts liegen hinter Traefiks preview-chain (ForwardAuth). Weitergeleitet wird
// ausschließlich an das Ziel, das dev.wake/dev.ensure liefert (preview-dev-<sub>).
import http from 'node:http';
import { isValidSub } from './validate.js';

const esc = (s) => String(s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));

function page(title, text, { refresh = false, hint = '' } = {}) {
  return `<!doctype html><html lang="de"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">${refresh ? '<meta http-equiv="refresh" content="3">' : ''}<title>${esc(title)}</title><style>body{margin:0;min-height:100vh;display:flex;align-items:center;justify-content:center;font-family:system-ui,sans-serif;background:#f5f6f8;color:#1c2330}main{max-width:26rem;padding:2rem;text-align:center}h1{font-size:1.25rem;margin:0 0 .5rem}p{margin:.25rem 0;color:#5b6575}</style></head><body><main><h1>${esc(title)}</h1><p>${esc(text)}</p>${hint ? `<p>${esc(hint)}</p>` : ''}</main></body></html>`;
}

const PAGES = {
  starting: page('Preview startet …', 'Der Dev-Server wird gestartet. Die Seite lädt automatisch neu.', { refresh: true }),
  failed: page('Preview konnte nicht starten', 'Der Dev-Server ist nicht hochgekommen.', { hint: 'Details stehen im Protokoll im WOMS.' }),
  unknown: page('Preview nicht verfügbar', 'Diese Preview ist gerade nicht verfügbar.'),
  busy: page('Preview nicht verfügbar', 'Der Server ist gerade ausgelastet. Bitte später erneut versuchen.'),
};

function html(res, status, body, extra = {}) {
  res.writeHead(status, { 'Content-Type': 'text/html; charset=utf-8', 'Content-Length': Buffer.byteLength(body), 'Cache-Control': 'no-store', ...extra });
  res.end(body);
}

const HOP = ['connection', 'keep-alive', 'proxy-authorization', 'proxy-connection', 'te', 'trailer', 'transfer-encoding', 'upgrade'];
// allowHalfOpen: ein vom Client geschlossener Socket ist zwar nicht 'destroyed', aber nicht mehr lesbar
const gone = (s) => s.destroyed || !s.readable;
const TOUCH_MS = 60e3;

// Hop-by-hop-Header entfernen (samt der in Connection genannten Tokens). Auf dem Upgrade-Pfad bleiben Upgrade/Connection: Upgrade.
export function stripHop(headers, { upgrade = false } = {}) {
  const out = { ...headers };
  const listed = String(headers.connection || '').split(',').map((t) => t.trim().toLowerCase()).filter(Boolean);
  for (const k of Object.keys(out)) if (HOP.includes(k.toLowerCase()) || listed.includes(k.toLowerCase())) delete out[k];
  if (upgrade) { out.connection = 'Upgrade'; out.upgrade = headers.upgrade; }
  return out;
}

export function createProxy({ config, dev, request = http.request, upstreamTimeoutMs = 120e3, now = Date.now }) {
  // Sub aus dem Host-Header: exakt <sub>.<baseHost>, klein geschrieben, Port entfernt.
  function subOf(hostHeader) {
    const host = String(hostHeader || '').replace(/:\d+$/, '');
    const suffix = `.${config.baseHost}`;
    if (host !== host.toLowerCase() || !host.endsWith(suffix)) return null;
    const sub = host.slice(0, -suffix.length);
    return isValidSub(sub) ? sub : null;
  }

  function fwdHeaders(req, upgrade = false) {
    const h = stripHop(req.headers, { upgrade });
    const prior = req.headers['x-forwarded-for'];
    const ip = req.socket.remoteAddress || '';
    h['x-forwarded-for'] = prior ? `${prior}, ${ip}` : ip;
    h['x-forwarded-host'] = req.headers.host || '';
    h['x-forwarded-proto'] = req.headers['x-forwarded-proto'] || 'https';
    return h;
  }

  // Ergebnis: { target } wenn online, sonst { state }.
  async function resolve(sub) {
    let r;
    try { r = await dev.wake(sub); } catch (e) { if (e?.status !== 503) console.error('Proxy wake', sub, e); return { state: e?.status === 503 ? 'busy' : 'unknown' }; }
    if (r.state === 'online' && r.target) return { target: new URL(r.target) };
    return { state: r.state };
  }

  const server = http.createServer(async (req, res) => {
    try {
      const sub = subOf(req.headers.host);
      if (!sub) return html(res, 404, page('Nicht gefunden', 'Diese Adresse gibt es nicht.'));
      const r = await resolve(sub);
      if (!r.target) {
        const key = PAGES[r.state] ? r.state : 'unknown';
        return html(res, 503, PAGES[key], key === 'starting' ? { 'Retry-After': '3' } : {});
      }
      dev.touch(sub);
      const up = request({
        hostname: r.target.hostname, port: r.target.port, method: req.method, path: req.url, headers: fwdHeaders(req),
      }, (ures) => {
        res.writeHead(ures.statusCode, stripHop(ures.headers));
        ures.pipe(res);
        ures.on('error', () => res.destroy());
      });
      let timedOut = false;
      up.setTimeout(upstreamTimeoutMs, () => { timedOut = true; up.destroy(); });
      up.on('error', (err) => {
        if (['ECONNREFUSED', 'ENOTFOUND', 'EHOSTUNREACH', 'EAI_AGAIN'].includes(err?.code)) dev.markDead?.(sub)?.catch?.(() => {});
        if (!res.headersSent) {
          const body = timedOut ? 'Die Preview antwortet nicht rechtzeitig (504).' : 'Die Preview ist gerade nicht erreichbar (502).';
          res.writeHead(timedOut ? 504 : 502, { 'Content-Type': 'text/plain; charset=utf-8', 'Content-Length': Buffer.byteLength(body) });
          res.end(body);
        } else res.destroy();
      });
      res.on('close', () => { if (!res.writableFinished) up.destroy(); });
      req.pipe(up);
    } catch (e) {
      console.error('Proxy-Fehler:', e);
      if (!res.headersSent) html(res, 500, page('Fehler', 'Interner Fehler.'));
      else res.destroy();
    }
  });

  server.on('upgrade', async (req, socket, head) => {
    socket.on('error', () => socket.destroy());
    try {
      const sub = subOf(req.headers.host);
      if (!sub) return socket.end('HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\n');
      const r = await resolve(sub);
      if (gone(socket)) return socket.destroy(); // Client hat sich während des Wartens verabschiedet
      if (!r.target) return socket.end('HTTP/1.1 503 Service Unavailable\r\nConnection: close\r\n\r\n');
      dev.touch(sub);
      const up = request({
        hostname: r.target.hostname, port: r.target.port, method: req.method, path: req.url, headers: fwdHeaders(req, true),
      });
      up.on('response', (ures) => { // Upstream lehnt das Upgrade ab: Antwort durchreichen und schließen
        let raw = `HTTP/1.1 ${ures.statusCode} ${ures.statusMessage}\r\n`;
        for (let i = 0; i < ures.rawHeaders.length; i += 2) raw += `${ures.rawHeaders[i]}: ${ures.rawHeaders[i + 1]}\r\n`;
        socket.write(`${raw}\r\n`);
        ures.pipe(socket);
      });
      up.on('upgrade', (ures, usock, uhead) => {
        if (gone(socket)) { usock.destroy(); up.destroy(); return; }
        usock.on('error', () => { usock.destroy(); socket.destroy(); });
        // allowHalfOpen-Sockets bleiben nach 'end' offen: bei Ende oder Schließen einer Seite beide zerstören
        const both = () => { usock.destroy(); socket.destroy(); };
        for (const ev of ['end', 'close']) { socket.on(ev, both); usock.on(ev, both); }
        let raw = `HTTP/1.1 ${ures.statusCode} ${ures.statusMessage}\r\n`;
        for (let i = 0; i < ures.rawHeaders.length; i += 2) raw += `${ures.rawHeaders[i]}: ${ures.rawHeaders[i + 1]}\r\n`;
        socket.write(`${raw}\r\n`);
        if (uhead?.length) socket.write(uhead);
        if (head?.length) usock.write(head);
        // Offene Verbindung (z. B. HMR) hält den Dev-Server wach: höchstens einmal pro Minute touch
        let last = now();
        const keep = () => { const t = now(); if (t - last >= TOUCH_MS) { last = t; dev.touch(sub); } };
        usock.on('data', keep); socket.on('data', keep);
        usock.pipe(socket);
        socket.pipe(usock);
      });
      up.on('error', () => socket.destroy());
      socket.on('close', () => up.destroy());
      up.end();
    } catch (e) {
      console.error('Proxy-Upgrade-Fehler:', e);
      socket.destroy();
    }
  });

  return server;
}