rippy/docker/worker/test_ripping_helpers.py

"""Tests für ripping.py: Kommando-Bau und Fortschritts-Parsing.

Deckt genau die Stellen ab, an denen Reviews erfundene Schnittstellen fanden
(abcde-Flags, Celery-API, HandBrake-Regex) — damit so etwas nie wieder still liegt.
Das PRGV-Format stammt aus der MakeMKV-Doku (makemkv.com/developers/usage.txt).
"""

import os

from ripping import (
    build_abcde_cmd,
    build_handbrake_cmd,
    build_makemkv_cmd,
    get_progress_from_line,
    get_progress_from_prgv,
    hb_schluss,
    parse_msg,
    unbekannter_schalter,
    write_abcde_config,
)


def test_makemkv_cmd_vollstaendig():
    cmd = build_makemkv_cmd("/dev/sr0", "/app/media/dvd/x")
    # Seit V2-4 steht hier der GEFUNDENE Pfad statt des blossen Namens: Unter
    # Windows liegt makemkvcon in Program Files und nicht im PATH — mit dem
    # nackten Namen faende `subprocess` es dort nie. Im Container bleibt es
    # der blosse Name (der Katalog findet nichts, der Rueckfall greift), auf
    # dem Entwicklungsrechner ist es der volle Pfad. Beides ist richtig;
    # gepruefet wird deshalb, WORAUF der Befehl zeigt.
    assert "makemkvcon" in cmd[0].lower()
    assert "-r" in cmd                       # Robot-Mode: maschinenlesbar
    assert "--noscan" in cmd                 # Scan hängt/crasht im Container (23.07.)
    assert "--progress=-same" in cmd         # Fortschritt im selben Stream
    assert "mkv" in cmd
    assert "dev:/dev/sr0" in cmd             # Geräte-Notation laut Doku
    assert cmd[-2:] == ["all", "/app/media/dvd/x"]


def test_handbrake_cmd_arbeitet_auf_datei_nicht_geraet():
    """HandBrake kann AACS nicht — es bekommt IMMER die MKV-Datei aus dem
    MakeMKV-Rip, nie das Laufwerk (die alte Direkt-am-Gerät-Pipeline war
    für Blu-rays prinzipiell funktionsunfähig)."""
    cmd = build_handbrake_cmd("/app/temp/raw/x/t00.mkv", "/app/media/bluray/x/t00.mkv")
    # Wie beim MakeMKV-Befehl: seit V2-4 steht hier der GEFUNDENE Pfad. Unter
    # Windows liegt HandBrakeCLI in Program Files oder in Rippys eigenem
    # Werkzeug-Ordner und nicht im PATH — mit dem nackten Namen faende
    # `subprocess` es dort nie.
    assert "handbrakecli" in cmd[0].lower()
    assert cmd[cmd.index("--input") + 1] == "/app/temp/raw/x/t00.mkv"
    assert cmd[cmd.index("--output") + 1] == "/app/media/bluray/x/t00.mkv"
    assert "--preset" in cmd
    assert "--first-audio" in cmd              # beste Spur pro Sprache behalten
    assert "--aencoder" in cmd
    assert "--all-subtitles" in cmd


def test_handbrake_kennt_keinen_schalter_audio_codec():
    """Der Schalter heißt `--aencoder`. `--audio-codec` gibt es nicht.

    Befund 30.08.2026, am mitgelieferten HandBrakeCLI 1.11.2 gemessen:

        unknown option (--audio-codec)
        HandBrake has exited.        $? = 0

    Rippy baute genau diesen Befehl. HandBrake stieg sofort aus und meldete
    das mit Rückgabewert 0 als ERFOLG — ein fertiger 16,5-GB-Rip lief damit
    ins Leere, ohne dass irgendwo ein Grund stand.

    ⚠️ Bis dahin stand hier `assert "--audio-codec" in cmd`: ein Test, der
    den Fehler festschrieb, statt ihn zu finden. Ein Kommandozeilen-Schalter
    ist eine externe Schnittstelle (AGENTS Regel D) — er gehört am echten
    Programm gemessen, nicht aus dem Gedächtnis behauptet.
    """
    cmd = build_handbrake_cmd("/tmp/a.mkv", "/tmp/b.mkv")
    assert "--audio-codec" not in cmd
    assert cmd[cmd.index("--aencoder") + 1] == "copy"


