/* =====================================================================
   Die Rechtetafel von Hand umstellen (11.09.2026)
   =====================================================================

   Filipe: *„ich will die kategorie auch auf der team dogi seite für die
   dogfather und rechte hand rollen … und wenn man drauf drückt,
   perfektionieren so dass ich die da auch manuell wechseln und
   speichern kann."*

   ---------------------------------------------------------------------
   WAS GESPEICHERT WIRD: NUR DER UNTERSCHIED

   In `seitenrecht` steht eine Zeile nur, wenn sie vom Grundstand in
   rechte.js ABWEICHT. Drei Gründe, und der dritte ist der wichtigste:

     * Der Code oben bedeutet weiterhin etwas. Man sieht, was gedacht
       war — und daneben, was daraus geworden ist.
     * „Zurück auf Grundstand" ist ein DELETE, kein Umschreiben.
     * Eine neue Seite erbt automatisch den Grundstand. Eine
       vollständige Kopie in der Datenbank hätte sie nicht gekannt, und
       sie wäre für alle zu gewesen — ohne dass es jemand entschieden
       hätte.

   ---------------------------------------------------------------------
   WER DARF WAS

   SEHEN: DogFather und die rechte Hand. Sie führen das Team zusammen;
   wer mitentscheidet, muss nachsehen können.

   UMSTELLEN: nur DogFather. Das ist dieselbe Linie wie bei den
   Zugängen („Zugang anlegen: nur DogFather") — wer Rechte vergeben
   kann, kann sich Rechte vergeben, und diese eine Tür bleibt bei ihm.
   Das stellt ihn nicht über sein Team; es ist die Aufgabe, die er
   ohnehin hat.

   UND DREI ZEILEN KANN AUCH ER NICHT ANFASSEN (rechte.js, UNANTASTBAR):
   sich selbst die Rechte-, die Personen- oder die Startseite
   wegzunehmen. Eine Einstellung, aus der man sich aussperren kann, ist
   keine Einstellung, sondern eine Falle — und sie wäre genau einen
   Fehlklick entfernt.

   ---------------------------------------------------------------------
   WANN DIE TAFEL NEU GELADEN WIRD

   Beim Start und nach jeder Änderung — in DIESEM Prozess. Der Server
   läuft als ein Prozess; eine zweite Instanz gäbe es nur bei einem
   Neustart, und der lädt ohnehin neu. Ein Zwischenspeicher mit
   Laufzeit wäre hier falsch: Wer ein Recht wegnimmt, will nicht, dass
   es noch zehn Minuten gilt.

   FÄLLT DAS LESEN AUS, gilt der Grundstand — und es wird laut
   protokolliert. Das ist die richtige Richtung: Der Grundstand ist der
   geprüfte Zustand. Eine Tafel, die still auf etwas anderes
   zurückfällt, wäre die schlimmste Sorte Fehler in diesem Haus.
   ===================================================================== */

import express from "express";
import {
  db, sitzungLesen, protokolliere, echteIp, fuehrtTeamDogi, ROLLEN_NAME,
} from "./workspace.js";
import {
  SEITEN, ALLE_ROLLEN, OHNE_ANMELDUNG, UNANTASTBAR,
  tafelSetzen, tafelJetzt, darfUmstellen, alleSeiten,
} from "./rechte.js";

export const rechteRouter = express.Router();

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

let bereit = false;
function tabelle() {
  if (bereit) return;
  db().exec(`
    /* Eine Abweichung vom Grundstand. NUR Abweichungen -- was hier
       nicht steht, gilt so, wie es in rechte.js steht. */
    CREATE TABLE IF NOT EXISTS seitenrecht (
      pfad    TEXT NOT NULL,
      rolle   TEXT NOT NULL,
      erlaubt INTEGER NOT NULL CHECK (erlaubt IN (0, 1)),
      von     INTEGER REFERENCES personen(id) ON DELETE SET NULL,
      am      TEXT NOT NULL,
      PRIMARY KEY (pfad, rolle)
    );
  `);
  bereit = true;
}

