/* KALENDER ZUM ABONNIEREN — der einzige Weg ohne Anmeldung

   Stufe 3.2 des Plans. Google, Apple und Outlook holen einen Kalender
   im Hintergrund ab: ohne Browser, ohne Sitzung, ohne Anmeldemaske. Ein
   Kalender, der eine Anmeldung verlangt, laesst sich nicht abonnieren.

   Damit ist der geheime Schluessel in der Adresse der GANZE Schutz
   dieses Weges -- und deshalb ist diese Pruefung strenger als die
   anderen. Sie fragt vor allem zwei Dinge:

     1. Sieht wirklich NUR die eigene Person ihre eigenen Termine?
        Eine zweite Sichtbarkeitsregel neben der des Workspace waere der
        Weg, auf dem ausgerechnet die Tuer ohne Schloss mehr zeigt als
        die mit.
     2. Ist der Schluessel wirklich widerrufbar? Ein Geheimnis, das man
        nicht zuruecknehmen kann, ist keins.

   Dazu das Format selbst. ICS sieht harmlos aus und ist voller Fallen:
   Zeilen ueber 75 Byte schneidet Outlook ab, ein Komma im Titel trennt
   das Feld, LF statt CRLF laesst die Datei stumm verwerfen. Geprueft
   wird deshalb nicht "es steht etwas da", sondern es wird
   ZURUECKGELESEN -- entfaltet, entschluesselt, verglichen.

   GEGENPROBEN durchgehend.
   ===================================================================== */

import { mkdtempSync, rmSync, appendFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

const ordner = mkdtempSync(join(tmpdir(), "ws-ics-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");

import { notbremse } from "./helfer-notbremse.mjs";
const { eigenerPort } = await import("./helfer-port.mjs");
const PORT = await eigenerPort(import.meta, "die Kalender-Abo-Pruefung");

process.env.PORT = String(PORT);
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";

const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
await import("./index.js");
notbremse(240_000, "pruef-ics");
await new Promise((r) => setTimeout(r, 900));
const BASIS = `http://127.0.0.1:${PORT}`;

const PROTOKOLL = join(process.cwd(), "pruef-ics-lauf.txt");
try { rmSync(PROTOKOLL, { force: true }); } catch { /* gab es noch nicht */ }
const melde = (z) => {
  console.log(z);
  try { appendFileSync(PROTOKOLL, z + "\n"); } catch { /* Zugabe */ }
};
let fehler = 0;
let gemacht = 0;
const ok = (b, t) => { gemacht++; melde((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };

/* ---- Bestand ------------------------------------------------------------ */
const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes } = await import("node:crypto");
const { heuteLokal } = await import("./helfer-zeit.mjs");
await fetch(BASIS + "/workspace/api/anmelden", {
  method: "POST", headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ rolle: "admin", code: "x" }) }).catch(() => {});
for (let i = 0; i < 60; i++) {
  try {
    const p = new DatabaseSync(process.env.WORKSPACE_DB);
    try { p.prepare("SELECT 1 FROM personen LIMIT 1").get(); break; } finally { p.close(); }
  } catch { await new Promise((r) => setTimeout(r, 250)); }
}

const d = new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();
const heute = heuteLokal();
function anlegen(name, rolle, code) {
  const salt = randomBytes(16).toString("hex");
  const hash = scryptSync(code, salt, 64, { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
  d.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, aktiv, erstellt) VALUES (?,?,?,?,?,1,?)")
    .run(name, rolle, hash, salt, 32768, jetzt);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}
const idDogi = anlegen("Filipe", "admin", "CODE-DOGI-0001");
const idPat  = anlegen("Patrick", "scout", "CODE-SCOU-0001");
const idLuna = anlegen("Luna", "creator", "CODE-CREA-0001");
/* Nora gehoert einem ANDEREN Scout -- ihre Termine darf Luna nirgends
   sehen, auch nicht ueber den Weg ohne Anmeldung. */
const idBea  = anlegen("Bea", "scout", "CODE-SCOU-0002");
const idNora = anlegen("Nora", "creator", "CODE-CREA-0002");
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idLuna, idPat, jetzt);
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idNora, idBea, jetzt);

