/* =====================================================================
   EIN ANRUF KLINGELT AUCH NACHTS -- 18.09.2026

   Filipe, 23:44 Uhr: „sie bekommt nur eine benarichtigung das eine
   neue nachricht ist aber sonst nichts irgendwas laeuft da gewaltig
   schief."

   Serverseitig war alles in Ordnung: Der Anruf kam an, der Raum
   stimmte, sie war angemeldet, sie hatte ein Geraet. Die
   Benachrichtigung wurde trotzdem nie verschickt -- eine einzige
   Zeile, die ich beim Bauen des Anrufs nie gesehen hatte:

       if (art !== "test" && istRuhezeit()) return { grund: "ruhezeit" };

   Ab 22 Uhr geht nichts mehr hinaus. Fuer eine Aufgabenerinnerung ist
   das genau richtig -- die schickt der Server von sich aus, weil eine
   Frist naeher rueckt. Ein Anruf ist das Gegenteil: Ein Mensch
   drueckt gerade auf den Hoerer und wartet auf eine Antwort.

   DIESE PRUEFUNG HAELT DIE UNTERSCHEIDUNG FEST. Ohne sie waere die
   Ausnahme eine Zeile, die beim naechsten Umbau jemand „aufraeumt".

   Aufrufen mit:  node server/pruef-anruf-ruhezeit.mjs
   ===================================================================== */
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { portMussFreiSein } from "./helfer-port.mjs";

const PORT = await portMussFreiSein(4199, "pruef-anruf-ruhezeit");
const ordner = mkdtempSync(join(tmpdir(), "ws-ruhe-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
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";

/* IMMER RUHEZEIT. Die Pruefung soll nicht davon abhaengen, wann sie
   laeuft -- eine Pruefung, die tagsueber gruen und nachts rot ist,
   waere schlimmer als keine. */
process.env.PUSH_RUHE_AB = "0";
process.env.PUSH_RUHE_BIS = "24";

import { notbremse } from "./helfer-notbremse.mjs";
await import("./index.js");
notbremse(90_000, "pruef-anruf-ruhezeit");
await new Promise((r) => setTimeout(r, 600));

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

const { istRuhezeit, benachrichtige } = await import("./workspace-push.js");
const { DatabaseSync } = await import("node:sqlite");
const { randomBytes, scryptSync } = await import("node:crypto");

/* Eine Person, damit `willHaben` etwas zu fragen hat. */
let personId;
{
  const d = new DatabaseSync(process.env.WORKSPACE_DB);
  const salz = randomBytes(16).toString("hex");
  const hash = scryptSync("CODE-X", salz, 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("Mara", "hand", hash, salz, 32768, new Date().toISOString());
  personId = d.prepare("SELECT last_insert_rowid() AS id").get().id;
  d.close();
}

melde("");
melde("=== 1. Es ist Ruhezeit ===");
ok(istRuhezeit() === true, "die Ruhezeit gilt (fuer diese Pruefung rund um die Uhr)");

melde("");
melde("=== 2. Was durchkommt und was nicht ===");
{
  /* KEIN ECHTER PUSH NOETIG. `benachrichtige` nennt den Grund, warum
     es nicht hinausging -- und genau der ist die Frage:

       "ruhezeit"      -> an der Uhrzeit gescheitert
       "keine_geraete" -> durchgekommen, es fehlt nur ein Empfaenger

     Ein Anruf, der bis "keine_geraete" kommt, hat die Ruhezeit hinter
     sich. Das ist der ganze Unterschied. */
  const erinnerung = await benachrichtige(personId, "chat_nachricht", {
    titel: "Neue Nachricht", text: "Hallo", ziel: "/workspace/chat.html",
  });
  ok(erinnerung.grund === "ruhezeit",
    `eine Chatnachricht bleibt nachts liegen (${erinnerung.grund})`);

  const anruf = await benachrichtige(personId, "anruf", {
    titel: "Filipe ruft an", text: "Tippen zum Rangehen",
    ziel: "/workspace/chat.html?raum=1",
  });
  ok(anruf.grund !== "ruhezeit",
    `ein Anruf kommt durch (${anruf.grund})`);
  ok(anruf.grund === "keine_geraete",
    "und scheitert erst daran, dass kein Geraet angemeldet ist"
    + ` (${anruf.grund}) -- also wirklich an der Ruhezeit vorbei`);

  /* UND DIE ART MUSS ES GEBEN. Eine unbekannte Art wird stillschweigend
     verworfen -- dann waere oben „nicht ruhezeit" wahr, ohne dass
     jemals etwas verschickt wuerde. */
  const erfunden = await benachrichtige(personId, "gibtsnicht", {
    titel: "x", text: "y", ziel: "/workspace/start.html",
  });
  ok(erfunden.grund === "unbekannte_art",
    `eine erfundene Art faellt durch (${erfunden.grund}) -- „anruf" also nicht zufaellig gruen`);
}

melde("");
melde("=== 3. Und sie laesst sich abschalten ===");
{
  /* Wer nachts seine Ruhe will, soll sie bekommen -- aber als eigene
     Entscheidung, nicht als Regel, die man nicht kennt. */
  const d = new DatabaseSync(process.env.WORKSPACE_DB);
  /* Die Spalte heisst "art", nicht "schluessel" -- abgeschrieben aus
     workspace-push.js statt geraten. */
  d.prepare("INSERT INTO push_einstellungen (person_id, art, an)"
    + " VALUES (?,?,0) ON CONFLICT(person_id, art) DO UPDATE SET an = 0")
    .run(personId, "anruf");
  d.close();

  const aus = await benachrichtige(personId, "anruf", {
    titel: "Filipe ruft an", text: "…", ziel: "/workspace/chat.html?raum=1",
  });
  ok(aus.grund === "abgeschaltet",
    `wer sie abschaltet, hat Ruhe (${aus.grund})`);
}

melde("");
melde(`${geprueft} Pruefungen, ${fehler} Fehler`);
melde(fehler ? "NICHT IN ORDNUNG" : "ALLES IN ORDNUNG");
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* Rest */ }
process.exit(fehler ? 1 : 0);