# imports
from functools import cached_property, partial, partialmethod, wraps
from typing import Any

import pytest  # used for our unit tests
from pydantic._internal._decorators import unwrap_wrapped_function

# unit tests

def test_simple_function():
    # Test a simple undecorated function
    def simple_function():
        pass
    assert unwrap_wrapped_function(simple_function) is simple_function

def test_property():
    # Test a class with a property
    class MyClass:
        @property
        def my_property(self):
            return 42
    assert unwrap_wrapped_function(MyClass.my_property) is MyClass.my_property.fget

def test_cached_property():
    # Test a class with a cached property
    class MyClass:
        @cached_property
        def my_cached_property(self):
            return 42
    assert unwrap_wrapped_function(MyClass.my_cached_property) is MyClass.my_cached_property.func

def test_partial_function():
    # Test a function wrapped with functools.partial
    def original_function(a, b):
        return a + b
    partial_function = partial(original_function, 1)
    assert unwrap_wrapped_function(partial_function) is original_function

def test_partial_method():
    # Test a class with a method wrapped with functools.partialmethod
    class MyClass:
        def original_method(self, a, b):
            return a + b
        partial_method = partialmethod(original_method, 1)
    assert unwrap_wrapped_function(MyClass.partial_method) is MyClass.original_method

def test_class_method():
    # Test a class with a class method
    class MyClass:
        @classmethod
        def my_class_method(cls):
            return 42
    assert unwrap_wrapped_function(MyClass.my_class_method) is MyClass.my_class_method.__func__

def test_static_method():
    # Test a class with a static method
    class MyClass:
        @staticmethod
        def my_static_method():
            return 42
    assert unwrap_wrapped_function(MyClass.my_static_method) is MyClass.my_static_method.__func__

def test_nested_decorators():
    # Test a function with multiple decorators
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            return func(*args, **kwargs)
        return wrapper

    @decorator
    @partial
    def nested_function(a, b):
        return a + b

    assert unwrap_wrapped_function(nested_function) is nested_function.__wrapped__

def test_combined_decorators():
    # Test a class with methods that have combined decorators
    class MyClass:
        @classmethod
        @staticmethod
        def combined_method(cls):
            return 42
        partial_combined_method = partialmethod(combined_method, 1)
    assert unwrap_wrapped_function(MyClass.combined_method) is MyClass.combined_method.__func__
    assert unwrap_wrapped_function(MyClass.partial_combined_method) is MyClass.combined_method

def test_non_callable():
    # Test passing a non-callable object
    non_callable = 42
    assert unwrap_wrapped_function(non_callable) is non_callable

def test_unwrapped_function():
    # Test a function that is already unwrapped
    def already_unwrapped():
        pass
    assert unwrap_wrapped_function(already_unwrapped) is already_unwrapped

def test_large_scale():
    # Test performance with a deeply nested function wrapped with many partial decorators
    def deeply_nested_function(a, b):
        return a + b
    for _ in range(1000):
        deeply_nested_function = partial(deeply_nested_function, 1)
    assert unwrap_wrapped_function(deeply_nested_function) is deeply_nested_function.func