/* DIE FALLEN DES FORMATS, absichtlich in die Daten gelegt:
   ein Komma, ein Semikolon, ein Backslash und ein sehr langer Titel mit
   Umlauten. Ohne solche Titel prueft die Datei nur den einfachen Fall
   -- und genau der geht immer gut. */
const HEIKEL = 'Call: Ziele, Technik; Rückblick \\ Ausblick';
const LANG = "Ein absichtlich sehr langer Titel für den Kalender mit Umlauten "
  + "wie Ärger, Öffnung und Übermut, damit die Zeile über fünfundsiebzig Byte hinausgeht";

function termin(titel, wer, versatz, ort = null) {
  const t = new Date();
  t.setDate(t.getDate() + versatz);
  const p = (n) => String(n).padStart(2, "0");
  const beginn = `${t.getFullYear()}-${p(t.getMonth() + 1)}-${p(t.getDate())}T14:30`;
  d.prepare(`INSERT INTO termine (titel, art, beginn, dauer_min, ort, creator_id,
    teilnehmer_id, erstellt, erstellt_von) VALUES (?,'call',?,45,?,?,?,?,?)`)
    .run(titel, beginn, ort, wer, wer, jetzt, idDogi);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}

const idLunaTermin = termin(HEIKEL, idLuna, 3, "https://meet.example.invalid/raum");
termin(LANG, idLuna, 5);
termin("Ganz normal", idLuna, 9);
const idNoraTermin = termin("NORAS GEHEIMER TERMIN", idNora, 4);
/* Beas eigener Termin. Er ist seit dem 07.09.2026 noetig: Bis dahin war
   Beas Kalender allein dadurch gefuellt, dass sie Nora betreut. Die
   Betreuung entscheidet im Kalender aber nicht mehr mit (siehe
   termineSichtbar in workspace.js) -- ohne eigenen Termin waere ihr
   Kalender leer, und ein leerer Kalender ist der sauberste Befund von
   allen: Er beweist gar nichts. */
termin("BEAS EIGENER TERMIN", idBea, 6);
d.close();

/* ---- Werkzeug: ICS zurueckLESEN ----------------------------------------
   Nicht "es steht etwas da", sondern: entfalten, entschluesseln,
   vergleichen. Sonst prueft man die eigene Schreibweise. */
function entfalten(roh) {
  /* Eine Fortsetzungszeile beginnt mit Leerzeichen oder Tabulator --
     genau das macht das Format aus. */
  return String(roh).replace(/\r\n[ \t]/g, "");
}
function entschluesseln(w) {
  return String(w)
    .replace(/\\n/g, "\n").replace(/\\,/g, ",")
    .replace(/\\;/g, ";").replace(/\\\\/g, "\\");
}
function ereignisse(roh) {
  const zeilen = entfalten(roh).split("\r\n");
  const raus = [];
  let jetztE = null;
  for (const z of zeilen) {
    if (z === "BEGIN:VEVENT") { jetztE = {}; continue; }
    if (z === "END:VEVENT") { if (jetztE) raus.push(jetztE); jetztE = null; continue; }
    if (!jetztE) continue;
    const t = z.indexOf(":");
    if (t < 0) continue;
    const schluessel = z.slice(0, t).split(";")[0];
    jetztE[schluessel] = entschluesseln(z.slice(t + 1));
    if (schluessel === "DTSTART") jetztE.DTSTART_ROH = z.slice(0, t);
  }
  return raus;
}