def test_unbekannter_schalter_wird_erkannt():
    """Wortlaut aus dem echten Lauf (30.08.2026, HandBrakeCLI 1.11.2)."""
    assert unbekannter_schalter(
        "unknown option (--audio-codec)") == "--audio-codec"
    # Mit Zeitstempel davor — HandBrake stellt vielen Zeilen einen voran.
    assert unbekannter_schalter(
        "[13:30:54] unknown option (--gibt-es-nicht)") == "--gibt-es-nicht"
    assert unbekannter_schalter("Encoding: task 1 of 1, 5.00 %") == ""
    assert unbekannter_schalter("") == ""
    assert unbekannter_schalter(None) == ""


def test_hb_schluss_haengt_handbrakes_letzte_worte_an():
    """Ohne sie stand im Fehlerfall nur der Rückgabewert da — und wenn der
    0 ist, sagt er nichts (Befund 30.08.2026)."""
    assert hb_schluss([]) == ""
    assert hb_schluss(None) == ""
    assert hb_schluss(["  ", "   "]) == ""
    text = hb_schluss(["eins", "zwei", "drei", "vier", "fünf"])
    assert "fünf" in text and "vier" in text
    # Nur die letzten HB_ZEILEN_MELDUNG — sonst steht Muxer-Statistik im UI.
    assert "eins" not in text


def test_handbrake_progress_parsing():
    # Testfund 22.07.: echtes HandBrake schreibt 45.50 % MIT Leerzeichen
    assert get_progress_from_line("Encoding: task 1 of 1, 45.50 %") == 45
    assert get_progress_from_line("Encoding: task 1 of 1, 100.00 %") == 100
    # Echte Zeile mit fps-Anhang, wie sie im Binary steht
    assert get_progress_from_line(
        "Encoding: task 1 of 1, 12.34 % (5.67 fps, avg 4.32 fps, ETA 00h12m34s)"
    ) == 12
    # Ein echtes 0 % ist eine ANGABE, keine Leermeldung
    assert get_progress_from_line("Encoding: task 1 of 1, 0.00 %") == 0


def test_handbrake_progress_ignoriert_scan_durchlauf():
    """Befund 25.07.2026 (Akira-UHD, live gemessen): HandBrake läuft VOR dem
    Encodieren einen Scan-Durchlauf, der ebenfalls Prozente ausgibt und dabei
    bis 100 % steigt. Die alte Regex nahm jede Zahl vor einem Prozentzeichen
    und meldete deshalb 99 %, während der Encode bei 1 % stand.

    -1 heißt „keine Encode-Fortschrittszeile" — dasselbe Muster wie bei
    get_progress_from_prgv. Fremde Zeilen dürfen NIE als 0 % gelten.
    """
    assert get_progress_from_line("Scanning title 1 of 1, preview 3, 30.00 %") == -1
    assert get_progress_from_line("Scanning title 1 of 1, preview 10, 100.00 %") == -1
    # Vorlauf-Phase: Prozente beziehen sich auf die Suche, nicht auf den Encode
    assert get_progress_from_line(
        "Encoding: task 1 of 1, Searching for start time, 42.00 %"
    ) == -1
    assert get_progress_from_line("kein Fortschritt hier") == -1
    assert get_progress_from_line("Muxing: this may take awhile...") == -1
    assert get_progress_from_line("") == -1


def test_handbrake_progress_rechnet_zwei_durchlaeufe_zusammen():
    """Presets mit zwei Durchläufen zählen die Prozente je Durchlauf neu.
    Ohne Verrechnung sprang die Anzeige mitten in der Datei zurück auf 0."""
    assert get_progress_from_line("Encoding: task 1 of 2, 50.00 %") == 25
    assert get_progress_from_line("Encoding: task 2 of 2, 0.00 %") == 50
    assert get_progress_from_line("Encoding: task 2 of 2, 100.00 %") == 100


def test_prgv_parsing():
    # PRGV:current,total,max — total/max ist der Gesamtfortschritt
    assert get_progress_from_prgv("PRGV:100,32768,65536") == 50
    assert get_progress_from_prgv("PRGV:0,65536,65536") == 100
    assert get_progress_from_prgv("PRGV:0,0,65536") == 0


