"""Tests for tasks capability checking utilities."""

import pytest

from mcp.shared.exceptions import McpError
from mcp.shared.experimental.tasks.capabilities import (
    check_tasks_capability,
    has_task_augmented_elicitation,
    has_task_augmented_sampling,
    require_task_augmented_elicitation,
    require_task_augmented_sampling,
)
from mcp.types import (
    ClientCapabilities,
    ClientTasksCapability,
    ClientTasksRequestsCapability,
    TasksCreateElicitationCapability,
    TasksCreateMessageCapability,
    TasksElicitationCapability,
    TasksSamplingCapability,
)


class TestCheckTasksCapability:
    """Tests for check_tasks_capability function."""

    def test_required_requests_none_returns_true(self) -> None:
        """When required.requests is None, should return True."""
        required = ClientTasksCapability()
        client = ClientTasksCapability()
        assert check_tasks_capability(required, client) is True

    def test_client_requests_none_returns_false(self) -> None:
        """When client.requests is None but required.requests is set, should return False."""
        required = ClientTasksCapability(requests=ClientTasksRequestsCapability())
        client = ClientTasksCapability()
        assert check_tasks_capability(required, client) is False

    def test_elicitation_required_but_client_missing(self) -> None:
        """When elicitation is required but client doesn't have it."""
        required = ClientTasksCapability(
            requests=ClientTasksRequestsCapability(elicitation=TasksElicitationCapability())
        )
        client = ClientTasksCapability(requests=ClientTasksRequestsCapability())
        assert check_tasks_capability(required, client) is False

    def test_elicitation_create_required_but_client_missing(self) -> None:
        """When elicitation.create is required but client doesn't have it."""
        required = ClientTasksCapability(
            requests=ClientTasksRequestsCapability(
                elicitation=TasksElicitationCapability(create=TasksCreateElicitationCapability())
            )
        )
        client = ClientTasksCapability(
            requests=ClientTasksRequestsCapability(
                elicitation=TasksElicitationCapability()  # No create
            )
        )
        assert check_tasks_capability(required, client) is False

    def test_elicitation_create_present(self) -> None:
        """When elicitation.create is required and client has it."""
        required = ClientTasksCapability(
            requests=ClientTasksRequestsCapability(
                elicitation=TasksElicitationCapability(create=TasksCreateElicitationCapability())
            )
        )
        client = ClientTasksCapability(
            requests=ClientTasksRequestsCapability(
                elicitation=TasksElicitationCapability(create=TasksCreateElicitationCapability())
            )
        )
        assert check_tasks_capability(required, client) is True

    def test_sampling_required_but_client_missing(self) -> None:
        """When sampling is required but client doesn't have it."""
        required = ClientTasksCapability(requests=ClientTasksRequestsCapability(sampling=TasksSamplingCapability()))
        client = ClientTasksCapability(requests=ClientTasksRequestsCapability())
        assert check_tasks_capability(required, client) is False

    def test_sampling_create_message_required_but_client_missing(self) -> None:
        """When sampling.createMessage is required but client doesn't have it."""
        required = ClientTasksCapability(
            requests=ClientTasksRequestsCapability(
                sampling=TasksSamplingCapability(createMessage=TasksCreateMessageCapability())
            )
        )
        client = ClientTasksCapability(
            requests=ClientTasksRequestsCapability(
                sampling=TasksSamplingCapability()  # No createMessage
            )
        )
        assert check_tasks_capability(required, client) is False

    def test_sampling_create_message_present(self) -> None:
        """When sampling.createMessage is required and client has it."""
        required = ClientTasksCapability(
            requests=ClientTasksRequestsCapability(
                sampling=TasksSamplingCapability(createMessage=TasksCreateMessageCapability())
            )
        )
        client = ClientTasksCapability(
            requests=ClientTasksRequestsCapability(
                sampling=TasksSamplingCapability(createMessage=TasksCreateMessageCapability())
            )
        )
        assert check_tasks_capability(required, client) is True

    def test_both_elicitation_and_sampling_present(self) -> None:
        """When both elicitation.create and sampling.createMessage are required and client has both."""
        required = ClientTasksCapability(
            requests=ClientTasksRequestsCapability(
                elicitation=TasksElicitationCapability(create=TasksCreateElicitationCapability()),
                sampling=TasksSamplingCapability(createMessage=TasksCreateMessageCapability()),
            )
        )
        client = ClientTasksCapability(
            requests=ClientTasksRequestsCapability(
                elicitation=TasksElicitationCapability(create=TasksCreateElicitationCapability()),
                sampling=TasksSamplingCapability(createMessage=TasksCreateMessageCapability()),
            )
        )
        assert check_tasks_capability(required, client) is True

    def test_elicitation_without_create_required(self) -> None:
        """When elicitation is required but not create specifically."""
        required = ClientTasksCapability(
            requests=ClientTasksRequestsCapability(
                elicitation=TasksElicitationCapability()  # No create
            )
        )
        client = ClientTasksCapability(
            requests=ClientTasksRequestsCapability(
                elicitation=TasksElicitationCapability(create=TasksCreateElicitationCapability())
            )
        )
        assert check_tasks_capability(required, client) is True

    def test_sampling_without_create_message_required(self) -> None:
        """When sampling is required but not createMessage specifically."""
        required = ClientTasksCapability(
            requests=ClientTasksRequestsCapability(
                sampling=TasksSamplingCapability()  # No createMessage
            )
        )
        client = ClientTasksCapability(
            requests=ClientTasksRequestsCapability(
                sampling=TasksSamplingCapability(createMessage=TasksCreateMessageCapability())
            )
        )
        assert check_tasks_capability(required, client) is True