/* ---- Anmelden und Link holen -------------------------------------------- */
async function anmelden(rolle, code) {
  const a = await fetch(BASIS + "/workspace/api/anmelden", {
    method: "POST", headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ rolle, code }) });
  const keks = (a.headers.getSetCookie?.() || []).map((z) => z.split(";")[0]).join("; ");
  if (!keks) throw new Error(`Anmeldung ${rolle} fehlgeschlagen (${a.status})`);
  return keks;
}
const keksLuna = await anmelden("creator", "CODE-CREA-0001");
const keksBea = await anmelden("scout", "CODE-SCOU-0002");

async function linkHolen(keks) {
  const a = await fetch(BASIS + "/workspace/api/ics", {
    method: "POST", headers: { "Content-Type": "application/json", cookie: keks, origin: BASIS },
    body: "{}" });
  return (await a.json()).link;
}

/* =======================================================================
   1. Der Link entsteht erst auf Wunsch
   ======================================================================= */
melde("=== Der Link entsteht erst auf Wunsch ===");
{
  const a = await fetch(BASIS + "/workspace/api/ics", { headers: { cookie: keksLuna } });
  const d0 = await a.json();
  /* Ein Geheimnis, das von selbst entsteht, liegt danach herum und
     niemand weiss, dass es existiert. */
  ok(d0.link === null, `vor dem ersten Klick gibt es keinen Link (${d0.link})`);
}

const linkLuna = await linkHolen(keksLuna);
ok(new RegExp(`^http://127\\.0\\.0\\.1:${PORT}/workspace/kalender/[A-Za-z0-9_-]{40,}\\.ics$`).test(linkLuna || ""),
  `der Link sieht richtig aus (…${String(linkLuna).slice(-24)})`);

/* =======================================================================
   2. OHNE ANMELDUNG abrufbar — darauf beruht die ganze Sache
   ======================================================================= */
melde("\n=== Ohne Anmeldung, wie ein echter Kalender ihn holt ===");
let icsLuna = "";
{
  /* Kein Cookie, kein Origin -- genau wie Googles Abholer. */
  const a = await fetch(linkLuna);
  icsLuna = await a.text();
  ok(a.status === 200, `HTTP ${a.status} ohne jede Anmeldung`);
  ok(/^text\/calendar/.test(a.headers.get("content-type") || ""),
    `als "${a.headers.get("content-type")}"`);
  ok((a.headers.get("cache-control") || "").includes("no-store"),
    "und ohne Zwischenspeicher — ein Kalender, der Altes zeigt, ist schlimmer als keiner");
}

/* =======================================================================
   3. Ist es wirklich ICS?
   ======================================================================= */
melde("\n=== Das Format ===");
{
  ok(icsLuna.startsWith("BEGIN:VCALENDAR\r\n"), "beginnt mit BEGIN:VCALENDAR");
  ok(icsLuna.trimEnd().endsWith("END:VCALENDAR"), "endet mit END:VCALENDAR");

  /* CRLF, nicht LF. Outlook verwirft eine Datei mit blossen
     Zeilenvorschueben wortlos -- der Kalender bleibt leer, ohne dass
     irgendwo etwas rot wird. */
  const nurLF = icsLuna.split("\n").filter((z, i, a) => i < a.length - 1 && !z.endsWith("\r"));
  ok(nurLF.length === 0,
    nurLF.length ? `${nurLF.length} Zeilen ohne CR: ${nurLF[0].slice(0, 40)}`
      : `alle ${icsLuna.split("\r\n").length} Zeilen enden mit CRLF`);

  ok(icsLuna.includes("BEGIN:VTIMEZONE") && icsLuna.includes("TZID:Europe/Berlin"),
    "die Zeitzone steht als eigener Block drin (sonst zeigt Outlook eine Stunde daneben)");

  /* KEINE ZEILE UEBER 75 BYTE. Outlook schneidet ab, statt umzubrechen
     -- der Termin verliert dann seinen halben Titel. Gemessen werden
     BYTES: Ein Umlaut ist in UTF-8 zwei, und deutsche Titel reissen die
     Grenze genau deshalb. */
  const zuLang = icsLuna.split("\r\n")
    .filter((z) => Buffer.from(z, "utf8").length > 75);
  ok(zuLang.length === 0,
    zuLang.length ? `${zuLang.length} Zeilen ueber 75 Byte: "${zuLang[0].slice(0, 50)}…"`
      : `keine Zeile ueber 75 Byte (laengste: ${Math.max(...icsLuna.split("\r\n").map((z) => Buffer.from(z, "utf8").length))})`);

  /* GEGENPROBE zur Messung: Ein bewusst zu langer Text MUSS auffallen.
     Ohne sie bewiese "0 zu lange Zeilen" nur, dass die Messung nie
     etwas findet. */
  ok(Buffer.from("x".repeat(80), "utf8").length > 75,
    "Gegenprobe: die Byte-Messung erkennt eine 80 Zeichen lange Zeile als zu lang");
}

