"""
v6 behavior tests — per-file av1an→ffmpeg fallback.

Verifies that when av1an fails for a specific file (concat failure,
scene-detection panic, or other per-file issue), the encoder automatically
retries with the ffmpeg fallback path.
"""
import importlib.util
import os
import shutil
import subprocess
import sys
from pathlib import Path
from unittest.mock import MagicMock

import pytest


V3_PATH = Path(__file__).resolve().parent.parent / "open-transcode.v3.py"


def _load_v3_module():
    if not V3_PATH.exists():
        pytest.skip(f"v3 source not found at {V3_PATH}")
    _install_pyside6_stubs()
    spec = importlib.util.spec_from_file_location("open_transcode_v3", str(V3_PATH))
    mod = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(mod)
    return mod


def _install_pyside6_stubs():
    if any(name in sys.modules for name in
           ("PySide6", "PySide6.QtWidgets", "PySide6.QtCore", "PySide6.QtGui")):
        return
    import types
    pyside6 = types.ModuleType("PySide6")
    qt_widgets = types.ModuleType("PySide6.QtWidgets")
    qt_core = types.ModuleType("PySide6.QtCore")
    qt_gui = types.ModuleType("PySide6.QtGui")

    class _QThread:
        def __init__(self, *a, **kw): pass
        def start(self): pass
        def isRunning(self): return False
        def wait(self, ms=None): pass

    class _Signal:
        def __init__(self, *a, **kw): pass
        def connect(self, *a, **kw): pass
        def emit(self, *a, **kw): pass

    def _Slot(*a, **kw):
        def deco(fn): return fn
        return deco

    qt_core.QThread = _QThread
    qt_core.Signal = _Signal
    qt_core.Slot = _Slot
    qt_core.Qt = MagicMock()
    qt_core.QPointF = MagicMock()
    qt_core.QRectF = MagicMock()
    qt_core.QTimer = MagicMock()

    class _QWidget:
        def __init__(self, *a, **kw): pass
    class _QMainWindow(_QWidget): pass
    qt_widgets.QWidget = _QWidget
    qt_widgets.QMainWindow = _QMainWindow
    for name in ("QApplication", "QVBoxLayout", "QHBoxLayout", "QLabel",
                 "QLineEdit", "QPushButton", "QComboBox", "QCheckBox",
                 "QTextEdit", "QFileDialog", "QGroupBox", "QStatusBar",
                 "QMessageBox", "QStyleFactory"):
        setattr(qt_widgets, name, MagicMock())

    for n in ("QFont", "QPalette", "QColor", "QPainter", "QPen", "QBrush",
              "QRadialGradient", "QFontMetrics"):
        setattr(qt_gui, n, MagicMock())

    pyside6.QtWidgets = qt_widgets
    pyside6.QtCore = qt_core
    pyside6.QtGui = qt_gui
    sys.modules["PySide6"] = pyside6
    sys.modules["PySide6.QtWidgets"] = qt_widgets
    sys.modules["PySide6.QtCore"] = qt_core
    sys.modules["PySide6.QtGui"] = qt_gui


@pytest.fixture(scope="module")
def v3_module():
    return _load_v3_module()


class TestCanFfmpegFallback:
    """v6-01: _can_ffmpeg_fallback checks if ffmpeg has the encoder."""

    def test_returns_true_when_ffmpeg_has_encoder(self, v3_module):
        """When ffmpeg_libs has the encoder, _can_ffmpeg_fallback returns True."""
        worker = v3_module.EncoderWorker.__new__(v3_module.EncoderWorker)
        worker.video_codec = MagicMock()
        worker.video_codec.ffmpeg_encoder = "libsvtav1"
        worker.env = MagicMock()
        worker.env.ffmpeg_libs = {"libsvtav1": True, "libx265": True}

        assert worker._can_ffmpeg_fallback() is True

    def test_returns_false_when_ffmpeg_lacks_encoder(self, v3_module):
        """When ffmpeg_libs does NOT have the encoder, returns False."""
        worker = v3_module.EncoderWorker.__new__(v3_module.EncoderWorker)
        worker.video_codec = MagicMock()
        worker.video_codec.ffmpeg_encoder = "libsvtav1"
        worker.env = MagicMock()
        worker.env.ffmpeg_libs = {"libsvtav1": False, "libx265": True}

        assert worker._can_ffmpeg_fallback() is False


class TestErrorPatternsIncludeSplitScores:
    """v6-02: 'split scores is not empty' panic is in the error_patterns table."""

    def test_split_scores_pattern_in_source(self, v3_module):
        """The error_patterns table should include the 'split scores' pattern."""
        src = Path(V3_PATH).read_text()
        assert "split scores is not empty" in src, \
            "error_patterns table should include 'split scores is not empty'"

    def test_summary_detection_in_source(self, v3_module):
        """v6-03: SUMMARY + Average Speed detection for concat failures."""
        src = Path(V3_PATH).read_text()
        assert "SUMMARY" in src and "Average Speed" in src, \
            "Should detect encoder SUMMARY block for concat failure diagnosis"


