"""Stress tests for all history-walking ``muse code`` analytics commands.

The mega-suite (test_code_commands.py) has comprehensive CLI integration
coverage for each command.  This file adds the missing stress layer:
a large repo with many commits and symbols to verify that each command
completes in a reasonable time, emits valid JSON, and handles filters
correctly under load.

Stress budget per command: < 15 s on a standard developer machine.

Commands covered
----------------
muse code hotspots       — symbol churn leaderboard
muse code stable         — symbol stability leaderboard
muse code coupling       — file-level co-change
muse code compare        — symbol diff between refs
muse code blast-risk     — impact risk score
muse code age            — symbol age / staleness
muse code velocity       — commit velocity by module
muse code entangle       — cross-module coupling
muse code narrative      — prose timeline
muse code gravity        — call-graph gravity
muse code contract       — type/call contract inference
muse code predict        — change prediction
muse code semantic-test-coverage — test coverage mapping
"""

from __future__ import annotations

import json
import pathlib
import textwrap
import time
from collections.abc import Generator

import pytest

from tests.cli_test_helper import CliRunner

cli = None
runner = CliRunner()

# ── Time budget (generous to avoid flakiness on CI) ─────────────────────────

_TIME_BUDGET_S: float = 15.0


# ---------------------------------------------------------------------------
# Shared large repo fixture — built once per module
# ---------------------------------------------------------------------------


