/* DER WECKER — eigene Erinnerungen zu einem Termin.

   Wunsch Filipe (07.09.2026): *"wie so ein wecker, den man auch in den
   eintraegen aktivieren oder ausschalten kann, den soll man sogar so
   einstellen koennen, dass er einen auch mehrmals informiert, einmal
   eine woche vorher, einmal drei tage vorher und einmal am tag selber.
   das soll man auch selbst jeder fuer sich einstellen koennen."*

   ---------------------------------------------------------------------
   WARUM DAS EINE EIGENE PRUEFUNG BRAUCHT

   Ein Wecker ist die einzige Stelle im Haus, an der die Anwendung von
   sich aus etwas TUT, ohne dass jemand davorsitzt. Alles andere
   passiert auf Klick und wird sofort gesehen. Ein Wecker, der nicht
   klingelt, faellt niemandem auf -- man verpasst den Termin und haelt
   sich selbst fuer schuld. Und einer, der zu oft klingelt, wird nach
   drei Tagen stummgeschaltet, womit auch die richtigen Meldungen weg
   sind.

   DIE VIER FEHLER, die dabei moeglich sind, und alle vier sind hier
   nachgestellt:

     KLINGELT NICHT   die Weckzeit ist erreicht, es kommt nichts
     KLINGELT DOPPELT dieselbe Erinnerung zweimal
     KLINGELT NUR EINMAL  von drei gesetzten Weckern kommt einer, weil
                      die Doppelsperre den ganzen Termin sperrt statt
                      des einzelnen Abstands
     KLINGELT ZU SPAET  nach einem Ausfall des Dienstes klingeln alle
                      alten Wecker der letzten Wochen nach

   Der letzte ist der teuerste: Er tritt genau dann auf, wenn ohnehin
   etwas kaputt war, und schuettet den Nutzer mit Meldungen zu Terminen
   zu, die laengst vorbei sind.

   GEMESSEN WIRD AM ECHTEN SERVER, nicht an der Rechnung im Kopf: Die
   Wecker werden ueber die Schnittstelle gesetzt, der Weckerlauf wird
   wirklich aufgerufen, und nachgesehen wird in `push_verschickt` --
   der Tabelle, die der Melder fuehrt.

   Aufruf:  node server/pruef-wecker.mjs */

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

const ordner = mkdtempSync(join(tmpdir(), "ws-wecker-"));
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 Weckerpruefung");

process.env.PORT = `${PORT}`;
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
/* KEINE RUHEZEIT WAEHREND DER PRUEFUNG.

   Beim ersten Lauf um 23:42 meldete diese Datei vier Fehler -- und
   keiner davon war echt: Der Melder schweigt zwischen 22 und 7 Uhr.
   Sie haette also den Kalender gemessen statt die Software und waere am
   naechsten Vormittag gruen gewesen. Ein Test, der die Wanduhr als
   Annahme benutzt, misst irgendwann das Gegenteil.

   Dass die Gegenprobe MITGEFALLEN ist, war dabei die eigentliche
   Auskunft: Waeren nur die Grenzen falsch gewesen, haette sie gehalten.
   Sie fiel mit -- also feuerte der Mechanismus ueberhaupt nicht, und
   die Ursache lag ausserhalb der geprueften Regel.

   `ab 24` und `bis 0` heisst: nie. Die Ruhezeit selbst wird davon nicht
   ungeprueft -- dafuer gibt es pruef-push. */
process.env.PUSH_RUHE_AB = "24";
process.env.PUSH_RUHE_BIS = "0";

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(300_000, "pruef-wecker");
await new Promise((r) => setTimeout(r, 900));
const BASIS = `http://127.0.0.1:${PORT}`;

let fehler = 0, gemacht = 0;
const ok = (b, t) => { gemacht++; console.log((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };

const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes } = await import("node:crypto");
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 jetztIso = new Date().toISOString();
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, jetztIso);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}
const idDogi = anlegen("Filipe", "admin", "CODE-DOGI-0001");
const idLuna = anlegen("Luna", "creator", "CODE-CREA-0001");
const idNora = anlegen("Nora", "creator", "CODE-CREA-0002");

/* EIN ECHTER EMPFAENGER, kein erfundener.

   Erster Anlauf: Adressen auf `example.invalid`, in der Annahme, der
   Melder trage den Versand nach dem VERSUCH ein. Falsch -- er traegt
   ihn nach der erfolgreichen ZUSTELLUNG ein (siehe benachrichtige:
   `if (raus && merkmal)`), und das ist richtig so: Was nicht ankam,
   darf nicht als geschickt gelten, sonst schweigt der Wecker beim
   naechsten Lauf endgueltig.

   Meine Annahme war also falsch, nicht der Code. Deshalb steht hier
   jetzt ein winziger Empfaenger, der wie ein Push-Dienst antwortet
   (201). Nebennutzen: Damit laeuft in dieser Pruefung auch der echte
   Versandweg mit -- Verschluesselung, VAPID-Kopf, HTTP -- statt nur
   der Buchhaltung darum herum. */
