/* =====================================================================
   workspace-dateien.js — Zentrale Ablage mit Freigabe-Ablauf.

   Aus dem Konzept, Seite 13: "Bilder / PDFs / Guides, Technik-Screenshots,
   Content-Material" und der Ablauf "Entwurf -> Review -> Freigabe ->
   finale Version markieren".

   OHNE NEUE ABHÄNGIGKEIT. Uploads laufen üblicherweise über multer o. ä.
   Hier schickt der Browser die Datei stattdessen roh im Rumpf
   (fetch(..., { body: datei })), der Name steht im Kopf. Express bringt
   mit express.raw() den passenden Empfänger schon mit -- kein Parsen von
   multipart/form-data von Hand, was an dieser Stelle heikel wäre.

   Sicherheit -- die drei Punkte, an denen Dateiablagen typischerweise
   scheitern:
     1. Die Dateien liegen AUSSERHALB des Repos. Lägen sie darin, würde
        express.static sie ohne jede Prüfung ans Netz geben.
     2. Auf der Platte bekommt jede Datei einen erzeugten Zufallsnamen.
        Der Originalname steht nur in der Datenbank und kann damit weder
        Pfade verlassen (../) noch etwas überschreiben.
     3. Ausgeliefert wird immer als Download (Content-Disposition:
        attachment) mit neutralem Typ. Sonst könnte eine hochgeladene
        HTML- oder SVG-Datei im Browser Code im Namen der Domain
        ausführen.
   ===================================================================== */

import express from "express";
import { randomBytes } from "node:crypto";
import { join, extname, basename } from "node:path";
import { mkdirSync, writeFileSync, unlinkSync, statSync,
  openSync, readSync, closeSync } from "node:fs";
import { liefereDatei } from "./helfer-ausliefern.mjs";
import {
  db, protokolliere, echteIp, sitzungLesen, DATEN_ORDNER, betreutWo, darfCreator, betreuteIds, istLeitung, istDogFather, siehtAlles, istSpicy, ohneDogFather, ROLLEN_SORTIERUNG,
  externSql, EXTERN_MAX, sichtbarePersonenIds,
  ohneTeamDogi, ohneAgentur, siehtModis,
  TREFF_BRETTER, TREFF_ROLLEN,
} from "./workspace.js";
/* Die eine Stelle, die beantwortet, wer welchen Eintrag sehen darf.
   Kein Zirkel: workspace-bereiche.js kennt diese Datei nicht. */
import { darfEintragSehen } from "./workspace-bereiche.js";

export const dateienRouter = express.Router();

const ORDNER = join(DATEN_ORDNER, "dateien");
const MAX_BYTES = 25 * 1024 * 1024;          // 25 MB je Datei
const NAME_MAX = 200;
const NOTIZ_MAX = 500;
const STATUS = ["entwurf", "review", "freigegeben"];

/* Wer Dateien ablegen darf. Creator ausdruecklich NICHT (Wunsch vom
   28.08.2026): Sie sehen und laden die Dateien ihres Bereichs, abgelegt
   werden sie vom Management oder von Scouts. */
const DARF_HOCHLADEN = new Set(["admin", "scout"]);

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

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

dateienRouter.use("/workspace/api/dateien", angemeldet);

/* =====================================================================
   DIE UMHUELLUNG: was einem Modi gehoert, faellt hier heraus.

   Sie sitzt UM die eigentliche Regel und nicht darin -- damit sie auch
   fuer Regeln gilt, die es heute noch nicht gibt. Beim ersten Anlauf
   war nur der eine bekannte Fall geflickt (Spicy Media); das haette den
   naechsten Rollenzweig wieder offen gelassen, und niemand haette es
   gemerkt, weil an der geaenderten Stelle nichts davon steht.

   DogFather und die Modis gehen unveraendert durch.
   ===================================================================== */
export function sichtbar(person) {
  const regel = sichtbarRoh(person);
  if (!regel) return regel;
  /* AUF DER ADRESSE VON TEAM DOGI NUR TEAM DOGI (10.09.2026).

     Filipe: "die daten von dieser seite sollen nichts mit den daten am
     hut haben von der workspace seite ... komplett von der anderen
     getrennt sein."

     Die Bedingung steht VOR der Regel fuer das andere Haus und nicht
     danach: Beide schliessen sich aus, und wer sie hintereinander
     haengt, bekommt auf der Team-Adresse eine Bedingung, die sich
     selbst widerspricht -- und damit eine leere Seite, die aussieht
     wie ein Fehler.

     `person.haus` setzt sitzungLesen() aus der Adresse. Es aendert
     keine Rechte, nur den Ausschnitt. */
  if (person.haus === "crew") {
    return {
      wo: `(${regel.wo}) AND ${ohneAgentur("d", ["creator_id", "hochgeladen_von"])}`,
      werte: regel.werte,
    };
  }
  /* ==== DREI FAELLE UND NICHT ZWEI (24.09.2026, nachgebessert) =====

     Hier stand bis heute `if (siehtModis(person)) return regel;` --
     "wer Modi-Daten sehen darf, bekommt sie ungefiltert". Auf der
     AGENTURADRESSE hiess das in der Praxis: DogFather sieht dort auch
     Team Dogi. Genau das hat Filipe am 24.09.2026 abgeschafft.

     DIE ERSTE FASSUNG DIESER REPARATUR WAR ZU GROB: Ich habe die Zeile
     einfach gestrichen. Damit fiel auch der Fall "keine der beiden
     Adressen" durch -- also jede Pruefadresse. Gemessen: 19
     Fehlschlaege in drei Pruefungen, weil ein Modi seine eigenen
     Aufgaben nicht mehr sah. Nicht weil etwas kaputt war, sondern weil
     `ohneTeamDogi` dort ploetzlich auf ihn selbst zeigte.

     ES SIND DREI LAGEN, und jede bekommt ihre Zeile:
       crew    -> ohne die Agentur
       agentur -> ohne Team Dogi, AUCH fuer DogFather (das ist neu)
       kein Haus (localhost, Pruefungen) -> die alte Rollenregel,
                  unveraendert. Sonst waeren alle Modi-Pruefungen des
                  Hauses still gruen und blind -- die Falle, vor der
                  crew-adresse.js dreimal warnt.

     `siehtModis` BLEIBT UNVERAENDERT und wird anderswo weiter
     gebraucht (Rechtefragen, z.B. in der Checkliste). "Darf ich das
     sehen" und "welchen Ausschnitt sehe ich gerade" sind zwei Fragen;
     wer sie in eine Funktion legt, kann spaeter nicht mehr sagen,
     welche zugeschlagen hat. */
  if (person.haus === "agentur") {
    return {
      wo: `(${regel.wo}) AND ${ohneTeamDogi("d", ["creator_id", "hochgeladen_von"])}`,
      werte: regel.werte,
    };
  }
  if (siehtModis(person)) return regel;
  return {
    wo: `(${regel.wo}) AND ${ohneTeamDogi("d", ["creator_id", "hochgeladen_von"])}`,
    werte: regel.werte,
  };
}