class TestPerFileFallbackRetry:
    """v6-01: When av1an fails, retry with ffmpeg fallback."""

    def test_av1an_failure_triggers_ffmpeg_retry(self, v3_module, tmp_path):
        """When av1an fails (non-systematic) and ffmpeg has the encoder,
        the code should retry with _ffmpeg_fallback_encode."""
        # Create a real test video
        ffmpeg_bin = shutil.which("ffmpeg")
        if not ffmpeg_bin:
            pytest.skip("ffmpeg not available")

        test_video = tmp_path / "input.mp4"
        subprocess.run(
            [ffmpeg_bin, "-f", "lavfi", "-i", "testsrc=duration=1:size=64x64:rate=24",
             "-c:v", "libx264", "-y", str(test_video)],
            capture_output=True, timeout=15,
        )
        if not test_video.exists():
            pytest.skip("Could not generate test video")

        # Build a worker in av1an mode (not ffmpeg fallback)
        av1_codec = next(c for c in v3_module.VIDEO_CODECS if c.label == "AV1 (SVT-AV1)")
        opus_audio = next(a for a in v3_module.AUDIO_PROFILES if a.label == "Opus (96k)")
        mkv_container = next(c for c in v3_module.CONTAINER_PROFILES if c.ext == "mkv")
        original_res = next(r for r in v3_module.RESOLUTION_PRESETS if r.category == "original")

        env = v3_module.probe_environment()
        # Set fake av1an path + flags so the command builder doesn't crash
        env.av1an_path = "/usr/bin/av1an"
        env.av1an_flags = {
            "worker": "--workers",
            "video_params": "--video-params",
            "audio_params": "--audio-params",
            "svt_name": "svt-av1",
            "concat_method": "ffmpeg",
        }

        worker = v3_module.EncoderWorker(
            in_dir=tmp_path,
            out_dir=tmp_path / "output",
            video_codec=av1_codec,
            audio_profile=opus_audio,
            container=mkv_container,
            crf=32,
            preset_label="Fast (4)",
            delete_source=False,
            env=env,
            extensions={".mp4"},
            resolution=original_res,
            use_ffmpeg_fallback=False,  # av1an mode — will fail and retry
        )

        # Mock _run_with_stop_check to simulate av1an failure
        # (return a SUMMARY block in stderr + non-zero exit code = concat failure)
        def mock_run(cmd, **kw):
            # Simulate av1an encoding all frames then failing at concat
            fake_stderr = (
                "Encoding: 24/24 Frames @ 3.52 fps\n"
                "SUMMARY -----------------------------------------\n"
                "Total Frames\t\tFrame Rate\t\tByte Count\n"
                "          24\t\t23.98 fps\t\t   12345\n\n"
                "Average Speed:\t\t3.598 fps\n"
                "SvtMalloc[info]: you have no memory leak\n\n"
                "source pipe stderr:\n\n"
                "ffmpeg pipe stderr:\n\n"
            )
            return ("ok", 1, "", fake_stderr)

        worker._run_with_stop_check = mock_run

        # Mock _ffmpeg_fallback_encode to simulate success
        def mock_ffmpeg_fallback(file_path, encode_input, output_f):
            # Create the output file so the verify step passes
            output_f.parent.mkdir(parents=True, exist_ok=True)
            output_f.write_bytes(b"\x00" * 1024)  # 1KB fake output
            return True

        worker._ffmpeg_fallback_encode = mock_ffmpeg_fallback

        logs = []
        worker.log_msg.emit = lambda msg: logs.append(msg)

        # Set up _current_temps and _file_res_map (needed by _process_one_file)
        worker._current_temps = []
        worker._file_res_map = {}
        worker._stop = False
        worker._consecutive_fail_count = 0
        worker._last_fail_pattern = None

        # Call _encode_one directly
        output_f = tmp_path / "output" / "input_archived.mkv"
        result = worker._encode_one(test_video, test_video, output_f, 1)

        # Should have retried with ffmpeg and succeeded
        assert result is True, f"Expected retry to succeed. Logs: {logs}"

        # Should have logged the RETRY message
        assert any("RETRY" in l and "ffmpeg fallback" in l for l in logs), \
            f"Expected RETRY message in logs: {logs}"

        # Should have logged RETRY OK
        assert any("RETRY OK" in l for l in logs), \
            f"Expected RETRY OK in logs: {logs}"

        # fail_count should NOT be incremented (retry succeeded)
        assert worker.fail_count == 0, \
            f"fail_count should be 0 after successful retry, got {worker.fail_count}"

    def test_av1an_failure_no_retry_when_ffmpeg_lacks_encoder(self, v3_module, tmp_path):
        """When av1an fails and ffmpeg does NOT have the encoder,
        no retry should happen — just increment fail_count and return False."""
        ffmpeg_bin = shutil.which("ffmpeg")
        if not ffmpeg_bin:
            pytest.skip("ffmpeg not available")

        test_video = tmp_path / "input.mp4"
        test_video.write_bytes(b"\x00" * 1024)  # fake video

        av1_codec = next(c for c in v3_module.VIDEO_CODECS if c.label == "AV1 (SVT-AV1)")
        opus_audio = next(a for a in v3_module.AUDIO_PROFILES if a.label == "Opus (96k)")
        mkv_container = next(c for c in v3_module.CONTAINER_PROFILES if c.ext == "mkv")
        original_res = next(r for r in v3_module.RESOLUTION_PRESETS if r.category == "original")

        # Build env with libsvtav1=False — can't fallback
        env = v3_module.probe_environment()
        env.av1an_path = "/usr/bin/av1an"
        env.av1an_flags = {
            "worker": "--workers",
            "video_params": "--video-params",
            "audio_params": "--audio-params",
            "svt_name": "svt-av1",
            "concat_method": "ffmpeg",
        }
        env.ffmpeg_libs["libsvtav1"] = False

        worker = v3_module.EncoderWorker(
            in_dir=tmp_path,
            out_dir=tmp_path / "output",
            video_codec=av1_codec,
            audio_profile=opus_audio,
            container=mkv_container,
            crf=32,
            preset_label="Fast (4)",
            delete_source=False,
            env=env,
            extensions={".mp4"},
            resolution=original_res,
            use_ffmpeg_fallback=False,
        )

        # Mock av1an failure
        def mock_run(cmd, **kw):
            return ("ok", 1, "", "some av1an error")
        worker._run_with_stop_check = mock_run

        # Mock _ffmpeg_fallback_encode — should NOT be called
        worker._ffmpeg_fallback_encode = MagicMock(return_value=True)

        logs = []
        worker.log_msg.emit = lambda msg: logs.append(msg)
        worker._current_temps = []
        worker._stop = False

        output_f = tmp_path / "output" / "input_archived.mkv"
        result = worker._encode_one(test_video, test_video, output_f, 1)

        # Should fail (no retry possible)
        assert result is False
        assert worker.fail_count == 1
        # _ffmpeg_fallback_encode should NOT have been called
        worker._ffmpeg_fallback_encode.assert_not_called()
        # Should NOT have logged RETRY
        assert not any("RETRY" in l for l in logs)

    def test_systematic_failure_does_not_retry(self, v3_module, tmp_path):
        """When av1an fails with a systematic issue (VSScript API),
        self._stop is set and no retry should happen."""
        ffmpeg_bin = shutil.which("ffmpeg")
        if not ffmpeg_bin:
            pytest.skip("ffmpeg not available")

        test_video = tmp_path / "input.mp4"
        test_video.write_bytes(b"\x00" * 1024)

        av1_codec = next(c for c in v3_module.VIDEO_CODECS if c.label == "AV1 (SVT-AV1)")
        opus_audio = next(a for a in v3_module.AUDIO_PROFILES if a.label == "Opus (96k)")
        mkv_container = next(c for c in v3_module.CONTAINER_PROFILES if c.ext == "mkv")
        original_res = next(r for r in v3_module.RESOLUTION_PRESETS if r.category == "original")

        env = v3_module.probe_environment()
        env.av1an_path = "/usr/bin/av1an"
        env.av1an_flags = {
            "worker": "--workers",
            "video_params": "--video-params",
            "audio_params": "--audio-params",
            "svt_name": "svt-av1",
            "concat_method": "ffmpeg",
        }

        worker = v3_module.EncoderWorker(
            in_dir=tmp_path,
            out_dir=tmp_path / "output",
            video_codec=av1_codec,
            audio_profile=opus_audio,
            container=mkv_container,
            crf=32,
            preset_label="Fast (4)",
            delete_source=False,
            env=env,
            extensions={".mp4"},
            resolution=original_res,
            use_ffmpeg_fallback=False,
        )

        # Mock av1an VSScript failure — this sets self._stop = True
        def mock_run(cmd, **kw):
            return ("ok", 1, "", "Failed to get VSScript API")
        worker._run_with_stop_check = mock_run

        worker._ffmpeg_fallback_encode = MagicMock(return_value=True)

        logs = []
        worker.log_msg.emit = lambda msg: logs.append(msg)
        worker._current_temps = []
        worker._stop = False  # will be set by the pattern matcher

        output_f = tmp_path / "output" / "input_archived.mkv"
        result = worker._encode_one(test_video, test_video, output_f, 1)

        # Should fail — systematic issue, no retry
        assert result is False
        assert worker._stop is True, "VSScript failure should set _stop"
        # _ffmpeg_fallback_encode should NOT have been called (self._stop is True)
        worker._ffmpeg_fallback_encode.assert_not_called()
        # Should NOT have logged RETRY
        assert not any("RETRY" in l for l in logs)