def test_prgv_parsing_ignoriert_fremde_zeilen():
    # -1 heißt „keine Fortschrittszeile" — MSG-Zeilen dürfen NIE als 0% gelten,
    # sonst springt die Anzeige ständig auf null zurück.
    assert get_progress_from_prgv('MSG:1005,0,1,"MakeMKV gestartet","%1","x"') == -1
    assert get_progress_from_prgv("irgendwas") == -1
    assert get_progress_from_prgv("PRGV:kaputt") == -1


def test_parse_msg_trennt_code_und_klartext():
    """Echte Zeilen aus einem makemkvcon-Lauf vom 25.07.2026 (Akira UHD).

    Feld 4 ist laut https://www.makemkv.com/developers/usage.txt der fertig
    zusammengesetzte Klartext — genau der landet im Rippy-Log.
    """
    assert parse_msg(
        'MSG:1005,0,1,"MakeMKV v1.18.4 linux(x64-release) started","%1 started","MakeMKV v1.18.4 linux(x64-release)"'
    ) == (1005, "MakeMKV v1.18.4 linux(x64-release) started")
    assert parse_msg(
        'MSG:1011,0,1,"Using LibreDrive mode (v06.3 id=866A98CB9C4E)","%1","Using LibreDrive mode (v06.3 id=866A98CB9C4E)"'
    ) == (1011, "Using LibreDrive mode (v06.3 id=866A98CB9C4E)")


def test_parse_msg_liest_die_uhd_fehlermeldung():
    """3303 ist der Befund, um den es beim ganzen KEYDB-Thema geht: das
    Laufwerk läuft im LibreDrive-Modus, MakeMKV kennt nur den Schluessel
    DIESER Pressung nicht. Ohne diese Zeile im Log raet der Commander."""
    assert parse_msg(
        'MSG:3303,16777216,0,"The volume key is unknown for this disc - video can\'t be decrypted","The volume key is unknown for this disc - video can\'t be decrypted"'
    ) == (3303, "The volume key is unknown for this disc - video can't be decrypted")
    assert parse_msg('MSG:5010,0,0,"Failed to open disc","Failed to open disc"') == (
        5010,
        "Failed to open disc",
    )


def test_parse_msg_schneidet_meldungen_mit_komma_nicht_ab():
    """DER Grund für die Regex (Stand 25.07.2026): vorher stand hier
    line.split(",", 4)[3]. Das schnitt jede Meldung ab, die selbst ein Komma
    enthält — und MakeMKV schreibt solche laufend. Im Log stand dann nur noch
    ein Satzfragment, das mehr verwirrt als hilft."""
    zeile = (
        'MSG:3025,0,3,"Title #1 has length of 12 seconds, which is less than '
        'minimum title length of 120 seconds and was therefore skipped",'
        '"Title #%1 has length of %2 seconds which is less than minimum title '
        'length of %3 seconds and was therefore skipped","1","12","120"'
    )
    code, text = parse_msg(zeile)
    assert code == 3025
    assert text.endswith("and was therefore skipped")
    assert "which is less than" in text


def test_parse_msg_ignoriert_fremde_zeilen():
    # Alles außer MSG muss None liefern, sonst landet Fortschritts-Rauschen
    # (PRGV kommt mehrmals pro Sekunde) als Log-Eintrag in der Datenbank.
    assert parse_msg("PRGV:100,32768,65536") is None
    assert parse_msg('DRV:0,2,999,12,"BD-RE ASUS BW-16D1HT","AKIRA","/dev/sr0"') is None
    assert parse_msg("TCOUNT:5") is None
    assert parse_msg("") is None
    assert parse_msg("irgendwelcher Muell ohne Struktur") is None


def test_abcde_cmd_hat_genau_ein_ausgabeformat():
    """Review-Fund 22.07.: '-o' stand doppelt (Format UND Verzeichnis) — abcde
    parste das Verzeichnis als Format, CD-Ripping war nie funktionsfähig."""
    cmd = build_abcde_cmd("/dev/sr0", "/tmp/test.abcde.conf")
    assert cmd.count("-o") == 1
    assert cmd[cmd.index("-o") + 1] == "flac"
    assert "-c" in cmd
    assert cmd[cmd.index("-c") + 1] == "/tmp/test.abcde.conf"
    assert "-N" in cmd  # nicht-interaktiv, sonst hängt der Worker


