/* =====================================================================
   workspace-push.js — Benachrichtigungen, die wirklich ankommen.

   Wunsch Filipe (05.09.2026), mit dem Bild eines "Benachrichtigungen
   aus"-Knopfes: *"ich will auch sowas und dass es perfekt funktioniert
   auf der seite fuer jeden."*

   ---------------------------------------------------------------------
   WAS DAS LOEST

   Bis hierher erscheinen Hinweise NUR, wenn man die Seite aufruft. Wer
   nicht hinschaut, verpasst sie -- und genau das ist der Normalfall:
   Man macht den Workspace auf, wenn man ohnehin daran denkt. Der
   Perfektionsplan sagt dazu: *"Das Deck verspricht Erinnerungen. Wer
   nicht hinschaut, verpasst sie."*

   ---------------------------------------------------------------------
   OHNE FREMDEN DIENST, OHNE KONTO, OHNE GEBUEHR

   Push API und Service Worker sind Browserstandard. Der Server braucht
   nur ein eigenes Schluesselpaar (VAPID); die Nachricht wird fuer jedes
   Geraet einzeln verschluesselt. Google, Mozilla und Apple leiten sie
   weiter, sehen aber nur Zeichensalat -- der Inhalt bleibt zwischen
   diesem Server und dem Browser.

   Die Rechnung dafuer steht in workspace-push-krypto.js und ist gegen
   die Testvektoren von RFC 8291 und 8292 geprueft.

   ---------------------------------------------------------------------
   VIER REGELN, DIE DARUEBER ENTSCHEIDEN, OB ES BENUTZT WIRD

   1. NICHTS ZWEIMAL. Jede Erinnerung wird je Person und Sache genau
      einmal verschickt (Tabelle push_verschickt). Viermal am Tag
      dieselbe Meldung ist der schnellste Weg, dass jemand alles
      abschaltet -- und dann fehlt auch die wichtige.

   2. NACHTS NICHT. Zwischen 22 und 7 Uhr wird nichts zugestellt.
      Aufgehoben wird nichts: Was morgens noch gilt, geht morgens raus;
      was sich erledigt hat, ist zu Recht weg.

   3. JE ART ABSCHALTBAR, nicht alles oder nichts.

   4. EINE BENACHRICHTIGUNG HAT IMMER EIN ZIEL. Wer sie antippt, landet
      an der Stelle, um die es geht -- nicht auf der Startseite.

   ---------------------------------------------------------------------
   WICHTIG FUERS IPHONE

   Dort funktioniert Push NUR, wenn die Seite zum Home-Bildschirm
   hinzugefuegt wurde. Im Safari-Reiter gibt es keine Berechtigung --
   der Knopf sagt das dann auch genau so, statt einen Fehler zu zeigen.
   ===================================================================== */

import express from "express";
import {
  db, protokolliere, echteIp, sitzungLesen, istDogFather,
  einstellung, einstellungSetzen, heuteLokal,
} from "./workspace.js";
import { schluesselErzeugen, schicken } from "./workspace-push-krypto.js";

export const pushRouter = express.Router();

const jetzt = () => new Date().toISOString();

/* ---------------------------------------------------------------------
   DIE ARTEN. Was es gibt, steht hier -- nicht in der Datenbank: Es ist
   eine bewusste Auswahl, keine Nutzdaten. Wer eine neue Art braucht,
   traegt sie hier ein und sie erscheint von selbst in den
   Einstellungen.
   ------------------------------------------------------------------ */
export const ARTEN = [
  { schluessel: "aufgabe_faellig", name: "Aufgabe wird morgen fällig", vorgabe: true },
  { schluessel: "aufgabe_ueberfaellig", name: "Aufgabe ist überfällig", vorgabe: true },
  { schluessel: "termin_gleich", name: "Termin in einer Stunde", vorgabe: true },
  { schluessel: "protokoll_fehlt", name: "Gespräch ohne Protokoll", vorgabe: true },
  { schluessel: "followup", name: "Follow-up in der Pipeline fällig", vorgabe: true },
  /* Chat (06.09.2026). Steht bewusst VOR der Probe: Es ist die Art,
     die am haeufigsten kommt, und wer die Liste ueberfliegt, sucht
     zuerst sie. */
  { schluessel: "chat_nachricht", name: "Neue Nachricht im Chat", vorgabe: true },
  { schluessel: "test", name: "Probe-Benachrichtigung", vorgabe: true },
];
const ARTEN_SCHLUESSEL = new Set(ARTEN.map((a) => a.schluessel));