const { createServer } = await import("node:http");
let angekommen = 0;
const empfaenger = createServer((req, res) => { angekommen++; res.writeHead(201); res.end(); });
await new Promise((r) => empfaenger.listen(0, "127.0.0.1", r));
const pushPort = empfaenger.address().port;
empfaenger.unref?.();

const geraet = d.prepare(`INSERT INTO push_anmeldungen
  (person_id, endpunkt, p256dh, auth, erstellt) VALUES (?,?,?,?,?)`);
/* Gueltige Schluessel, keine Platzhalter: Die Verschluesselung rechnet
   wirklich damit, und ein Fantasieschluessel liesse sie scheitern --
   die Pruefung waere rot, ohne dass am Wecker etwas falsch waere. */
const { createECDH, randomBytes: zufall } = await import("node:crypto");
const b64u = (b) => Buffer.from(b).toString("base64")
  .replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
for (const pid of [idDogi, idLuna, idNora]) {
  const kurve = createECDH("prime256v1"); kurve.generateKeys();
  geraet.run(pid, `http://127.0.0.1:${pushPort}/push/${pid}`,
    b64u(kurve.getPublicKey()), b64u(zufall(16)), jetztIso);
}

/* Ortszeit, nie toISOString -- ein Termin "in zwei Stunden" darf nicht
   nachts auf gestern rutschen. */
const alsText = (dt) => {
  const p = (n) => String(n).padStart(2, "0");
  return `${dt.getFullYear()}-${p(dt.getMonth() + 1)}-${p(dt.getDate())}`
    + `T${p(dt.getHours())}:${p(dt.getMinutes())}`;
};
const inMinuten = (m) => alsText(new Date(Date.now() + m * 60_000));

const terminAnlegen = (titel, beginn, wer) => {
  d.prepare(`INSERT INTO termine (titel, art, beginn, dauer_min, erstellt, erstellt_von)
             VALUES (?, 'call', ?, 30, ?, ?)`).run(titel, beginn, jetztIso, wer);
  const id = d.prepare("SELECT last_insert_rowid() AS id").get().id;
  d.prepare("INSERT INTO termin_teilnehmer (termin_id, person_id) VALUES (?,?)").run(id, wer);
  return id;
};

/* Vier Termine, jeder fuer einen der vier Fehler oben. */
const idBald = terminAnlegen("Call in 90 Minuten", inMinuten(90), idDogi);
const idFern = terminAnlegen("Call in zehn Tagen", inMinuten(60 * 24 * 10), idDogi);
const idVorbei = terminAnlegen("Call von gestern", inMinuten(-60 * 26), idDogi);
const idFremd = terminAnlegen("Noras eigener Call", inMinuten(120), idNora);
d.close();

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 kDogi = await anmelden("admin", "CODE-DOGI-0001");
const kLuna = await anmelden("creator", "CODE-CREA-0001");

const ruf = async (art, pfad, rumpf, keks) => {
  const a = await fetch(BASIS + pfad, {
    method: art,
    headers: { "Content-Type": "application/json", cookie: keks, origin: BASIS },
    body: rumpf === undefined ? undefined : JSON.stringify(rumpf),
  });
  let daten = null; try { daten = await a.json(); } catch { /* leer erlaubt */ }
  return { status: a.status, daten };
};

/* =======================================================================
   1. Setzen, lesen, abwaehlen
   ======================================================================= */