@pytest.fixture(scope="module")
def large_repo(tmp_path_factory: pytest.TempPathFactory) -> Generator[pathlib.Path, None, None]:
    """Repo with 30 commits across 6 Python modules (~180 total symbol events).

    Module relationships:
      billing.py imports from utils.py
      auth.py imports from utils.py
      report.py imports from billing.py and auth.py
      api.py imports from report.py
      tests/test_billing.py imports from billing.py
    """
    tmp_path = tmp_path_factory.mktemp("large_analytics_repo")

    import os
    _prev_root = os.environ.get("MUSE_REPO_ROOT")
    _prev_cwd = os.getcwd()
    os.environ["MUSE_REPO_ROOT"] = str(tmp_path)
    os.chdir(tmp_path)

    r = runner.invoke(cli, ["init", "--domain", "code"])
    assert r.exit_code == 0, r.output

    (tmp_path / "tests").mkdir()

    # Commit 0 — scaffold all modules.
    (tmp_path / "utils.py").write_text(textwrap.dedent("""\
        def validate(amount: float) -> bool:
            return amount > 0

        def format_currency(amount: float) -> str:
            return f"${amount:.2f}"
    """))
    (tmp_path / "billing.py").write_text(textwrap.dedent("""\
        from utils import validate, format_currency

        class Invoice:
            def compute_total(self, items: list[float]) -> float:
                return sum(items)

            def apply_discount(self, total: float, rate: float) -> float:
                return total * (1 - rate)

        def process(invoice: Invoice, items: list[float]) -> str:
            total = invoice.compute_total(items)
            return format_currency(total)
    """))
    (tmp_path / "auth.py").write_text(textwrap.dedent("""\
        from utils import validate

        def authenticate(token: str) -> bool:
            return validate(len(token))

        def authorise(user: str, action: str) -> bool:
            return bool(user) and bool(action)
    """))
    (tmp_path / "report.py").write_text(textwrap.dedent("""\
        from billing import Invoice, process
        from auth import authenticate

        def generate_report(user: str, items: list[float]) -> dict[str, str | float]:
            if not authenticate(user):
                return {}
            inv = Invoice()
            return {"total": inv.compute_total(items), "result": process(inv, items)}
    """))
    (tmp_path / "api.py").write_text(textwrap.dedent("""\
        from report import generate_report

        def handle_request(user: str, payload: list[float]) -> dict[str, str | float]:
            return generate_report(user, payload)

        def health_check() -> bool:
            return True
    """))
    (tmp_path / "tests" / "test_billing.py").write_text(textwrap.dedent("""\
        from billing import Invoice, process

        def test_compute_total() -> None:
            inv = Invoice()
            assert inv.compute_total([1.0, 2.0]) == 3.0

        def test_apply_discount() -> None:
            inv = Invoice()
            assert inv.apply_discount(100.0, 0.1) == 90.0

        def test_process() -> None:
            inv = Invoice()
            assert "$" in process(inv, [10.0])
    """))
    runner.invoke(cli, ["code", "add", "."])
    r = runner.invoke(cli, ["commit", "-m", "scaffold all modules"])
    assert r.exit_code == 0, r.output

    # Commits 1–9 — iterative modifications to billing.py
    discounts = [0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.35, 0.40, 0.45]
    for i, rate in enumerate(discounts):
        (tmp_path / "billing.py").write_text(textwrap.dedent(f"""\
            from utils import validate, format_currency

            class Invoice:
                def compute_total(self, items: list[float]) -> float:
                    return sum(items)

                def apply_discount(self, total: float, rate: float = {rate}) -> float:
                    return total * (1 - rate)

            def process(invoice: Invoice, items: list[float]) -> str:
                total = invoice.compute_total(items)
                if not validate(total):
                    raise ValueError("invalid total")
                return format_currency(total)
        """))
        runner.invoke(cli, ["code", "add", "billing.py"])
        r = runner.invoke(cli, ["commit", "-m", f"billing: update discount default to {rate}"])
        assert r.exit_code == 0, r.output

    # Commits 10–14 — iterative modifications to auth.py
    for i in range(5):
        (tmp_path / "auth.py").write_text(textwrap.dedent(f"""\
            from utils import validate

            MIN_TOKEN_LEN: int = {8 + i}

            def authenticate(token: str) -> bool:
                return validate(len(token) - MIN_TOKEN_LEN)

            def authorise(user: str, action: str) -> bool:
                return bool(user) and bool(action) and len(user) > {i}
        """))
        runner.invoke(cli, ["code", "add", "auth.py"])
        r = runner.invoke(cli, ["commit", "-m", f"auth: tighten token min length to {8 + i}"])
        assert r.exit_code == 0, r.output

    # Commits 15–19 — add helpers to utils.py
    helpers = ["clamp", "round_up", "is_positive", "is_negative", "safe_divide"]
    utils_lines = [
        "def validate(amount: float) -> bool:\n    return amount > 0\n",
        "def format_currency(amount: float) -> str:\n    return f'${amount:.2f}'\n",
    ]
    for i, helper in enumerate(helpers):
        utils_lines.append(f"def {helper}(x: float) -> float:\n    return float(x)\n")
        (tmp_path / "utils.py").write_text("\n".join(utils_lines))
        runner.invoke(cli, ["code", "add", "utils.py"])
        r = runner.invoke(cli, ["commit", "-m", f"utils: add {helper}"])
        assert r.exit_code == 0, r.output

    # Commits 20–24 — add API endpoints to api.py
    for i in range(5):
        (tmp_path / "api.py").write_text(textwrap.dedent(f"""\
            from report import generate_report

            def handle_request(user: str, payload: list[float]) -> dict[str, str | float]:
                return generate_report(user, payload)

            def health_check() -> bool:
                return True

            def endpoint_{i:02d}(x: float) -> float:
                return float(x)
        """))
        runner.invoke(cli, ["code", "add", "api.py"])
        r = runner.invoke(cli, ["commit", "-m", f"api: add endpoint_{i:02d}"])
        assert r.exit_code == 0, r.output

    # Commits 25–29 — modify report.py
    for i in range(5):
        (tmp_path / "report.py").write_text(textwrap.dedent(f"""\
            from billing import Invoice, process
            from auth import authenticate

            REPORT_VERSION: int = {i + 1}

            def generate_report(user: str, items: list[float]) -> dict[str, str | float | int]:
                if not authenticate(user):
                    return {{}}
                inv = Invoice()
                return {{
                    "version": REPORT_VERSION,
                    "total": inv.compute_total(items),
                    "result": process(inv, items),
                }}
        """))
        runner.invoke(cli, ["code", "add", "report.py"])
        r = runner.invoke(cli, ["commit", "-m", f"report: version {i + 1}"])
        assert r.exit_code == 0, r.output

    yield tmp_path

    # Restore environment so subsequent test modules see a clean state.
    os.chdir(_prev_cwd)
    if _prev_root is None:
        os.environ.pop("MUSE_REPO_ROOT", None)
    else:
        os.environ["MUSE_REPO_ROOT"] = _prev_root


