/* =====================================================================
   Auskunft auf Knopfdruck — Art. 15 DSGVO (15.09.2026)

   Zweite Hälfte von Stufe 8. Jeder Mensch hier darf wissen, was über
   ihn gespeichert ist: DogFather, die rechte Hand, jeder Modi, jede
   Creatorin — und jedes Mitglied der Community.

   ---------------------------------------------------------------------
   DIE LISTE DER QUELLEN WIRD ABGELEITET, NICHT GEPFLEGT

   Eine Auskunft, die eine Tabelle vergisst, ist schlimmer als keine:
   Sie ist eine *falsche Aussage* über die Daten eines Menschen. Eine
   handgeschriebene Liste „wo Personendaten liegen" wäre in dem Moment
   falsch, in dem jemand eine Tabelle dazubaut — und im Projekt ist
   genau diese Bauart schon dreimal schiefgegangen.

   Deshalb fragt diese Datei die Datenbank selbst:
   `PRAGMA foreign_key_list` liefert jede Spalte, die auf `personen`
   zeigt. Gemessen am 15.09.2026: 37 von 42 Tabellen.

   ---------------------------------------------------------------------
   VIER SPALTEN ZEIGEN AUF ETWAS, OHNE ES ZU SAGEN

   Es gibt genau vier Spalten im ganzen Haus, die auf `_id` enden und
   keinen Fremdschlüssel deklarieren. Zwei davon sind Personen, zwei
   nicht. Sie stehen unten namentlich da — und `pruef-auskunft` schlägt
   an, sobald eine fünfte dazukommt, die niemand eingeordnet hat. Die
   Liste ist damit klein genug, um richtig zu sein, und kann nicht
   heimlich veralten.

   ---------------------------------------------------------------------
   ZWEI DINGE STEHEN NIE DRIN

   1. ZUGANGSGEHEIMNISSE. Hash, Salt, Kennung, Token — sie sind zwar
      „Daten über die Person", aber ihre Herausgabe schafft ein Risiko
      und keinen Nutzen. Art. 15 Abs. 4: die Rechte anderer bleiben
      unberührt, und das eigene Konto zu schützen ist auch ein Recht.

   2. ANDERE MENSCHEN. Wer eine Beobachtung über mich gesetzt hat, ist
      dessen Datum, nicht meines. Steht in einer Zeile über mich die
      Nummer eines anderen, wird daraus „eine andere Person" — eine
      Regel für alle Tabellen, keine Liste von Ausnahmen.
   ===================================================================== */

import express from "express";
import { db, sitzungLesen, istDogFather, protokolliere, echteIp } from "./workspace.js";
import { grundlageVon } from "./workspace-aufbewahrung.js";

export const auskunftRouter = express.Router();

/** Höchstens so viele Zeilen je Tabelle.
 *
 *  Nicht aus Bequemlichkeit: Ein Chatverlauf kann zehntausend Zeilen
 *  haben, und eine Datei, die der Browser nicht mehr oeffnet, ist keine
 *  Auskunft. Wird gekuerzt, steht es DRIN -- eine stille Kuerzung waere
 *  wieder eine falsche Aussage. */
export const ZEILEN_MAX = 500;

/** Personenverweise ohne deklarierten Fremdschluessel. */
export const ZUSATZ = [
  {
    tabelle: "protokoll", spalte: "person_id",
    warum: "Das Protokoll soll eine gelöschte Person überdauern – deshalb kein "
      + "Fremdschlüssel, der die Zeile mitnehmen würde.",
  },
  {
    tabelle: "treff_entfernt", spalte: "autor_id",
    warum: "Wer einen entfernten Beitrag geschrieben hat. Ohne Fremdschlüssel, damit "
      + "der Beleg bleibt, auch wenn das Konto geht.",
  },
];

/** Spalten auf `_id`, die KEINE Person meinen. Stehen hier, damit die
 *  Pruefung sagen kann: jede undeklarierte Spalte ist eingeordnet. */
