from dataclasses import dataclass, field, asdict, astuple, replace, InitVar
from typing import ClassVar

# --- dataclass de base : genere __init__, __repr__, __eq__ automatiquement ---
@dataclass
class Point:
    x: float
    y: float

p1 = Point(1.0, 2.0)
p2 = Point(1.0, 2.0)
print(p1)              # Point(x=1.0, y=2.0) -- __repr__ genere
print(p1 == p2)          # True -- __eq__ genere, compare champ par champ

# --- field() : valeurs par defaut mutables et options avancees ---
@dataclass
class Commande:
    id: int
    articles: list[str] = field(default_factory=list)     # JAMAIS un [] direct (piege mutable)
    metadonnees: dict = field(default_factory=dict, repr=False)   # exclu du __repr__
    total: float = field(default=0.0, compare=False)                # exclu du __eq__

c1 = Commande(1)
c1.articles.append("clavier")
c2 = Commande(1)
print(c2.articles)        # [] -- chaque instance a sa PROPRE liste, contrairement au piege classique

# --- frozen=True : immuabilite, genere aussi __hash__ automatiquement ---
@dataclass(frozen=True)
class Coordonnees:
    latitude: float
    longitude: float

coord = Coordonnees(48.85, 2.35)
try:
    coord.latitude = 0
except AttributeError as e:
    print(f"Refuse : {e}")

cache_lieux = {Coordonnees(48.85, 2.35): "Paris"}     # hashable grace a frozen=True

# --- order=True : genere __lt__, __le__, __gt__, __ge__ (tri par ordre des champs declares) ---
@dataclass(order=True)
class Version:
    majeur: int
    mineur: int
    patch: int

versions = [Version(1, 2, 0), Version(1, 0, 5), Version(2, 0, 0)]
print(sorted(versions))     # tri lexicographique sur (majeur, mineur, patch)

# --- __post_init__ : validation/derivation apres la generation de __init__ ---
@dataclass
class Rectangle:
    largeur: float
    hauteur: float
    aire: float = field(init=False)     # calcule, pas fourni par l'appelant

    def __post_init__(self):
        if self.largeur <= 0 or self.hauteur <= 0:
            raise ValueError("Dimensions invalides")
        self.aire = self.largeur * self.hauteur

rect = Rectangle(4, 5)
print(rect.aire)            # 20

# --- InitVar : parametre passe a __init__/__post_init__ mais PAS stocke comme champ ---
@dataclass
class Utilisateur:
    nom: str
    mot_de_passe_brut: InitVar[str]
    hash_mdp: str = field(init=False, default="")

    def __post_init__(self, mot_de_passe_brut: str):
        import hashlib
        self.hash_mdp = hashlib.sha256(mot_de_passe_brut.encode()).hexdigest()

u = Utilisateur("Alice", "secret123")
print(u.hash_mdp[:8])
# u.mot_de_passe_brut         # AttributeError : InitVar n'est jamais stocke sur l'instance

# --- ClassVar : declare une annotation SANS en faire un champ de dataclass ---
@dataclass
class Compteur:
    valeur: int = 0
    total_instances: ClassVar[int] = 0        # partage entre instances, ignore par __init__

    def __post_init__(self):
        Compteur.total_instances += 1

# --- Heritage de dataclasses : les champs du parent viennent EN PREMIER ---
@dataclass
class Animal:
    nom: str
    espece: str = "inconnue"

@dataclass
class Chien(Animal):
    race: str = "inconnue"
    # ATTENTION : un champ sans defaut ne peut pas suivre un champ avec defaut dans la hierarchie
    # (TypeError a la definition de la classe si l'ordre est incorrect)

# --- Utilitaires : asdict, astuple, replace (immuabilite fonctionnelle) ---
print(asdict(rect))                       # {'largeur': 4, 'hauteur': 5, 'aire': 20}
print(astuple(coord))                      # (48.85, 2.35)
coord2 = replace(coord, latitude=0.0)         # nouvelle instance, un seul champ modifie
print(coord2)

# --- slots=True (Python 3.10+) : gain memoire, empeche les attributs dynamiques ---
@dataclass(slots=True)
class PointOptimise:
    x: float
    y: float

import sys
print(sys.getsizeof(PointOptimise(1, 2)) < sys.getsizeof(Point(1, 2)))     # True

# --- attrs : la librairie qui a inspire dataclasses, avec plus de fonctionnalites ---
# pip install attrs
'''
import attrs

@attrs.define
class Produit:
    nom: str
    prix: float = attrs.field(validator=attrs.validators.gt(0))     # validation native
    tags: list = attrs.field(factory=list)

    @prix.validator
    def _verifie_prix(self, attribut, valeur):
        if valeur > 1_000_000:
            raise ValueError("Prix suspect")

# attrs.define genere aussi __slots__ par defaut (contrairement a @dataclass)
# et propose des converters :
@attrs.define
class Produit2:
    prix: float = attrs.field(converter=float)    # convertit automatiquement a l'assignation

p = Produit2(prix="19.99")     # converti en float automatiquement
'''