/* Sichtbarkeit wie überall: an einer Stelle, damit keine Abfrage sie
   vergisst. */
function sichtbarRoh(person) {
  /* NUR DogFather sieht alles (01.09.2026). Vorher stand hier
     istLeitung() -- damit sah auch jeder Manager jeden Creator. Ein
     Manager faellt jetzt in dieselbe Regel wie ein Scout: nur die
     Creator, die ihm zugeteilt sind. Ausdruecklicher Wunsch:
     "NUR DIE ROLLE DOGFATHER SOLL WIRKLICH ALLEINE ALLES SEHEN."

     Geaendert wird ausschliesslich, wer was SIEHT. Was ein Manager
     darf (freigeben, aendern, Personen verwalten), haengt weiterhin an
     istLeitung und bleibt unveraendert -- sonst haette dieser eine
     Wunsch stillschweigend seine halben Rechte mitgenommen. */
  if (istSpicy(person)) return { wo: ohneDogFather("d", ["creator_id", "hochgeladen_von"]), werte: [] };
  if (siehtAlles(person)) return { wo: "1=1", werte: [] };

  /* Ausdrueckliche Freigabe -- gilt fuer jede Rolle gleich. Wer in der
     Liste steht, sieht die Datei, egal ob Creator oder Scout. */
  const freigabe = "EXISTS (SELECT 1 FROM datei_personen dp WHERE dp.datei_id = d.id AND dp.person_id = ?)";

  if (person.rolle === "creator") {
    return {
      wo: `(d.creator_id = ? OR d.hochgeladen_von = ? OR ${freigabe})`,
      werte: [person.id, person.id, person.id],
    };
  }
  const b = betreutWo(person, "d.creator_id");
  return b
    ? { wo: `(d.hochgeladen_von = ? OR ${freigabe} OR ${b.wo})`,
        werte: [person.id, person.id, ...b.werte] }
    : { wo: `(d.hochgeladen_von = ? OR ${freigabe})`, werte: [person.id, person.id] };
}

/* Wem eine Datei freigegeben ist -- fuer die Anzeige. */
export function freigabenZu(ids) {
  if (!ids.length) return new Map();
  const platz = ids.map(() => "?").join(",");
  const karte = new Map();
  for (const z of db().prepare(`
    SELECT dp.datei_id, p.id, p.name, p.rolle
    FROM datei_personen dp JOIN personen p ON p.id = dp.person_id
    WHERE dp.datei_id IN (${platz})
    ORDER BY ${ROLLEN_SORTIERUNG.replace('rolle', 'p.rolle')}, p.name`).all(...ids)) {
    if (!karte.has(z.datei_id)) karte.set(z.datei_id, []);
    karte.get(z.datei_id).push({ id: z.id, name: z.name, rolle: z.rolle });
  }
  return karte;
}

/* Wen darf diese Person ueberhaupt auswaehlen? DogFather jeden aktiven
   Menschen ausser sich selbst, ein Scout nur die Creator, die er
   betreut -- sonst koennte er sich ueber eine Freigabe Zugang zu
   fremden Bereichen verschaffen. */