/* Ruhezeit. Nichts zwischen 22 und 7 Uhr. */
const RUHE_AB = 22, RUHE_BIS = 7;
export function istRuhezeit(d = new Date()) {
  const s = d.getHours();
  return s >= RUHE_AB || s < RUHE_BIS;
}

/* ---------------------------------------------------------------------
   Das Schluesselpaar des Servers. Einmal erzeugt, danach in den
   Einstellungen -- NICHT im Code und nicht in einer Datei im Repo.
   Der private Teil verlaesst den Server nie.
   ------------------------------------------------------------------ */
export function paarHolen() {
  let roh = einstellung("vapid_paar");
  if (roh) {
    try {
      const p = JSON.parse(roh);
      if (p?.oeffentlich && p?.privat) return p;
    } catch { /* kaputt -- unten neu erzeugen */ }
  }
  const neu = schluesselErzeugen();
  einstellungSetzen("vapid_paar", JSON.stringify(neu));
  console.log("[push] Neues VAPID-Schluesselpaar erzeugt.");
  return neu;
}

/** Die Absenderangabe fuer VAPID. Der Push-Dienst schreibt hierhin,
 *  wenn dauerhaft etwas nicht stimmt. */
const ABSENDER = process.env.PUSH_ABSENDER || "mailto:kontakt@dogfather-universe.com";

/* ---------------------------------------------------------------------
   Will diese Person diese Art bekommen?
   ------------------------------------------------------------------ */
export function willHaben(personId, art) {
  const z = db().prepare(
    "SELECT an FROM push_einstellungen WHERE person_id = ? AND art = ?").get(personId, art);
  if (z) return !!z.an;
  return ARTEN.find((a) => a.schluessel === art)?.vorgabe ?? true;
}

/* ---------------------------------------------------------------------
   VERSCHICKEN — der einzige Weg nach draussen.

   Alles laeuft hier durch: Ruhezeit, Einstellung, Doppelsperre,
   Aufraeumen toter Anmeldungen. Eine zweite Stelle, die selbst
   verschickt, wuerde eine dieser Regeln irgendwann vergessen.
   ------------------------------------------------------------------ */
export async function benachrichtige(personId, art, { titel, text, ziel, merkmal }) {
  if (!ARTEN_SCHLUESSEL.has(art)) return { verschickt: 0, grund: "unbekannte_art" };
  if (!willHaben(personId, art)) return { verschickt: 0, grund: "abgeschaltet" };

  /* Die Probe darf immer durch -- sie beantwortet die Frage "kommt
     ueberhaupt etwas an?", und die stellt man sich auch um 23 Uhr. */
  if (art !== "test" && istRuhezeit()) return { verschickt: 0, grund: "ruhezeit" };

  /* Schon einmal geschickt? */
  if (merkmal) {
    const da = db().prepare(
      "SELECT 1 FROM push_verschickt WHERE person_id = ? AND merkmal = ?").get(personId, merkmal);
    if (da) return { verschickt: 0, grund: "schon_geschickt" };
  }

  const anmeldungen = db().prepare(
    "SELECT * FROM push_anmeldungen WHERE person_id = ?").all(personId);
  if (!anmeldungen.length) return { verschickt: 0, grund: "keine_geraete" };

  const paar = paarHolen();
  const inhalt = JSON.stringify({ titel, text, ziel: ziel || "/workspace/start.html", art });

  let raus = 0;
  for (const a of anmeldungen) {
    const e = await schicken(a, inhalt, paar, ABSENDER);
    if (e.ok) {
      raus++;
      db().prepare("UPDATE push_anmeldungen SET zuletzt_ok = ?, fehler = 0 WHERE endpunkt = ?")
        .run(jetzt(), a.endpunkt);
    } else if (e.weg) {
      /* Der Push-Dienst sagt: dieses Geraet gibt es nicht mehr.
         Aufheben waere sinnlos und wuerde bei jedem Lauf erneut
         scheitern. */
      db().prepare("DELETE FROM push_anmeldungen WHERE endpunkt = ?").run(a.endpunkt);
    } else {
      db().prepare("UPDATE push_anmeldungen SET fehler = fehler + 1 WHERE endpunkt = ?")
        .run(a.endpunkt);
    }
  }

  if (raus && merkmal) {
    db().prepare("INSERT OR REPLACE INTO push_verschickt (person_id, merkmal, zeit) VALUES (?,?,?)")
      .run(personId, merkmal, jetzt());
  }
  return { verschickt: raus, grund: raus ? "ok" : "nicht_zugestellt" };
}