def test_abcde_auswurf_folgt_der_einstellung():
    """Befund 25.07.2026: `-x` (Auswurf) stand fest verdrahtet drin. Eine
    Audio-CD warf damit IMMER aus, eine DVD/Blu-ray NIE — und die Einstellung
    „Automatischer Auswurf" regelte keines von beidem, weil sie nirgends
    gelesen wurde."""
    assert "-x" in build_abcde_cmd("/dev/sr0", "/tmp/c.conf", auswerfen=True)
    assert "-x" not in build_abcde_cmd("/dev/sr0", "/tmp/c.conf", auswerfen=False)
    # Standard bleibt „auswerfen" — so war das Verhalten bisher
    assert "-x" in build_abcde_cmd("/dev/sr0", "/tmp/c.conf")
    # Die Config darf durch das weggefallene -x nicht verrutschen
    ohne = build_abcde_cmd("/dev/sr0", "/tmp/c.conf", auswerfen=False)
    assert ohne[ohne.index("-c") + 1] == "/tmp/c.conf"


def test_abcde_config_enthaelt_zielverzeichnis():
    pfad = write_abcde_config("/app/media/cd/test123")
    try:
        with open(pfad, encoding="utf-8") as f:
            inhalt = f.read()
        assert "OUTPUTDIR='/app/media/cd/test123'" in inhalt
        assert "INTERACTIVE=n" in inhalt
    finally:
        os.unlink(pfad)


def test_preset_fuer_nimmt_das_preset_des_disc_typs():
    # Befund 25.07.2026: vorher galt EIN Preset für alles — eine 4K-UHD wurde
    # damit auf 1080p heruntergerechnet, und beim ersten echten UHD-Rip wäre
    # die 4K-Aufloesung still verlorengegangen.
    from ripping import preset_fuer

    einstellungen = {
        "transcodePreset": "HQ 1080p30 Surround",
        "transcodePresetDvd": "H.265 MKV 576p25",
        "transcodePresetBluray": "H.265 MKV 1080p30",
        "transcodePresetUhd": "H.265 MKV 2160p60 4K",
    }
    assert preset_fuer("uhd", einstellungen) == "H.265 MKV 2160p60 4K"
    assert preset_fuer("bluray", einstellungen) == "H.265 MKV 1080p30"
    assert preset_fuer("dvd", einstellungen) == "H.265 MKV 576p25"


def test_preset_fuer_faellt_auf_das_allgemeine_preset_zurueck():
    # Bestandsinstallationen kennen die drei neuen Felder nicht. Solange der
    # Nutzer sie nicht speichert, MUSS sich sein Verhalten nicht ändern.
    from ripping import preset_fuer

    alt = {"transcodePreset": "HQ 1080p30 Surround"}
    assert preset_fuer("uhd", alt) == "HQ 1080p30 Surround"
    assert preset_fuer("dvd", alt) == "HQ 1080p30 Surround"
    # Leere Zeichenkette zählt als "nicht gesetzt" (leeres Select-Feld im UI)
    assert preset_fuer("uhd", {"transcodePresetUhd": "  ", "transcodePreset": "X"}) == "X"


def test_preset_fuer_ohne_einstellungen_nimmt_den_eingebauten_standard():
    # Unbekannter Disc-Typ, leere oder fehlende Einstellungen: nie None, nie
    # Absturz — sonst stirbt die Kompression an einem leeren --preset-Argument.
    from ripping import DEFAULT_HB_PRESET, preset_fuer

    assert preset_fuer("uhd", {}) == DEFAULT_HB_PRESET
    assert preset_fuer("", None) == DEFAULT_HB_PRESET
    assert preset_fuer(None, {}) == DEFAULT_HB_PRESET
    assert preset_fuer("cd", {"transcodePresetUhd": "egal"}) == DEFAULT_HB_PRESET


