"""Supercharge tests for ``muse code blast-risk`` — agent-usability gaps.

Coverage matrix
---------------
- --json / -j:   -j alias works identically to --json for table and explain modes
- exit_code:     every JSON output path includes it (0 on success)
- duration_ms:   every JSON output path includes it; non-negative float
- TypedDicts:    _BlastRiskOutput gains exit_code/duration_ms; _ExplainJson added
- Docstrings:    run() docstring mentions exit_code and duration_ms
- ANSI:          address fields in JSON never contain escape sequences
- Performance:   duration_ms stays < 2000 ms for small repos (blast-risk is heavier)
- Schema:        risk 0-100, weight sum ≈ 1.0, scores 0-100
"""

from __future__ import annotations
from collections.abc import Mapping

import json
import pathlib
import textwrap

import pytest

from tests.cli_test_helper import CliRunner

runner = CliRunner()


# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------


def _env(root: pathlib.Path) -> Mapping[str, str]:
    return {"MUSE_REPO_ROOT": str(root)}


def _run(root: pathlib.Path, *args: str) -> "InvokeResult":
    return runner.invoke(None, list(args), env=_env(root))


def _first_symbol_address(root: pathlib.Path) -> str:
    """Return the highest-risk symbol's address from the JSON output."""
    r = _run(root, "code", "blast-risk", "--json")
    assert r.exit_code == 0, r.output
    data = json.loads(r.output)
    syms = data["symbols"]
    assert syms, "blast_repo should always have at least one scored symbol"
    return syms[0]["address"]


# ---------------------------------------------------------------------------
# Fixture — repo with commits giving blast-risk meaningful data
# ---------------------------------------------------------------------------


@pytest.fixture()
def blast_repo(tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch) -> pathlib.Path:
    """Code-domain repo with two commits.

    billing.py defines Invoice.compute_total and process_order.
    test_billing.py imports both — so they have at least one test caller.
    A second commit modifies compute_total so churn > 0.
    """
    monkeypatch.chdir(tmp_path)

    r = _run(tmp_path, "init", "--domain", "code")
    assert r.exit_code == 0, r.output

    (tmp_path / "billing.py").write_text(textwrap.dedent("""\
        class Invoice:
            def compute_total(self, items):
                return sum(items)

            def apply_discount(self, total, pct):
                return total * (1 - pct)

        def process_order(invoice, items):
            return invoice.compute_total(items)
    """))
    (tmp_path / "test_billing.py").write_text(textwrap.dedent("""\
        from billing import Invoice, process_order

        def test_compute_total():
            inv = Invoice()
            assert inv.compute_total([1, 2, 3]) == 6

        def test_process_order():
            inv = Invoice()
            assert process_order(inv, [10]) == 10
    """))
    r1 = _run(tmp_path, "code", "add", "billing.py")
    assert r1.exit_code == 0, r1.output
    r2 = _run(tmp_path, "code", "add", "test_billing.py")
    assert r2.exit_code == 0, r2.output
    r3 = _run(tmp_path, "commit", "-m", "Add billing module and tests")
    assert r3.exit_code == 0, r3.output

    # Second commit: modify compute_total → churn > 0.
    (tmp_path / "billing.py").write_text(textwrap.dedent("""\
        class Invoice:
            def compute_total(self, items):
                return round(sum(items), 2)

            def apply_discount(self, total, pct):
                return total * (1 - pct)

        def process_order(invoice, items):
            return invoice.compute_total(items)
    """))
    r4 = _run(tmp_path, "code", "add", "billing.py")
    assert r4.exit_code == 0, r4.output
    r5 = _run(tmp_path, "commit", "-m", "Round compute_total result")
    assert r5.exit_code == 0, r5.output

    return tmp_path


# ---------------------------------------------------------------------------
# TestJsonAlias — -j works identically to --json
# ---------------------------------------------------------------------------