export function moeglicheEmpfaenger(person) {
  /* Nicht die ROLLE, sondern die ZUTEILUNG entscheidet (03.09.2026).
     Hier stand eine Abfrage ueber ALLE -- eine Managerin bekam damit
     auch Namen und Daten von Creators, die ihr nie zugeteilt waren.
     sichtbarePersonenIds/sichtbareCreatorIds liefern null fuer
     DogFather (= keine Einschraenkung) und sonst genau die erlaubten
     Nummern. */
  const erlaubt = sichtbarePersonenIds(person);
  if (erlaubt === null) {
    return db().prepare(
      "SELECT id, name, rolle FROM personen WHERE aktiv = 1 AND id <> ? ORDER BY " + ROLLEN_SORTIERUNG + ", name")
      .all(person.id);
  }
  if (istLeitung(person)) {
    const ohneMich = erlaubt.filter((x) => x !== person.id);
    if (!ohneMich.length) return [];
    return db().prepare(
      `SELECT id, name, rolle FROM personen WHERE aktiv = 1
         AND id IN (${ohneMich.map(() => "?").join(",")})
       ORDER BY ` + ROLLEN_SORTIERUNG + ", name").all(...ohneMich);
  }
  if (person.rolle === "scout") {
    const ids = betreuteIds(person);
    if (!ids.length) return [];
    return db().prepare(
      `SELECT id, name, rolle FROM personen WHERE aktiv = 1 AND id IN (${ids.map(() => "?").join(",")})
       ORDER BY name`).all(...ids);
  }
  return [];
}

/* Freigaben setzen. Prueft jede Id gegen die erlaubte Auswahl -- ein
   geschickter Aufruf soll keine Person erreichen, die im Formular gar
   nicht zur Wahl stand. */
export function freigabenSetzen(dateiId, ids, person) {
  const erlaubt = new Set(moeglicheEmpfaenger(person).map((p) => p.id));
  const sauber = [...new Set(ids.map(Number).filter((n) => Number.isInteger(n) && erlaubt.has(n)))];
  const d = db();
  d.prepare("DELETE FROM datei_personen WHERE datei_id = ?").run(dateiId);
  const einf = d.prepare("INSERT OR IGNORE INTO datei_personen (datei_id, person_id) VALUES (?,?)");
  for (const pid of sauber) einf.run(dateiId, pid);
  return sauber.length;
}

const SPALTEN = `
  d.id, d.name_original, d.groesse, d.typ, d.status, d.notiz,
  d.creator_id, d.hochgeladen_von, d.erstellt, d.geaendert,
  d.creator_extern, d.ersetzt_id, d.aufgabe_id,
  ${externSql("pc.name", "d.creator_extern")} AS creator_name,
  ph.name AS hochgeladen_name`;

const VERBUND = `
  FROM dateien d
  LEFT JOIN personen pc ON pc.id = d.creator_id
  LEFT JOIN personen ph ON ph.id = d.hochgeladen_von`;

/* =====================================================================
   WELCHE FASSUNG IST DAS? (15.09.2026)

   Aus „ersetzt_id“ wird eine Kette. Jede Datei bekommt zwei Angaben:

     fassung    die wievielte sie ist (1 = die erste)
     ersetzt_am ob es eine neuere gibt -- dann ist SIE nicht mehr aktuell

   GERECHNET, NICHT GESPEICHERT. Eine Spalte "version" muesste beim
   Loeschen einer mittleren Fassung nachgezogen werden, und genau das
   vergisst man. Die Kette steht in den Verweisen; die Nummer folgt
   daraus.

   NUR AUS DER UEBERGEBENEN LISTE: Ist eine frueherere Fassung fuer
   diese Person gar nicht sichtbar, zaehlt sie hier auch nicht mit --
   eine Zahl, die eine unsichtbare Datei mitzaehlt, waere eine Auskunft
   ueber etwas, das man nicht sehen darf.
   ===================================================================== */
function fassungenSetzen(liste) {
  const nachId = new Map(liste.map((d) => [d.id, d]));
  const ersetztVon = new Map();
  for (const d of liste) if (d.ersetzt_id) ersetztVon.set(d.ersetzt_id, d.id);

  for (const d of liste) {
    /* Nach hinten zaehlen, bis keine Vorgaengerin mehr da ist. Die
       Schranke ist keine Vorsicht, sondern Pflicht: Ein Ring in den
       Daten (durch einen Fehler anderswo) wuerde die Seite sonst
       einfrieren, und ein Stillstand ist schlimmer als ein Fehler. */
    let n = 1;
    let jetzige = d;
    const gesehen = new Set([d.id]);
    while (jetzige.ersetzt_id && nachId.has(jetzige.ersetzt_id)
      && !gesehen.has(jetzige.ersetzt_id) && n < 200) {
      gesehen.add(jetzige.ersetzt_id);
      jetzige = nachId.get(jetzige.ersetzt_id);
      n++;
    }
    d.fassung = n;
    d.ersetzt_durch = ersetztVon.get(d.id) ?? null;
  }
}

/* =====================================================================
   DIE VERKNUEPFUNG WIEDER LOESEN (15.09.2026)

   Der Server verknuepft von selbst, wenn Name und Creator gleich sind.
   Meistens stimmt das; manchmal nicht -- zwei verschiedene Dateien
   koennen denselben Namen tragen.

   EINE AUTOMATIK OHNE AUSWEG IST EINE BEHAUPTUNG. Deshalb dieser Weg:
   ein Klick, und die Datei steht wieder fuer sich. NUR die Verknuepfung
   geht, nie eine Datei -- der Weg kann also nichts anrichten, was sich
   nicht in einem zweiten Klick zuruecknehmen liesse.
   ===================================================================== */
