"""Unit tests for the ``ToolSet`` builder and empty-mode helpers."""

from __future__ import annotations

import pytest

from copilot import BUILTIN_TOOLS_ISOLATED, CopilotClient, ToolSet, UriRuntimeConnection
from copilot._mode import (
    _embedding_cache_storage_default,
    _enable_file_hooks_default,
    _enable_host_git_operations_default,
    _enable_on_demand_instruction_discovery_default,
    _enable_session_store_default,
    _enable_session_telemetry_default,
    _enable_skills_default,
    _post_create_options_patch,
    _require_available_tools_for_empty_mode,
    _require_storage_for_empty_mode,
    _skip_embedding_retrieval_default,
    _system_message_for_mode,
    _validate_tool_filter_list,
)


class TestToolSet:
    def test_add_builtin_string(self):
        ts = ToolSet().add_builtin("bash")
        assert ts.to_list() == ["builtin:bash"]

    def test_add_builtin_wildcard(self):
        ts = ToolSet().add_builtin("*")
        assert ts.to_list() == ["builtin:*"]

    def test_add_builtin_iterable(self):
        ts = ToolSet().add_builtin(["bash", "edit"])
        assert ts.to_list() == ["builtin:bash", "builtin:edit"]

    def test_add_builtin_isolated(self):
        ts = ToolSet().add_builtin(BUILTIN_TOOLS_ISOLATED)
        assert ts.to_list() == [f"builtin:{name}" for name in BUILTIN_TOOLS_ISOLATED]

    def test_add_mcp(self):
        ts = ToolSet().add_mcp("github-list_issues")
        assert ts.to_list() == ["mcp:github-list_issues"]

    def test_add_mcp_wildcard(self):
        assert ToolSet().add_mcp("*").to_list() == ["mcp:*"]

    def test_add_custom(self):
        assert ToolSet().add_custom("my_tool").to_list() == ["custom:my_tool"]

    def test_chained(self):
        ts = ToolSet().add_builtin(BUILTIN_TOOLS_ISOLATED).add_mcp("*").add_custom("*")
        assert ts.to_list()[-2:] == ["mcp:*", "custom:*"]

    def test_rejects_bad_name(self):
        with pytest.raises(ValueError, match="tool names must match"):
            ToolSet().add_builtin("has space")

    def test_rejects_empty(self):
        with pytest.raises(ValueError, match="must not be empty"):
            ToolSet().add_custom("")

    def test_rejects_colon(self):
        with pytest.raises(ValueError, match="tool names must match"):
            ToolSet().add_mcp("server:tool")

    def test_iterable_protocol(self):
        ts = ToolSet().add_builtin("bash").add_mcp("*")
        assert list(ts) == ["builtin:bash", "mcp:*"]
        assert len(ts) == 2


class TestEmptyModeValidation:
    def test_empty_mode_requires_storage(self):
        with pytest.raises(ValueError, match="requires base_directory"):
            _require_storage_for_empty_mode(
                mode="empty",
                base_directory=None,
                session_fs_set=False,
                is_uri_connection=False,
            )

    def test_empty_mode_accepts_base_directory(self):
        _require_storage_for_empty_mode(
            mode="empty",
            base_directory="/tmp/x",
            session_fs_set=False,
            is_uri_connection=False,
        )

    def test_empty_mode_accepts_session_fs(self):
        _require_storage_for_empty_mode(
            mode="empty",
            base_directory=None,
            session_fs_set=True,
            is_uri_connection=False,
        )

    def test_empty_mode_accepts_uri_connection(self):
        _require_storage_for_empty_mode(
            mode="empty",
            base_directory=None,
            session_fs_set=False,
            is_uri_connection=True,
        )

    def test_copilot_cli_mode_no_storage_required(self):
        _require_storage_for_empty_mode(
            mode="copilot-cli",
            base_directory=None,
            session_fs_set=False,
            is_uri_connection=False,
        )

    def test_empty_mode_requires_available_tools(self):
        with pytest.raises(ValueError, match="available_tools"):
            _require_available_tools_for_empty_mode("empty", None)

    def test_empty_mode_accepts_available_tools(self):
        _require_available_tools_for_empty_mode("empty", ["builtin:bash"])

    def test_copilot_cli_mode_no_tool_filter_required(self):
        _require_available_tools_for_empty_mode("copilot-cli", None)


class TestToolFilterListValidation:
    def test_rejects_bare_wildcard(self):
        with pytest.raises(ValueError, match="bare wildcard"):
            _validate_tool_filter_list("available_tools", ["*"])

    def test_accepts_source_qualified_wildcard(self):
        _validate_tool_filter_list("available_tools", ["builtin:*", "mcp:*"])

    def test_accepts_none(self):
        _validate_tool_filter_list("available_tools", None)