/* =======================================================================
   4. Kommen die Termine richtig an? (zurueckgelesen, nicht angesehen)
   ======================================================================= */
melde("\n=== Die Termine, zurueckgelesen ===");
const evLuna = ereignisse(icsLuna);
{
  ok(evLuna.length === 3, `${evLuna.length} Termine im Kalender (erwartet 3)`);

  /* Der heikle Titel MUSS Zeichen fuer Zeichen zurueckkommen. Komma,
     Semikolon und Backslash haben im Format eine Bedeutung -- wer sie
     nicht verpackt, zerlegt damit das Feld. */
  const heikel = evLuna.find((e) => String(e.SUMMARY).includes("Rückblick"));
  ok(heikel?.SUMMARY === `Call: ${HEIKEL}`,
    `Komma, Semikolon und Backslash ueberleben: "${heikel?.SUMMARY}"`);

  /* Und der lange Titel muss nach dem Entfalten wieder GANZ da sein --
     nicht abgeschnitten und nicht mit einem Fragezeichen mitten im
     Umlaut (das passiert, wenn man in ein Mehrbyte-Zeichen schneidet). */
  const lang = evLuna.find((e) => String(e.SUMMARY).includes("Übermut"));
  ok(lang?.SUMMARY === `Call: ${LANG}`,
    `der lange Titel ist nach dem Entfalten vollstaendig (${String(lang?.SUMMARY).length} Zeichen)`);
  ok(!/[�?]{1}/.test(String(lang?.SUMMARY).replace(/[?]/g, "")),
    "und kein Umlaut ist beim Falten zerbrochen");

  /* Ortszeit MIT Zonenangabe, nicht nach UTC gerechnet. Wer selbst
     umrechnet, muss die Sommerzeit nachbilden und liegt zweimal im Jahr
     eine Stunde daneben. */
  const eins = evLuna[0];
  ok(/TZID=Europe\/Berlin/.test(eins?.DTSTART_ROH || ""),
    `die Startzeit traegt ihre Zone (${eins?.DTSTART_ROH})`);
  ok(/^\d{8}T143000$/.test(eins?.DTSTART || ""),
    `und die Uhrzeit stimmt (${eins?.DTSTART})`);
  ok(eins?.DURATION === "PT45M", `die Dauer stimmt (${eins?.DURATION})`);

  const mitOrt = evLuna.find((e) => e.LOCATION);
  ok(mitOrt?.URL === "https://meet.example.invalid/raum",
    `ein Link steht auch im URL-Feld (${mitOrt?.URL}) — daraus macht der Kalender einen Knopf`);

  /* Eine Erinnerung gehoert dazu -- ohne sie ist es nur eine Liste. */
  ok((icsLuna.match(/BEGIN:VALARM/g) || []).length === evLuna.length,
    `jeder Termin hat eine Erinnerung (${(icsLuna.match(/BEGIN:VALARM/g) || []).length})`);
}

