#!/usr/bin/env python3
"""
srt_check.py — Schnelle Tauglichkeitsprüfung für YouTube-Untertitel (.srt)
Ta-Na-Si Projekt · Keylam Folker und Raven D. Pond

Aufruf:
    python srt_check.py pfad/zur/datei.srt

Gibt eine Ampel-Bewertung aus (GRÜN / GELB / ROT), ob das .srt
sauber genug für eine zuverlässige Zusammenfassung ist.
"""

import sys
import re


def parse_srt(path):
    """Liest ein .srt und gibt den reinen Textinhalt (ohne Zeitstempel) zurück."""
    with open(path, encoding="utf-8-sig", errors="replace") as f:
        raw = f.read()

    lines = []
    for line in raw.splitlines():
        s = line.strip()
        if not s:
            continue
        if s.isdigit():                       # Block-Nummer
            continue
        if "-->" in s:                        # Zeitstempelzeile
            continue
        # HTML-/Formatierungs-Tags entfernen (z. B. <i>, <c>)
        s = re.sub(r"<[^>]+>", "", s)
        lines.append(s)
    return lines


def analyse(lines):
    text = " ".join(lines)
    words = re.findall(r"[^\W\d_]+", text, flags=re.UNICODE)
    n_words = len(words)

    if n_words == 0:
        return None  # leeres / unlesbares File

    # 1) Satzzeichen-Dichte
    sentence_marks = len(re.findall(r"[.!?]", text))
    marks_per_100 = sentence_marks / n_words * 100

    # 2) Großschreibung (Anteil großgeschriebener Wort-Anfänge)
    cap_words = sum(1 for w in words if w[:1].isupper())
    cap_ratio = cap_words / n_words

    # 3) Dubletten-Quote (auto-Untertitel wiederholen oft Zeilen)
    dup_lines = len(lines) - len(set(lines))
    dup_ratio = dup_lines / len(lines) if lines else 0

    # 4) Durchschnittliche Zeilenlänge (sehr kurze Fragmente = Auto-Stil)
    avg_len = sum(len(l.split()) for l in lines) / len(lines)

    return {
        "n_words": n_words,
        "marks_per_100": marks_per_100,
        "cap_ratio": cap_ratio,
        "dup_ratio": dup_ratio,
        "avg_len": avg_len,
    }


def verdict(m):
    flags = []

    # Satzzeichen: gesund sind ca. 8-20 Marken pro 100 Wörter
    if m["marks_per_100"] < 3:
        flags.append(("ROT", "Kaum Satzzeichen — sehr wahrscheinlich auto-generiert."))
    elif m["marks_per_100"] < 6:
        flags.append(("GELB", "Wenig Satzzeichen — Satzgrenzen evtl. unklar."))

    # Großschreibung: bei normalem Text > ~0.12
    if m["cap_ratio"] < 0.04:
        flags.append(("ROT", "Fast alles kleingeschrieben — Auto-Untertitel-Muster."))
    elif m["cap_ratio"] < 0.10:
        flags.append(("GELB", "Wenig Großschreibung — bitte gegenprüfen."))

    # Dubletten
    if m["dup_ratio"] > 0.25:
        flags.append(("GELB", "Viele wiederholte Zeilen — typisch für Auto-Captions."))

    # sehr kurze Fragmente
    if m["avg_len"] < 4:
        flags.append(("GELB", "Sehr kurze Textfragmente — Fließtext fehlt evtl."))

    if any(level == "ROT" for level, _ in flags):
        overall = "ROT"
    elif flags:
        overall = "GELB"
    else:
        overall = "GRÜN"
    return overall, flags


AMPEL = {
    "GRÜN": "🟢 GRÜN  — Sauber. Direkt für die Zusammenfassung verwendbar.",
    "GELB": "🟡 GELB  — Brauchbar, aber vor der Verarbeitung kurz durchsehen.",
    "ROT":  "🔴 ROT   — Wahrscheinlich auto-generiert. Erst korrigieren.",
}


def main():
    if len(sys.argv) != 2:
        print("Aufruf: python srt_check.py pfad/zur/datei.srt")
        sys.exit(1)

    path = sys.argv[1]
    lines = parse_srt(path)
    m = analyse(lines)

    print("\n" + "=" * 56)
    print(f"  SRT-Tauglichkeitsprüfung · Ta-Na-Si")
    print(f"  Datei: {path}")
    print("=" * 56)

    if m is None:
        print("🔴 ROT — Datei enthält keinen lesbaren Text.")
        return

    overall, flags = verdict(m)

    print(f"\n  Wörter gesamt:        {m['n_words']}")
    print(f"  Satzzeichen/100 Wört.: {m['marks_per_100']:.1f}")
    print(f"  Großschreib.-Anteil:   {m['cap_ratio']*100:.0f}%")
    print(f"  Wiederholte Zeilen:    {m['dup_ratio']*100:.0f}%")
    print(f"  Ø Wörter pro Zeile:    {m['avg_len']:.1f}")

    print("\n  " + AMPEL[overall])

    if flags:
        print("\n  Hinweise:")
        for level, msg in flags:
            print(f"    • [{level}] {msg}")
    print()


if __name__ == "__main__":
    main()