/* ---------------------------------------------------------------------
   WAS STEHT AN? — der Takt.

   Fragt dieselben Daten ab, aus denen auch die Hinweisliste auf der
   Startseite entsteht. Bewusst KEINE eigenen Daten: Was erledigt wird,
   verschwindet von selbst, und es gibt nichts zu pflegen, das
   veralten kann.
   ------------------------------------------------------------------ */
export async function laufen() {
  const d = db();
  const heute = heuteLokal();
  const morgen = new Date(Date.parse(heute + "T00:00:00Z") + 86400_000).toISOString().slice(0, 10);
  let gesamt = 0;

  const senden = async (personId, art, sache) => {
    const e = await benachrichtige(personId, art, sache);
    gesamt += e.verschickt;
  };

  try {
    /* --- Aufgaben, die morgen faellig sind ---------------------------- */
    for (const a of d.prepare(`
      SELECT a.id, a.titel, a.verantwortlich_id FROM aufgaben a
      WHERE a.status <> 'erledigt' AND a.frist = ? AND a.verantwortlich_id IS NOT NULL`).all(morgen)) {
      await senden(a.verantwortlich_id, "aufgabe_faellig", {
        titel: "Morgen fällig",
        text: a.titel,
        ziel: "/workspace/aufgaben.html",
        merkmal: `aufgabe_faellig:${a.id}:${morgen}`,
      });
    }

    /* --- Aufgaben, die ueberfaellig sind ------------------------------ */
    for (const a of d.prepare(`
      SELECT a.id, a.titel, a.frist, a.verantwortlich_id FROM aufgaben a
      WHERE a.status <> 'erledigt' AND a.frist IS NOT NULL AND a.frist < ?
        AND a.verantwortlich_id IS NOT NULL`).all(heute)) {
      await senden(a.verantwortlich_id, "aufgabe_ueberfaellig", {
        titel: "Überfällig",
        text: a.titel,
        ziel: "/workspace/aufgaben.html",
        /* Das Datum gehoert ins Merkmal: Eine Aufgabe, die drei Wochen
           liegen bleibt, soll nicht dreimal am Tag erinnern -- aber
           einmal am Tag schon. */
        merkmal: `aufgabe_ueberfaellig:${a.id}:${heute}`,
      });
    }

    /* --- Termine in der naechsten Stunde ------------------------------ */
    const gleich = new Date(Date.now() + 60 * 60_000);
    const p = (n) => String(n).padStart(2, "0");
    const bis = `${gleich.getFullYear()}-${p(gleich.getMonth() + 1)}-${p(gleich.getDate())}`
      + `T${p(gleich.getHours())}:${p(gleich.getMinutes())}`;
    const jetztText = (() => {
      const n = new Date();
      return `${n.getFullYear()}-${p(n.getMonth() + 1)}-${p(n.getDate())}`
        + `T${p(n.getHours())}:${p(n.getMinutes())}`;
    })();

    for (const t of d.prepare(`
      SELECT t.id, t.titel, t.beginn, t.art FROM termine t
      WHERE t.erledigt = 0 AND t.beginn >= ? AND t.beginn <= ?`).all(jetztText, bis)) {
      /* An ALLE Teilnehmer, nicht nur an das Haupt-Gegenueber -- seit
         ein Termin mehrere haben kann (05.09.2026). */
      const leute = d.prepare(
        "SELECT person_id FROM termin_teilnehmer WHERE termin_id = ?").all(t.id).map((r) => r.person_id);
      for (const pid of new Set(leute)) {
        await senden(pid, "termin_gleich", {
          titel: t.art === "call" ? "Call in Kürze" : "Termin in Kürze",
          text: `${t.titel} · ${t.beginn.slice(11, 16)} Uhr`,
          ziel: t.art === "call" ? "/workspace/calls.html" : "/workspace/kalender.html",
          merkmal: `termin_gleich:${t.id}`,
        });
      }
    }

    /* --- Gespraeche ohne Protokoll ------------------------------------ */
    for (const t of d.prepare(`
      SELECT t.id, t.titel, t.erstellt_von FROM termine t
      LEFT JOIN protokolle pr ON pr.termin_id = t.id
      WHERE t.art IN ('call','review') AND t.beginn < ? AND pr.id IS NULL
        AND t.beginn > ? AND t.erstellt_von IS NOT NULL`)
      .all(jetztText, heute + "T00:00")) {
      await senden(t.erstellt_von, "protokoll_fehlt", {
        titel: "Protokoll fehlt",
        text: t.titel,
        ziel: "/workspace/calls.html",
        merkmal: `protokoll_fehlt:${t.id}`,
      });
    }

    /* --- Faellige Follow-ups in der Pipeline --------------------------- */
    for (const l of d.prepare(`
      SELECT l.id, l.name, l.scout_id FROM leads l
      WHERE l.naechster_followup IS NOT NULL AND l.naechster_followup <= ?
        AND l.status NOT IN ('uebergeben','abgelehnt') AND l.scout_id IS NOT NULL`).all(heute)) {
      await senden(l.scout_id, "followup", {
        titel: "Nachfassen",
        text: l.name,
        ziel: "/workspace/scouting.html",
        merkmal: `followup:${l.id}:${heute}`,
      });
    }

    /* Alte Merkmale aufraeumen -- nach 60 Tagen braucht sie niemand
       mehr, und die Tabelle soll nicht ewig wachsen. */
    const grenze = new Date(Date.now() - 60 * 86400_000).toISOString();
    d.prepare("DELETE FROM push_verschickt WHERE zeit < ?").run(grenze);
  } catch (fehler) {
    console.error("[push] Lauf:", fehler?.message);
  }
  return gesamt;
}