def test_handbrake_prueft_abbruch_bei_jeder_zeile_nicht_nur_bei_fortschritt():
    """Befund 25.07.2026 (am laufenden Akira-Job beobachtet): Der Abbruch hing
    am Fortschritts-Callback, und der stieg bei unveraenderter Prozentzahl
    sofort aus. Bei einem 4K-Encode mit einem Prozent je halber Stunde sah
    „Abbrechen" minutenlang wirkungslos aus (gemessen: 3,4 min).

    Der Abbruch-Kanal muss deshalb JEDE Ausgabezeile sehen — auch die des
    Scan-Durchlaufs, der gar keine Encode-Prozente liefert.
    """
    import ripping

    zeilen = [
        "Scanning title 1 of 1, preview 1, 10.00 %\n",
        "Scanning title 1 of 1, preview 2, 20.00 %\n",
        "Encoding: task 1 of 1, 0.00 %\n",
        "Encoding: task 1 of 1, 0.00 %\n",
    ]
    gesehen = []

    class FakeProcess:
        def __init__(self):
            self.stdout = iter(zeilen)
            self.returncode = 0
            self.getoetet = False

        def kill(self):
            self.getoetet = True

        def wait(self):
            return 0

    prozess = FakeProcess()

    def abbruch_cb():
        gesehen.append(1)
        if len(gesehen) == 2:  # beim zweiten Mal abbrechen
            raise ripping.RipAbbruch()

    ergebnis = ripping._handbrake_schleife(prozess, "/x.mkv", abbruch_cb, None)

    assert ergebnis["status"] == "cancelled"
    assert prozess.getoetet is True
    # Zwei Scan-Zeilen genügten — es musste NICHT auf eine Encode-Zeile gewartet
    # werden. Genau das war der Fehler.
    assert len(gesehen) == 2


def test_komprimieren_fuer_globaler_schalter_schlaegt_alles():
    from ripping import komprimieren_fuer

    assert komprimieren_fuer("uhd", {"transcodeEnabled": False}) is False
    assert komprimieren_fuer("dvd", {"transcodeEnabled": False}) is False
    # Standard ist AN - Bestandsinstallationen ändern ihr Verhalten nicht
    assert komprimieren_fuer("bluray", {}) is True
    assert komprimieren_fuer("bluray", None) is True


def test_komprimieren_fuer_einzelner_disc_typ_abwaehlbar():
    """Der Grund dafür (Befund 25.07.2026): 4K-HEVC brauchte auf der Rippy-VM
    gemessene 28-55 Stunden, weil die CPU kein AVX2 hat. Vorher gab es nur
    einen globalen Schalter - wer 4K verlustfrei behalten und DVDs trotzdem
    schrumpfen wollte, hatte keine Möglichkeit."""
    from ripping import PRESET_KEINE, komprimieren_fuer

    nur_uhd_aus = {"transcodePresetUhd": PRESET_KEINE,
                   "transcodePresetDvd": "H.265 MKV 576p25"}
    assert komprimieren_fuer("uhd", nur_uhd_aus) is False
    assert komprimieren_fuer("dvd", nur_uhd_aus) is True
    assert komprimieren_fuer("bluray", nur_uhd_aus) is True


def test_preset_fuer_gibt_den_reservewert_nie_als_preset_zurueck():
    """Sonst bekaeme HandBrake `--preset keine` und würde scheitern. Wer über
    "Neu komprimieren" ausdruecklich doch komprimieren will, soll ein
    brauchbares Preset bekommen statt eines Fehlers."""
    from ripping import DEFAULT_HB_PRESET, PRESET_KEINE, preset_fuer

    assert preset_fuer("uhd", {"transcodePresetUhd": PRESET_KEINE,
                               "transcodePreset": "HQ 1080p30 Surround"}) == "HQ 1080p30 Surround"
    # Auch ohne allgemeines Preset kommt ein gültiger Name heraus
    assert preset_fuer("uhd", {"transcodePresetUhd": PRESET_KEINE}) == DEFAULT_HB_PRESET


def test_reservewert_kollidiert_mit_keinem_echten_preset():
    """Gegengeprueft gegen alle 90 Presets aus `HandBrakeCLI --preset-list`
    im Worker-Image (25.07.2026) - keines heißt so."""
    from ripping import PRESET_KEINE

    assert PRESET_KEINE == "keine"
    assert " " not in PRESET_KEINE  # echte Preset-Namen haben durchweg Leerzeichen


# --- Unbekanntes Preset: aus „Code 3" wird eine handelbare Meldung -----------