class TestHasTaskAugmentedElicitation:
    """Tests for has_task_augmented_elicitation function."""

    def test_tasks_none(self) -> None:
        """Returns False when caps.tasks is None."""
        caps = ClientCapabilities()
        assert has_task_augmented_elicitation(caps) is False

    def test_requests_none(self) -> None:
        """Returns False when caps.tasks.requests is None."""
        caps = ClientCapabilities(tasks=ClientTasksCapability())
        assert has_task_augmented_elicitation(caps) is False

    def test_elicitation_none(self) -> None:
        """Returns False when caps.tasks.requests.elicitation is None."""
        caps = ClientCapabilities(tasks=ClientTasksCapability(requests=ClientTasksRequestsCapability()))
        assert has_task_augmented_elicitation(caps) is False

    def test_create_none(self) -> None:
        """Returns False when caps.tasks.requests.elicitation.create is None."""
        caps = ClientCapabilities(
            tasks=ClientTasksCapability(
                requests=ClientTasksRequestsCapability(elicitation=TasksElicitationCapability())
            )
        )
        assert has_task_augmented_elicitation(caps) is False

    def test_create_present(self) -> None:
        """Returns True when full capability path is present."""
        caps = ClientCapabilities(
            tasks=ClientTasksCapability(
                requests=ClientTasksRequestsCapability(
                    elicitation=TasksElicitationCapability(create=TasksCreateElicitationCapability())
                )
            )
        )
        assert has_task_augmented_elicitation(caps) is True


class TestHasTaskAugmentedSampling:
    """Tests for has_task_augmented_sampling function."""

    def test_tasks_none(self) -> None:
        """Returns False when caps.tasks is None."""
        caps = ClientCapabilities()
        assert has_task_augmented_sampling(caps) is False

    def test_requests_none(self) -> None:
        """Returns False when caps.tasks.requests is None."""
        caps = ClientCapabilities(tasks=ClientTasksCapability())
        assert has_task_augmented_sampling(caps) is False

    def test_sampling_none(self) -> None:
        """Returns False when caps.tasks.requests.sampling is None."""
        caps = ClientCapabilities(tasks=ClientTasksCapability(requests=ClientTasksRequestsCapability()))
        assert has_task_augmented_sampling(caps) is False

    def test_create_message_none(self) -> None:
        """Returns False when caps.tasks.requests.sampling.createMessage is None."""
        caps = ClientCapabilities(
            tasks=ClientTasksCapability(requests=ClientTasksRequestsCapability(sampling=TasksSamplingCapability()))
        )
        assert has_task_augmented_sampling(caps) is False

    def test_create_message_present(self) -> None:
        """Returns True when full capability path is present."""
        caps = ClientCapabilities(
            tasks=ClientTasksCapability(
                requests=ClientTasksRequestsCapability(
                    sampling=TasksSamplingCapability(createMessage=TasksCreateMessageCapability())
                )
            )
        )
        assert has_task_augmented_sampling(caps) is True


class TestRequireTaskAugmentedElicitation:
    """Tests for require_task_augmented_elicitation function."""

    def test_raises_when_none(self) -> None:
        """Raises McpError when client_caps is None."""
        with pytest.raises(McpError) as exc_info:
            require_task_augmented_elicitation(None)
        assert "task-augmented elicitation" in str(exc_info.value)

    def test_raises_when_missing(self) -> None:
        """Raises McpError when capability is missing."""
        caps = ClientCapabilities()
        with pytest.raises(McpError) as exc_info:
            require_task_augmented_elicitation(caps)
        assert "task-augmented elicitation" in str(exc_info.value)

    def test_passes_when_present(self) -> None:
        """Does not raise when capability is present."""
        caps = ClientCapabilities(
            tasks=ClientTasksCapability(
                requests=ClientTasksRequestsCapability(
                    elicitation=TasksElicitationCapability(create=TasksCreateElicitationCapability())
                )
            )
        )
        require_task_augmented_elicitation(caps)


class TestRequireTaskAugmentedSampling:
    """Tests for require_task_augmented_sampling function."""

    def test_raises_when_none(self) -> None:
        """Raises McpError when client_caps is None."""
        with pytest.raises(McpError) as exc_info:
            require_task_augmented_sampling(None)
        assert "task-augmented sampling" in str(exc_info.value)

    def test_raises_when_missing(self) -> None:
        """Raises McpError when capability is missing."""
        caps = ClientCapabilities()
        with pytest.raises(McpError) as exc_info:
            require_task_augmented_sampling(caps)
        assert "task-augmented sampling" in str(exc_info.value)

    def test_passes_when_present(self) -> None:
        """Does not raise when capability is present."""
        caps = ClientCapabilities(
            tasks=ClientTasksCapability(
                requests=ClientTasksRequestsCapability(
                    sampling=TasksSamplingCapability(createMessage=TasksCreateMessageCapability())
                )
            )
        )
        require_task_augmented_sampling(caps)