from typing import Literal

import mcp_types as types
import pytest
from mcp_types import (
    LoggingMessageNotificationParams,
    TextContent,
)

from mcp import Client
from mcp.server.mcpserver import Context, MCPServer
from mcp.shared.session import RequestResponder


class LoggingCollector:
    def __init__(self):
        self.log_messages: list[LoggingMessageNotificationParams] = []

    async def __call__(self, params: LoggingMessageNotificationParams) -> None:
        self.log_messages.append(params)


@pytest.mark.anyio
async def test_logging_callback():
    server = MCPServer("test")
    logging_collector = LoggingCollector()

    # Create a simple test tool
    @server.tool("test_tool")
    async def test_tool() -> bool:
        # The actual tool is very simple and just returns True
        return True

    # Create a function that can send a log notification
    @server.tool("test_tool_with_log")
    async def test_tool_with_log(
        message: str, level: Literal["debug", "info", "warning", "error"], logger: str, ctx: Context
    ) -> bool:
        """Send a log notification to the client."""
        await ctx.log(level=level, data=message, logger_name=logger)  # pyright: ignore[reportDeprecated]
        return True

    @server.tool("test_tool_with_log_dict")
    async def test_tool_with_log_dict(
        level: Literal["debug", "info", "warning", "error"],
        logger: str,
        ctx: Context,
    ) -> bool:
        """Send a log notification with a dict payload."""
        await ctx.log(  # pyright: ignore[reportDeprecated]
            level=level,
            data={"message": "Test log message", "extra_string": "example", "extra_dict": {"a": 1, "b": 2, "c": 3}},
            logger_name=logger,
        )
        return True

    # Create a message handler to catch exceptions
    async def message_handler(
        message: RequestResponder[types.ServerRequest, types.ClientResult] | types.ServerNotification | Exception,
    ) -> None:
        if isinstance(message, Exception):  # pragma: no cover
            raise message

    async with Client(
        server,
        logging_callback=logging_collector,
        message_handler=message_handler,
        mode="legacy",
    ) as client:
        # First verify our test tool works
        result = await client.call_tool("test_tool", {})
        assert result.is_error is False
        assert isinstance(result.content[0], TextContent)
        assert result.content[0].text == "true"

        # Now send a log message via our tool
        log_result = await client.call_tool(
            "test_tool_with_log",
            {
                "message": "Test log message",
                "level": "info",
                "logger": "test_logger",
            },
        )
        log_result_with_dict = await client.call_tool(
            "test_tool_with_log_dict",
            {
                "level": "info",
                "logger": "test_logger",
            },
        )
        assert log_result.is_error is False
        assert log_result_with_dict.is_error is False
        assert len(logging_collector.log_messages) == 2
        # Create meta object with related_request_id added dynamically
        log = logging_collector.log_messages[0]
        assert log.level == "info"
        assert log.logger == "test_logger"
        assert log.data == "Test log message"

        log_with_dict = logging_collector.log_messages[1]
        assert log_with_dict.level == "info"
        assert log_with_dict.logger == "test_logger"
        assert log_with_dict.data == {
            "message": "Test log message",
            "extra_string": "example",
            "extra_dict": {"a": 1, "b": 2, "c": 3},
        }