dateienRouter.delete("/workspace/api/dateien/:id(\\d+)/fassung", (req, res) => {
  try {
    const id = Number(req.params.id);
    const { wo, werte } = sichtbar(req.sicht || req.person);
    const d = db().prepare(
      `SELECT d.id, d.name_original, d.ersetzt_id ${VERBUND} WHERE ${wo} AND d.id = ?`)
      .get(...werte, id);
    if (!d) return res.status(404).json({ fehler: "nicht_gefunden" });
    if (!d.ersetzt_id) return res.status(409).json({ fehler: "keine_fassung" });

    db().prepare("UPDATE dateien SET ersetzt_id = NULL WHERE id = ?").run(id);
    protokolliere("datei_fassung_geloest", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `#${id} ${d.name_original} war Fassung von #${d.ersetzt_id}`.slice(0, 120),
    });
    res.json({ ok: true });
  } catch (fehler) {
    console.error("[dateien] Fassung loesen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Darf dieser Mensch diese Aufgabe sehen?
 *
 *  BEWUSST EINFACH GEHALTEN und nicht aus workspace-aufgaben.js
 *  importiert: Dort haengt die Sichtbarkeit an einer laengeren Abfrage
 *  mit Betreuung und Sicht. Hier wird nur gefragt, ob die Datei an eine
 *  Aufgabe darf, und dafuer gilt dieselbe Schranke wie fuer die Datei
 *  selbst -- der Creator-Bezug. Wer den Creator sehen darf, darf die
 *  Aufgabe daran haengen.
 *
 *  Waere hier mehr erlaubt als bei der Datei, entstuende genau das
 *  Leck, das die Spalte verhindern soll. */
function aufgabeSichtbar(aufgabe, person) {
  if (!aufgabe) return false;
  /* Eine Aufgabe ohne Creator-Bezug gehoert dem Haus -- sie ist fuer
     alle sichtbar, die ueberhaupt Dateien sehen duerfen. */
  if (!aufgabe.creator_id) return true;
  /* `darfCreator` ist genau diese Frage, und sie steht an einer Stelle
     im Haus. Eine eigene Herleitung hier waere eine zweite Meinung
     darueber -- und die zweite ist immer die, die mehr durchlaesst.
     (Erster Anlauf: eine handgebaute Abfrage plus sichtbareCreatorIds,
     das gar nicht importiert war.) */
  return darfCreator(person, aufgabe.creator_id);
}

/* ---------- Anhaenge einer Aufgabe --------------------------------------
   Eigener Weg statt eines Filters auf der grossen Liste: Die Aufgabe
   fragt nach IHREN Dateien, und die Antwort ist kurz genug, um sie beim
   Oeffnen des Dialogs zu holen. */
dateienRouter.get("/workspace/api/aufgaben/:id(\\d+)/dateien", (req, res) => {
  try {
    const id = Number(req.params.id);
    const { wo, werte } = sichtbar(req.sicht || req.person);
    const liste = db().prepare(`
        SELECT ${SPALTEN} ${VERBUND}
        WHERE ${wo} AND d.aufgabe_id = ?
        ORDER BY d.erstellt DESC`).all(...werte, id);
    fassungenSetzen(liste);
    res.json({ dateien: liste });
  } catch (fehler) {
    console.error("[dateien] Anhaenge:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------- Liste ------------------------------------------------------- */

dateienRouter.get("/workspace/api/dateien", (req, res) => {
  try {
    const { wo, werte } = sichtbar(req.sicht || req.person);
    const liste = db().prepare(`
        SELECT ${SPALTEN} ${VERBUND}
        WHERE ${wo}
        ORDER BY d.erstellt DESC`).all(...werte);
    const karte = freigabenZu(liste.map((d) => d.id));
    for (const d of liste) d.freigaben = karte.get(d.id) || [];
    fassungenSetzen(liste);
    res.json({
      dateien: liste,
      empfaenger: moeglicheEmpfaenger(req.person),
      darf_freigeben: req.person.rolle !== "creator",
      max_bytes: MAX_BYTES,
    });
  } catch (fehler) {
    console.error("[workspace] Dateien lesen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------- Hochladen ---------------------------------------------------- */

/* Der Name kommt im Kopf, nicht im Rumpf -- dort liegt die Datei selbst.
   Er wird als URI-Komponente kodiert übertragen, damit Umlaute und
   Leerzeichen unterwegs heil bleiben. */
function nameAusKopf(req) {
  const roh = req.get("x-dateiname") || "";
  let name;
  try { name = decodeURIComponent(roh); } catch { name = roh; }
  /* basename() entfernt alles, was nach Pfad aussieht -- danach kann der
     Name die Ablage nicht mehr verlassen. Zusätzlich werden Zeichen
     ersetzt, die in Dateinamen Ärger machen. */
  name = basename(name).replace(/[\x00-\x1f<>:"/\\|?*]/g, "_").trim();
  return name.slice(0, NAME_MAX) || "datei";
}

/* Steht bewusst VOR express.raw: Wer nicht hochladen darf, wird
   abgewiesen, bevor auch nur ein Byte der Datei entgegengenommen wird.
   Andernfalls wanderten bis zu 25 MB durch die Leitung, nur um danach
   verworfen zu werden. */
function darfHochladen(req, res, next) {
  if (!DARF_HOCHLADEN.has(req.person.rolle)) {
    return res.status(403).json({
      fehler: "Dateien legen DogFather und die Scouts ab.",
    });
  }
  next();
}

dateienRouter.post("/workspace/api/dateien",
  gleicheHerkunft,
  darfHochladen,
  express.raw({ type: "*/*", limit: MAX_BYTES }),
  (req, res) => {
    try {
      if (!Buffer.isBuffer(req.body) || !req.body.length) {
        return res.status(400).json({ fehler: "Keine Datei empfangen." });
      }

      const name = nameAusKopf(req);
      let notiz = "";
      try { notiz = decodeURIComponent(req.get("x-notiz") || ""); } catch { notiz = ""; }
      notiz = notiz.slice(0, NOTIZ_MAX).trim() || null;

      /* Wer nicht Management ist, lädt immer in den eigenen Bereich --
         ein betreuender Scout in den seines Creators. */
      let creatorId = null;
      if (req.person.rolle === "scout") {
        const w = Number(req.get("x-creator"));
        if (w) {
          if (!darfCreator(req.person, w)) {
            return res.status(403).json({ fehler: "Dieser Creator ist dir nicht zugeteilt." });
          }
          creatorId = w;
        }
      } else if (istLeitung(req.person)) {
        const w = req.get("x-creator");
        if (w) {
          const z = Number(w);
          if (!Number.isInteger(z) || z < 1) return res.status(400).json({ fehler: "Ungültige Zuordnung." });
          if (!db().prepare("SELECT 1 FROM personen WHERE id = ? AND aktiv = 1").get(z)) {
            return res.status(400).json({ fehler: "Zugeordnete Person gibt es nicht." });
          }
          creatorId = z;
        }
      }
      /* Ein frei eingetragener Name statt einer Person -- eine Agentur,
         eine Marke, ein Partner ohne Konto. Er kommt wie der Dateiname
         URL-kodiert im Kopf, sonst zerbrechen Umlaute: Kopfzeilen sind
         streng genommen nur ASCII, und "Müller" käme als "Müller" an.
         Der Name schlaegt die Auswahl -- wer tippt, meint das Getippte.
         Sichtbar bleibt die Datei ueber hochgeladen_von. */
      let creatorExtern = null;
      if (req.person.rolle !== "creator") {
        let roh = "";
        try { roh = decodeURIComponent(req.get("x-creator-extern") || ""); } catch { roh = ""; }
        roh = roh.replace(/[\u0000-\u001f\u007f]/g, "").trim().slice(0, EXTERN_MAX);
        if (roh) { creatorExtern = roh; creatorId = null; }
      }

      /* Ein Scout laedt ohne Bereichszuordnung ab -- die Datei sehen dann
         er selbst und das Management. Einem Creator direkt etwas in den
         Bereich zu legen bleibt dem Management vorbehalten, so wie im
         Konzept die Uebergabe ueber das Management laeuft. */

      mkdirSync(ORDNER, { recursive: true });
      /* Erzeugter Name auf der Platte. Die Endung wird aus dem
         Originalnamen übernommen, aber auf harmlose Zeichen begrenzt --
         sie dient nur der Wiedererkennung, ausgeliefert wird ohnehin
         immer als Download. */
      const endung = (extname(name).match(/^\.[A-Za-z0-9]{1,8}$/) || [""])[0].toLowerCase();
      const dateiname = `${Date.now().toString(36)}-${randomBytes(8).toString("hex")}${endung}`;
      writeFileSync(join(ORDNER, dateiname), req.body, { flag: "wx" });

      /* ---- GEHOERT DIE DATEI ZU EINER AUFGABE? (15.09.2026) ---------

         Die Nummer kommt im Kopf, wie der Dateiname auch. Geprueft wird
         sie gegen die Aufgaben, die dieser Mensch ueberhaupt sehen
         darf -- sonst waere der Kopf ein Weg, eine Datei an eine fremde
         Aufgabe zu haengen und damit ihre Existenz zu verraten.

         EINE UNBEKANNTE NUMMER IST EIN FEHLER, kein stilles Ignorieren:
         Wer eine Datei an eine Aufgabe haengen wollte und sie liegt
         danach lose in der Ablage, sucht sie spaeter an der Aufgabe. */
      let aufgabeId = null;
      const rohAufgabe = req.get("x-aufgabe");
      if (rohAufgabe) {
        const n = Number(rohAufgabe);
        const gefunden = Number.isInteger(n) && n > 0
          ? db().prepare(`SELECT a.id, a.creator_id FROM aufgaben a WHERE a.id = ?`).get(n)
          : null;
        if (!gefunden || !aufgabeSichtbar(gefunden, req.sicht || req.person)) {
          return res.status(404).json({ fehler: "aufgabe_nicht_gefunden" });
        }
        aufgabeId = gefunden.id;
        /* Der Creator-Bezug folgt der Aufgabe, wenn keiner mitkam --
           sonst laege die Datei fuer die Sichtbarkeit woanders als die
           Aufgabe, an der sie haengt. */
        if (creatorId === null && gefunden.creator_id) creatorId = gefunden.creator_id;
      }

      /* ---- IST DAS EINE NEUE FASSUNG? (15.09.2026) ------------------

         AUTOMATISCH VERKNUEPFT, NICHT GEFRAGT -- und das ist eine
         Abwaegung, keine Bequemlichkeit: Wer die Verknuepfung vergisst,
         hat zwei Dateien gleichen Namens ohne Zusammenhang, und
         irgendwann laedt jemand die alte herunter. Wer sie faelschlich
         bekommt, sieht sie sofort ("Fassung 2, ersetzt ...") und kann
         sie mit einem Klick loesen. Der stille Schaden ist groesser als
         der sichtbare.

         GENAU EINE Bedingung, und sie ist eng: gleicher Originalname,
         gleicher Creator-Bezug, und die Vorgaengerin darf nicht selbst
         schon ersetzt sein. Faende die Abfrage mehrere, wird NICHT
         geraten -- dann bleibt die Datei eigenstaendig. */
      const vorgaenger = db().prepare(`
          SELECT id FROM dateien
           WHERE name_original = ?
             AND ((creator_id IS NULL AND ? IS NULL) OR creator_id = ?)
             AND id NOT IN (SELECT ersetzt_id FROM dateien WHERE ersetzt_id IS NOT NULL)
           ORDER BY id DESC`).all(name, creatorId, creatorId);
      const ersetztId = vorgaenger.length === 1 ? vorgaenger[0].id : null;

      /* AN EINEN COMMUNITY-BEITRAG (17.09.2026). Dieselbe Regel wie bei
         der Aufgabe eine Ebene hoeher: Eine unbekannte Nummer ist ein
         FEHLER, kein stilles Ignorieren -- wer ein Bild an ein Highlight
         haengen wollte und es liegt danach lose in der Ablage, sucht es
         spaeter am Highlight. */
      let eintragId = null;
      const rohEintrag = req.get("x-eintrag");
      if (rohEintrag) {
        const n = Number(rohEintrag);
        const e = Number.isInteger(n) && n > 0
          ? db().prepare("SELECT id, bereich FROM eintraege WHERE id = ?").get(n)
          : null;
        if (!e || !TREFF_BRETTER.includes(e.bereich)) {
          return res.status(404).json({ fehler: "eintrag_nicht_gefunden" });
        }
        eintragId = e.id;
      }

      const { lastInsertRowid } = db().prepare(`
        INSERT INTO dateien
          (name_original, name_datei, groesse, typ, status, notiz,
           creator_id, hochgeladen_von, erstellt, ersetzt_id, aufgabe_id, eintrag_id)
        VALUES (?,?,?,?,'entwurf',?,?,?,?,?,?,?)`).run(
        name, dateiname, req.body.length,
        (req.get("content-type") || "application/octet-stream").slice(0, 100),
        notiz, creatorId, req.person.id, jetzt(), ersetztId, aufgabeId, eintragId);

      /* Ausdrueckliche Freigaben. Der Kopf traegt eine Liste von Ids --
         geprueft wird jede einzelne gegen die erlaubte Auswahl. */
      let anzahl = 0;
      const roh = req.get("x-personen");
      if (roh) {
        anzahl = freigabenSetzen(Number(lastInsertRowid),
          String(roh).split(",").map((x) => x.trim()).filter(Boolean), req.person);
      }

      protokolliere("datei_hochgeladen", {
        personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
        detail: `#${lastInsertRowid} ${name} (${Math.round(req.body.length / 1024)} KB)`
          + (anzahl ? `, freigegeben fuer ${anzahl}` : "").slice(0, 40),
      });
      res.status(201).json({
        id: Number(lastInsertRowid), ersetzt_id: ersetztId, aufgabe_id: aufgabeId,
      });
    } catch (fehler) {
      if (fehler?.type === "entity.too.large") {
        return res.status(413).json({ fehler: "Datei ist zu groß (max. 25 MB)." });
      }
      console.error("[workspace] Datei hochladen:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/* ---------- Herunterladen ------------------------------------------------ */

/* =====================================================================
   EIN BILD INLINE AUSLIEFERN (17.09.2026)

   Alles in dieser Ablage geht sonst als DOWNLOAD hinaus
   (`application/octet-stream`, `Content-Disposition: attachment`), und
   das ist richtig so: Eine hochgeladene HTML- oder SVG-Datei wuerde im
   Browser als Seite DIESER Domain laufen -- mit Zugriff auf die
   Sitzung.

   Eine Galerie braucht Bilder im Bild. Also ein eigener, enger Weg --
   und der beantwortet die Frage "ist das ein Bild?" NICHT so, wie man
   es zuerst tut:

     `dateien.typ` ist der vom Browser BEHAUPTETE Typ
     (`req.get("content-type")`). Wer hochlaedt, bestimmt ihn selbst.
     Eine Galerie, die ihm glaubt, liefert auf Zuruf alles inline aus.

   Erkannt wird deshalb an den ERSTEN BYTES der Datei. Die kann niemand
   behaupten; sie stehen da oder nicht.

   UND SVG IST AUSDRUECKLICH NICHT DABEI. Es ist ein Bildformat, und es
   kann Skript enthalten -- genau die Luecke, gegen die die Regel oben
   gebaut wurde. Ein Format, das beides ist, gehoert nicht in die
   Ausnahme. */
const BILD_KENNUNGEN = [
  { typ: "image/png", pruefe: (b) => b[0] === 0x89 && b[1] === 0x50 && b[2] === 0x4e && b[3] === 0x47 },
  { typ: "image/jpeg", pruefe: (b) => b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff },
  { typ: "image/gif", pruefe: (b) => b.slice(0, 6).toString("latin1") === "GIF87a"
    || b.slice(0, 6).toString("latin1") === "GIF89a" },
  { typ: "image/webp", pruefe: (b) => b.slice(0, 4).toString("latin1") === "RIFF"
    && b.slice(8, 12).toString("latin1") === "WEBP" },
];

/** Welches Bildformat steht wirklich am Dateianfang? `null` heisst:
 *  kein Bild -- und dann wird nichts inline ausgeliefert. */
export function bildArtVon(anfang) {
  if (!Buffer.isBuffer(anfang) || anfang.length < 12) return null;
  for (const k of BILD_KENNUNGEN) {
    try { if (k.pruefe(anfang)) return k.typ; } catch { /* naechste */ }
  }
  return null;
}

dateienRouter.get("/workspace/api/dateien/:id/bild", (req, res) => {
  try {
    const id = Number(req.params.id);
    if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });

    const datei = db().prepare(
      "SELECT id, name_datei, name_original, eintrag_id FROM dateien WHERE id = ?").get(id);
    if (!datei) return res.status(404).json({ fehler: "nicht_gefunden" });

    /* WESSEN REGEL GILT? Ein Bild an einem Community-Beitrag folgt dem
       BEITRAG, nicht der Dateiablage: Wer das Brett sehen darf, sieht
       das Bild. Die Ablage-Regel haengt an Creator-Zuordnungen, und ein
       Gast hat keine -- er saehe sonst nie ein Highlight, obwohl es
       fuer ihn gemacht ist. Alles ohne Beitrag faellt auf die normale
       Regel zurueck. */
    let erlaubt = false;
    if (datei.eintrag_id) {
      const e = db().prepare("SELECT bereich FROM eintraege WHERE id = ?").get(datei.eintrag_id);
      erlaubt = !!e && TREFF_BRETTER.includes(e.bereich)
        && TREFF_ROLLEN.has((req.sicht || req.person)?.rolle);
      /* ==== UND SONST: WER DEN EINTRAG SIEHT, SIEHT SEIN BILD =======
         (03.10.2026, gemessen am Banner eines Agentur-Events.)

         Die Zeile darueber deckt die sieben Community-Bretter ab. Ein
         Agentur-Event ist keines davon -- und es gehoert auch
         niemandem, also griff danach auch die Ablage-Regel nicht, die
         an Creator-Zuordnungen haengt. Ergebnis, nachgemessen:

             admin   -> Bild 200
             creator -> Bild 404

         Also genau an der Karte, die fuer Creator gemacht ist, eine
         leere Buehne. Vor dem Umbau war das Bild ein Anhang unter dem
         Text und fiel kaum auf.

         GEFRAGT WIRD DIESELBE REGEL WIE AUF DEM BRETT
         (darfEintragSehen -> sichtbarEintrag). Keine zweite Liste von
         Brettnamen hier: Was dort verborgen ist, bleibt auch hier
         verborgen, und beim naechsten neuen Brett muss niemand daran
         denken. Die Gegenprobe dazu steht in pruef-eventkarte.mjs --
         ein Eintrag, den die Person NICHT sehen darf, liefert
         weiterhin 404. */
      if (!erlaubt) erlaubt = darfEintragSehen(req.sicht || req.person, datei.eintrag_id);
    }
    if (!erlaubt) {
      const { wo, werte } = sichtbar(req.person);
      erlaubt = !!db().prepare(`SELECT d.id ${VERBUND} WHERE ${wo} AND d.id = ?`)
        .get(...werte, id);
    }
    if (!erlaubt) return res.status(404).json({ fehler: "nicht_gefunden" });

    const pfad = join(ORDNER, datei.name_datei);
    let anfang;
    try {
      const f = openSync(pfad, "r");
      anfang = Buffer.alloc(16);
      readSync(f, anfang, 0, 16, 0);
      closeSync(f);
    } catch { return res.status(410).json({ fehler: "Datei fehlt auf der Platte." }); }

    const art = bildArtVon(anfang);
    /* KEIN BILD HEISST 404, nicht 415. Eine eigene Antwort waere die
       Auskunft "diese Nummer gibt es, sie ist nur kein Bild" -- und die
       laesst sich durchzaehlen. */
    if (!art) return res.status(404).json({ fehler: "nicht_gefunden" });

    res.setHeader("Content-Type", art);
    res.setHeader("X-Content-Type-Options", "nosniff");
    res.setHeader("Content-Security-Policy", "default-src 'none'; sandbox");
    res.setHeader("Content-Disposition",
      `inline; filename*=UTF-8''${encodeURIComponent(datei.name_original)}`);
    res.setHeader("Cache-Control", "private, max-age=3600");
    liefereDatei(req, res, pfad);
  } catch (fehler) {
    console.error("[workspace] Bild ausliefern:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

dateienRouter.get("/workspace/api/dateien/:id/inhalt", (req, res) => {
  try {
    const id = Number(req.params.id);
    if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });

    const { wo, werte } = sichtbar(req.person);
    const datei = db().prepare(
      `SELECT d.name_original, d.name_datei ${VERBUND} WHERE ${wo} AND d.id = ?`).get(...werte, id);
    if (!datei) return res.status(404).json({ fehler: "nicht_gefunden" });

    const pfad = join(ORDNER, datei.name_datei);
    try { statSync(pfad); } catch { return res.status(410).json({ fehler: "Datei fehlt auf der Platte." }); }

    /* Immer als Download und immer mit neutralem Typ. Eine hochgeladene
       HTML- oder SVG-Datei würde sonst im Browser als Seite dieser Domain
       ausgeführt -- mit Zugriff auf die Sitzung. */
    res.setHeader("Content-Type", "application/octet-stream");
    res.setHeader("X-Content-Type-Options", "nosniff");
    res.setHeader("Content-Security-Policy", "default-src 'none'; sandbox");
    res.setHeader("Content-Disposition",
      `attachment; filename*=UTF-8''${encodeURIComponent(datei.name_original)}`);

    protokolliere("datei_geladen", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `#${id} ${datei.name_original}`.slice(0, 120),
    });
    liefereDatei(req, res, pfad);
  } catch (fehler) {
    console.error("[workspace] Datei ausliefern:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------- Freigabe und Notiz ------------------------------------------- */

dateienRouter.patch("/workspace/api/dateien/:id", gleicheHerkunft, (req, res) => {
  try {
    const id = Number(req.params.id);
    if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });

    const { wo, werte } = sichtbar(req.person);
    const datei = db().prepare(`SELECT d.* ${VERBUND} WHERE ${wo} AND d.id = ?`).get(...werte, id);
    if (!datei) return res.status(404).json({ fehler: "nicht_gefunden" });

    /* Freigaben aendern. Steht vor den Feldern, weil es eine eigene
       Tabelle ist und nicht in das UPDATE unten passt. Ein Creator darf
       das nie -- er wuerde sich sonst selbst Publikum verschaffen. */
    if (req.body?.freigaben !== undefined) {
      if (req.person.rolle === "creator") {
        return res.status(403).json({ fehler: "Freigeben darf nur DogFather oder ein Scout." });
      }
      if (!Array.isArray(req.body.freigaben)) {
        return res.status(400).json({ fehler: "Ungültige Auswahl." });
      }
      const n = freigabenSetzen(id, req.body.freigaben, req.person);
      protokolliere("datei_freigaben", {
        personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
        detail: `#${id} an ${n} Person(en)`.slice(0, 120),
      });
      if (Object.keys(req.body).length === 1) return res.json({ ok: true });
    }

    const setz = [];
    const daten = [];

    if (req.body?.status !== undefined) {
      if (!STATUS.includes(req.body.status)) return res.status(400).json({ fehler: "Unbekannter Status." });
      /* "freigegeben" ist eine Abnahme -- die trifft laut Konzept das
         Management, nicht der, der die Datei hochgeladen hat. */
      if (req.body.status === "freigegeben" && !istLeitung(req.person)) {
        return res.status(403).json({ fehler: "Freigeben darf nur DogFather." });
      }
      if (datei.status === "freigegeben" && !istLeitung(req.person)) {
        return res.status(403).json({ fehler: "Freigegebene Dateien ändert nur DogFather." });
      }
      setz.push("status = ?"); daten.push(req.body.status);
    }

    if (req.body?.notiz !== undefined) {
      const n = String(req.body.notiz ?? "").trim().slice(0, NOTIZ_MAX);
      setz.push("notiz = ?"); daten.push(n || null);
    }

    if (!setz.length) return res.status(400).json({ fehler: "nichts_zu_aendern" });
    setz.push("geaendert = ?"); daten.push(jetzt());

    db().prepare(`UPDATE dateien SET ${setz.join(", ")} WHERE id = ?`).run(...daten, id);
    protokolliere("datei_geaendert", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `#${id} ${req.body?.status || "notiz"}`.slice(0, 120),
    });
    res.json({ ok: true });
  } catch (fehler) {
    console.error("[workspace] Datei ändern:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------- Löschen ------------------------------------------------------ */

dateienRouter.delete("/workspace/api/dateien/:id", gleicheHerkunft, (req, res) => {
  try {
    const id = Number(req.params.id);
    if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });

    const { wo, werte } = sichtbar(req.person);
    const datei = db().prepare(
      `SELECT d.id, d.name_original, d.name_datei, d.status, d.hochgeladen_von ${VERBUND}
       WHERE ${wo} AND d.id = ?`).get(...werte, id);
    if (!datei) return res.status(404).json({ fehler: "nicht_gefunden" });

    if (!istLeitung(req.person)) {
      if (datei.hochgeladen_von !== req.person.id) {
        return res.status(403).json({ fehler: "nicht_erlaubt" });
      }
      if (datei.status === "freigegeben") {
        return res.status(403).json({ fehler: "Freigegebene Dateien löscht nur DogFather." });
      }
    }

    db().prepare("DELETE FROM dateien WHERE id = ?").run(id);
    /* Erst der Eintrag, dann die Datei: Bleibt eine verwaiste Datei auf
       der Platte liegen, ist das harmlos. Ein Eintrag ohne Datei wäre
       dagegen ein toter Verweis in der Liste. */
    try { unlinkSync(join(ORDNER, datei.name_datei)); } catch { /* schon weg */ }

    protokolliere("datei_geloescht", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `#${id} ${datei.name_original}`.slice(0, 120),
    });
    res.json({ ok: true });
  } catch (fehler) {
    console.error("[workspace] Datei löschen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------- Fehler aus express.raw --------------------------------------
   Ist der Rumpf zu gross, bricht express.raw ab, BEVOR der eigene Code
   laeuft -- das try/catch dort greift also nicht, und der Fehler landete
   im allgemeinen Behandler als HTTP 500. Fuer die Nutzerin sah das aus
   wie ein kaputter Server statt wie "Datei zu gross". Dieser Behandler
   muss ZULETZT stehen: Express erkennt ihn an den vier Parametern und
   ruft ihn nur fuer Fehler aus den Routen davor auf. */
// eslint-disable-next-line no-unused-vars
dateienRouter.use((fehler, req, res, next) => {
  if (!req.path.startsWith("/workspace/api/dateien")) return next(fehler);
  if (fehler?.type === "entity.too.large" || fehler?.status === 413) {
    return res.status(413).json({
      fehler: `Datei ist zu groß – erlaubt sind ${Math.round(MAX_BYTES / 1024 / 1024)} MB.`,
    });
  }
  console.error("[workspace] Dateien:", fehler?.message);
  res.status(503).json({ fehler: "nicht_verfuegbar" });
});