console.log("\n=== Eigene Wecker setzen ===");
{
  const leer = await ruf("GET", `/workspace/api/termine/${idBald}/wecker`, undefined, kDogi);
  ok(leer.status === 200, `die Wecker sind abrufbar (${leer.status})`);
  ok((leer.daten?.meine || []).length === 0, "am Anfang ist keiner gesetzt");
  ok((leer.daten?.stufen || []).includes(10080) && (leer.daten?.stufen || []).includes(1440),
    `die Staffel enthaelt Woche und Tag (${(leer.daten?.stufen || []).join(", ")})`);

  const gesetzt = await ruf("PUT", `/workspace/api/termine/${idBald}/wecker`,
    { minuten: [10080, 1440, 60] }, kDogi);
  ok(gesetzt.status === 200, `drei Wecker gesetzt (${gesetzt.status})`);
  ok(JSON.stringify(gesetzt.daten?.meine) === JSON.stringify([10080, 1440, 60]),
    `und zwar absteigend sortiert (${JSON.stringify(gesetzt.daten?.meine)})`);

  const wieder = await ruf("GET", `/workspace/api/termine/${idBald}/wecker`, undefined, kDogi);
  ok(JSON.stringify(wieder.daten?.meine) === JSON.stringify([10080, 1440, 60]),
    "sie stehen beim naechsten Abruf noch da");

  /* ABWAEHLEN MUSS WIRKEN. Wer nur einfuegt statt vorher zu raeumen,
     sammelt bei jedem Speichern eine Zeile mehr an -- und der
     abgewaehlte Wecker klingelt trotzdem. */
  const weniger = await ruf("PUT", `/workspace/api/termine/${idBald}/wecker`,
    { minuten: [1440] }, kDogi);
  ok(JSON.stringify(weniger.daten?.meine) === JSON.stringify([1440]),
    `abwaehlen entfernt die anderen wirklich (${JSON.stringify(weniger.daten?.meine)})`);
  await ruf("PUT", `/workspace/api/termine/${idBald}/wecker`,
    { minuten: [10080, 1440, 60] }, kDogi);
}

/* =======================================================================
   2. Was NICHT geht
   ======================================================================= */
console.log("\n=== Die Grenzen ===");
{
  const quatsch = await ruf("PUT", `/workspace/api/termine/${idFern}/wecker`,
    { minuten: [7, 999999, 1440, 1440] }, kDogi);
  ok(JSON.stringify(quatsch.daten?.meine) === JSON.stringify([1440]),
    `unbekannte Stufen und Dubletten fallen weg, der Rest bleibt (${JSON.stringify(quatsch.daten?.meine)})`);

  const zuviele = await ruf("PUT", `/workspace/api/termine/${idFern}/wecker`,
    { minuten: [10080, 4320, 1440, 720, 60, 10] }, kDogi);
  ok((zuviele.daten?.meine || []).length === 5,
    `hoechstens fuenf je Termin (${(zuviele.daten?.meine || []).length})`);

  /* Der fremde Termin: Luna sieht Noras Call nicht -- also darf sie
     sich auch nicht zu ihm wecken lassen. Sonst liesse sich aus dem
     Meldungstext Titel und Uhrzeit eines fremden Termins lesen. */
  const fremd = await ruf("PUT", `/workspace/api/termine/${idFremd}/wecker`,
    { minuten: [60] }, kLuna);
  ok(fremd.status === 404, `an einem fremden Termin geht es nicht (${fremd.status})`);

  /* GEGENPROBE: An IHREM eigenen ginge es sehr wohl -- sonst bewiese
     die Zeile darueber nur, dass gar nichts geht. */
  const eigener = await ruf("PUT", `/workspace/api/termine/${idBald}/wecker`,
    { minuten: [60] }, kDogi);
  ok(eigener.status === 200, "am eigenen dagegen schon");
  await ruf("PUT", `/workspace/api/termine/${idBald}/wecker`,
    { minuten: [10080, 1440, 60] }, kDogi);
}

/* =======================================================================
   3. JEDER FUER SICH
   ======================================================================= */
console.log("\n=== Jeder stellt seine eigenen ein ===");
{
  d2Auf();
  /* Luna wird Teilnehmerin an DogFathers Termin -- damit sieht sie ihn
     und kann sich eigene Wecker setzen. Genau der Fall aus Filipes
     Satz: derselbe Termin, zwei Personen, verschiedene Wecker. */
  const dd = new DatabaseSync(process.env.WORKSPACE_DB);
  dd.prepare("INSERT OR IGNORE INTO termin_teilnehmer (termin_id, person_id) VALUES (?,?)")
    .run(idBald, idLuna);
  dd.close();

  const lunas = await ruf("PUT", `/workspace/api/termine/${idBald}/wecker`,
    { minuten: [10] }, kLuna);
  ok(lunas.status === 200 && JSON.stringify(lunas.daten?.meine) === JSON.stringify([10]),
    `Luna setzt ihren eigenen (${JSON.stringify(lunas.daten?.meine)})`);

  const dogis = await ruf("GET", `/workspace/api/termine/${idBald}/wecker`, undefined, kDogi);
  ok(JSON.stringify(dogis.daten?.meine) === JSON.stringify([10080, 1440, 60]),
    `DogFathers bleiben davon unberuehrt (${JSON.stringify(dogis.daten?.meine)})`);
}
function d2Auf() { /* nur zur Lesbarkeit oben */ }

