# SPDX-FileCopyrightText: 2026 Olaf Willerding
# SPDX-License-Identifier: EUPL-1.2
"""Erzeugt die Datenschutzerklärung für die Anwendung.

## Warum es diese Datei gibt

Die Datenschutzerklärung stand bis Fassung 0.24.2 **nirgends in der
Anwendung**. Das Wort kam in der ganzen Oberfläche kein einziges Mal als
sichtbarer Text vor; `docs/datenschutz.html` wurde nicht mitgeliefert, und der
einzige Weg nach außen führt zur Unterstützungsseite und nicht zur Erklärung.
Zugleich sagt „Über diese Software“ zu, die Anwendung übertrage keine Daten —
eine Zusage, deren Beleg der Nutzende nicht erreichen konnte.

## Warum aus derselben Quelle und nicht daneben

Der Fehler, der hier droht, ist nicht „die Erklärung fehlt“. Er ist: **es gibt
sie zweimal, und die zweite ist die falsche.** Der Fall ist bereits
eingetreten — die veröffentlichte Seite stand am 30.08.2026 auf Fassung 1.1,
während `docs/datenschutz.md` bei 1.5 war. Der Erzeuger der HTML-Fassung hatte
gehalten, was er sollte; ausgelaufen ist der Schritt, den nur ein Mensch tut.

Deshalb wird hier nichts abgeschrieben. Dieses Werkzeug ruft **denselben**
Markdown-Umsetzer auf wie `datenschutz_html.py` — es gibt genau einen Parser
für dieses Dokument — und setzt dessen HTML in Blöcke um, die die Anwendung
ohne `dangerouslySetInnerHTML` darstellen kann.

## Warum über das HTML und nicht über das Markdown

Der Umweg ist Absicht. Ein zweiter Markdown-Parser wäre eine zweite Meinung
darüber, was im Dokument steht — und die erste ist sorgfältig gegen fünf
Auszeichnungsformen abgesichert, an denen sie ausdrücklich abbricht
(Blockzitat, Aufzählung mit `*`, vierte Überschriftenebene, verschachtelte
Liste, Kursivsatz; siehe Befund H41). Diese Absicherung gilt hier mit, ohne
dass sie ein zweites Mal geschrieben werden müsste.

Der Tagvorrat der Ausgabe ist klein und geschlossen — nachgezählt am
erzeugten Dokument vom 03.09.2026: `h1`, `h2`, `h3`, `p`, `ul`, `li`, `pre`,
`table`, `thead`, `tbody`, `tr`, `th`, `td`, `code`, `strong`, `a`. Alles
andere lässt dieses Werkzeug abbrechen.

Der Kopf nannte bis Fassung 0.27.2 nur die ersten zehn und verschwieg die
sechs Tabellen-Tags — die den aufwendigsten Zweig dieses Umsetzers ausmachen
und seit dem Wechsel von `<ul>` auf ein echtes `<table>` in
`datenschutz_html.tabelle()` erzeugt werden. Wer sich auf den Kopf verließ,
hielt eine Tabelle in `docs/datenschutz.md` für verboten. `BLOCKTAGS`,
`TABELLENTAGS` und `TEILTAGS` unten sind der maßgebliche Bestand;
`app/tests/datenschutz.test.ts` hält diesen Absatz dagegen.

## Die Wache

`content/datenschutz.json` trägt die Prüfsumme des Veröffentlichungsteils von
`docs/datenschutz.md`. `app/tests/datenschutz.test.ts` rechnet sie nach und
wird rot, sobald jemand die Quelle ändert und diesen Erzeuger vergisst. Ein
erzeugtes Dokument, das niemand neu erzeugt, ist stiller falsch als ein
handgeschriebenes — weil niemand mehr hinsieht.

Aufruf: ``python tools/datenschutz_anwendung.py``
"""

from __future__ import annotations

import hashlib
import json
import re
import sys
from html.parser import HTMLParser
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parent))

from datenschutz_html import kennung, umsetzen, veroeffentlichungsteil  # noqa: E402

WURZEL = Path(__file__).resolve().parent.parent
QUELLE = WURZEL / "docs" / "datenschutz.md"
ZIEL = WURZEL / "content" / "datenschutz.json"

#: Die Standtabelle am Ende der Erklärung führt beide Angaben. Sie werden
#: gelesen und nicht hier eingetragen: Eine Fassungsnummer an zwei Orten ist
#: genau die zweite Wahrheit, die dieses Werkzeug verhindern soll.
FASSUNG_MUSTER = re.compile(r"^\|\s*\*\*Fassung der Erklärung\*\*\s*\|\s*([^|]+?)\s*\|", re.M)
STAND_MUSTER = re.compile(r"^\|\s*\*\*Stand\*\*\s*\|\s*([^|]+?)\s*\|", re.M)

#: Genau die Elemente, die `datenschutz_html.umsetzen()` erzeugt.
BLOCKTAGS = {"h1", "h2", "h3", "p", "ul", "pre", "table"}
#: Die Teile einer Tabelle. Sie stehen INNERHALB von <table> und dürfen
#: deshalb nicht in BLOCKTAGS – sonst überschriebe <tr> den Blockzustand.
TABELLENTAGS = {"thead", "tbody", "tr", "th", "td"}
TEILTAGS = {"strong", "code", "a"}


class Umsetzer(HTMLParser):
    """Setzt das erzeugte HTML in Blöcke um und bricht bei allem Fremden ab."""

    def __init__(self) -> None:
        super().__init__(convert_charrefs=True)
        self.bloecke: list[dict[str, object]] = []
        self._block: str | None = None
        self._teile: list[dict[str, str]] = []
        self._punkte: list[list[dict[str, str]]] = []
        self._in_li = False
        self._kopf: list[str] = []
        self._zeilen: list[list[list[dict[str, str]]]] = []
        self._zelle: list[dict[str, str]] | None = None
        self._teil: str | None = None
        self._ziel: str | None = None

    # ── Hilfen ───────────────────────────────────────────────────────────

    def _text_anhaengen(self, roh: str) -> None:
        if self._block is None and not self._in_li and self._zelle is None:
            if roh.strip():
                self._abbruch(f"Text außerhalb eines Blocks: {roh.strip()[:60]!r}")
            return
        art = self._teil or "text"
        eintrag: dict[str, str] = {"art": art, "text": roh}
        if art == "verweis":
            eintrag["ziel"] = self._ziel or ""
        self._teile.append(eintrag)

    def _abbruch(self, was: str) -> None:
        sys.exit(f"ABBRUCH: {was}. Der Umsetzer kennt diese Form nicht.")

    @staticmethod
    def _zusammenfassen(teile: list[dict[str, str]]) -> list[dict[str, str]]:
        """Benachbarte gleichartige Teile verschmelzen, Leeres entfällt."""
        fertig: list[dict[str, str]] = []
        for teil in teile:
            if teil["text"] == "":
                continue
            if (
                fertig
                and fertig[-1]["art"] == teil["art"] == "text"
            ):
                fertig[-1]["text"] += teil["text"]
            else:
                fertig.append(dict(teil))
        return fertig

    # ── HTMLParser ───────────────────────────────────────────────────────

    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
        werte = dict(attrs)
        if tag in BLOCKTAGS:
            self._block = tag
            self._teile = []
            if tag == "ul":
                self._punkte = []
            if tag == "table":
                self._kopf = []
                self._zeilen = []
            return
        if tag in TABELLENTAGS:
            if tag in {"th", "td"}:
                self._zelle = []
                self._teile = []
            elif tag == "tr":
                self._teile = []
                # Auch die Kopfzeile legt eine an; sie bleibt leer, weil ihre
                # Zellen <th> sind, und wird bei </tr> wieder verworfen.
                self._zeilen.append([])
            return
        if tag == "li":
            self._in_li = True
            self._teile = []
            return
        if tag in TEILTAGS:
            if tag == "code" and self._block == "pre":
                return  # <pre><code> – der Inhalt ist reiner Text
            self._teil = {"strong": "stark", "code": "kennzeichnung", "a": "verweis"}[tag]
            self._ziel = werte.get("href")
            return
        self._abbruch(f"unbekanntes Element <{tag}>")

    def handle_endtag(self, tag: str) -> None:
        if tag in TEILTAGS:
            if tag == "code" and self._block == "pre":
                return
            self._teil = None
            self._ziel = None
            return
        if tag == "li":
            self._punkte.append(self._zusammenfassen(self._teile))
            self._teile = []
            self._in_li = False
            return
        if tag == "ul":
            self.bloecke.append({"art": "liste", "punkte": self._punkte})
            self._block = None
            return
        if tag in TABELLENTAGS:
            if tag == "tr":
                # Die Kopfzeile hinterlässt keine Datenzeile.
                if self._zeilen and not self._zeilen[-1]:
                    self._zeilen.pop()
                return
            if tag == "th":
                self._kopf.append("".join(t["text"] for t in self._zusammenfassen(self._teile)))
            elif tag == "td":
                assert self._zelle is not None
                self._zelle = self._zusammenfassen(self._teile)
                if not self._zeilen:
                    self._abbruch("Tabellenzelle ohne Zeile")
                self._zeilen[-1].append(self._zelle)
            if tag in {"th", "td"}:
                self._zelle = None
                self._teile = []
            return
        if tag == "table":
            self.bloecke.append(
                {"art": "tabelle", "kopf": self._kopf, "zeilen": self._zeilen}
            )
            self._block = None
            self._teile = []
            return
        if tag == "pre":
            self.bloecke.append(
                {"art": "code", "text": "".join(t["text"] for t in self._teile)}
            )
            self._block = None
            self._teile = []
            return
        if tag in {"h1", "h2", "h3"}:
            teile = self._zusammenfassen(self._teile)
            text = "".join(t["text"] for t in teile)
            self.bloecke.append(
                {
                    "art": "ueberschrift",
                    "ebene": int(tag[1]),
                    "text": text,
                    "kennung": kennung(text),
                }
            )
            self._block = None
            self._teile = []
            return
        if tag == "p":
            self.bloecke.append({"art": "absatz", "teile": self._zusammenfassen(self._teile)})
            self._block = None
            self._teile = []
            return
        self._abbruch(f"unbekanntes schließendes Element </{tag}>")

    def handle_data(self, data: str) -> None:
        self._text_anhaengen(data)


def pruefsumme(text: str) -> str:
    """SHA-256 über den Veröffentlichungsteil, mit Zeilenenden vereinheitlicht.

    Ohne die Vereinheitlichung wäre die Wache auf einem Arbeitsbaum mit CRLF
    dauerhaft und grundlos rot – und eine grundlos rote Wache wird
    abgeschaltet.
    """
    return hashlib.sha256(text.replace("\r\n", "\n").encode("utf-8")).hexdigest()


def main() -> None:
    markdown = QUELLE.read_text(encoding="utf-8")
    teil = veroeffentlichungsteil(markdown)

    fassung = FASSUNG_MUSTER.search(markdown)
    stand = STAND_MUSTER.search(markdown)
    if fassung is None or stand is None:
        sys.exit(
            "ABBRUCH: Fassung oder Stand nicht in der Standtabelle gefunden. "
            "Beide werden gelesen und nicht eingetragen; ohne sie wüsste die "
            "Anwendung nicht, welche Fassung sie zeigt."
        )

    umsetzer = Umsetzer()
    umsetzer.feed(umsetzen(teil))
    umsetzer.close()

    if not umsetzer.bloecke:
        sys.exit("ABBRUCH: kein einziger Block entstanden.")

    inhalt = {
        "quellpruefsumme": pruefsumme(teil),
        "fassung": fassung.group(1),
        "stand": stand.group(1),
        "bloecke": umsetzer.bloecke,
    }

    ZIEL.parent.mkdir(parents=True, exist_ok=True)
    with ZIEL.open("w", encoding="utf-8", newline="\n") as datei:
        json.dump(inhalt, datei, ensure_ascii=False, indent=2)
        datei.write("\n")

    zahl = len(umsetzer.bloecke)
    print(f"Geschrieben: {ZIEL.relative_to(WURZEL)} ({zahl} Blöcke, Fassung {inhalt['fassung']}).")


if __name__ == "__main__":
    main()