/* =====================================================================
   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, festeFelder,
  darfFeldAnfassen,
} 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: DogFather und die rechte Hand (24.09.2026).
 *
 *  Filipe: „die selben rechte da haben wie dogfather. das einzige was
 *  sie nicht kann ist die dogfather rolle oder leute anfassen."
 *
 *  WAS SIE NICHT DARF, STEHT NICHT HIER, sondern in
 *  `darfFeldAnfassen` (rechte.js) -- an genau einer Stelle, aus der
 *  auch die Oberflaeche ihre Auskunft zieht. Dieser Waechter laesst
 *  nur die beiden Rollen ueberhaupt herein; welches FELD sie anfassen
 *  duerfen, entscheidet die Route darunter. */
function nurLeitungUmstellen(req, res, next) {
  if (req.person?.rolle === "admin" || req.person?.rolle === "hand") return next();
  return res.status(403).json({
    fehler: "Umstellen kann das nur DogFather und die rechte Hand. "
      + "Ansehen darfst du alles.",
  });
}

/** Alles zurueck auf den Grundstand: weiterhin nur DogFather.
 *
 *  UND DAS IST ABSICHT, keine Vergesslichkeit. Ein Knopf, der die
 *  ganze Tafel zuruecksetzt, wuerde auch Aenderungen an der Spalte
 *  „DogFather" und an der Zeile „Personen & Zugaenge" mitnehmen --
 *  genau die zwei Dinge, die die rechte Hand nicht anfassen soll.
 *  Eine Sperre, die ein zweiter Knopf daneben aufhebt, ist keine. */
function nurDogFather(req, res, next) {
  if (req.person?.rolle === "admin") return next();
  return res.status(403).json({
    fehler: "Alles zurücksetzen kann nur DogFather – es würde auch "
      + "Einstellungen mitnehmen, die dir nicht offenstehen.",
  });
}

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. */
      /* WAS DIESE PERSON NICHT ANFASSEN DARF -- nicht nur, was
         allgemein festliegt (24.09.2026). Fuer DogFather unveraendert
         UNANTASTBAR; die rechte Hand bekommt zusaetzlich die Spalte
         „DogFather", die Zeile „Personen & Zugaenge" und ihre eigenen
         zwei Zugaenge als fest gezeichnet.

         Abgeleitet aus derselben Funktion, die die Route gleich
         darunter befragt -- damit die Oberflaeche nie einen Knopf
         zeigt, den der Server danach ablehnt. */
      fest: festeFelder(req.person, pfad),
      /* UND WARUM. Ein festes Feld ohne Grund ist eine graue Fläche,
         bei der man sich fragt, ob etwas kaputt ist. Der Text kommt
         aus derselben Funktion, die das Feld festgesetzt hat -- nicht
         aus einer Liste in der Oberfläche, die beim nächsten neuen
         Grund nicht mitwächst. */
      fest_grund: Object.fromEntries(ALLE_ROLLEN
        .map((r) => [r, darfFeldAnfassen(req.person, pfad, r)
          || (UNANTASTBAR.some((u) => u.pfad === pfad && u.rolle === r)
            ? "Diese Seite kannst du dir nicht selbst wegnehmen – sonst käme "
              + "niemand mehr an die Rechte, an die Zugänge oder auf die Startseite."
            : null)])
        .filter(([, grund]) => grund)),
    }));

    res.json({
      darf_aendern: req.person.rolle === "admin" || req.person.rolle === "hand",
      /* Zuruecksetzen bleibt bei DogFather -- die Oberflaeche zeigt
         den Knopf deshalb nur ihm. */
      darf_zuruecksetzen: 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, nurLeitungUmstellen, (req, res) => {
  try {
    const pfad = String(req.body?.pfad || "");
    const rolle = String(req.body?.rolle || "");
    const erlaubt = req.body?.erlaubt === true;

    /* DIE PERSON GEHT MIT. Ohne sie prueft `darfUmstellen` nur die
       allgemeinen Sperren -- und die rechte Hand koennte DogFathers
       Spalte aendern. */
    const nein = darfUmstellen(pfad, rolle, erlaubt, req.person);
    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" });
    }
  });