/**
 * Baut die geltende Tafel aus Grundstand + Abweichungen und setzt sie.
 *
 * WIRD BEIM START GERUFEN (index.js) UND NACH JEDER AENDERUNG. Ohne den
 * Aufruf beim Start gaelte nach einem Neustart wieder der Grundstand --
 * und niemand haette es gemerkt, denn es saehe aus wie vorher.
 */
export function tafelLaden() {
  try {
    tabelle();
    const zeilen = db().prepare("SELECT pfad, rolle, erlaubt FROM seitenrecht").all();
    if (!zeilen.length) { tafelSetzen(null); return { abweichungen: 0 }; }

    /* Eine KOPIE, nicht der Grundstand selbst -- sonst waere er nach der
       ersten Aenderung ueberschrieben und "zurueck auf Grundstand"
       haette nichts mehr, wohin es zurueckkann. */
    const neu = {};
    for (const [pfad, rollen] of Object.entries(SEITEN)) neu[pfad] = [...rollen];

    let gezaehlt = 0;
    for (const z of zeilen) {
      if (!Object.prototype.hasOwnProperty.call(neu, z.pfad)) continue;  // Seite gibt es nicht mehr
      if (!ALLE_ROLLEN.includes(z.rolle)) continue;                      // Rolle gibt es nicht mehr
      const drin = neu[z.pfad].includes(z.rolle);
      if (z.erlaubt && !drin) { neu[z.pfad].push(z.rolle); gezaehlt++; }
      if (!z.erlaubt && drin) {
        neu[z.pfad] = neu[z.pfad].filter((r) => r !== z.rolle);
        gezaehlt++;
      }
    }
    tafelSetzen(neu);
    return { abweichungen: gezaehlt };
  } catch (f) {
    /* LAUT, NICHT LEISE. Eine Tafel, die still auf den Grundstand
       zurueckfaellt, sieht aus wie eine Tafel, die stimmt. */
    console.error("[rechte] Tafel konnte nicht geladen werden, es gilt der "
      + "Grundstand aus rechte.js:", f?.message);
    tafelSetzen(null);
    return { abweichungen: 0, fehler: String(f?.message || f) };
  }
}

/* ---------------------------------------------------------------------
   Die Wege
   ------------------------------------------------------------------- */

function angemeldet(req, res, next) {
  const person = sitzungLesen(req);
  if (!person) return res.status(401).json({ fehler: "nicht_angemeldet" });
  req.person = person;
  try { tabelle(); } catch (f) {
    console.error("[rechte] Tabelle:", f?.message);
    return res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
  next();
}

/** Sehen: DogFather und die rechte Hand. 404 fuer alle anderen -- wer
 *  "kein Zugriff" liest, fragt als Naechstes, wer denn dann. */
function nurLeitung(req, res, next) {
  if (fuehrtTeamDogi(req.person)) return next();
  return res.status(404).json({ fehler: "nicht_gefunden" });
}

/** Umstellen: nur DogFather. */
function nurDogFather(req, res, next) {
  if (req.person?.rolle === "admin") return next();
  return res.status(403).json({
    fehler: "Umstellen kann das nur DogFather. Ansehen darfst du alles.",
  });
}

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();
}

rechteRouter.use("/workspace/api/rechte", angemeldet, nurLeitung);