class TestJsonAlias:
    """The -j shorthand must behave identically to --json."""

    def test_j_alias_table_exits_zero(self, blast_repo: pathlib.Path) -> None:
        r = _run(blast_repo, "code", "blast-risk", "-j")
        assert r.exit_code == 0, r.output

    def test_j_alias_table_valid_json(self, blast_repo: pathlib.Path) -> None:
        r = _run(blast_repo, "code", "blast-risk", "-j")
        json.loads(r.output)  # must not raise

    def test_j_alias_table_has_symbols_key(self, blast_repo: pathlib.Path) -> None:
        r = _run(blast_repo, "code", "blast-risk", "-j")
        data = json.loads(r.output)
        assert "symbols" in data

    def test_j_alias_explain_exits_zero(self, blast_repo: pathlib.Path) -> None:
        addr = _first_symbol_address(blast_repo)
        r = _run(blast_repo, "code", "blast-risk", "--explain", addr, "-j")
        assert r.exit_code == 0, r.output

    def test_j_alias_explain_valid_json(self, blast_repo: pathlib.Path) -> None:
        addr = _first_symbol_address(blast_repo)
        r = _run(blast_repo, "code", "blast-risk", "--explain", addr, "-j")
        json.loads(r.output)  # must not raise

    def test_j_alias_table_same_keys_as_json_flag(self, blast_repo: pathlib.Path) -> None:
        r1 = _run(blast_repo, "code", "blast-risk", "--json")
        r2 = _run(blast_repo, "code", "blast-risk", "-j")
        d1 = json.loads(r1.output)
        d2 = json.loads(r2.output)
        d1.pop("duration_ms", None)
        d2.pop("duration_ms", None)
        assert set(d1.keys()) == set(d2.keys())

    def test_j_alias_explain_same_keys_as_json_flag(self, blast_repo: pathlib.Path) -> None:
        addr = _first_symbol_address(blast_repo)
        r1 = _run(blast_repo, "code", "blast-risk", "--explain", addr, "--json")
        r2 = _run(blast_repo, "code", "blast-risk", "--explain", addr, "-j")
        d1 = json.loads(r1.output)
        d2 = json.loads(r2.output)
        d1.pop("duration_ms", None)
        d2.pop("duration_ms", None)
        assert set(d1.keys()) == set(d2.keys())


# ---------------------------------------------------------------------------
# TestDurationMs — every JSON path emits duration_ms
# ---------------------------------------------------------------------------


class TestDurationMs:
    """Every JSON output path must include a non-negative float duration_ms."""

    def test_table_json_has_duration_ms(self, blast_repo: pathlib.Path) -> None:
        r = _run(blast_repo, "code", "blast-risk", "--json")
        data = json.loads(r.output)
        assert "duration_ms" in data

    def test_table_json_duration_ms_nonnegative(self, blast_repo: pathlib.Path) -> None:
        r = _run(blast_repo, "code", "blast-risk", "--json")
        data = json.loads(r.output)
        assert data["duration_ms"] >= 0

    def test_table_json_duration_ms_is_float(self, blast_repo: pathlib.Path) -> None:
        r = _run(blast_repo, "code", "blast-risk", "--json")
        data = json.loads(r.output)
        assert isinstance(data["duration_ms"], float)

    def test_explain_json_has_duration_ms(self, blast_repo: pathlib.Path) -> None:
        addr = _first_symbol_address(blast_repo)
        r = _run(blast_repo, "code", "blast-risk", "--explain", addr, "--json")
        data = json.loads(r.output)
        assert "duration_ms" in data

    def test_explain_json_duration_ms_nonnegative(self, blast_repo: pathlib.Path) -> None:
        addr = _first_symbol_address(blast_repo)
        r = _run(blast_repo, "code", "blast-risk", "--explain", addr, "--json")
        data = json.loads(r.output)
        assert data["duration_ms"] >= 0

    def test_explain_json_duration_ms_is_float(self, blast_repo: pathlib.Path) -> None:
        addr = _first_symbol_address(blast_repo)
        r = _run(blast_repo, "code", "blast-risk", "--explain", addr, "--json")
        data = json.loads(r.output)
        assert isinstance(data["duration_ms"], float)

    def test_j_alias_duration_ms_present(self, blast_repo: pathlib.Path) -> None:
        r = _run(blast_repo, "code", "blast-risk", "-j")
        data = json.loads(r.output)
        assert "duration_ms" in data


