/* =====================================================================
   DIE SPENDEN — die Wege (28.09.2026)

   Drei Herkuenfte, eine Tabelle, ein Weg ins Bild. Die Begruendung
   fuer die drei steht in spenden-tabellen.js.

   ---------------------------------------------------------------------
   DER EINFACHSTE WEG FUER EINEN ZUSCHAUER

   Vier Knoepfe mit Betraegen. Ein Tipp oeffnet PayPal mit schon
   eingetragener Summe (`paypal.me/<name>/5EUR`). Danach kommt er
   zurueck, und die Seite fragt EINMAL: „Hast du gespendet?" Sagt er
   ja, steht die Spende als OFFEN im Pult und wartet auf einen Tipp
   der Leitung.

   DIE ADRESSE WIRD NICHT ZWEIMAL GEPFLEGT. Sie steht auf der
   Unterstuetzen-Seite, dort und nur dort. Was hier passiert, ist
   Lesen und Anhaengen des Betrags -- und wenn dort nichts steht oder
   der Weg auf unsichtbar gestellt ist, gibt es hier auch keine
   Knoepfe. Eine geratene Kontoadresse waere die gefaehrlichste aller
   Abkuerzungen.

   ---------------------------------------------------------------------
   WARUM DER BETRAG NICHT AN DIE ADRESSE GEBUNDEN IST

   `paypal.me/x/5EUR` traegt den Betrag VOR -- aendern kann ihn jeder
   auf PayPals Seite, und das ist auch richtig so. Was hier steht,
   ist deshalb nie die Wahrheit ueber das Geld, sondern nur ein
   Vorschlag. Die Wahrheit kommt entweder von PayPal selbst (Webhook)
   oder von einem Menschen, der die Meldung auf seinem Handy gesehen
   hat. Alles andere waere geraten.
   ===================================================================== */
import express from "express";
import { db, sitzungLesen, protokolliere, echteIp } from "./workspace.js";
import { stromAn } from "./workspace-chat.js";
import { buehneMelden } from "./workspace-buehne.js";
import {
  BETRAG_MAX_CENT, NAME_MAX, GRUSS_MAX, BETRAG_KNOEPFE, SPENDEN_TAGE,
} from "./spenden-tabellen.js";

export const spendenRouter = express.Router();

/** Wer eine Spende bestaetigen, eintragen oder ablehnen darf.
 *
 *  Dieselben zwei, die die Sendung fuehren. Geld ist keine
 *  Moderationsaufgabe: Einen Beitrag wegzunehmen ist umkehrbar,
 *  einen Betrag im Bild gross zu machen nicht. */
const GELD_ROLLEN = new Set(["admin", "hand"]);
export const SPENDEN_ROLLEN = GELD_ROLLEN;

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

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

/** Spenden gehoeren zum Team-Dogi-Haus.
 *
 *  Dieselbe Form wie bei der Reaction und beim Notizblock: gefragt
 *  wird, ob es das ANDERE Haus ist -- nicht, ob es Crew ist. Auf
 *  einer Pruefadresse hat niemand ein Haus, und „ist nicht crew"
 *  haette die Tuer dort zugemacht. */
function nurTeamDogi(req, res, next) {
  if (req.person?.haus === "agentur") return res.status(404).end();
  next();
}

function nurGeld(req, res, next) {
  if (!GELD_ROLLEN.has(req.person.rolle)) {
    return res.status(403).json({ fehler: "nur_leitung" });
  }
  next();
}

/** Schuetzt gegen fremde Seiten, die im Namen eines Angemeldeten
 *  schreiben. Dieselbe Pruefung wie im Anruf- und Reaktionsteil. */
function gleicheHerkunft(req, res, next) {
  if (req.method === "GET") return next();
  const woher = req.get("Origin") || "";
  if (!woher) return next();
  try {
    if (new URL(woher).host !== req.get("Host")) {
      return res.status(403).json({ fehler: "fremde_herkunft" });
    }
  } catch { return res.status(403).json({ fehler: "fremde_herkunft" }); }
  next();
}

/* ---------- Wer erfaehrt davon? ---------------------------------------
   Alle, die gerade in der Reaction sitzen, plus der Host. Steht
   gerade keine Sendung, gibt es niemanden -- dann wird die Spende
   eingetragen und beim naechsten Mal gezeigt. Eine Karte, die ins
   Leere laeuft, waere schlimmer als eine, die wartet. */
