from pydantic import BaseModel, field_validator, model_validator, ValidationInfo
from typing import Any


# field_validator avec accès aux autres champs déjà validés via ValidationInfo
class PasswordChange(BaseModel):
    new_password: str
    confirm_password: str

    @field_validator("confirm_password")
    @classmethod
    def passwords_match(cls, v: str, info: ValidationInfo) -> str:
        if "new_password" in info.data and v != info.data["new_password"]:
            raise ValueError("Les mots de passe ne correspondent pas")
        return v

# Validateurs "before" — transforment les données brutes AVANT la validation de type
from pydantic import BeforeValidator
from typing import Annotated


def strip_and_lower(v: Any) -> Any:
    if isinstance(v, str):
        return v.strip().lower()
    return v


class Contact(BaseModel):
    email: Annotated[str, BeforeValidator(strip_and_lower)]

# Types custom réutilisables avec Annotated — validation composable
from pydantic import AfterValidator
import re

def validate_phone(v: str) -> str:
    if not re.match(r"^\+33[67]\d{8}$", v):
        raise ValueError("Numéro de mobile français invalide (format +33612345678)")
    return v

PhoneNumber = Annotated[str, AfterValidator(validate_phone)]


class Contact2(BaseModel):
    name: str
    phone: PhoneNumber  # réutilisable dans n'importe quel modèle sans dupliquer la logique

# Sérialisation custom — field_serializer pour contrôler le format de sortie
from pydantic import field_serializer
from decimal import Decimal


class Invoice(BaseModel):
    amount: Decimal

    @field_serializer("amount")
    def serialize_amount(self, value: Decimal) -> str:
        return f"{value:.2f} €"  # ex. "49.99 €" au lieu du Decimal brut en JSON

# Validation contextuelle — comportement différent selon le contexte d'appel
class ProductUpdate(BaseModel):
    name: str | None = None
    price: float | None = None

    @model_validator(mode="after")
    def check_admin_only_fields(self, info: ValidationInfo) -> "ProductUpdate":
        context = info.context or {}
        if self.price is not None and not context.get("is_admin", False):
            raise ValueError("Seul un admin peut modifier le prix")
        return self


# Utilisation avec contexte dans un endpoint
@router.patch("/products/{id}")
def update_product(id: int, data: dict, current_user: Annotated[User, Depends(get_current_user)]):
    validated = ProductUpdate.model_validate(data, context={"is_admin": current_user.role == "admin"})
    return validated

# Validation stricte vs permissive — strict=True refuse la coercition implicite de type
class StrictOrder(BaseModel):
    quantity: int

    model_config = {"strict": True}

# StrictOrder(quantity="5")  -> lève une erreur (pas de coercition string -> int)
# StrictOrder(quantity=5)    -> OK