# ---------------------------------------------------------------------------
# Helper
# ---------------------------------------------------------------------------


def _assert_under_budget(elapsed: float, cmd: str) -> None:
    assert elapsed < _TIME_BUDGET_S, (
        f"'{cmd}' took {elapsed:.1f}s — exceeds {_TIME_BUDGET_S}s budget"
    )


# ---------------------------------------------------------------------------
# muse code hotspots — stress
# ---------------------------------------------------------------------------


class TestHotspotsStress:
    def test_exits_zero_on_large_repo(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "hotspots"])
        assert result.exit_code == 0, result.output

    def test_json_schema_correct(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "hotspots", "--json"])
        assert result.exit_code == 0, result.output
        data = json.loads(result.output)
        assert "hotspots" in data
        assert "commits_analysed" in data

    def test_completes_under_budget(self, large_repo: pathlib.Path) -> None:
        start = time.monotonic()
        runner.invoke(cli, ["code", "hotspots", "--json"])
        _assert_under_budget(time.monotonic() - start, "hotspots --json")

    def test_top_n_respected(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "hotspots", "--top", "5", "--json"])
        assert result.exit_code == 0
        data = json.loads(result.output)
        assert len(data["hotspots"]) <= 5

    def test_kind_filter(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "hotspots", "--kind", "function", "--json"])
        assert result.exit_code == 0
        data = json.loads(result.output)
        for h in data["hotspots"]:
            assert h.get("kind") in (None, "function", "method")

    def test_min_changes_filter(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "hotspots", "--min", "5", "--json"])
        assert result.exit_code == 0

    def test_from_to_range(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "hotspots", "--from", "HEAD~10", "--to", "HEAD", "--json"])
        assert result.exit_code == 0


# ---------------------------------------------------------------------------
# muse code stable — stress
# ---------------------------------------------------------------------------


class TestStableStress:
    def test_exits_zero_on_large_repo(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "stable"])
        assert result.exit_code == 0, result.output

    def test_json_schema_correct(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "stable", "--json"])
        assert result.exit_code == 0, result.output
        data = json.loads(result.output)
        assert "stable" in data
        assert "commits_analysed" in data

    def test_completes_under_budget(self, large_repo: pathlib.Path) -> None:
        start = time.monotonic()
        runner.invoke(cli, ["code", "stable", "--json"])
        _assert_under_budget(time.monotonic() - start, "stable --json")

    def test_top_n_respected(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "stable", "--top", "3", "--json"])
        assert result.exit_code == 0
        data = json.loads(result.output)
        assert len(data["stable"]) <= 3

    def test_kind_filter_function(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "stable", "--kind", "function", "--json"])
        assert result.exit_code == 0


# ---------------------------------------------------------------------------
# muse code coupling — stress
# ---------------------------------------------------------------------------


class TestCouplingStress:
    def test_exits_zero_on_large_repo(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "coupling"])
        assert result.exit_code == 0, result.output

    def test_json_schema_correct(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "coupling", "--json"])
        assert result.exit_code == 0
        data = json.loads(result.output)
        assert "pairs" in data

    def test_completes_under_budget(self, large_repo: pathlib.Path) -> None:
        start = time.monotonic()
        runner.invoke(cli, ["code", "coupling", "--json"])
        _assert_under_budget(time.monotonic() - start, "coupling --json")

    def test_top_n_respected(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "coupling", "--top", "5", "--json"])
        assert result.exit_code == 0
        data = json.loads(result.output)
        assert len(data["pairs"]) <= 5

    def test_min_filter(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "coupling", "--min", "2", "--json"])
        assert result.exit_code == 0
        data = json.loads(result.output)
        for c in data["pairs"]:
            assert c["count"] >= 2


# ---------------------------------------------------------------------------
# muse code compare — stress
# ---------------------------------------------------------------------------


