"""Supercharge tests for ``muse code semantic-test-coverage``.

Coverage tiers
--------------
Unit        — TypedDict shape (_JsonOut gains exit_code/duration_ms/schema_version),
              alias registration (-j), docstring completeness.
Integration — -j alias produces same output as --json; exit_code/duration_ms/
              schema_version present in JSON; --min-coverage exit code mirrors
              process exit; uncovered-only JSON still carries envelope fields.
Security    — ANSI in --file/--kind args not echoed raw.
Performance — duration_ms < 5000 ms on a small repo.
"""

from __future__ import annotations

import argparse
import json
import os
import pathlib
import textwrap

import pytest

from tests.cli_test_helper import CliRunner, InvokeResult

runner = CliRunner()


# ──────────────────────────────────────────────────────────────────────────────
# Fixtures
# ──────────────────────────────────────────────────────────────────────────────


def _invoke(repo: pathlib.Path, args: list[str]) -> InvokeResult:
    saved = os.getcwd()
    try:
        os.chdir(repo)
        return runner.invoke(None, args)
    finally:
        os.chdir(saved)


def _stc(repo: pathlib.Path, *args: str) -> InvokeResult:
    return _invoke(repo, ["code", "semantic-test-coverage", *args])


@pytest.fixture()
def cov_repo(tmp_path: pathlib.Path) -> pathlib.Path:
    """Minimal repo with one production file and one test file."""
    saved = os.getcwd()
    try:
        os.chdir(tmp_path)
        runner.invoke(None, ["init"])
    finally:
        os.chdir(saved)

    (tmp_path / "billing.py").write_text(
        textwrap.dedent("""\
            class Invoice:
                def compute_total(self, items):
                    return sum(item["price"] for item in items)

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

                def generate_pdf(self):
                    pass
        """),
        encoding="utf-8",
    )
    (tmp_path / "tests").mkdir()
    (tmp_path / "tests" / "test_billing.py").write_text(
        textwrap.dedent("""\
            from billing import Invoice

            def test_compute_total():
                inv = Invoice()
                assert inv.compute_total([{"price": 10}]) == 10

            def test_apply_discount():
                inv = Invoice()
                assert inv.apply_discount(100, 10) == 90
        """),
        encoding="utf-8",
    )

    saved = os.getcwd()
    try:
        os.chdir(tmp_path)
        runner.invoke(None, ["code", "add", "."])
        runner.invoke(None, ["commit", "-m", "init"])
    finally:
        os.chdir(saved)

    return tmp_path


# ──────────────────────────────────────────────────────────────────────────────
# Unit — TypedDict
# ──────────────────────────────────────────────────────────────────────────────


class TestTypedDict:
    def test_json_out_has_exit_code(self) -> None:
        import typing
        from muse.cli.commands.semantic_test_coverage import _JsonOut

        hints = typing.get_type_hints(_JsonOut)
        assert "exit_code" in hints, "exit_code missing from _JsonOut"

    def test_json_out_has_duration_ms(self) -> None:
        import typing
        from muse.cli.commands.semantic_test_coverage import _JsonOut

        hints = typing.get_type_hints(_JsonOut)
        assert "duration_ms" in hints, "duration_ms missing from _JsonOut"

    def test_json_out_has_schema_version(self) -> None:
        import typing
        from muse.cli.commands.semantic_test_coverage import _JsonOut

        hints = typing.get_type_hints(_JsonOut)
        assert "schema" in hints, "schema_version missing from _JsonOut"

    def test_json_out_retains_core_fields(self) -> None:
        import typing
        from muse.cli.commands.semantic_test_coverage import _JsonOut

        hints = typing.get_type_hints(_JsonOut)
        required = {"ref", "snapshot_id", "depth", "transitive", "filters", "summary", "files"}
        missing = required - set(hints)
        assert not missing, f"Core fields missing from _JsonOut: {missing}"


# ──────────────────────────────────────────────────────────────────────────────
# Unit — -j alias registration
# ──────────────────────────────────────────────────────────────────────────────


