import logging
from collections.abc import AsyncIterator, Callable
from contextlib import AbstractAsyncContextManager, asynccontextmanager
from typing import Any, Literal, TypeVar
from unittest.mock import MagicMock, patch

# imports
import pytest  # used for our unit tests
from mcp.server.fastmcp.prompts import PromptManager
from mcp.server.fastmcp.resources import ResourceManager
from mcp.server.fastmcp.tools import ToolManager
from mcp.server.fastmcp.utilities.logging import configure_logging
# function to test
from mcp.server.lowlevel.server import LifespanResultT
from mcp.server.lowlevel.server import Server as MCPServer
from mcp.server.lowlevel.server import lifespan as default_lifespan
from mcp.server.session import ServerSession
from src.mcp.server.fastmcp.server import FastMCP

# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.


import logging
from collections.abc import AsyncIterator, Callable
from contextlib import AbstractAsyncContextManager, asynccontextmanager
from typing import Any, Literal, TypeVar

# imports
import pytest  # used for our unit tests
from mcp.server.fastmcp.prompts import PromptManager
from mcp.server.fastmcp.resources import ResourceManager
from mcp.server.fastmcp.tools import ToolManager
from mcp.server.fastmcp.utilities.logging import configure_logging
# function to test
from mcp.server.lowlevel.server import LifespanResultT
from mcp.server.lowlevel.server import Server as MCPServer
from mcp.server.lowlevel.server import lifespan as default_lifespan
from mcp.server.session import ServerSession
from src.mcp.server.fastmcp.server import FastMCP


def lifespan_wrapper(
    app: FastMCP,
    lifespan: Callable[[FastMCP], AbstractAsyncContextManager[LifespanResultT]],
) -> Callable[[MCPServer[LifespanResultT]], AbstractAsyncContextManager[object]]:
    @asynccontextmanager
    async def wrap(s: MCPServer[LifespanResultT]) -> AsyncIterator[object]:
        async with lifespan(app) as context:
            yield context

    return wrap
from src.mcp.server.fastmcp.server import FastMCP

LifespanResultT = TypeVar("LifespanResultT")


@asynccontextmanager
async def lifespan(server: Server[LifespanResultT]) -> AsyncIterator[object]:
    """Default lifespan context manager that does nothing.

    Args:
        server: The server instance this lifespan is managing

    Returns:
        An empty context object
    """
    yield {}




def configure_logging(
    level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "INFO",
) -> None:
    """Configure logging for MCP.

    Args:
        level: the log level to use
    """
    handlers: list[logging.Handler] = []
    try:
        from rich.console import Console
        from rich.logging import RichHandler

        handlers.append(RichHandler(console=Console(stderr=True), rich_tracebacks=True))
    except ImportError:
        pass

    if not handlers:
        handlers.append(logging.StreamHandler())

    logging.basicConfig(
        level=level,
        format="%(message)s",
        handlers=handlers,
    )

# Mock classes for testing
class MockMCPServer:
    def __init__(self, request_context=None):
        self.request_context = request_context

class Context:
    def __init__(self, request_context, fastmcp):
        self.request_context = request_context
        self.fastmcp = fastmcp

class Settings:
    def __init__(self, **kwargs):
        self.lifespan = kwargs.get('lifespan', None)
        self.warn_on_duplicate_tools = kwargs.get('warn_on_duplicate_tools', False)
        self.warn_on_duplicate_resources = kwargs.get('warn_on_duplicate_resources', False)
        self.warn_on_duplicate_prompts = kwargs.get('warn_on_duplicate_prompts', False)
        self.dependencies = kwargs.get('dependencies', [])
        self.log_level = kwargs.get('log_level', 'INFO')

# unit tests
@pytest.fixture
def fastmcp_instance():
    """Fixture to create a FastMCP instance with default settings."""
    return FastMCP()

def test_valid_request_context(fastmcp_instance):
    """Test get_context with a valid request context."""
    fastmcp_instance._mcp_server = MockMCPServer(request_context={"user": "test"})
    codeflash_output = fastmcp_instance.get_context(); context = codeflash_output

def test_no_request_context(fastmcp_instance):
    """Test get_context when no request context is available."""
    fastmcp_instance._mcp_server = MockMCPServer()
    codeflash_output = fastmcp_instance.get_context(); context = codeflash_output

def test_exception_handling(fastmcp_instance):
    """Test get_context exception handling for unexpected exceptions."""
    class FaultyMCPServer:
        @property
        def request_context(self):
            raise AttributeError("Unexpected error")

    fastmcp_instance._mcp_server = FaultyMCPServer()
    with pytest.raises(AttributeError):
        fastmcp_instance.get_context()

def test_integration_with_fastmcp(fastmcp_instance):
    """Test that the context includes a reference to the FastMCP instance."""
    fastmcp_instance._mcp_server = MockMCPServer(request_context={"session": "active"})
    codeflash_output = fastmcp_instance.get_context(); context = codeflash_output

def test_large_scale_request_context(fastmcp_instance):
    """Test performance with a large request context."""
    large_context = {f"key_{i}": f"value_{i}" for i in range(1000)}
    fastmcp_instance._mcp_server = MockMCPServer(request_context=large_context)
    codeflash_output = fastmcp_instance.get_context(); context = codeflash_output

def test_deterministic_behavior(fastmcp_instance):
    """Ensure consistent results across multiple test runs."""
    fastmcp_instance._mcp_server = MockMCPServer(request_context={"consistent": "test"})
    codeflash_output = fastmcp_instance.get_context(); context1 = codeflash_output
    codeflash_output = fastmcp_instance.get_context(); context2 = codeflash_output

def test_edge_case_empty_fastmcp():
    """Test get_context with an empty FastMCP instance."""
    empty_fastmcp = FastMCP()
    empty_fastmcp._mcp_server = MockMCPServer()
    codeflash_output = empty_fastmcp.get_context(); context = codeflash_output
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from src.mcp.server.fastmcp.server import FastMCP

def test_FastMCP_get_context():
    FastMCP.get_context(FastMCP(name=None, instructions=None))