"""#278 — torch.compile failures must fall back to eager, never fail generation.

On GPU architectures Triton/Inductor doesn't support yet (e.g. RTX 50-series
Blackwell, sm_120), `torch.compile` succeeds at load time but the *first
generation* dies inside the Dynamo/FX/Inductor stack ("Detected that you are
using FX to symbolically trace a dynamo-optimized function", AssertionError in
torch/_inductor/cudagraph_trees.py) and was mislabeled as an OOM.

These tests pin the contract: compile is an optimization, never a point of
failure — a compile-stack error during generation triggers a one-shot eager
retry, disables compile for the session, and genuine model errors (real OOM,
validation) still propagate unchanged.
"""
from __future__ import annotations

import importlib

import pytest


@pytest.fixture
def engine_env(monkeypatch):
    """The *live* services.engine_env, with the session flag isolated.

    Resolved at test time (not module import time): other tests (e.g.
    tests/backend/test_perf_settings.py) delete and re-import the whole
    ``services`` package mid-session, and the production fallback wrapper's
    runtime ``from services import engine_env`` always resolves the fresh
    module — a module-level import here would assert against a stale one.
    """
    mod = importlib.import_module("services.engine_env")
    monkeypatch.setattr(mod, "_compile_runtime_failure", None)
    return mod


@pytest.fixture
def model_manager(engine_env):
    """The *live* services.model_manager (same rationale as engine_env)."""
    return importlib.import_module("services.model_manager")


# ── helpers ─────────────────────────────────────────────────────────────────


def _dynamo_exc() -> Exception:
    """An exception whose type lives in the torch._dynamo namespace."""

    class TorchRuntimeError(RuntimeError):
        pass

    TorchRuntimeError.__module__ = "torch._dynamo.exc"
    return TorchRuntimeError("backend='inductor' raised")


def _fx_trace_exc() -> Exception:
    """The exact failure mode from issue #278's logs (message-based)."""
    return RuntimeError(
        "Detected that you are using FX to symbolically trace "
        "a dynamo-optimized function. This is not supported at the moment."
    )


def _cudagraph_assertion() -> BaseException:
    """A bare AssertionError raised from torch/_inductor/cudagraph_trees.py.

    Compiles a snippet under that filename so the traceback frame carries the
    inductor path — exactly what the real cudagraph_trees failure looks like
    (no message, builtin type; only the traceback identifies it).
    """
    src = "def boom():\n    raise AssertionError\n"
    ns: dict = {}
    exec(compile(src, "/x/site-packages/torch/_inductor/cudagraph_trees.py", "exec"), ns)
    try:
        ns["boom"]()
    except AssertionError as e:
        return e
    raise RuntimeError("unreachable")


class _FakeCompiledLLM:
    """Stands in for torch.compile's OptimizedModule (has ``_orig_mod``)."""

    def __init__(self, orig):
        self._orig_mod = orig


class _FakeModel:
    """Model whose ``generate`` raises the given exceptions, in order, then
    succeeds."""

    def __init__(self, failures):
        self.eager_llm = object()
        self.llm = _FakeCompiledLLM(self.eager_llm)
        self.calls = 0
        self._failures = list(failures)

    def generate(self, *args, **kwargs):
        self.calls += 1
        if self._failures:
            raise self._failures.pop(0)
        return ["audio-tensor"]


# ── _is_compile_runtime_failure classification ──────────────────────────────


def test_detects_dynamo_module_exception(model_manager):
    assert model_manager._is_compile_runtime_failure(_dynamo_exc()) is True


def test_detects_fx_symbolic_trace_message(model_manager):
    assert model_manager._is_compile_runtime_failure(_fx_trace_exc()) is True


def test_detects_inductor_traceback_frames(model_manager):
    # Bare AssertionError — only the traceback file path identifies it.
    assert model_manager._is_compile_runtime_failure(_cudagraph_assertion()) is True


def test_detects_compile_error_wrapped_in_chain(model_manager):
    try:
        try:
            raise _fx_trace_exc()
        except RuntimeError as inner:
            raise RuntimeError("TTS engine stopped mid-generation") from inner
    except RuntimeError as outer:
        assert model_manager._is_compile_runtime_failure(outer) is True


def test_real_oom_is_not_classified_as_compile_failure(model_manager):
    exc = RuntimeError("CUDA out of memory. Tried to allocate 2.50 GiB")
    assert model_manager._is_compile_runtime_failure(exc) is False


def test_validation_error_is_not_classified(model_manager):
    assert model_manager._is_compile_runtime_failure(ValueError("bad preset")) is False


# ── generate() fallback wrapper ─────────────────────────────────────────────


def test_compile_failure_falls_back_to_eager_and_succeeds(engine_env, model_manager):
    model = _FakeModel(failures=[_fx_trace_exc()])
    model_manager._install_compile_fallback(model)

    result = model.generate(text="hello")

    assert result == ["audio-tensor"]
    assert model.calls == 2  # compiled attempt + eager retry
    assert model.llm is model.eager_llm  # compiled module swapped out
    # Compile is disabled for the rest of the session...
    assert engine_env._compile_runtime_failure is not None
    # ...so the next load goes straight to eager.
    assert engine_env.should_torch_compile("cuda") is False


def test_cudagraph_assertion_falls_back_to_eager(engine_env, model_manager):
    model = _FakeModel(failures=[_cudagraph_assertion()])
    model_manager._install_compile_fallback(model)

    assert model.generate(text="hello") == ["audio-tensor"]
    assert model.calls == 2
    assert model.llm is model.eager_llm


def test_non_compile_error_propagates_unchanged(engine_env, model_manager):
    model = _FakeModel(failures=[ValueError("bad input")])
    model_manager._install_compile_fallback(model)

    with pytest.raises(ValueError, match="bad input"):
        model.generate(text="hello")

    assert model.calls == 1  # no retry
    assert isinstance(model.llm, _FakeCompiledLLM)  # compiled module kept
    assert engine_env._compile_runtime_failure is None  # compile stays enabled


def test_no_fallback_when_already_eager(engine_env, model_manager):
    """If llm has no ``_orig_mod`` (already eager) the error propagates."""
    model = _FakeModel(failures=[_fx_trace_exc()])
    model.llm = object()  # no _orig_mod
    model_manager._install_compile_fallback(model)

    with pytest.raises(RuntimeError):
        model.generate(text="hello")
    assert model.calls == 1


def test_eager_retry_failure_is_not_misclassified(engine_env, model_manager):
    """If the eager retry then hits a *real* error (e.g. OOM), the propagated
    exception must not be classified as a compile failure via the chained
    original compile error."""
    real_oom = RuntimeError("CUDA out of memory. Tried to allocate 2.50 GiB")
    model = _FakeModel(failures=[_dynamo_exc(), real_oom])
    model_manager._install_compile_fallback(model)

    with pytest.raises(RuntimeError) as excinfo:
        model.generate(text="hello")

    assert excinfo.value is real_oom
    assert model_manager._is_compile_runtime_failure(excinfo.value) is False