class TestAliasRegistration:
    def _make_parser(self) -> "argparse.ArgumentParser":
        import argparse
        from muse.cli.commands.semantic_test_coverage import register

        p = argparse.ArgumentParser()
        sub = p.add_subparsers()
        register(sub)
        return p

    def test_j_alias_sets_json_true(self) -> None:
        p = self._make_parser()
        ns = p.parse_args(["semantic-test-coverage", "-j"])
        assert ns.json_out is True

    def test_j_alias_and_other_flags_coexist(self) -> None:
        p = self._make_parser()
        ns = p.parse_args(["semantic-test-coverage", "-j", "--uncovered-only"])
        assert ns.json_out is True
        assert ns.uncovered_only is True


# ──────────────────────────────────────────────────────────────────────────────
# Integration — -j alias
# ──────────────────────────────────────────────────────────────────────────────


class TestJsonAlias:
    def test_j_alias_exit_code_zero(self, cov_repo: pathlib.Path) -> None:
        result = _stc(cov_repo, "-j")
        assert result.exit_code == 0

    def test_j_alias_valid_json(self, cov_repo: pathlib.Path) -> None:
        result = _stc(cov_repo, "-j")
        data = json.loads(result.output)
        assert isinstance(data, dict)

    def test_j_alias_same_top_level_keys_as_json_flag(self, cov_repo: pathlib.Path) -> None:
        r_json = _stc(cov_repo, "--json")
        r_j = _stc(cov_repo, "-j")
        assert set(json.loads(r_json.output)) == set(json.loads(r_j.output))

    def test_j_alias_summary_matches_json_flag(self, cov_repo: pathlib.Path) -> None:
        r_json = _stc(cov_repo, "--json")
        r_j = _stc(cov_repo, "-j")
        assert json.loads(r_json.output)["summary"] == json.loads(r_j.output)["summary"]

    def test_j_alias_with_uncovered_only(self, cov_repo: pathlib.Path) -> None:
        result = _stc(cov_repo, "-j", "--uncovered-only")
        data = json.loads(result.output)
        # All symbols in output should be uncovered.
        for fc in data["files"]:
            for sym in fc["symbols"]:
                assert not sym["covered"]


# ──────────────────────────────────────────────────────────────────────────────
# Integration — JSON envelope: exit_code, duration_ms, schema_version
# ──────────────────────────────────────────────────────────────────────────────


class TestJsonEnvelope:
    def test_has_exit_code(self, cov_repo: pathlib.Path) -> None:
        result = _stc(cov_repo, "--json")
        data = json.loads(result.output)
        assert "exit_code" in data

    def test_exit_code_is_zero_on_success(self, cov_repo: pathlib.Path) -> None:
        result = _stc(cov_repo, "--json")
        data = json.loads(result.output)
        assert data["exit_code"] == 0

    def test_exit_code_is_int(self, cov_repo: pathlib.Path) -> None:
        result = _stc(cov_repo, "--json")
        data = json.loads(result.output)
        assert isinstance(data["exit_code"], int)

    def test_has_duration_ms(self, cov_repo: pathlib.Path) -> None:
        result = _stc(cov_repo, "--json")
        data = json.loads(result.output)
        assert "duration_ms" in data

    def test_duration_ms_is_nonnegative_float(self, cov_repo: pathlib.Path) -> None:
        result = _stc(cov_repo, "--json")
        data = json.loads(result.output)
        assert isinstance(data["duration_ms"], float)
        assert data["duration_ms"] >= 0.0

    def test_has_schema_version(self, cov_repo: pathlib.Path) -> None:
        result = _stc(cov_repo, "--json")
        data = json.loads(result.output)
        assert "schema" in data

    def test_schema_version_is_nonempty_string(self, cov_repo: pathlib.Path) -> None:
        result = _stc(cov_repo, "--json")
        data = json.loads(result.output)
        assert isinstance(data["schema"], int)
        assert data["schema"] > 0

    def test_uncovered_only_json_still_has_envelope(self, cov_repo: pathlib.Path) -> None:
        result = _stc(cov_repo, "--json", "--uncovered-only")
        data = json.loads(result.output)
        assert "exit_code" in data
        assert "duration_ms" in data
        assert "schema" in data

    def test_j_alias_has_exit_code(self, cov_repo: pathlib.Path) -> None:
        result = _stc(cov_repo, "-j")
        data = json.loads(result.output)
        assert "exit_code" in data

    def test_j_alias_has_duration_ms(self, cov_repo: pathlib.Path) -> None:
        result = _stc(cov_repo, "-j")
        data = json.loads(result.output)
        assert "duration_ms" in data

    def test_j_alias_has_schema_version(self, cov_repo: pathlib.Path) -> None:
        result = _stc(cov_repo, "-j")
        data = json.loads(result.output)
        assert "schema" in data

    def test_min_coverage_violation_exit_code_one(self, cov_repo: pathlib.Path) -> None:
        # generate_pdf is uncovered, so 100% threshold must fail.
        result = _stc(cov_repo, "--min-coverage", "100")
        assert result.exit_code == 1

    def test_min_coverage_zero_exit_code_zero(self, cov_repo: pathlib.Path) -> None:
        result = _stc(cov_repo, "--min-coverage", "0")
        assert result.exit_code == 0