class TestSystemMessageForMode:
    def test_copilot_cli_pass_through(self):
        assert _system_message_for_mode("copilot-cli", None) is None
        msg = {"mode": "append", "content": "hi"}
        assert _system_message_for_mode("copilot-cli", msg) is msg

    def test_empty_mode_none_supplied(self):
        out = _system_message_for_mode("empty", None)
        assert out == {
            "mode": "customize",
            "sections": {"environment_context": {"action": "remove"}},
        }

    def test_empty_mode_replace_pass_through(self):
        msg = {"mode": "replace", "content": "verbatim"}
        assert _system_message_for_mode("empty", msg) is msg

    def test_empty_mode_customize_adds_section(self):
        msg = {"mode": "customize", "sections": {"identity": {"action": "remove"}}}
        out = _system_message_for_mode("empty", msg)
        assert out["sections"]["environment_context"] == {"action": "remove"}
        assert out["sections"]["identity"] == {"action": "remove"}

    def test_empty_mode_customize_does_not_overwrite_existing(self):
        msg = {
            "mode": "customize",
            "sections": {"environment_context": {"action": "replace", "content": "X"}},
        }
        assert _system_message_for_mode("empty", msg) is msg

    def test_empty_mode_append_promoted_to_customize(self):
        msg = {"mode": "append", "content": "tip"}
        out = _system_message_for_mode("empty", msg)
        assert out["mode"] == "customize"
        assert out["content"] == "tip"
        assert out["sections"]["environment_context"] == {"action": "remove"}


class TestEmptyModeEmbeddingCacheStorageDefaults:
    def test_empty_mode_defaults_to_in_memory(self):
        assert _embedding_cache_storage_default("empty", None) == "in-memory"

    def test_caller_wins(self):
        assert _embedding_cache_storage_default("empty", "persistent") == "persistent"
        assert _embedding_cache_storage_default("empty", "in-memory") == "in-memory"

    def test_copilot_cli_does_not_change(self):
        assert _embedding_cache_storage_default("copilot-cli", None) is None
        assert _embedding_cache_storage_default("copilot-cli", "persistent") == "persistent"


class TestEmptyModeBooleanDefaults:
    @pytest.mark.parametrize(
        ("helper", "empty_default"),
        [
            (_enable_session_telemetry_default, False),
            (_skip_embedding_retrieval_default, True),
            (_enable_on_demand_instruction_discovery_default, False),
            (_enable_file_hooks_default, False),
            (_enable_host_git_operations_default, False),
            (_enable_session_store_default, False),
            (_enable_skills_default, False),
        ],
    )
    def test_empty_mode_defaults(self, helper, empty_default):
        assert helper("empty", None) is empty_default

    @pytest.mark.parametrize(
        "helper",
        [
            _enable_session_telemetry_default,
            _skip_embedding_retrieval_default,
            _enable_on_demand_instruction_discovery_default,
            _enable_file_hooks_default,
            _enable_host_git_operations_default,
            _enable_session_store_default,
            _enable_skills_default,
        ],
    )
    def test_caller_wins(self, helper):
        assert helper("empty", True) is True
        assert helper("empty", False) is False

    @pytest.mark.parametrize(
        "helper",
        [
            _enable_session_telemetry_default,
            _skip_embedding_retrieval_default,
            _enable_on_demand_instruction_discovery_default,
            _enable_file_hooks_default,
            _enable_host_git_operations_default,
            _enable_session_store_default,
            _enable_skills_default,
        ],
    )
    def test_copilot_cli_does_not_change(self, helper):
        assert helper("copilot-cli", None) is None


class TestPostCreatePatch:
    def test_empty_mode_defaults(self):
        patch = _post_create_options_patch("empty", None, None, None, None)
        assert patch == {
            "skipCustomInstructions": True,
            "customAgentsLocalOnly": True,
            "coauthorEnabled": False,
            "manageScheduleEnabled": False,
            "installedPlugins": [],
        }

    def test_empty_mode_caller_wins(self):
        patch = _post_create_options_patch("empty", False, False, True, True)
        assert patch == {
            "skipCustomInstructions": False,
            "customAgentsLocalOnly": False,
            "coauthorEnabled": True,
            "manageScheduleEnabled": True,
            "installedPlugins": [],
        }

    def test_copilot_cli_returns_none_when_unset(self):
        assert _post_create_options_patch("copilot-cli", None, None, None, None) is None

    def test_copilot_cli_passes_through_explicit_values(self):
        patch = _post_create_options_patch("copilot-cli", True, None, False, None)
        assert patch == {"skipCustomInstructions": True, "coauthorEnabled": False}


class TestClientConstruction:
    def test_empty_mode_without_storage_raises(self):
        with pytest.raises(ValueError, match="requires base_directory"):
            CopilotClient(mode="empty")

    def test_empty_mode_with_base_directory_ok(self, tmp_path):
        # Use URI connection to skip bundled-CLI discovery.
        client = CopilotClient(
            mode="empty",
            base_directory=str(tmp_path),
            connection=UriRuntimeConnection(url="http://localhost:1234"),
        )
        assert client._options.mode == "empty"

    def test_empty_mode_with_uri_connection_ok(self):
        client = CopilotClient(
            mode="empty",
            connection=UriRuntimeConnection(url="http://localhost:1234"),
        )
        assert client._options.mode == "empty"

    def test_default_mode_copilot_cli(self):
        client = CopilotClient(
            connection=UriRuntimeConnection(url="http://localhost:1234"),
        )
        assert client._options.mode == "copilot-cli"