/* ---------------------------------------------------------------------
   Der Takt. Wie bei der Sicherung: im Prozess, kein Systemdienst, kein
   Cron -- eine Sache weniger, die stillschweigend ausfallen kann.
   ------------------------------------------------------------------ */
let takt = null;
export function pushStarten() {
  if (takt) return;
  /* Alle fuenf Minuten. Feiner braucht es nicht: Die feinste
     Erinnerung ist "Termin in einer Stunde". */
  takt = setInterval(() => { laufen().catch(() => {}); }, 5 * 60_000);
  takt.unref?.();
  setTimeout(() => { laufen().catch(() => {}); }, 20_000).unref?.();
}

/* =====================================================================
   Die Schnittstellen
   ===================================================================== */

function angemeldet(req, res, next) {
  const person = sitzungLesen(req);
  if (!person) return res.status(401).json({ fehler: "nicht_angemeldet" });
  req.person = person;
  next();
}

function gleicheHerkunft(req, res, next) {
  const herkunft = req.get("origin");
  if (!herkunft) return next();
  let erlaubt;
  try { erlaubt = new URL(herkunft).host === req.get("host"); } catch { erlaubt = false; }
  if (!erlaubt) return res.status(403).json({ fehler: "fremde_herkunft" });
  next();
}

pushRouter.use("/workspace/api/push", angemeldet);

/** Was der Browser braucht, um sich anzumelden: der oeffentliche
 *  Schluessel. Der private bleibt hier. */