/* =======================================================================
   5. DIE KENNUNG BLEIBT — sonst wird aus einem Termin zwei
   ======================================================================= */
melde("\n=== Die Kennung ueberlebt den naechsten Abruf ===");
{
  const zweite = ereignisse(await (await fetch(linkLuna)).text());
  const vorher = evLuna.map((e) => e.UID).sort();
  const nachher = zweite.map((e) => e.UID).sort();
  ok(JSON.stringify(vorher) === JSON.stringify(nachher),
    `dieselben Kennungen wie beim ersten Abruf (${vorher.length})`);
  ok(vorher.every((u) => /^termin-\d+@/.test(u)),
    `sie haengen an der Datenbanknummer (${vorher[0]})`);
  /* Waere sie nicht stabil, loeschte der Kalender den alten Eintrag und
     legte einen neuen an -- aus einem verschobenen Termin wuerden zwei,
     und die Erinnerung haengt an der falschen Haelfte. */
  ok(new Set(vorher).size === vorher.length, "und jede kommt genau einmal vor");
}

/* =======================================================================
   6. DIE WICHTIGSTE FRAGE: sieht jemand fremde Termine?
   ======================================================================= */
melde("\n=== Sichtbarkeit — der Weg ohne Anmeldung darf nicht mehr zeigen ===");
{
  ok(!icsLuna.includes("NORAS GEHEIMER TERMIN"),
    "Lunas Kalender enthaelt Noras Termin NICHT");

  /* SEIT DEM 07.09.2026 SIEHT AUCH BEA NORAS TERMIN NICHT MEHR.
     Hier stand vorher das Gegenteil, und es war damals richtig: Bea
     betreut Nora, also stand Noras Termin in ihrem Kalender. Der
     Kalender fragt seit dem Umbau nicht mehr nach Rolle oder
     Betreuung, sondern nur noch nach Beteiligung -- und Bea ist an
     diesem Termin nicht beteiligt.

     Die GEGENPROBE bleibt notwendig, sie braucht nur einen anderen
     Beleg: Beas eigener Termin muss in ihrem Kalender stehen. Ohne
     ihn bewiesen die beiden Zeilen darueber nur, dass ihr Kalender
     leer ist. */
  const linkBea = await linkHolen(keksBea);
  const icsBea = await (await fetch(linkBea)).text();
  ok(!icsBea.includes("NORAS GEHEIMER TERMIN"),
    "Beas Kalender enthaelt ihn ebenfalls nicht — Betreuung zaehlt hier nicht mehr");
  ok(icsBea.includes("BEAS EIGENER TERMIN"),
    "ihr eigener steht sehr wohl darin — die Messung unterscheidet also");
  ok(!icsBea.includes("Rückblick"),
    "und Lunas heikler Termin steht NICHT in Beas Kalender");

  /* Und die Zahl gehoert in die Bedingung: zwei leere Kalender waeren
     sonst der sauberste Befund von allen. */
  const evBea = ereignisse(icsBea);
  ok(evLuna.length === 3 && evBea.length === 1,
    `Luna ${evLuna.length} Termine, Bea ${evBea.length} — beide Kalender sind gefuellt`);
}

/* =======================================================================
   7. Ein falscher Schluessel kommt nirgends hinein
   ======================================================================= */