# ──────────────────────────────────────────────────────────────────────────────
# Security — ANSI injection
# ──────────────────────────────────────────────────────────────────────────────


class TestSecurity:
    def test_ansi_in_file_filter_not_echoed(self, cov_repo: pathlib.Path) -> None:
        result = _stc(cov_repo, "--file", "\x1b[31mbilling\x1b[0m")
        combined = result.output + (result.stderr or "")
        assert "\x1b[31m" not in combined

    def test_null_byte_in_file_filter_no_crash(self, cov_repo: pathlib.Path) -> None:
        # Should not crash — may return empty or error gracefully.
        result = _stc(cov_repo, "--file", "billing\x00malicious")
        assert result.exit_code in (0, 1)


# ──────────────────────────────────────────────────────────────────────────────
# Performance
# ──────────────────────────────────────────────────────────────────────────────


class TestPerformance:
    def test_duration_ms_under_5000(self, cov_repo: pathlib.Path) -> None:
        result = _stc(cov_repo, "--json")
        data = json.loads(result.output)
        assert data["duration_ms"] < 5000.0


# ──────────────────────────────────────────────────────────────────────────────
# Unit — docstrings
# ──────────────────────────────────────────────────────────────────────────────


class TestDocstrings:
    def test_run_has_docstring(self) -> None:
        from muse.cli.commands.semantic_test_coverage import run

        assert run.__doc__ and len(run.__doc__.strip()) > 30

    def test_register_has_docstring(self) -> None:
        from muse.cli.commands.semantic_test_coverage import register

        assert register.__doc__ and len(register.__doc__.strip()) > 20

    def test_run_docstring_mentions_schema_version(self) -> None:
        from muse.cli.commands.semantic_test_coverage import run

        doc = run.__doc__ or ""
        assert "exit_code" in doc or "json" in doc.lower()

    def test_register_docstring_mentions_j_alias(self) -> None:
        from muse.cli.commands.semantic_test_coverage import register

        doc = register.__doc__ or ""
        assert "-j" in doc


class TestRegisterFlags:
    def test_default_json_out_is_false(self) -> None:
        import argparse
        from muse.cli.commands.semantic_test_coverage import register
        p = argparse.ArgumentParser()
        subs = p.add_subparsers()
        register(subs)
        args = p.parse_args(["semantic-test-coverage"])
        assert args.json_out is False

    def test_json_flag_sets_json_out(self) -> None:
        import argparse
        from muse.cli.commands.semantic_test_coverage import register
        p = argparse.ArgumentParser()
        subs = p.add_subparsers()
        register(subs)
        args = p.parse_args(["semantic-test-coverage", "--json"])
        assert args.json_out is True

    def test_j_shorthand_sets_json_out(self) -> None:
        import argparse
        from muse.cli.commands.semantic_test_coverage import register
        p = argparse.ArgumentParser()
        subs = p.add_subparsers()
        register(subs)
        args = p.parse_args(["semantic-test-coverage", "-j"])
        assert args.json_out is True