from typing import Annotated, Any, Self

from pydantic import (
    AfterValidator,
    BaseModel,
    BeforeValidator,
    ModelWrapValidatorHandler,
    ValidatorFunctionWrapHandler,
    WrapValidator,
    model_validator,
)


def _field_before_validator(value: Any) -> Any:
    print("field before validator", value, type(value))
    return value


def _field_after_validator(value: Any) -> Any:
    print("field after validator:", value, type(value))
    return value


def _field_wrap_validator(value: Any, handler: ValidatorFunctionWrapHandler) -> Any:
    print("field wrap validator (before):", value, type(value))
    self = handler(value)
    print("field wrap validator (after):", self, type(self))
    return self


class M(BaseModel, validate_assignment=True):
    x: Annotated[
        str,
        AfterValidator(_field_after_validator),
        BeforeValidator(_field_before_validator),
        WrapValidator(_field_wrap_validator),
    ]

    @model_validator(mode="wrap")
    @classmethod
    def _model_wrap_validator(
        cls, data: Any, handler: ModelWrapValidatorHandler[Self]
    ) -> Self:
        print("model wrap validator (before):", data, type(data))
        self = handler(data)
        print("model wrap validator (after):", self, type(self))
        return self

    @model_validator(mode="before")
    @classmethod
    def _model_before_validator(cls, data: Any) -> Any:
        print("model before validator:", data, type(data))
        return data

    @model_validator(mode="after")
    def _model_after_validator(self) -> Self:
        print("model after validator:", self, type(self))
        return self


m = M(x="foo")
# model wrap validator (before): {'x': 'foo'} <class 'dict'>
# model before validator: {'x': 'foo'} <class 'dict'>
# field wrap validator (before): foo <class 'str'>
# field before validator foo <class 'str'>
# field after validator: foo <class 'str'>
# field wrap validator (after): foo <class 'str'>
# model wrap validator (after): x='foo' <class '__main__.M'>
# model after validator: x='foo' <class '__main__.M'>

m.x = "bar"
# model wrap validator (before): x='foo' <class '__main__.M'>
# model before validator: {'x': 'bar'} <class 'dict'>
# field wrap validator (before): bar <class 'str'>
# field before validator bar <class 'str'>
# field after validator: bar <class 'str'>
# field wrap validator (after): bar <class 'str'>
# model wrap validator (after): x='bar' <class '__main__.M'>
# model after validator: x='bar' <class '__main__.M'>