/* =======================================================================
   4. KLINGELT ES AUCH? Der Weckerlauf am echten Melder
   ======================================================================= */
console.log("\n=== Der Lauf ===");
{
  const { laufen } = await import("./workspace-push.js");
  await laufen();

  const dd = new DatabaseSync(process.env.WORKSPACE_DB);
  const merkmale = dd.prepare(
    "SELECT person_id, merkmal FROM push_verschickt WHERE merkmal LIKE 'wecker:%'").all();
  dd.close();
  const alsSatz = merkmale.map((m) => `${m.person_id}/${m.merkmal}`).sort();

  /* Der Termin ist in 90 Minuten. Faellig sind damit die Wecker fuer
     eine Woche (10080) und einen Tag (1440) -- beide Zeitpunkte liegen
     in der Vergangenheit. Der Stunden-Wecker (60) noch NICHT: Er
     klingelt erst in 30 Minuten. */
  ok(alsSatz.includes(`${idDogi}/wecker:${idBald}:10080`),
    `der Wochen-Wecker ist raus (${alsSatz.join(" | ") || "nichts"})`);
  ok(alsSatz.includes(`${idDogi}/wecker:${idBald}:1440`),
    "der Tages-Wecker ebenfalls -- ZWEI aus einem Termin, nicht einer");
  ok(!alsSatz.includes(`${idDogi}/wecker:${idBald}:60`),
    "der Stunden-Wecker noch nicht -- seine Zeit ist noch nicht da");
  ok(alsSatz.includes(`${idLuna}/wecker:${idBald}:10`) === false,
    "Lunas Zehn-Minuten-Wecker auch nicht");

  /* KEINE ALTLASTEN. Der Termin von gestern hat einen Wecker, dessen
     Zeitpunkt laengst vorbei ist -- er darf NICHT nachtraeglich
     klingeln. Das ist der Fall nach einem Ausfall des Dienstes, und er
     faellt sonst erst im Ernstfall auf. */
  const dd2 = new DatabaseSync(process.env.WORKSPACE_DB);
  dd2.prepare(`INSERT OR IGNORE INTO termin_wecker (termin_id, person_id, minuten_vorher, gesetzt)
               VALUES (?,?,?,?)`).run(idVorbei, idDogi, 1440, jetztIso);
  dd2.close();
  await laufen();
  const dd3 = new DatabaseSync(process.env.WORKSPACE_DB);
  const spaet = dd3.prepare(
    "SELECT 1 FROM push_verschickt WHERE merkmal = ?").get(`wecker:${idVorbei}:1440`);
  dd3.close();
  ok(!spaet, "ein Wecker zu einem vergangenen Termin klingelt NICHT nach");

  /* KEINE DOPPELUNG. Ein zweiter Lauf darf nichts Neues erzeugen --
     sonst klingelt es alle fuenf Minuten erneut, bis der Termin da ist. */
  const vorher = alsSatz.length;
  await laufen();
  const dd4 = new DatabaseSync(process.env.WORKSPACE_DB);
  const nachher = dd4.prepare(
    "SELECT COUNT(*) AS n FROM push_verschickt WHERE merkmal LIKE 'wecker:%'").get().n;
  dd4.close();
  ok(nachher === vorher,
    `ein zweiter Lauf schickt nichts noch einmal (${vorher} -> ${nachher})`);
}

/* =======================================================================
   5. GEGENPROBE: erkennt diese Pruefung ueberhaupt ein Klingeln?
   ======================================================================= */
console.log("\n=== Gegenprobe ===");
{
  /* Ohne sie bewiesen alle "klingelt nicht"-Zeilen oben nur, dass der
     Melder gar nichts tut. Ein Wecker, dessen Zeit JETZT gekommen ist,
     muss ankommen. */
  const dd = new DatabaseSync(process.env.WORKSPACE_DB);
  dd.prepare(`INSERT OR IGNORE INTO termin_wecker (termin_id, person_id, minuten_vorher, gesetzt)
              VALUES (?,?,?,?)`).run(idFremd, idNora, 720, jetztIso);
  dd.close();

  const { laufen } = await import("./workspace-push.js");
  await laufen();

  const dd2 = new DatabaseSync(process.env.WORKSPACE_DB);
  const da = dd2.prepare("SELECT 1 FROM push_verschickt WHERE person_id = ? AND merkmal = ?")
    .get(idNora, `wecker:${idFremd}:720`);
  dd2.close();
  ok(!!da, "ein faelliger Wecker kommt wirklich an -- die Messung erkennt beides");
}

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