function empfaenger() {
  try {
    const ids = new Set(
      db().prepare("SELECT person_id FROM reaktion_dabei").all().map((z) => z.person_id));
    const s = db().prepare("SELECT host_id FROM reaktion WHERE id = 1").get();
    if (s?.host_id) ids.add(s.host_id);
    return [...ids];
  } catch { return []; }
}

/** Die PayPal-Adresse, wie sie auf der Unterstuetzen-Seite steht. */
function paypalAdresse() {
  try {
    const w = db().prepare(`SELECT ziel, knopf FROM unterstuetzung_wege
        WHERE schluessel = 'paypal' AND sichtbar = 1`).get();
    return w?.ziel ? { ziel: w.ziel, knopf: w.knopf || "" } : null;
  } catch { return null; }
}

/** Haengt einen Betrag an eine PayPal.me-Adresse.
 *
 *  NUR BEI paypal.me. Bei jeder anderen Adresse wird nichts
 *  angehaengt und es gibt auch keine Betragsknoepfe -- ein Betrag an
 *  einer Adresse, die ihn nicht versteht, fuehrt zu einer Seite, auf
 *  der etwas anderes steht als auf dem Knopf. */
export function mitBetrag(ziel, cent, waehrung = "EUR") {
  if (!ziel || !/^https:\/\/(www\.)?paypal\.me\//i.test(ziel)) return null;
  const sauber = ziel.replace(/\/+$/, "");
  const zahl = (cent % 100 === 0) ? String(cent / 100)
    : (cent / 100).toFixed(2);
  return `${sauber}/${zahl}${waehrung}`;
}

/** Welche Stufe gilt fuer diesen Betrag?
 *
 *  DIE HOECHSTE, DIE NOCH PASST. Ohne diese Regel muesste jede Stufe
 *  eine Ober- UND eine Untergrenze haben, und zwei Grenzen je Stufe
 *  sind die doppelte Gelegenheit, eine Luecke zu lassen -- durch die
 *  faellt dann ausgerechnet der grosse Betrag. */
export function stufeFuer(cent) {
  try {
    return db().prepare(`SELECT * FROM spenden_stufen
        WHERE ab_cent <= ? ORDER BY ab_cent DESC LIMIT 1`).get(cent) || null;
  } catch { return null; }
}

function alsKarte(z) {
  const st = stufeFuer(z.betrag_cent);
  return {
    id: z.id,
    betrag_cent: z.betrag_cent,
    waehrung: z.waehrung,
    name: z.name,
    gruss: z.gruss,
    herkunft: z.herkunft,
    stand: z.stand,
    erstellt: z.erstellt,
    stufe: st ? {
      name: st.name, vorlage: st.vorlage, bild: st.bild,
      farbe: st.farbe, dauer_ms: st.dauer_ms,
    } : null,
  };
}

/** Eine bestaetigte Spende ins Bild schicken. */
function zeigen(z) {
  db().prepare("UPDATE spenden SET gezeigt_am = ? WHERE id = ?").run(jetzt(), z.id);
  const daten = { was: "zeigen", karte: alsKarte(z) };
  stromAn(empfaenger(), "spende", daten);
  /* Die Karte gehoert auch auf die Buehne -- sonst laeuft sie in der
     Seite und fehlt ausgerechnet im Stream. */
  buehneMelden("spende", daten);
}

/* ======================================================================
   DIE WEGE
   ====================================================================== */
spendenRouter.use("/workspace/api/spenden", angemeldet, nurTeamDogi, gleicheHerkunft);

/** Was die Seite zum Anzeigen braucht. */
spendenRouter.get("/workspace/api/spenden", (req, res) => {
  try {
    const pp = paypalAdresse();
    const darf = GELD_ROLLEN.has(req.person.rolle);
    const knoepfe = pp
      ? BETRAG_KNOEPFE.map((c) => ({ cent: c, ziel: mitBetrag(pp.ziel, c) }))
        .filter((k) => k.ziel)
      : [];
    res.json({
      paypal: pp ? { ziel: pp.ziel, knopf: pp.knopf } : null,
      knoepfe,
      stufen: db().prepare("SELECT ab_cent, name, vorlage, bild, farbe, dauer_ms"
        + " FROM spenden_stufen ORDER BY ab_cent").all(),
      betrag_max_cent: BETRAG_MAX_CENT,
      ich: { darf },
      /* Die offenen Meldungen sieht nur, wer sie bestaetigen kann.
         Fuer alle anderen waere es eine Liste fremder Geldbetraege. */
      offen: darf
        ? db().prepare("SELECT * FROM spenden WHERE stand = 'offen' ORDER BY id")
          .all().map(alsKarte)
        : null,
      letzte: darf
        ? db().prepare("SELECT * FROM spenden WHERE stand = 'bestaetigt'"
          + " ORDER BY id DESC LIMIT 20").all().map(alsKarte)
        : null,
    });
  } catch (fehler) {
    console.error("[spenden] Lage:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** „Ich habe gespendet." — landet als OFFEN.
 *
 *  BEWUSST OHNE PRUEFUNG DES BETRAGS GEGEN PAYPAL. Wir koennen ihn
 *  nicht kennen (siehe Kopf). Was hier entsteht, ist eine BEHAUPTUNG,
 *  und sie wird auch so behandelt: Sie steht im Pult und wartet. */
spendenRouter.post("/workspace/api/spenden/melden", express.json({ limit: "4kb" }),
  (req, res) => {
    try {
      const cent = Math.round(Number(req.body?.betrag_cent) || 0);
      if (!Number.isFinite(cent) || cent <= 0 || cent > BETRAG_MAX_CENT) {
        return res.status(400).json({ fehler: "betrag_unklar" });
      }
      /* EINE MELDUNG JE MINUTE UND PERSON. Nicht gegen Betrug -- die
         Leitung bestaetigt ja -- sondern gegen den Doppelklick und
         gegen eine Liste, die man nicht mehr durchsieht. */
      const kurz = new Date(Date.now() - 60_000).toISOString();
      const schon = db().prepare(`SELECT COUNT(*) AS n FROM spenden
          WHERE person_id = ? AND erstellt > ?`).get(req.person.id, kurz);
      if ((schon?.n || 0) >= 1) return res.status(429).json({ fehler: "zu_schnell" });

      const name = String(req.body?.name ?? req.person.name).trim().slice(0, NAME_MAX);
      const gruss = String(req.body?.gruss ?? "").trim().slice(0, GRUSS_MAX);
      const { lastInsertRowid } = db().prepare(`INSERT INTO spenden
          (betrag_cent, waehrung, name, gruss, person_id, herkunft, stand, erstellt)
          VALUES (?,?,?,?,?,'gemeldet','offen',?)`)
        .run(cent, "EUR", name, gruss, req.person.id, jetzt());

      const z = db().prepare("SELECT * FROM spenden WHERE id = ?").get(Number(lastInsertRowid));
      /* Die Leitung erfaehrt es sofort -- sonst liegt die Meldung da,
         und der Zuschauer wartet auf eine Karte, die niemand sieht. */
      stromAn(
        db().prepare("SELECT id FROM personen WHERE rolle IN ('admin','hand') AND aktiv = 1")
          .all().map((p) => p.id),
        "spende", { was: "offen", karte: alsKarte(z) },
      );
      res.status(201).json({ ok: true, wartet: true });
    } catch (fehler) {
      console.error("[spenden] Melden:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/** Die Leitung traegt eine Spende ein — sie gilt sofort. */
spendenRouter.post("/workspace/api/spenden", nurGeld, express.json({ limit: "4kb" }),
  (req, res) => {
    try {
      const cent = Math.round(Number(req.body?.betrag_cent) || 0);
      if (!Number.isFinite(cent) || cent <= 0 || cent > BETRAG_MAX_CENT) {
        return res.status(400).json({ fehler: "betrag_unklar" });
      }
      const name = String(req.body?.name ?? "").trim().slice(0, NAME_MAX);
      if (!name) return res.status(400).json({ fehler: "name_fehlt" });
      const gruss = String(req.body?.gruss ?? "").trim().slice(0, GRUSS_MAX);

      const { lastInsertRowid } = db().prepare(`INSERT INTO spenden
          (betrag_cent, waehrung, name, gruss, herkunft, stand, erstellt,
           bestaetigt_am, bestaetigt_von)
          VALUES (?,?,?,?,'hand','bestaetigt',?,?,?)`)
        .run(cent, "EUR", name, gruss, jetzt(), jetzt(), req.person.id);

      const z = db().prepare("SELECT * FROM spenden WHERE id = ?").get(Number(lastInsertRowid));
      protokolliere(req.person.id, "spende_hand", `${cent} Cent von ${name}`, echteIp(req));
      zeigen(z);
      res.status(201).json(alsKarte(z));
    } catch (fehler) {
      console.error("[spenden] Eintragen:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/** Eine gemeldete Spende bestaetigen — dann geht sie ins Bild. */
spendenRouter.post("/workspace/api/spenden/:id(\\d+)/bestaetigen", nurGeld,
  express.json({ limit: "4kb" }), (req, res) => {
    try {
      const z = db().prepare("SELECT * FROM spenden WHERE id = ?").get(Number(req.params.id));
      if (!z) return res.status(404).json({ fehler: "nicht_gefunden" });
      /* SCHON BESTAETIGT IST KEIN FEHLER, ABER AUCH KEIN GRUND, ES
         NOCH EINMAL ZU ZEIGEN. Zwei Leute tippen gleichzeitig, und
         die Karte liefe zweimal. */
      if (z.stand === "bestaetigt") return res.json(alsKarte(z));

      /* Beim Bestaetigen darf der Betrag berichtigt werden: Die
         Leitung hat die PayPal-Meldung vor sich und weiss es besser
         als die Behauptung. */
      const cent = req.body?.betrag_cent === undefined
        ? z.betrag_cent : Math.round(Number(req.body.betrag_cent) || 0);
      if (!Number.isFinite(cent) || cent <= 0 || cent > BETRAG_MAX_CENT) {
        return res.status(400).json({ fehler: "betrag_unklar" });
      }

      db().prepare(`UPDATE spenden SET stand = 'bestaetigt', betrag_cent = ?,
          bestaetigt_am = ?, bestaetigt_von = ? WHERE id = ?`)
        .run(cent, jetzt(), req.person.id, z.id);
      const neu = db().prepare("SELECT * FROM spenden WHERE id = ?").get(z.id);
      protokolliere(req.person.id, "spende_bestaetigt", `#${z.id}, ${cent} Cent`, echteIp(req));
      zeigen(neu);
      res.json(alsKarte(neu));
    } catch (fehler) {
      console.error("[spenden] Bestaetigen:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

spendenRouter.post("/workspace/api/spenden/:id(\\d+)/ablehnen", nurGeld, (req, res) => {
  try {
    const n = db().prepare(`UPDATE spenden SET stand = 'abgelehnt',
        bestaetigt_am = ?, bestaetigt_von = ? WHERE id = ? AND stand = 'offen'`)
      .run(jetzt(), req.person.id, Number(req.params.id));
    if (!n.changes) return res.status(409).json({ fehler: "nicht_offen" });
    res.json({ ok: true });
  } catch (fehler) {
    console.error("[spenden] Ablehnen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Dieselbe Karte noch einmal zeigen — fuer den Fall, dass sie
 *  jemand verpasst hat oder die Technik im falschen Moment hakte. */
spendenRouter.post("/workspace/api/spenden/:id(\\d+)/nochmal", nurGeld, (req, res) => {
  try {
    const z = db().prepare("SELECT * FROM spenden WHERE id = ? AND stand = 'bestaetigt'")
      .get(Number(req.params.id));
    if (!z) return res.status(404).json({ fehler: "nicht_gefunden" });
    zeigen(z);
    res.json({ ok: true });
  } catch (fehler) {
    console.error("[spenden] Nochmal:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Aufraeumen: alte Spenden fallen aus dem Verlauf. */
export function spendenAufraeumen() {
  try {
    const grenze = new Date(Date.now() - SPENDEN_TAGE * 86400_000).toISOString();
    const a = db().prepare("DELETE FROM spenden WHERE erstellt < ?").run(grenze);
    if (a.changes) console.log(`[spenden] Aufgeraeumt: ${a.changes} Zeilen.`);
  } catch (fehler) {
    console.error("[spenden] Aufraeumen:", fehler?.message);
  }
}