import asyncio
from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
from sqlalchemy import select
from sqlalchemy.orm import selectinload

# Driver async : asyncpg pour PostgreSQL, aiosqlite pour SQLite
engine = create_async_engine("postgresql+asyncpg://user:pass@localhost/technologik")
AsyncSessionLocal = async_sessionmaker(bind=engine, expire_on_commit=False)

async def creer_utilisateur(email: str, nom: str) -> Utilisateur:
    async with AsyncSessionLocal() as session:
        utilisateur = Utilisateur(email=email, nom=nom)
        session.add(utilisateur)
        await session.commit()
        await session.refresh(utilisateur)  # recharge les champs générés côté base
        return utilisateur

async def lister_actifs() -> list[Utilisateur]:
    async with AsyncSessionLocal() as session:
        stmt = select(Utilisateur).where(Utilisateur.est_actif == True)
        resultat = await session.execute(stmt)
        return list(resultat.scalars().all())

# Eager loading obligatoire en async : accéder à une relation lazy hors session lève une erreur
async def lister_auteurs_avec_articles() -> list[Auteur]:
    async with AsyncSessionLocal() as session:
        stmt = select(Auteur).options(selectinload(Auteur.articles))
        resultat = await session.execute(stmt)
        return list(resultat.scalars().all())

# Dependency FastAPI async
from collections.abc import AsyncGenerator

async def get_async_db() -> AsyncGenerator[AsyncSession, None]:
    async with AsyncSessionLocal() as session:
        yield session

# @app.get("/utilisateurs")
# async def route(db: AsyncSession = Depends(get_async_db)):
#     resultat = await db.execute(select(Utilisateur))
#     return resultat.scalars().all()

# Requêtes concurrentes : chaque tâche a besoin de SA PROPRE session (non partageable)
async def charger_en_parallele():
    async def charger_utilisateur(uid: int):
        async with AsyncSessionLocal() as session:
            return await session.get(Utilisateur, uid)

    resultats = await asyncio.gather(
        charger_utilisateur(1),
        charger_utilisateur(2),
        charger_utilisateur(3),
    )
    return resultats

# Transaction async explicite
async def transferer(source_id: int, dest_id: int, montant: float):
    async with AsyncSessionLocal() as session:
        async with session.begin():
            source = await session.get(Compte, source_id)
            dest = await session.get(Compte, dest_id)
            source.solde -= montant
            dest.solde += montant
            if source.solde < 0:
                raise ValueError("Solde insuffisant")   # déclenche un rollback automatique

# run_sync : exécuter du code synchrone (legacy) dans un contexte async
async def utiliser_api_synchrone():
    async with AsyncSessionLocal() as session:
        def operation_sync(sync_session):
            return sync_session.execute(select(Utilisateur)).scalars().all()
        return await session.run_sync(operation_sync)