# ---------------------------------------------------------------------------
# TestExitCode — every JSON path emits exit_code
# ---------------------------------------------------------------------------


class TestExitCode:
    """Every JSON output path must include exit_code; 0 on success."""

    def test_table_json_has_exit_code(self, blast_repo: pathlib.Path) -> None:
        r = _run(blast_repo, "code", "blast-risk", "--json")
        data = json.loads(r.output)
        assert "exit_code" in data

    def test_table_json_exit_code_zero_on_success(self, blast_repo: pathlib.Path) -> None:
        r = _run(blast_repo, "code", "blast-risk", "--json")
        assert r.exit_code == 0
        data = json.loads(r.output)
        assert data["exit_code"] == 0

    def test_table_json_exit_code_is_int(self, blast_repo: pathlib.Path) -> None:
        r = _run(blast_repo, "code", "blast-risk", "--json")
        data = json.loads(r.output)
        assert isinstance(data["exit_code"], int)

    def test_explain_json_has_exit_code(self, blast_repo: pathlib.Path) -> None:
        addr = _first_symbol_address(blast_repo)
        r = _run(blast_repo, "code", "blast-risk", "--explain", addr, "--json")
        data = json.loads(r.output)
        assert "exit_code" in data

    def test_explain_json_exit_code_zero_on_success(self, blast_repo: pathlib.Path) -> None:
        addr = _first_symbol_address(blast_repo)
        r = _run(blast_repo, "code", "blast-risk", "--explain", addr, "--json")
        assert r.exit_code == 0
        data = json.loads(r.output)
        assert data["exit_code"] == 0

    def test_explain_json_exit_code_is_int(self, blast_repo: pathlib.Path) -> None:
        addr = _first_symbol_address(blast_repo)
        r = _run(blast_repo, "code", "blast-risk", "--explain", addr, "--json")
        data = json.loads(r.output)
        assert isinstance(data["exit_code"], int)

    def test_table_exit_code_mirrors_process_exit(self, blast_repo: pathlib.Path) -> None:
        r = _run(blast_repo, "code", "blast-risk", "--json")
        data = json.loads(r.output)
        assert data["exit_code"] == r.exit_code

    def test_j_alias_exit_code_present(self, blast_repo: pathlib.Path) -> None:
        r = _run(blast_repo, "code", "blast-risk", "-j")
        data = json.loads(r.output)
        assert "exit_code" in data


# ---------------------------------------------------------------------------
# TestTypedDicts — envelope TypedDicts carry the new fields
# ---------------------------------------------------------------------------


class TestTypedDicts:
    """_BlastRiskOutput must gain exit_code/duration_ms; _ExplainJson added."""

    def test_blast_risk_output_typed_dict_exists(self) -> None:
        from muse.cli.commands.blast_risk import _BlastRiskOutput  # noqa: F401

    def test_blast_risk_output_has_exit_code_annotation(self) -> None:
        from muse.cli.commands.blast_risk import _BlastRiskOutput
        assert "exit_code" in _BlastRiskOutput.__annotations__

    def test_blast_risk_output_has_duration_ms_annotation(self) -> None:
        from muse.cli.commands.blast_risk import _BlastRiskOutput
        assert "duration_ms" in _BlastRiskOutput.__annotations__

    def test_blast_risk_output_has_symbols_annotation(self) -> None:
        from muse.cli.commands.blast_risk import _BlastRiskOutput
        assert "symbols" in _BlastRiskOutput.__annotations__

    def test_explain_json_typed_dict_exists(self) -> None:
        from muse.cli.commands.blast_risk import _ExplainJson  # noqa: F401

    def test_explain_json_has_exit_code_annotation(self) -> None:
        from muse.cli.commands.blast_risk import _ExplainJson
        assert "exit_code" in _ExplainJson.__annotations__

    def test_explain_json_has_duration_ms_annotation(self) -> None:
        from muse.cli.commands.blast_risk import _ExplainJson
        assert "duration_ms" in _ExplainJson.__annotations__

    def test_explain_json_has_risk_annotation(self) -> None:
        from muse.cli.commands.blast_risk import _ExplainJson
        assert "risk" in _ExplainJson.__annotations__

    def test_symbol_risk_json_typed_dict_exists(self) -> None:
        from muse.cli.commands.blast_risk import _SymbolRiskJson  # noqa: F401