pushRouter.get("/workspace/api/push/schluessel", (req, res) => {
  try {
    res.json({ schluessel: paarHolen().oeffentlich });
  } catch (fehler) {
    console.error("[push] Schluessel:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Der eigene Stand: angemeldete Geraete und die Einstellungen. */
pushRouter.get("/workspace/api/push/stand", (req, res) => {
  try {
    const geraete = db().prepare(`
      SELECT endpunkt, geraet, erstellt, zuletzt_ok FROM push_anmeldungen
      WHERE person_id = ? ORDER BY erstellt`).all(req.person.id);
    const arten = ARTEN.map((a) => ({
      ...a, an: willHaben(req.person.id, a.schluessel),
    }));
    res.json({
      /* Nur die Anzahl und ein Kuerzel nach aussen -- der volle
         Endpunkt ist die Zustelladresse dieses Geraets und hat in der
         Oberflaeche nichts zu suchen. */
      geraete: geraete.map((g) => ({
        kennung: g.endpunkt.slice(-12),
        geraet: g.geraet || "Unbekanntes Gerät",
        erstellt: g.erstellt, zuletzt_ok: g.zuletzt_ok,
      })),
      arten,
      ruhe: { ab: RUHE_AB, bis: RUHE_BIS, jetzt: istRuhezeit() },
    });
  } catch (fehler) {
    console.error("[push] Stand:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Ein Geraet anmelden. */
pushRouter.post("/workspace/api/push/anmelden", gleicheHerkunft, express.json({ limit: "8kb" }), (req, res) => {
  try {
    const { endpunkt, p256dh, auth, geraet } = req.body || {};
    if (typeof endpunkt !== "string" || !/^https:\/\//.test(endpunkt) || endpunkt.length > 1000) {
      return res.status(400).json({ fehler: "Die Adresse sieht nicht richtig aus." });
    }
    if (typeof p256dh !== "string" || typeof auth !== "string" || !p256dh || !auth) {
      return res.status(400).json({ fehler: "Es fehlen die Schlüssel des Browsers." });
    }

    /* INSERT OR REPLACE auf dem Endpunkt: Meldet sich derselbe Browser
       erneut, wird der Eintrag ersetzt statt verdoppelt -- sonst kaeme
       jede Nachricht mehrfach an. */
    db().prepare(`
      INSERT OR REPLACE INTO push_anmeldungen
        (endpunkt, person_id, p256dh, auth, geraet, erstellt, zuletzt_ok, fehler)
      VALUES (?,?,?,?,?,?,NULL,0)`).run(
      endpunkt, req.person.id, p256dh, auth,
      String(geraet || "").slice(0, 80) || null, jetzt());

    protokolliere("push_angemeldet", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: String(geraet || "").slice(0, 60),
    });
    res.status(201).json({ ok: true });
  } catch (fehler) {
    console.error("[push] Anmelden:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Ein Geraet abmelden. */
pushRouter.post("/workspace/api/push/abmelden", gleicheHerkunft, express.json({ limit: "8kb" }), (req, res) => {
  try {
    const endpunkt = String(req.body?.endpunkt || "");
    /* NUR die eigenen -- sonst koennte man fremde Geraete stumm
       schalten, wenn man deren Adresse kennt. */
    const e = db().prepare("DELETE FROM push_anmeldungen WHERE endpunkt = ? AND person_id = ?")
      .run(endpunkt, req.person.id);
    protokolliere("push_abgemeldet", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
    });
    res.json({ ok: true, entfernt: Number(e.changes) });
  } catch (fehler) {
    console.error("[push] Abmelden:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Eine Art an- oder abschalten. */
pushRouter.put("/workspace/api/push/art", gleicheHerkunft, express.json({ limit: "8kb" }), (req, res) => {
  try {
    const art = String(req.body?.art || "");
    if (!ARTEN_SCHLUESSEL.has(art)) return res.status(400).json({ fehler: "Diese Art gibt es nicht." });
    const an = req.body?.an ? 1 : 0;
    db().prepare(`INSERT INTO push_einstellungen (person_id, art, an) VALUES (?,?,?)
      ON CONFLICT(person_id, art) DO UPDATE SET an = excluded.an`).run(req.person.id, art, an);
    res.json({ ok: true, art, an: !!an });
  } catch (fehler) {
    console.error("[push] Art:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Eine Probe an die eigenen Geraete. Beantwortet die einzige Frage,
 *  die man wirklich hat: Kommt etwas an? */
pushRouter.post("/workspace/api/push/probe", gleicheHerkunft, async (req, res) => {
  try {
    const e = await benachrichtige(req.person.id, "test", {
      titel: "Es funktioniert",
      text: "So sieht eine Benachrichtigung aus dem Workspace aus.",
      ziel: "/workspace/start.html",
    });
    res.json(e);
  } catch (fehler) {
    console.error("[push] Probe:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});