class TestCompareStress:
    def test_exits_zero_on_large_repo(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "compare", "HEAD~5", "HEAD"])
        assert result.exit_code == 0, result.output

    def test_json_schema_correct(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "compare", "HEAD~5", "HEAD", "--json"])
        assert result.exit_code == 0
        data = json.loads(result.output)
        # compare returns from/to refs and an ops list (or stat breakdown).
        assert "from" in data or "ops" in data or "stat" in data

    def test_completes_under_budget(self, large_repo: pathlib.Path) -> None:
        start = time.monotonic()
        runner.invoke(cli, ["code", "compare", "HEAD~10", "HEAD", "--json"])
        _assert_under_budget(time.monotonic() - start, "compare HEAD~10 HEAD")

    def test_kind_filter_function(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, [
            "code", "compare", "HEAD~5", "HEAD", "--kind", "function", "--json",
        ])
        assert result.exit_code == 0

    def test_same_refs_empty_diff(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "compare", "HEAD", "HEAD", "--json"])
        assert result.exit_code == 0
        data = json.loads(result.output)
        # With identical refs, ops list should be empty and stat should show 0 changes.
        ops = data.get("ops", [])
        assert len(ops) == 0


# ---------------------------------------------------------------------------
# muse code blast-risk — stress
# ---------------------------------------------------------------------------


class TestBlastRiskStress:
    def test_exits_zero_on_large_repo(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "blast-risk"])
        assert result.exit_code == 0, result.output

    def test_json_schema_correct(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "blast-risk", "--json"])
        assert result.exit_code == 0
        data = json.loads(result.output)
        assert "symbols" in data

    def test_completes_under_budget(self, large_repo: pathlib.Path) -> None:
        start = time.monotonic()
        runner.invoke(cli, ["code", "blast-risk", "--json"])
        _assert_under_budget(time.monotonic() - start, "blast-risk --json")

    def test_top_n_respected(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "blast-risk", "--top", "5", "--json"])
        assert result.exit_code == 0
        data = json.loads(result.output)
        assert len(data["symbols"]) <= 5


# ---------------------------------------------------------------------------
# muse code age — stress
# ---------------------------------------------------------------------------


class TestAgeStress:
    def test_exits_zero_on_large_repo(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "age"])
        assert result.exit_code == 0, result.output

    def test_json_schema_correct(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "age", "--json"])
        assert result.exit_code == 0
        data = json.loads(result.output)
        assert "symbols" in data

    def test_completes_under_budget(self, large_repo: pathlib.Path) -> None:
        start = time.monotonic()
        runner.invoke(cli, ["code", "age", "--json"])
        _assert_under_budget(time.monotonic() - start, "age --json")

    def test_top_n_respected(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "age", "--top", "5", "--json"])
        assert result.exit_code == 0
        data = json.loads(result.output)
        assert len(data["symbols"]) <= 5

    def test_kind_filter(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "age", "--kind", "function", "--json"])
        assert result.exit_code == 0


# ---------------------------------------------------------------------------
# muse code velocity — stress
# ---------------------------------------------------------------------------


class TestVelocityStress:
    def test_exits_zero_on_large_repo(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "velocity"])
        assert result.exit_code == 0, result.output

    def test_json_schema_correct(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "velocity", "--json"])
        assert result.exit_code == 0
        data = json.loads(result.output)
        assert "modules" in data

    def test_completes_under_budget(self, large_repo: pathlib.Path) -> None:
        start = time.monotonic()
        runner.invoke(cli, ["code", "velocity", "--json"])
        _assert_under_budget(time.monotonic() - start, "velocity --json")

    def test_window_flag(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "velocity", "--window", "10", "--json"])
        assert result.exit_code == 0


# ---------------------------------------------------------------------------
# muse code entangle — stress
# ---------------------------------------------------------------------------


class TestEntangleStress:
    def test_exits_zero_on_large_repo(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "entangle"])
        assert result.exit_code == 0, result.output

    def test_json_schema_correct(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "entangle", "--json"])
        assert result.exit_code == 0
        data = json.loads(result.output)
        assert "pairs" in data

    def test_completes_under_budget(self, large_repo: pathlib.Path) -> None:
        start = time.monotonic()
        runner.invoke(cli, ["code", "entangle", "--json"])
        _assert_under_budget(time.monotonic() - start, "entangle --json")

    def test_top_n_respected(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "entangle", "--top", "5", "--json"])
        assert result.exit_code == 0
        data = json.loads(result.output)
        assert len(data["pairs"]) <= 5


# ---------------------------------------------------------------------------
# muse code narrative — stress
# ---------------------------------------------------------------------------


