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

# imports
import pytest  # used for our unit tests
from pydantic import AnyUrl
from src.mcp.server.fastmcp.server import FastMCP


# Mock classes to simulate the environment
class FunctionResource:
    def __init__(self, uri, name, description, mime_type, fn):
        self.uri = uri
        self.name = name
        self.description = description
        self.mime_type = mime_type
        self.fn = fn

class ResourceManager:
    def __init__(self, warn_on_duplicate_resources=False):
        self.resources = {}
        self.warn_on_duplicate_resources = warn_on_duplicate_resources

    def add_template(self, fn, uri_template, name, description, mime_type):
        self.resources[uri_template] = fn
from src.mcp.server.fastmcp.server import FastMCP

# unit tests

@pytest.fixture
def server():
    return FastMCP()

def test_register_simple_uri(server):
    """Test registering a function with a simple static URI."""
    @server.resource("resource://simple")
    def simple_resource():
        return "Simple Resource"

def test_register_parameterized_uri(server):
    """Test registering a function with a parameterized URI."""
    @server.resource("resource://{param}")
    def param_resource(param):
        return f"Resource with {param}"


def test_decorator_misuse(server):
    """Test error when decorator is used without calling it."""
    with pytest.raises(TypeError):
        @server.resource
        def misuse_resource():
            return "Misused Resource"

def test_duplicate_resource_registration(server):
    """Test registering the same function with the same URI."""
    @server.resource("resource://duplicate")
    def duplicate_resource():
        return "Duplicate Resource"

    @server.resource("resource://duplicate")
    def duplicate_resource_again():
        return "Duplicate Resource Again"

def test_register_async_function(server):
    """Test registering an asynchronous function."""
    @server.resource("resource://async")
    async def async_resource():
        return "Async Resource"

def test_large_number_of_resources(server):
    """Test registering a large number of resources."""
    for i in range(1000):
        @server.resource(f"resource://large{i}")
        def large_resource():
            return f"Resource {i}"

def test_complex_return_type(server):
    """Test registering a function with a complex return type."""
    @server.resource("resource://complex")
    def complex_resource():
        return {"key": "value"}
# 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_resource():
    FastMCP.resource(FastMCP(name=None, instructions=None), '', name=None, description=None, mime_type=None)