# ---------------------------------------------------------------------------
# TestDocstrings — run() docstring documents new fields
# ---------------------------------------------------------------------------


class TestDocstrings:
    """run() must document exit_code in its docstring."""

    def test_run_docstring_documents_fields(self) -> None:
        from muse.cli.commands.blast_risk import run
        assert "Exit codes" in run.__doc__


# ---------------------------------------------------------------------------
# TestAnsiSanitization — JSON fields must not contain terminal escape codes
# ---------------------------------------------------------------------------


class TestAnsiSanitization:
    """No ANSI escape sequences in JSON string fields."""

    def test_table_json_no_ansi_in_output(self, blast_repo: pathlib.Path) -> None:
        r = _run(blast_repo, "code", "blast-risk", "--json")
        assert "\x1b" not in r.output

    def test_explain_json_no_ansi_in_output(self, blast_repo: pathlib.Path) -> None:
        addr = _first_symbol_address(blast_repo)
        r = _run(blast_repo, "code", "blast-risk", "--explain", addr, "--json")
        assert "\x1b" not in r.output

    def test_table_json_addresses_no_ansi(self, blast_repo: pathlib.Path) -> None:
        r = _run(blast_repo, "code", "blast-risk", "--json")
        data = json.loads(r.output)
        for sym in data["symbols"]:
            assert "\x1b" not in sym["address"]


# ---------------------------------------------------------------------------
# TestPerformance — duration_ms stays in a reasonable range
# ---------------------------------------------------------------------------


class TestPerformance:
    """duration_ms must be non-negative and under 2000 ms for small repos.

    blast-risk does AST scanning + BFS commit walk so the budget is 2x larger
    than simpler commands.
    """

    def test_table_json_duration_under_2000ms(self, blast_repo: pathlib.Path) -> None:
        r = _run(blast_repo, "code", "blast-risk", "--json")
        data = json.loads(r.output)
        assert data["duration_ms"] < 2000

    def test_explain_json_duration_under_2000ms(self, blast_repo: pathlib.Path) -> None:
        addr = _first_symbol_address(blast_repo)
        r = _run(blast_repo, "code", "blast-risk", "--explain", addr, "--json")
        data = json.loads(r.output)
        assert data["duration_ms"] < 2000

    def test_duration_ms_is_float_not_int(self, blast_repo: pathlib.Path) -> None:
        r = _run(blast_repo, "code", "blast-risk", "--json")
        data = json.loads(r.output)
        assert isinstance(data["duration_ms"], float)


# ---------------------------------------------------------------------------
# Flag registration tests
# ---------------------------------------------------------------------------

import argparse as _argparse
from muse.cli.commands.blast_risk import register as _register_blast_risk


def _parse_br(*args: str) -> _argparse.Namespace:
    """Build an argument parser via register() and parse args."""
    root_p = _argparse.ArgumentParser()
    subs = root_p.add_subparsers(dest="cmd")
    _register_blast_risk(subs)
    return root_p.parse_args(["blast-risk", *args])


class TestRegisterFlags:
    def test_default_json_out_is_false(self) -> None:
        ns = _parse_br()
        assert ns.json_out is False

    def test_json_flag_sets_json_out(self) -> None:
        ns = _parse_br("--json")
        assert ns.json_out is True

    def test_j_shorthand_sets_json_out(self) -> None:
        ns = _parse_br("-j")
        assert ns.json_out is True

    def test_file_has_no_f_shorthand(self) -> None:
        import pytest
        with pytest.raises(SystemExit):
            _parse_br("-f", "src/foo.py")

    def test_top_flag(self) -> None:
        ns = _parse_br("--top", "5")
        assert ns.top == 5