class TestNarrativeStress:
    def test_exits_zero_on_large_repo(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "narrative", "billing.py::Invoice.apply_discount"])
        assert result.exit_code == 0, result.output

    def test_json_schema_correct(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, [
            "code", "narrative", "billing.py::Invoice.apply_discount", "--json",
        ])
        assert result.exit_code == 0
        data = json.loads(result.output)
        assert "address" in data
        assert "events" in data

    def test_completes_under_budget(self, large_repo: pathlib.Path) -> None:
        start = time.monotonic()
        runner.invoke(cli, [
            "code", "narrative", "billing.py::Invoice.apply_discount", "--json",
        ])
        _assert_under_budget(time.monotonic() - start, "narrative billing.py::... --json")

    def test_format_prose_mode(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, [
            "code", "narrative", "billing.py::Invoice.apply_discount", "--format", "prose",
        ])
        assert result.exit_code == 0


# ---------------------------------------------------------------------------
# muse code gravity — stress
# ---------------------------------------------------------------------------


class TestGravityStress:
    def test_exits_zero_on_large_repo(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "gravity"])
        assert result.exit_code == 0, result.output

    def test_json_schema_correct(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "gravity", "--json"])
        assert result.exit_code == 0
        data = json.loads(result.output)
        assert "symbols" in data

    def test_completes_under_budget(self, large_repo: pathlib.Path) -> None:
        start = time.monotonic()
        runner.invoke(cli, ["code", "gravity", "--json"])
        _assert_under_budget(time.monotonic() - start, "gravity --json")

    def test_top_n_respected(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "gravity", "--top", "5", "--json"])
        assert result.exit_code == 0
        data = json.loads(result.output)
        assert len(data["symbols"]) <= 5


# ---------------------------------------------------------------------------
# muse code contract — stress
# ---------------------------------------------------------------------------


class TestContractStress:
    def test_exits_zero_on_large_repo(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "contract", "billing.py::Invoice.compute_total"])
        assert result.exit_code == 0, result.output

    def test_json_schema_correct(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, [
            "code", "contract", "billing.py::Invoice.compute_total", "--json",
        ])
        assert result.exit_code == 0
        data = json.loads(result.output)
        assert "address" in data

    def test_completes_under_budget(self, large_repo: pathlib.Path) -> None:
        start = time.monotonic()
        runner.invoke(cli, [
            "code", "contract", "billing.py::Invoice.compute_total", "--json",
        ])
        _assert_under_budget(time.monotonic() - start, "contract billing.py::... --json")


# ---------------------------------------------------------------------------
# muse code predict — stress
# ---------------------------------------------------------------------------


class TestPredictStress:
    def test_exits_zero_on_large_repo(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "predict"])
        assert result.exit_code == 0, result.output

    def test_json_schema_correct(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "predict", "--json"])
        assert result.exit_code == 0
        data = json.loads(result.output)
        assert "predictions" in data

    def test_completes_under_budget(self, large_repo: pathlib.Path) -> None:
        start = time.monotonic()
        runner.invoke(cli, ["code", "predict", "--json"])
        _assert_under_budget(time.monotonic() - start, "predict --json")

    def test_top_n_respected(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "predict", "--top", "5", "--json"])
        assert result.exit_code == 0
        data = json.loads(result.output)
        assert len(data.get("predictions", [])) <= 5


# ---------------------------------------------------------------------------
# muse code semantic-test-coverage — stress
# ---------------------------------------------------------------------------


class TestSemanticTestCoverageStress:
    def test_exits_zero_on_large_repo(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "semantic-test-coverage"])
        assert result.exit_code == 0, result.output

    def test_json_schema_correct(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "semantic-test-coverage", "--json"])
        assert result.exit_code == 0
        data = json.loads(result.output)
        assert "files" in data or "coverage" in data or "summary" in data

    def test_completes_under_budget(self, large_repo: pathlib.Path) -> None:
        start = time.monotonic()
        runner.invoke(cli, ["code", "semantic-test-coverage", "--json"])
        _assert_under_budget(time.monotonic() - start, "semantic-test-coverage --json")

    def test_file_filter(self, large_repo: pathlib.Path) -> None:
        result = runner.invoke(cli, ["code", "semantic-test-coverage", "--file", "billing.py"])
        assert result.exit_code == 0