def test_unbekanntes_preset_wird_erkannt():
    """Wortlaut echt gemessen (26.07.2026, Worker-Image): HandBrake antwortet
    „Invalid preset <Name>" und listet danach die gültigen auf."""
    from ripping import unbekanntes_preset

    assert unbekanntes_preset("Invalid preset Gibt Es Nicht 999p") == "Gibt Es Nicht 999p"
    assert unbekanntes_preset("  Invalid preset H.265 XYZ 4K  ") == "H.265 XYZ 4K"
    # Alles andere ist kein Preset-Fehler
    assert unbekanntes_preset("Valid presets are:") == ""
    assert unbekanntes_preset("Encoding: task 1 of 1, 5.00 %") == ""
    assert unbekanntes_preset("") == ""
    assert unbekanntes_preset(None) == ""


def test_falsches_preset_erklaert_den_fehlschlag_statt_nur_den_code():
    """Vorher stand im UI nur „HandBrake endete mit Code 3" — daraus war nicht
    zu erraten, dass der Preset-NAME das Problem ist. Der Fall wird häufiger,
    weil ein Remote-Worker eine andere HandBrake-Version haben kann."""
    import ripping

    class FakeProcess:
        def __init__(self):
            self.stdout = iter([
                "Invalid preset H.265 VCN 2160p 4K\n",
                "Valid presets are:\n",
            ])
            self.returncode = 3

        def kill(self):
            pass

        def wait(self):
            return 3

    ergebnis = ripping._handbrake_schleife(FakeProcess(), "/gibt-es-nicht.mkv")

    assert ergebnis["status"] == "error"
    assert "H.265 VCN 2160p 4K" in ergebnis["error"]
    assert "Bestes wählen" in ergebnis["error"]
    assert ergebnis["return_code"] == 3


def test_fehler_ohne_preset_problem_nennt_handbrakes_letzte_worte():
    """Der Code allein reicht nicht — HandBrake selbst muss zu Wort kommen.

    Bis zum 30.08.2026 stand hier nur „HandBrake endete mit Code N", und
    jede Ausgabezeile wurde weggeworfen. Bei Code 0 (den HandBrake auch
    für Fehler vergibt) blieb damit gar keine Auskunft übrig.
    """
    import ripping

    class FakeProcess:
        def __init__(self):
            self.stdout = iter(["irgendwas ganz anderes\n"])
            self.returncode = 1

        def kill(self):
            pass

        def wait(self):
            return 1

    ergebnis = ripping._handbrake_schleife(FakeProcess(), "/gibt-es-nicht.mkv")
    assert ergebnis["error"].startswith("HandBrake endete mit Code 1")
    assert "irgendwas ganz anderes" in ergebnis["error"]
    assert ergebnis["return_code"] == 1


def test_unbekannter_schalter_schlaegt_den_nichtssagenden_code_null():
    """Der Fall vom 30.08.2026, nachgestellt: HandBrake steigt an einem
    Schalter aus, den es nicht kennt, und meldet das mit 0 als Erfolg.

    Ohne diese Erkennung landete er unten bei „HandBrake meldet Erfolg,
    aber es ist keine Datei entstanden" samt der falschen Vermutung
    „Zielordner nicht beschreibbar" — und die schickte die Suche in die
    vollkommen falsche Richtung.
    """
    import ripping

    class FakeProcess:
        def __init__(self):
            self.stdout = iter([
                "[13:30:54] hb_init: starting libhb thread\n",
                "unknown option (--audio-codec)\n",
                "HandBrake has exited.\n",
            ])
            self.returncode = 0

        def kill(self):
            pass

        def wait(self):
            return 0

    ergebnis = ripping._handbrake_schleife(FakeProcess(), "/gibt-es-nicht.mkv")
    assert ergebnis["status"] == "error"
    assert "--audio-codec" in ergebnis["error"]
    assert "Fehler in Rippy" in ergebnis["error"]
    # ... und NICHT die alte Vermutung über den Zielordner
    assert "beschreibbar" not in ergebnis["error"]


# --- Sprachen der Disc: gemessen an der Akira-Blu-ray (26.07.2026) -----------
#
# Woertlich aus `makemkvcon -r --noscan info dev:/dev/sr0` im Worker-Container
# der Rippy-VM, gekuerzt auf die Attribute, die Rippy liest (AGENTS Regel D).

