from sqlalchemy.orm import validates, Mapped, mapped_column
from sqlalchemy.ext.hybrid import hybrid_property, hybrid_method
from sqlalchemy import select, and_

# @validates : valide/transforme une valeur AVANT qu'elle soit assignée à l'attribut
class Utilisateur(Base):
    __tablename__ = "utilisateurs_v2"
    id: Mapped[int] = mapped_column(primary_key=True)
    email: Mapped[str] = mapped_column(String(255))
    age: Mapped[int | None]

    @validates("email")
    def valider_email(self, cle: str, valeur: str) -> str:
        if "@" not in valeur:
            raise ValueError(f"Email invalide : {valeur}")
        return valeur.strip().lower()   # normalisation systématique

    @validates("age")
    def valider_age(self, cle: str, valeur: int | None) -> int | None:
        if valeur is not None and valeur < 0:
            raise ValueError("L'âge ne peut pas être négatif")
        return valeur

u = Utilisateur(email="  Jean@Exemple.COM  ", age=30)
print(u.email)  # "jean@exemple.com" -- normalisé automatiquement

# hybrid_property : fonctionne à la fois en Python (instance) ET en SQL (au niveau classe)
class Produit(Base):
    __tablename__ = "produits_v2"
    id: Mapped[int] = mapped_column(primary_key=True)
    prix_ht: Mapped[float]
    taux_tva: Mapped[float] = mapped_column(default=20.0)

    @hybrid_property
    def prix_ttc(self) -> float:
        # Accès Python : produit.prix_ttc sur une instance déjà chargée
        return self.prix_ht * (1 + self.taux_tva / 100)

    @prix_ttc.expression
    def prix_ttc(cls):
        # Accès SQL : utilisable dans un WHERE/ORDER BY, traduit en expression SQL
        return cls.prix_ht * (1 + cls.taux_tva / 100)

p = Produit(prix_ht=100, taux_tva=20)
print(p.prix_ttc)  # 120.0 -- calculé en Python

with SessionLocal() as session:
    # utilisé directement dans une requête -- traduit en SQL, PAS chargé puis filtré en Python
    stmt = select(Produit).where(Produit.prix_ttc > 100).order_by(Produit.prix_ttc.desc())
    resultats = session.scalars(stmt).all()

# hybrid_method : version paramétrable d'une hybrid_property
class Commande(Base):
    __tablename__ = "commandes_v2"
    id: Mapped[int] = mapped_column(primary_key=True)
    montant: Mapped[float]
    cree_le: Mapped[datetime]

    @hybrid_method
    def est_recente(self, jours: int = 30) -> bool:
        return (datetime.utcnow() - self.cree_le).days <= jours

    @est_recente.expression
    def est_recente(cls, jours: int = 30):
        from sqlalchemy import func
        return cls.cree_le >= func.now() - func.make_interval(days=jours)

# Validation au niveau applicatif avec Pydantic AVANT de toucher l'ORM (couche schemas/)
from pydantic import BaseModel, EmailStr, field_validator

class UtilisateurCreate(BaseModel):
    email: EmailStr
    age: int

    @field_validator("age")
    @classmethod
    def age_valide(cls, v: int) -> int:
        if v < 0 or v > 150:
            raise ValueError("Âge hors limites plausibles")
        return v
# Pattern recommandé : Pydantic valide l'entrée HTTP, @validates protège l'intégrité au niveau ORM