"""Tests for list_tools.

Two failures this tool must not have. It must not advertise a tool the agent
cannot call — the list is built from the profile config, but the call goes to
the live registry, and an MCP server that never connected leaves a phantom
entry the agent then calls into a "tool not found". And it must not dump the
whole catalogue: an MCP-heavy profile carries ~125 tools / ~35 KB, which is
9k tokens spent to answer "do I have anything for ssh".
"""

import pytest

from navi.core.registry import ProfileRegistry, ToolRegistry
from navi.profiles.base import ToolConfig, ToolScopeConfig
from navi.tools._internal.base import ToolContext
from navi.tools.list_tools import ListToolsTool
from tests.conftest_factory import FakeTool, make_profile


@pytest.fixture(autouse=True)
def no_user_enabled_tools(monkeypatch):
    """Every profile also picks up tools/enabled.json, a real file on the machine
    running the tests — tests must see exactly what they declare."""
    monkeypatch.setattr("navi.core.tool_utils.load_user_enabled_tools", list)


class FakeMcpManager:
    """Stand-in for McpManager — group name to tool names, as the server config holds them."""

    def __init__(self, groups: dict[str, dict[str, list[str]]] | None = None) -> None:
        self._groups = groups or {}

    def resolve_group(self, server_name: str, group_name: str) -> list[str]:
        return list(self._groups.get(server_name, {}).get(group_name, []))


def make_profile_with(
    profile_id: str,
    native: list[str],
    mcp: dict | None = None,
    subagent_native: list[str] | None = None,
):
    """A profile holding exactly the declared tools — no enabled_tools migration on top."""
    subagent = (
        ToolScopeConfig(native=list(subagent_native))
        if subagent_native is not None
        else ToolScopeConfig()
    )
    return make_profile(
        profile_id,
        enabled_tools=[],
        tools=ToolConfig(
            agent=ToolScopeConfig(native=list(native), mcp=dict(mcp or {})),
            subagent=subagent,
        ),
    )


def make_profiles(*profiles) -> ProfileRegistry:
    registry = ProfileRegistry()
    for profile in profiles:
        registry.register(profile)
    return registry


def make_registry(*specs: tuple[str, str]) -> ToolRegistry:
    """specs: (name, description) pairs — the live, registered tools."""
    registry = ToolRegistry()
    for name, description in specs:
        registry.register(FakeTool(name, description=description), builtin=True)
    return registry


def make_tool(registry, profiles, groups=None) -> ListToolsTool:
    return ListToolsTool(
        registry=registry,
        profile_registry=profiles,
        mcp_manager=FakeMcpManager(groups),
    )


@pytest.mark.asyncio
async def test_lists_only_the_requested_profiles_tools():
    profiles = make_profiles(
        make_profile_with("secretary", ["todo"]),
        make_profile_with("developer", ["code_exec"]),
    )
    registry = make_registry(("todo", "notes"), ("code_exec", "runs"), ("weather", "forecast"))

    result = await make_tool(registry, profiles).execute({"profile_id": "secretary"})

    assert result.success is True
    assert "todo" in result.output
    assert "code_exec" not in result.output
    assert "weather" not in result.output


@pytest.mark.asyncio
async def test_compact_output_groups_names_by_source():
    groups = {"tgclient": {"read": ["dialogs_list", "messages_history"]}}
    profiles = make_profiles(
        make_profile_with("secretary", ["todo"], {"tgclient": ["read"]})
    )
    registry = make_registry(
        ("todo", "notes and tasks"),
        ("mcp__tgclient__dialogs_list", "list dialogs"),
        ("mcp__tgclient__messages_history", "read history"),
    )

    result = await make_tool(registry, profiles, groups).execute({"profile_id": "secretary"})

    assert "native (1): todo" in result.output
    assert (
        "mcp__tgclient__ (2): mcp__tgclient__dialogs_list, mcp__tgclient__messages_history"
        in result.output
    )
    # Descriptions are what makes the output huge — they stay out unless asked for.
    assert "notes and tasks" not in result.output


@pytest.mark.asyncio
async def test_verbose_is_an_order_of_magnitude_larger():
    """Descriptions are what costs the context — 125 tools of them is ~35 KB."""
    names = [f"tool_{i}" for i in range(20)]
    profiles = make_profiles(make_profile_with("secretary", names))
    registry = make_registry(*[(name, "d" * 200) for name in names])
    tool = make_tool(registry, profiles)

    compact = (await tool.execute({"profile_id": "secretary"})).output
    verbose = (await tool.execute({"profile_id": "secretary", "verbose": True})).output

    assert "d" * 200 not in compact
    assert "d" * 200 in verbose
    assert len(verbose) > len(compact) * 5


@pytest.mark.asyncio
async def test_query_filters_by_name_and_by_description():
    profiles = make_profiles(make_profile_with("secretary", ["todo", "sync_files"]))
    registry = make_registry(("todo", "notes and tasks"), ("sync_files", "copy files"))
    tool = make_tool(registry, profiles)

    by_name = (await tool.execute({"profile_id": "secretary", "query": "files"})).output
    assert "mcp__" not in by_name
    assert "sync_files" in by_name
    assert "todo" not in by_name
    assert "matching 'files'" in by_name

    by_description = (await tool.execute({"profile_id": "secretary", "query": "tasks"})).output
    assert "todo" in by_description
    assert "sync_files" not in by_description


@pytest.mark.asyncio
async def test_declared_but_unregistered_tools_are_not_advertised():
    """The navi_ui case: the profile config declares it, the server never connected."""
    groups = {"navi_ui": {"ui": ["render_component"]}}
    profiles = make_profiles(
        make_profile_with("secretary", ["todo"], {"navi_ui": ["ui"]})
    )
    registry = make_registry(("todo", "notes"))  # render_component was never registered

    result = await make_tool(registry, profiles, groups).execute({"profile_id": "secretary"})

    assert "Not registered (1): mcp__navi_ui__render_component" in result.output
    # Counted as neither available nor part of a source section.
    assert "(1 available)" in result.output
    assert "mcp__navi_ui__ (1)" not in result.output


@pytest.mark.asyncio
async def test_query_still_reports_a_matching_unregistered_tool():
    """"Do I have anything for render" must answer "declared, but not callable"."""
    groups = {"navi_ui": {"ui": ["render_component"]}}
    profiles = make_profiles(
        make_profile_with("secretary", ["todo"], {"navi_ui": ["ui"]})
    )
    registry = make_registry(("todo", "notes"))

    result = await make_tool(registry, profiles, groups).execute(
        {"profile_id": "secretary", "query": "render"}
    )

    assert "Not registered (1): mcp__navi_ui__render_component" in result.output
    assert "0 of 2 declared" in result.output


@pytest.mark.asyncio
async def test_wildcard_group_takes_every_registered_tool_of_that_server():
    profiles = make_profiles(
        make_profile_with("secretary", ["todo"], {"tgclient": ["*"]})
    )
    registry = make_registry(
        ("todo", "notes"),
        ("mcp__tgclient__dialogs_list", "dialogs"),
        ("mcp__other__whatever", "not this server"),
    )

    result = await make_tool(registry, profiles).execute({"profile_id": "secretary"})

    assert "mcp__tgclient__dialogs_list" in result.output
    assert "mcp__other__whatever" not in result.output


@pytest.mark.asyncio
async def test_no_profile_in_context_is_an_error_that_says_what_to_do():
    result = await make_tool(make_registry(), make_profiles()).execute({})

    assert result.success is False
    assert result.error == "no_active_profile"
    assert "list_profiles" in result.output


@pytest.mark.asyncio
async def test_unknown_profile_is_rejected():
    registry = make_registry(("todo", "notes"))
    profiles = make_profiles(make_profile_with("secretary", ["todo"]))

    result = await make_tool(registry, profiles).execute({"profile_id": "nope"})

    assert result.success is False
    assert result.error == "profile_not_found"


@pytest.mark.asyncio
async def test_defaults_to_the_profile_the_run_executes_as():
    """Omitted profile_id means "mine" — the agent answers "what do I have" with no argument."""
    profiles = make_profiles(
        make_profile_with("secretary", ["todo"]),
        make_profile_with("server_admin", ["ssh_exec"]),
    )
    registry = make_registry(("todo", "notes"), ("ssh_exec", "remote"))
    tool = make_tool(registry, profiles)

    result = await tool.execute({}, ctx=ToolContext(profile_id="server_admin"))

    assert "ssh_exec" in result.output
    assert "todo" not in result.output
    # Which profile was assumed, so the answer cannot be misread as another's.
    assert "'server_admin' (current profile)" in result.output


@pytest.mark.asyncio
async def test_explicit_profile_id_beats_the_running_profile():
    profiles = make_profiles(
        make_profile_with("secretary", ["todo"]),
        make_profile_with("server_admin", ["ssh_exec"]),
    )
    registry = make_registry(("todo", "notes"), ("ssh_exec", "remote"))

    result = await make_tool(registry, profiles).execute(
        {"profile_id": "secretary"}, ctx=ToolContext(profile_id="server_admin")
    )

    assert "todo" in result.output
    assert "ssh_exec" not in result.output
    assert "current profile" not in result.output


@pytest.mark.asyncio
async def test_scope_subagent_lists_what_a_spawned_agent_would_get():
    profiles = make_profiles(
        make_profile_with("server_admin", ["ssh_exec", "todo"], subagent_native=["ssh_exec"])
    )
    registry = make_registry(("ssh_exec", "remote"), ("todo", "planning"))

    agent_side = await make_tool(registry, profiles).execute({"profile_id": "server_admin"})
    subagent_side = await make_tool(registry, profiles).execute(
        {"profile_id": "server_admin", "scope": "subagent"}
    )

    assert "todo" in agent_side.output
    assert "todo" not in subagent_side.output
    assert "ssh_exec" in subagent_side.output
    assert "(subagent scope)" in subagent_side.output


@pytest.mark.asyncio
async def test_unknown_scope_is_rejected():
    profiles = make_profiles(make_profile_with("secretary", ["todo"]))
    registry = make_registry(("todo", "notes"))

    result = await make_tool(registry, profiles).execute(
        {"profile_id": "secretary", "scope": "worker"}
    )

    assert result.success is False
    assert result.error == "unknown_scope"