export const KEINE_PERSON = [
  "eintraege.saeule_id",
  "treff_entfernt.eintrag_id",
  /* Welche Aufgabe aus einer angenommenen Bewerbung entstanden ist
     (workspace-vorlagen.js). Sie zeigt auf `aufgaben`, nicht auf einen
     Menschen -- die Person steht eine Spalte weiter in `person_id`,
     und die hat einen Fremdschluessel.

     EINGETRAGEN AM 24.09.2026, gefunden von pruef-auskunft. Ohne
     diesen Eintrag ist die Spalte „nicht eingeordnet", und das ist
     mehr als Ordnungsliebe: Bei einer Auskunftsanfrage muss das Haus
     sagen koennen, welche Spalten auf einen Menschen zeigen. Eine
     unbekannte Spalte ist eine, bei der niemand weiss, ob sie
     mitgehoert. */
  "vorlagen_bewerbungen.aufgabe_id",
];

const GEHEIM = /hash|salt|kennung|token|secret|geheim/i;

/** Jede Spalte im Haus, die auf einen Menschen zeigt.
 *
 *  @returns {Array<{tabelle: string, spalte: string, quelle: string}>} */
export function personenSpalten(d) {
  const raus = [];
  const tabellen = d.prepare(
    "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name")
    .all().map((z) => z.name);

  for (const tabelle of tabellen) {
    if (tabelle === "personen") continue;          // die eigene Zeile kommt getrennt
    let fks = [];
    try { fks = d.prepare(`PRAGMA foreign_key_list(${tabelle})`).all(); } catch { fks = []; }
    for (const f of fks) {
      if (f.table === "personen") raus.push({ tabelle, spalte: f.from, quelle: "fremdschluessel" });
    }
  }
  for (const z of ZUSATZ) {
    if (!tabellen.includes(z.tabelle)) continue;
    if (raus.some((r) => r.tabelle === z.tabelle && r.spalte === z.spalte)) continue;
    raus.push({ tabelle: z.tabelle, spalte: z.spalte, quelle: "nachgetragen" });
  }
  return raus;
}

/** Alle Spalten einer Tabelle, die auf einen Menschen zeigen. */
function personenSpaltenVon(alle, tabelle) {
  return alle.filter((s) => s.tabelle === tabelle).map((s) => s.spalte);
}

/** Eine Zeile so aufbereiten, dass nichts darin steht, was nicht
 *  hineingehört. */
function zeileSaeubern(zeile, personId, personSpalten) {
  const raus = {};
  for (const [spalte, wert] of Object.entries(zeile)) {
    if (GEHEIM.test(spalte)) { raus[spalte] = "(nicht enthalten – Zugangsgeheimnis)"; continue; }
    if (personSpalten.includes(spalte) && wert !== null && Number(wert) !== Number(personId)) {
      raus[spalte] = "(eine andere Person)";
      continue;
    }
    raus[spalte] = wert;
  }
  return raus;
}

/** Was über diesen Menschen gespeichert ist.
 *
 *  @param {number} personId
 *  @returns {object|null} null, wenn es die Person nicht gibt */