SINFO_ECHT = """SINFO:0,0,1,6201,"Video"
SINFO:0,0,19,0,"1920x1080"
SINFO:0,0,28,0,"eng"
SINFO:0,0,29,0,"English"
SINFO:0,1,1,6202,"Audio"
SINFO:0,1,3,0,"deu"
SINFO:0,1,4,0,"German"
SINFO:0,1,6,0,"DTS-HD MA"
SINFO:0,1,14,0,"2"
SINFO:0,1,28,0,"eng"
SINFO:0,1,29,0,"English"
SINFO:0,1,30,0,"DTS-HD MA Stereo German"
SINFO:0,2,1,6202,"Audio"
SINFO:0,2,3,0,"jpn"
SINFO:0,2,4,0,"Japanese"
SINFO:0,2,6,0,"DTS-HD MA"
SINFO:0,2,14,0,"6"
SINFO:0,2,30,0,"DTS-HD MA 5.1 Japanese"
SINFO:0,3,1,6203,"Subtitles"
SINFO:0,3,3,0,"deu"
SINFO:0,3,4,0,"German"
SINFO:0,3,6,0,"PGS"
SINFO:1,0,1,6202,"Audio"
SINFO:1,0,3,0,"eng"
SINFO:1,0,4,0,"English"
SINFO:1,0,6,0,"AC3"
"""


def test_streams_werden_nach_typ_getrennt():
    from ripping import parse_stream_info

    je_titel = parse_stream_info(SINFO_ECHT)
    assert set(je_titel) == {0, 1}
    assert [a["lang"] for a in je_titel[0]["audio"]] == ["deu", "jpn"]
    assert [u["lang"] for u in je_titel[0]["untertitel"]] == ["deu"]
    assert je_titel[0]["audio"][1]["kanaele"] == "6"
    assert je_titel[0]["audio"][0]["codec"] == "DTS-HD MA"


def test_die_sprache_steht_in_attribut_3_nicht_28():
    """DIE Falle: 28/29 tragen auf JEDEM Stream "eng"/"English" - auch auf einer
    deutschen Tonspur und auf dem Videostream. Das ist MakeMKVs Anzeigesprache.
    Wer 28 nimmt, haelt jede Disc fuer englisch."""
    from ripping import parse_stream_info

    deutsche_spur = parse_stream_info(SINFO_ECHT)[0]["audio"][0]
    assert deutsche_spur["lang"] == "deu"
    assert deutsche_spur["sprache"] == "German"


def test_video_taucht_nicht_als_tonspur_auf():
    from ripping import parse_stream_info

    je_titel = parse_stream_info(SINFO_ECHT)
    assert all(a["typ"] == "Audio" for a in je_titel[0]["audio"])


def test_sprachen_werden_ueber_alle_titel_vereinigt():
    """Vor dem Rip zaehlt nicht "Titel 3 Stream 7", sondern was die DISC hat."""
    from ripping import parse_stream_info, sprachen_zusammenfassen

    s = sprachen_zusammenfassen(parse_stream_info(SINFO_ECHT))
    assert [a["lang"] for a in s["audio"]] == ["deu", "jpn", "eng"]
    assert [a["sprache"] for a in s["audio"]] == ["German", "Japanese", "English"]
    assert [u["lang"] for u in s["untertitel"]] == ["deu"]
    # deu kommt in Titel 0 einmal vor
    assert s["audio"][0]["spuren"] == 1


def test_leere_ausgabe_gibt_leere_sprachen():
    from ripping import parse_stream_info, sprachen_zusammenfassen

    assert parse_stream_info("") == {}
    assert sprachen_zusammenfassen({}) == {"audio": [], "untertitel": []}
    assert sprachen_zusammenfassen(None) == {"audio": [], "untertitel": []}


# --- Sprachliste aus den Einstellungen --------------------------------------


def test_sprachliste_raeumt_auf():
    from ripping import sprachliste

    assert sprachliste("deu, eng , ,DEU") == ["deu", "eng"]
    assert sprachliste(["deu", "deu", "jpn"]) == ["deu", "jpn"]
    assert sprachliste("") == []
    assert sprachliste(None) == []