rechteRouter.get("/workspace/api/rechte/tafel", (req, res) => {
  try {
    const tafel = tafelJetzt();
    const seiten = alleSeiten().map((pfad) => ({
      pfad,
      datei: pfad.replace("/workspace/", ""),
      rollen: [...(tafel[pfad] || [])],
      grund: [...(SEITEN[pfad] || [])],
      /* Was DogFather hier NICHT abwaehlen kann -- damit die Oberflaeche
         den Knopf gar nicht erst als Knopf zeigt statt ihn eine Absage
         bringen zu lassen. */
      fest: UNANTASTBAR.filter((u) => u.pfad === pfad).map((u) => u.rolle),
    }));

    res.json({
      darf_aendern: req.person.rolle === "admin",
      rollen: ALLE_ROLLEN.map((r) => ({
        schluessel: r,
        name: ROLLEN_NAME[r] ?? r,
        seiten: seiten.filter((s) => s.rollen.includes(r)).length,
        /* Wie viele davon von Hand gesetzt sind -- die Zahl, an der man
           sieht, ob jemand etwas verstellt hat. */
        abweichend: seiten.filter((s) => s.rollen.includes(r) !== s.grund.includes(r)).length,
      })),
      seiten,
      ohne_anmeldung: [...OHNE_ANMELDUNG],
      abweichungen: seiten.reduce((n, s) => n
        + ALLE_ROLLEN.filter((r) => s.rollen.includes(r) !== s.grund.includes(r)).length, 0),
    });
  } catch (f) {
    console.error("[rechte] Tafel lesen:", f?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* EIN FELD UMSTELLEN.
   Gespeichert wird sofort. Ein "Speichern"-Knopf am Ende waere bei
   einer Tafel mit 200 Feldern die Stelle, an der man eine halbe
   Aenderung verliert -- und bei Rechten ist eine halbe Aenderung die
   gefaehrlichste Lage von allen. Zurueckgenommen wird mit demselben
   Klick. */
rechteRouter.put("/workspace/api/rechte/feld", gleicheHerkunft, nurDogFather, (req, res) => {
  try {
    const pfad = String(req.body?.pfad || "");
    const rolle = String(req.body?.rolle || "");
    const erlaubt = req.body?.erlaubt === true;

    const nein = darfUmstellen(pfad, rolle, erlaubt);
    if (nein) return res.status(400).json({ fehler: nein });

    const imGrundstand = (SEITEN[pfad] || []).includes(rolle);
    if (erlaubt === imGrundstand) {
      /* WIEDER WIE IM GRUNDSTAND -> die Abweichung verschwindet.
         Eine Zeile, die dasselbe sagt wie der Code, waere eine
         Abweichung, die keine ist -- und sie wuerde in der Anzeige als
         "von Hand gesetzt" stehen, obwohl nichts verstellt ist. */
      db().prepare("DELETE FROM seitenrecht WHERE pfad = ? AND rolle = ?").run(pfad, rolle);
    } else {
      db().prepare(`INSERT INTO seitenrecht (pfad, rolle, erlaubt, von, am)
          VALUES (?,?,?,?,?)
        ON CONFLICT(pfad, rolle) DO UPDATE SET
          erlaubt = excluded.erlaubt, von = excluded.von, am = excluded.am`)
        .run(pfad, rolle, erlaubt ? 1 : 0, req.person.id, jetzt());
    }

    const stand = tafelLaden();
    /* JEDE AENDERUNG INS PROTOKOLL. Rechte sind das Einzige im Haus,
       bei dem man spaeter fragt "seit wann eigentlich?" -- und dann
       muss es dastehen. */
    protokolliere("rechte_umgestellt", {
      personId: req.person.id, ip: echteIp(req),
      detail: `${pfad.replace("/workspace/", "")} · ${rolle} · ${erlaubt ? "darf" : "darf nicht"}`,
    });
    res.json({ ok: true, erlaubt, abweichungen: stand.abweichungen });
  } catch (f) {
    console.error("[rechte] Feld:", f?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ALLES ZURUECK AUF DEN GRUNDSTAND.
   Ein Knopf, nicht 200 Klicks. Er ist der Grund, warum man sich hier
   ueberhaupt trauen kann, etwas auszuprobieren. */
rechteRouter.delete("/workspace/api/rechte/abweichungen", gleicheHerkunft, nurDogFather,
  (req, res) => {
    try {
      const { n } = db().prepare("SELECT COUNT(*) AS n FROM seitenrecht").get();
      db().prepare("DELETE FROM seitenrecht").run();
      tafelLaden();
      protokolliere("rechte_zurueckgesetzt", {
        personId: req.person.id, ip: echteIp(req), detail: `${n} Abweichungen`,
      });
      res.json({ ok: true, zurueckgenommen: n });
    } catch (f) {
      console.error("[rechte] Zuruecksetzen:", f?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });