#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Angriffsfaelle fuer strip_code() aus linkcheck.py.

Vorgehen nach AI/Regelwerk/pruefwerkzeuge.md Abschnitt 3: je Fall ein
eigener Durchlauf, Grundlinie zuerst. Faellt die Grundlinie, misst der
Rest nichts.

Der Fall "Reihenfolge" (Link an erster UND letzter Position) ist Nr. 3 -
laut Regelwerk der Fall, dessen Fehlen am teuersten war.

Aufruf: python .vault-tools/linkcheck/faelle.py
"""

import os
import re
import sys

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from linkcheck import strip_code, wikilinks  # noqa: E402

_LINK = re.compile(r"\[\[([^\]\|#\^]+)")


class _V:
    """Minimaler Ersatz fuer vaultlib in den Faellen."""
    _WIKILINK_RE = _LINK


def links(text):
    return wikilinks(_V, text)


# (Nummer, Name, Text, erwartete Links)
FAELLE = [
    (0, "GRUNDLINIE: einfacher Link", "Siehe [[Zielnotiz]] dazu.", ["Zielnotiz"]),
    (1, "leerer Text", "", []),
    (2, "nur Fliesstext mit Link", "Ein [[A/B]] mitten im Satz.", ["A/B"]),
    (3, "Reihenfolge: Link vor UND nach einem Zaun",
     "[[Vorher]]\n\n```bash\n[[ $EUID -eq 0 ]]\n```\n\n[[Nachher]]",
     ["Vorher", "Nachher"]),
    (4, "Zaun mit Sprachangabe", "```bash\nif [[ -f x ]]; then :; fi\n```", []),
    (5, "Tilde-Zaun", "~~~\n[[drin]]\n~~~", []),
    (6, "Zaun ohne Abschluss", "Text\n```\n[[drin]]\nnoch drin", []),
    (7, "Inline-Code", "Der Ausdruck `[[:space:]]` trifft Leerzeichen.", []),
    (8, "doppelte Backticks", "Siehe ``[[roh]]`` im Text.", []),
    (9, "einzelner Backtick ohne Partner",
     "Ein ` einzelner Backtick und danach [[Echt]].", ["Echt"]),
    (10, "vier Backticks als Zaun", "````\n[[drin]]\n````", []),
    (11, "eingerueckter Zaun in einer Liste",
     "- Punkt:\n  ```\n  [[drin]]\n  ```\n- [[Danach]]", ["Danach"]),
    (12, "Link unmittelbar an der Zaunzeile",
     "[[Davor]]\n```\ncode\n```\n[[Danach]]", ["Davor", "Danach"]),
    (13, "Bestandsfall EUID im Block",
     "```bash\nif [[ $EUID -eq 0 ]]; then exit 1; fi\n```", []),
    (14, "Bestandsfall Zeichenklasse inline",
     "Mit `grep -o '[[:space:]]'` filtern.", []),
    (15, "escaptes Pipe in einer Tabellenzelle",
     r"| Datei | [[Pfad/Zur/Notiz\|Alias]] | Rest |", ["Pfad/Zur/Notiz"]),
    (16, "escaptes Pipe am Zeilenende ohne Alias",
     r"Siehe [[Ziel\|]] dort.", ["Ziel"]),
    (17, "Dreier-Zaun mit Info-String in Vierer-Zaun",
     "````markdown\n```bash\ngrep '[[:space:]]' datei\n```\n````\n[[Danach]]",
     ["Danach"]),
    (18, "Dreier-Schliesszaun schliesst Vierer nicht",
     "````\n```\n[[drin]]\n````\n[[Danach]]", ["Danach"]),
    (19, "Vierer-Zaun schliesst Vierer-Zaun",
     "````\n[[drin]]\n````\n[[Danach]]", ["Danach"]),
    (20, "```bash in einem ```-Block schliesst nicht",
     "```\n```bash\n[[drin]]\n```\n[[Danach]]", ["Danach"]),
    (21, "Schliesszaun mit Leerraum dahinter",
     "```\n[[drin]]\n``` \t\n[[Danach]]", ["Danach"]),
    (22, "Schliesszaun mit CR am Zeilenende",
     "```\r\n[[drin]]\r\n```\r\n[[Danach]]\r\n", ["Danach"]),
    (23, "anderes Zaunzeichen schliesst nicht (Backtick vs. Tilde)",
     "```\n[[drin]]\n~~~\n[[Danach]]", []),
    (24, "Schliesszaun mit vier Leerzeichen davor schliesst nicht",
     "```\n[[drin]]\n    ```\n[[Danach]]", []),
    (25, "Schliesszaun mit Tab davor schliesst (symmetrische Regel, benannte Luecke oberste Ebene)",
     "```\n[[drin]]\n\t```\n[[Danach]]", ["Danach"]),
    (26, "Liste: mit Tab eingerueckter Block schliesst mit Tab-Zaun",
     "- Punkt:\n\t```\n\t[[drin]]\n\t```\n- [[Danach]]", ["Danach"]),
]


def main():
    grundlinie = FAELLE[0]
    ist = links(grundlinie[2])
    if ist != grundlinie[3]:
        sys.stdout.write("GRUNDLINIE FAELLT: erwartet %r, bekommen %r\n"
                         % (grundlinie[3], ist))
        sys.stdout.write("Der Rest der Faelle misst damit nichts. Abbruch.\n")
        return 2

    fehler = 0
    for nr, name, text, erwartet in FAELLE:
        try:
            ist = links(text)
        except Exception as exc:  # ein Absturz ist ein Befund
            sys.stdout.write("  FALL %-2d ABSTURZ  %s -> %s\n" % (nr, name, exc))
            fehler += 1
            continue
        ok = ist == erwartet
        if not ok:
            fehler += 1
        sys.stdout.write("  FALL %-2d %-7s %-42s erwartet %r, bekommen %r\n"
                         % (nr, "ok" if ok else "FEHLER", name, erwartet, ist))

    gepruefte = len(FAELLE)
    sys.stdout.write("\n%d von %d Faellen bestanden.\n" % (gepruefte - fehler, gepruefte))
    return 1 if fehler else 0


if __name__ == "__main__":
    sys.exit(main())