def test_grossschreibung_macht_die_auswahl_nicht_unwirksam():
    """HandBrake will ISO-639-2 klein. Ein "DEU" aus einem Eingabefeld darf nicht
    still die ganze Auswahl aushebeln."""
    from ripping import sprachliste

    assert sprachliste("DEU,ENG") == ["deu", "eng"]


# --- Das HandBrake-Kommando -------------------------------------------------


def test_handbrake_kommando_ohne_auswahl_bleibt_wie_bisher():
    from ripping import build_handbrake_cmd

    cmd = build_handbrake_cmd("/a.mkv", "/b.mkv", "H.265 MKV 1080p30")
    assert "--audio-lang-list" not in cmd
    assert "--subtitle-lang-list" not in cmd
    assert "--first-audio" in cmd and "--all-subtitles" in cmd


def test_handbrake_kommando_mit_sprachauswahl():
    """--audio-lang-list zusammen mit --first-audio heisst laut HandBrake-Hilfe:
    nur die erste (beste) Tonspur, die zu einer der Sprachen passen."""
    from ripping import build_handbrake_cmd

    cmd = build_handbrake_cmd("/a.mkv", "/b.mkv", "H.265 MKV 1080p30",
                              audio_sprachen=["deu", "jpn"],
                              untertitel_sprachen=["deu"])
    assert cmd[cmd.index("--audio-lang-list") + 1] == "deu,jpn"
    assert cmd[cmd.index("--subtitle-lang-list") + 1] == "deu"
    assert "--first-audio" in cmd and "--all-subtitles" in cmd


# ── Erst nachsehen, dann rippen (Befund 29.08.2026) ─────────────────────
#
# Commander: „makemkvcon endete mit Code 11 — letzte Meldung: Das Öffnen der
# Disk schlug fehl  — keine MKV-Datei entstanden"
#
# Auffaellig war, was FEHLTE: kein „Ursache:". Waere der Geraetepfad schuld
# gewesen, stuende dort MSG 2024. Bleibt: kein Datentraeger. Nach einem
# fertigen Rip wirft Rippy die Disc aus — ein zweiter Versuch trifft dann ein
# leeres Laufwerk, laeuft zwei Minuten in makemkvcon hinein und meldet einen
# Satz, aus dem niemand das schliessen kann.


def test_ein_leeres_laufwerk_wird_vorher_erkannt():
    import ripping
    from rippy.drives.linux import CDS_NO_DISC

    grund = ripping.disc_fehlt("G:", zustand=lambda p: CDS_NO_DISC)
    assert "Kein Datentraeger" in grund
    assert "wirft Rippy die Disc aus" in grund, "der Grund muss erklaert sein"


def test_offene_schublade_auch():
    import ripping
    from rippy.drives.linux import CDS_TRAY_OPEN

    assert "Schublade" in ripping.disc_fehlt("G:", zustand=lambda p: CDS_TRAY_OPEN)


def test_mit_disc_wird_nicht_gemeckert():
    import ripping
    from rippy.drives.linux import CDS_DISC_OK

    assert ripping.disc_fehlt("G:", zustand=lambda p: CDS_DISC_OK) == ""


def test_ein_fehlgeschlagener_blick_verweigert_den_rip_NICHT():
    """„Ich weiss es nicht" darf nie zu „es geht nicht" werden. Wer das
    Laufwerk gerade nicht lesen kann, weiss nicht, dass es leer ist."""
    import ripping

    def wirft(p):
        raise OSError(5, "Zugriff verweigert")

    assert ripping.disc_fehlt("G:", zustand=wirft) == ""


def test_run_makemkv_sieht_vorher_nach():
    """Waechter: Die Pruefung muss VOR dem Prozessstart stehen, sonst laeuft
    man weiterhin zwei Minuten ins Leere."""
    import inspect

    import ripping

    quelle = inspect.getsource(ripping.run_makemkv)
    vor_popen = quelle.index("subprocess.Popen")
    assert "disc_fehlt(" in quelle[:vor_popen], \
        "die Disc-Pruefung gehoert vor den makemkvcon-Start"


def test_die_sammelmeldung_5010_wird_erklaert():
    """5010 ist MakeMKVs „ging nicht" und sagt fuer sich nichts."""
    from rippy.rip.makemkv_aufruf import KRITISCHE_CODES

    assert 5010 in KRITISCHE_CODES
    assert "Disc" in KRITISCHE_CODES[5010]