export function auskunft(personId) {
  const d = db();
  const person = d.prepare("SELECT * FROM personen WHERE id = ?").get(personId);
  if (!person) return null;

  const spalten = personenSpalten(d);
  const tabellen = [];
  const nichtLesbar = [];

  /* Nach Tabelle buendeln: Eine Zeile, in der ich zweimal vorkomme
     (erstellt_von UND creator_id), soll einmal dastehen, nicht zweimal. */
  const nachTabelle = new Map();
  for (const s of spalten) {
    if (!nachTabelle.has(s.tabelle)) nachTabelle.set(s.tabelle, []);
    nachTabelle.get(s.tabelle).push(s.spalte);
  }

  for (const [tabelle, sp] of [...nachTabelle].sort((a, b) => a[0].localeCompare(b[0]))) {
    try {
      const wo = sp.map((c) => `"${c}" = ?`).join(" OR ");
      const werte = sp.map(() => personId);
      const anzahl = d.prepare(`SELECT COUNT(*) AS n FROM "${tabelle}" WHERE ${wo}`).get(...werte).n;
      if (!anzahl) continue;
      const zeilen = d.prepare(
        `SELECT * FROM "${tabelle}" WHERE ${wo} LIMIT ${ZEILEN_MAX}`).all(...werte);
      tabellen.push({
        tabelle,
        gefunden_ueber: sp,
        anzahl,
        gekuerzt: anzahl > zeilen.length,
        zeilen: zeilen.map((z) => zeileSaeubern(z, personId, personenSpaltenVon(spalten, tabelle))),
      });
    } catch (f) {
      /* DRITTER AUSGANG: Eine Tabelle, die sich nicht lesen laesst, ist
         KEIN „nichts gefunden". Sie wird benannt -- sonst waere die
         Auskunft still unvollstaendig, und das ist das Einzige, was
         eine Auskunft nicht sein darf. */
      nichtLesbar.push({ tabelle, grund: String(f?.message || f).slice(0, 160) });
    }
  }

  /* WARUM WIR DIESE DATEN HABEN, gehoert in dieselbe Datei wie die
     Daten -- Art. 15 Abs. 1 lit. a. Eine Auskunft, die nur auflistet,
     beantwortet die halbe Frage. */
  const wozu = grundlageVon(person.rolle);

  return {
    stand: new Date().toISOString(),
    grundlage: wozu.grundlage,
    grundlage_warum: wozu.warum,
    person: zeileSaeubern(person, personId, []),
    hinweis: "Zugangsgeheimnisse (Hash, Salt, Kennung) sind absichtlich nicht enthalten. "
      + "Wo in einer Zeile eine andere Person steht, ist sie als „eine andere Person“ "
      + "eingetragen – ihre Daten gehören ihr.",
    durchsucht: nachTabelle.size,
    gefunden: tabellen.length,
    nicht_lesbar: nichtLesbar,
    tabellen,
  };
}

/* =====================================================================
   DIE WEGE
   ===================================================================== */

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

/** Über mich selbst — für JEDE Rolle, auch für die Community.
 *
 *  Kein Recht, das man erst beantragen muss: Wer hier ist, kann
 *  nachsehen. Das ist der ganze Punkt von „auf Knopfdruck". */
auskunftRouter.get("/workspace/api/auskunft/mich", angemeldet, (req, res) => {
  try {
    const d = auskunft(req.person.id);
    if (!d) return res.status(404).json({ fehler: "nicht_gefunden" });
    protokolliere("auskunft_selbst", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `${d.gefunden} von ${d.durchsucht} Stellen`,
    });
    res.json(d);
  } catch (fehler) {
    console.error("[auskunft] selbst:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Über einen anderen Menschen — nur DogFather.
 *
 *  Er ist der Verantwortliche im Sinne der Verordnung; wenn jemand ihn
 *  ausserhalb des Workspace um Auskunft bittet, muss er sie geben
 *  koennen. 404 statt 403 fuer alle anderen, wie ueberall im Haus. */
auskunftRouter.get("/workspace/api/auskunft/:id(\\d+)", angemeldet, (req, res) => {
  try {
    if (!istDogFather(req.person)) return res.status(404).json({ fehler: "nicht_gefunden" });
    const id = Number(req.params.id);
    const d = auskunft(id);
    if (!d) return res.status(404).json({ fehler: "nicht_gefunden" });
    /* WER UEBER WEN AUSKUNFT GEZOGEN HAT, GEHOERT INS PROTOKOLL. Eine
       vollstaendige Sammlung der Daten eines Menschen ist das
       Empfindlichste, was dieses Haus herausgibt. */
    protokolliere("auskunft_fremd", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `über #${id} (${d.person?.name || "?"}), ${d.gefunden} von ${d.durchsucht} Stellen`,
    });
    res.json(d);
  } catch (fehler) {
    console.error("[auskunft] fremd:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});