melde("\n=== Falsche Schluessel ===");
{
  /* DIE PROBE DARF NICHT DER ECHTE SCHLUESSEL SEIN (01.10.2026).

     Hier stand `echt.slice(0, -1) + "A"`. Der Schluessel ist base64url
     aus 32 Bytes; sein letztes Zeichen kodiert vier Bit und ist eines
     von sechzehn. Endet er auf „A", IST die Probe der echte
     Schluessel -- der Server antwortet zu Recht mit 200, und diese
     Pruefung meldet ein Loch, das es nicht gibt. Einmal je sechzehn
     Laeufe, also mehrmals im Monat; heute Nacht zweimal
     hintereinander, und die Suche ging eine halbe Stunde in eine
     Aenderung, die damit nichts zu tun hatte.

     Ein Fehlalarm, den man nicht nachstellen kann, ist der sicherste
     Weg, eine Pruefung abzuschalten. */
  const echt = String(linkLuna).split("/").pop().replace(".ics", "");
  const fastRichtig = echt.slice(0, -1) + (echt.at(-1) === "A" ? "B" : "A");
  ok(fastRichtig !== echt && fastRichtig.length === echt.length,
    `die Probe unterscheidet sich vom echten Schluessel (…${echt.slice(-4)} gegen …${fastRichtig.slice(-4)})`);

  const proben = [
    ["kurz", "abc"],
    ["leer", ""],
    ["fast richtig", fastRichtig],
    ["mit Punkten", "../../workspace/start"],
    ["SQL-Versuch", "' OR '1'='1"],
  ];
  let abgewiesen = 0;
  for (const [name, s] of proben) {
    const a = await fetch(`${BASIS}/workspace/kalender/${encodeURIComponent(s)}.ics`);
    const text = a.status === 200 ? await a.text() : "";
    const gut = a.status !== 200 || !text.includes("BEGIN:VEVENT");
    if (gut) abgewiesen++;
    else ok(false, `"${name}" kam durch (HTTP ${a.status})`);
  }
  ok(abgewiesen === proben.length,
    `alle ${proben.length} falschen Schluessel abgewiesen`);

  /* GEGENPROBE: Der richtige kommt weiterhin durch. Sonst bewiese das
     oben nur, dass der Weg gar nicht funktioniert. */
  const richtig = await fetch(linkLuna);
  ok(richtig.status === 200, `der richtige Schluessel funktioniert weiter (HTTP ${richtig.status})`);
}

/* =======================================================================
   8. WIDERRUFBAR — ein Geheimnis, das man nicht zuruecknehmen kann,
      ist keins
   ======================================================================= */
melde("\n=== Widerrufen ===");
{
  const neu = await linkHolen(keksLuna);
  ok(neu !== linkLuna, "der neue Link ist ein anderer");

  const alt = await fetch(linkLuna);
  ok(alt.status === 404, `der alte ist im selben Moment tot (HTTP ${alt.status})`);

  const jung = await fetch(neu);
  const text = await jung.text();
  ok(jung.status === 200 && text.includes("BEGIN:VEVENT"),
    `der neue liefert die Termine (HTTP ${jung.status})`);

  /* Abschalten heisst abschalten, nicht "neuer Link". */
  await fetch(BASIS + "/workspace/api/ics", {
    method: "DELETE", headers: { cookie: keksLuna, origin: BASIS } });
  const nachAus = await fetch(neu);
  ok(nachAus.status === 404, `nach dem Abschalten ist auch er tot (HTTP ${nachAus.status})`);

  const stand = await (await fetch(BASIS + "/workspace/api/ics",
    { headers: { cookie: keksLuna } })).json();
  ok(stand.link === null, "und die Verwaltung meldet: kein Link mehr");
}

/* =======================================================================
   9. Fremde Herkunft darf nichts erneuern
   ======================================================================= */
melde("\n=== Fremde Herkunft ===");
{
  const a = await fetch(BASIS + "/workspace/api/ics", {
    method: "POST",
    headers: { "Content-Type": "application/json", cookie: keksLuna,
      origin: "https://boese.example" },
    body: "{}" });
  ok(a.status === 403,
    `eine fremde Seite kann keinen neuen Link erzwingen (HTTP ${a.status})`);
  ok(!!heute, `(Bestand vom ${heute}, Termine ${idLunaTermin}/${idNoraTermin} angelegt)`);
}

try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
melde(`\n${gemacht} Pruefungen`);
melde(fehler === 0 ? "ALLES IN ORDNUNG" : `${fehler} FEHLER`);
process.exit(fehler ? 1 : 0);