import asyncio
import threading
from contextvars import ContextVar, copy_context

# --- Le probleme que contextvars resout ---
# Une variable globale classique est PARTAGEE entre toutes les taches concurrentes :
# dangereuse en asyncio (une seule execution mais entrelacee) et en threading (course critique).
utilisateur_courant_global = None      # anti-pattern en environnement concurrent

# --- ContextVar : une variable dont la valeur est isolee PAR CONTEXTE D'EXECUTION ---
utilisateur_courant: ContextVar[str] = ContextVar("utilisateur_courant", default="anonyme")

async def traiter_requete(nom_utilisateur: str):
    jeton = utilisateur_courant.set(nom_utilisateur)     # set() retourne un token pour restaurer plus tard
    try:
        await appeler_service_metier()
    finally:
        utilisateur_courant.reset(jeton)                   # toujours nettoyer explicitement

async def appeler_service_metier():
    # lit la valeur DEFINIE PAR LA TACHE APPELANTE, meme sans parametre explicite
    print(f"Traitement pour : {utilisateur_courant.get()}")
    await asyncio.sleep(0.1)

async def demo_isolation():
    # chaque Task cree par create_task obtient une COPIE du contexte au moment de sa creation
    await asyncio.gather(
        traiter_requete("alice"),
        traiter_requete("bob"),
    )
    # Alice et Bob restent isoles l'un de l'autre, meme executes de facon entrelacee

asyncio.run(demo_isolation())

# --- Difference cruciale avec threading.local ---
# threading.local() isole par THREAD -- inadapte a asyncio (un seul thread, plusieurs coroutines).
# ContextVar isole par CONTEXTE LOGIQUE, propage correctement a travers await et create_task.
local_thread = threading.local()

def demo_thread_local():
    def worker(nom):
        local_thread.nom = nom
        import time
        time.sleep(0.05)
        print(f"Thread local : {local_thread.nom}")     # jamais melange entre threads, MAIS
        # ne fonctionnerait PAS pour isoler des coroutines dans le meme thread asyncio

    threads = [threading.Thread(target=worker, args=(n,)) for n in ["t1", "t2"]]
    for t in threads:
        t.start()
    for t in threads:
        t.join()

demo_thread_local()

# --- copy_context() : executer une fonction dans une copie isolee du contexte courant ---
compteur_appels: ContextVar[int] = ContextVar("compteur_appels", default=0)

def incrementer_et_afficher():
    compteur_appels.set(compteur_appels.get() + 1)
    print(compteur_appels.get())

ctx = copy_context()
ctx.run(incrementer_et_afficher)      # s'execute dans la copie : n'affecte PAS le contexte appelant
ctx.run(incrementer_et_afficher)      # la copie garde son propre etat entre plusieurs run()
print(compteur_appels.get())            # 0 dans le contexte principal : totalement isole

# --- Cas d'usage reel : contexte de requete HTTP dans un framework ASGI ---
requete_id: ContextVar[str] = ContextVar("requete_id")
utilisateur_id: ContextVar[int | None] = ContextVar("utilisateur_id", default=None)

class MiddlewareContexte:
    """Injecte le contexte de requete AVANT d'appeler l'application, le nettoie apres."""
    def __init__(self, app):
        self.app = app

    async def __call__(self, scope, receive, send):
        import uuid
        jeton_requete = requete_id.set(str(uuid.uuid4()))
        try:
            await self.app(scope, receive, send)
        finally:
            requete_id.reset(jeton_requete)

async def handler_metier():
    # accessible depuis N'IMPORTE QUELLE fonction appelee pendant cette requete,
    # sans passer requete_id en parametre a travers toute la chaine d'appels
    print(f"Traitement de la requete {requete_id.get()}")

# --- Piege : ThreadPoolExecutor NE PROPAGE PAS automatiquement le contexte ---
async def demo_piege_threadpool():
    utilisateur_courant.set("alice")

    def tache_bloquante():
        # DANS un thread pool, le contexte n'est PAS automatiquement copie par defaut
        return utilisateur_courant.get()     # retourne "anonyme" (la valeur par defaut), pas "alice" !

    resultat = await asyncio.to_thread(tache_bloquante)
    print(resultat)          # "anonyme" -- piege classique

    # Solution : capturer le contexte explicitement et l'utiliser dans le thread
    ctx_capture = copy_context()
    resultat_correct = await asyncio.get_event_loop().run_in_executor(
        None, lambda: ctx_capture.run(tache_bloquante)
    )
    print(resultat_correct)     # "alice" -- contexte propage manuellement

asyncio.run(demo_piege_threadpool())