import functools
import time

# Decorateur de base : une fonction qui prend une fonction et en retourne une autre
def chronometrer(fonction):
    @functools.wraps(fonction)     # preserve __name__, __doc__ de la fonction originale
    def wrapper(*args, **kwargs):
        debut = time.perf_counter()
        resultat = fonction(*args, **kwargs)
        duree = time.perf_counter() - debut
        print(f"{fonction.__name__} a pris {duree:.4f}s")
        return resultat
    return wrapper

@chronometrer
def calcul_lourd(n):
    return sum(i ** 2 for i in range(n))

calcul_lourd(1_000_000)

# Sans le sucre syntaxique @, c'est equivalent a :
# calcul_lourd = chronometrer(calcul_lourd)

# Decorateur avec arguments : une usine a decorateurs (3 niveaux de fonctions)
def repeter(fois: int):
    def decorateur(fonction):
        @functools.wraps(fonction)
        def wrapper(*args, **kwargs):
            resultats = []
            for _ in range(fois):
                resultats.append(fonction(*args, **kwargs))
            return resultats
        return wrapper
    return decorateur

@repeter(fois=3)
def lancer_de(nombre_faces=6):
    import random
    return random.randint(1, nombre_faces)

print(lancer_de())

# Empiler plusieurs decorateurs : s'appliquent de bas en haut
def en_majuscules(fonction):
    @functools.wraps(fonction)
    def wrapper(*args, **kwargs):
        return fonction(*args, **kwargs).upper()
    return wrapper

def entre_crochets(fonction):
    @functools.wraps(fonction)
    def wrapper(*args, **kwargs):
        return f"[{fonction(*args, **kwargs)}]"
    return wrapper

@entre_crochets     # applique en dernier (exterieur)
@en_majuscules       # applique en premier (interieur)
def saluer(nom):
    return f"bonjour {nom}"

print(saluer("alice"))    # [BONJOUR ALICE]

# Decorateur avec validation / logging
def valider_positif(fonction):
    @functools.wraps(fonction)
    def wrapper(*args, **kwargs):
        for arg in args:
            if isinstance(arg, (int, float)) and arg < 0:
                raise ValueError(f"Argument negatif refuse : {arg}")
        return fonction(*args, **kwargs)
    return wrapper

@valider_positif
def racine_carree(x):
    return x ** 0.5

# Decorateurs pour la memoisation : functools.lru_cache / cache (natifs, tres utilises)
@functools.lru_cache(maxsize=None)
def fibonacci(n):
    return n if n < 2 else fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(35))          # instantane grace au cache
print(fibonacci.cache_info())  # statistiques hits/misses

# Decorateurs de classe (pas seulement de fonction)
def singleton(cls):
    instances = {}
    @functools.wraps(cls)
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance

@singleton
class Configuration:
    def __init__(self):
        self.parametres = {}

c1 = Configuration()
c2 = Configuration()
print(c1 is c2)     # True : meme instance

# Decorateur base sur une classe (avec __call__)
class CompteurAppels:
    def __init__(self, fonction):
        functools.update_wrapper(self, fonction)
        self.fonction = fonction
        self.appels = 0

    def __call__(self, *args, **kwargs):
        self.appels += 1
        print(f"Appel n°{self.appels} de {self.fonction.__name__}")
        return self.fonction(*args, **kwargs)

@CompteurAppels
def dire_bonjour():
    return "Bonjour !"

dire_bonjour()
dire_bonjour()