groupe-meditation/backend/app/routers/collectes.py

"""Routes S1 — Collecte 7e Tradition."""
from datetime import date, datetime, time as dt_time, timezone
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select, desc, extract, func

from app.core.database import get_db
from app.core.security import get_current_membre, require_executif
from app.models.collecte import Collecte
from app.models.groupe import Groupe
from app.models.membre import Membre
from app.models.depense import Depense
from app.models.envoi_contribution import EnvoiContribution
from app.models.operation_bancaire import OperationBancaire
from app.models.reserve import Reserve
from app.models.affectation import Affectation
from app.models.poste import Poste
from app.schemas.phase1 import CollecteCreate, CollecteOut, CollecteUpdate, SoldesOut

router = APIRouter(prefix="/collectes", tags=["S1 — Collecte 7e Tradition"])

JOURS_SEMAINE = {
    "lundi": 0, "mardi": 1, "mercredi": 2, "jeudi": 3,
    "vendredi": 4, "samedi": 5, "dimanche": 6,
}


async def _est_tresorier(membre_id, groupe_id, db: AsyncSession) -> bool:
    """Vérifie si un membre est trésorier ou exécutif."""
    result = await db.execute(
        select(Affectation).join(Poste).where(
            Affectation.membre_id == membre_id,
            Affectation.statut == "actif",
            (Poste.nom.ilike("%trésorier%") | (Poste.categorie == "executif")),
        )
    )
    return result.scalars().first() is not None


async def _require_tresorier(membre=Depends(get_current_membre), db: AsyncSession = Depends(get_db)):
    if not await _est_tresorier(membre.id, membre.groupe_id, db):
        raise HTTPException(status_code=403, detail="Réservé au trésorier ou à l'exécutif")
    return membre


async def _to_out(c: Collecte, db: AsyncSession) -> CollecteOut:
    detenteur = await db.get(Membre, c.detenteur_id) if c.detenteur_id else None
    saisi = await db.get(Membre, c.saisi_par) if c.saisi_par else None
    confirme = await db.get(Membre, c.confirme_par) if c.confirme_par else None
    recu = await db.get(Membre, c.recu_par) if c.recu_par else None
    return CollecteOut(
        id=c.id,
        date_collecte=c.date_collecte,
        montant=float(c.montant),
        detenteur_prenom=detenteur.prenom if detenteur else None,
        statut=c.statut,
        saisi_par_prenom=saisi.prenom if saisi else None,
        confirme_par_prenom=confirme.prenom if confirme else None,
        date_confirmation=c.date_confirmation,
        recu_par_prenom=recu.prenom if recu else None,
        date_reception=c.date_reception,
        cree_le=c.cree_le,
    )


@router.post("/", response_model=CollecteOut)
async def saisir_collecte(
    req: CollecteCreate,
    membre=Depends(get_current_membre),
    db: AsyncSession = Depends(get_db),
):
    """S1 — N'importe quel membre saisit la collecte. Rétroactif possible sur les dates de réunion."""
    groupe = await db.get(Groupe, membre.groupe_id)
    aujourdhui = date.today()

    # Validation : pas dans le futur
    if req.date_collecte > aujourdhui:
        raise HTTPException(status_code=400, detail="La date ne peut pas être dans le futur")

    # Validation : la date doit tomber un jour de réunion
    if groupe.jour_reunion:
        jour_attendu = JOURS_SEMAINE.get(groupe.jour_reunion.lower())
        if jour_attendu is not None and req.date_collecte.weekday() != jour_attendu:
            raise HTTPException(
                status_code=400,
                detail=f"La collecte doit avoir lieu un {groupe.jour_reunion}",
            )

    # Validation : si c'est aujourd'hui, pas avant l'heure de la réunion
    if req.date_collecte == aujourdhui and groupe.heure_reunion:
        now = datetime.now(timezone.utc)
        if isinstance(groupe.heure_reunion, dt_time) and now.time() < groupe.heure_reunion:
            raise HTTPException(
                status_code=400,
                detail=f"La saisie n'est possible qu'à partir de {groupe.heure_reunion.strftime('%H:%M')}",
            )

    # Validation : une seule collecte par date de réunion
    result = await db.execute(
        select(Collecte).where(
            Collecte.groupe_id == membre.groupe_id,
            Collecte.date_collecte == req.date_collecte,
        )
    )
    if result.scalars().first():
        raise HTTPException(
            status_code=400,
            detail=f"Il y a déjà une collecte pour le {req.date_collecte}",
        )

    collecte = Collecte(
        groupe_id=membre.groupe_id,
        date_collecte=req.date_collecte,
        montant=req.montant,
        reunion_id=req.reunion_id,
        detenteur_id=req.detenteur_id,
        statut="en_attente",
        saisi_par=membre.id,
    )
    db.add(collecte)
    await db.flush()
    return await _to_out(collecte, db)


@router.patch("/{collecte_id}", response_model=CollecteOut)
async def ajuster_collecte(
    collecte_id: str,
    req: CollecteUpdate,
    membre=Depends(get_current_membre),
    db: AsyncSession = Depends(get_db),
):
    """Ajuster le montant (exécutif ou celui qui a saisi, avant confirmation)."""
    result = await db.execute(
        select(Collecte).where(
            Collecte.id == collecte_id,
            Collecte.groupe_id == membre.groupe_id,
        )
    )
    collecte = result.scalar_one_or_none()
    if not collecte:
        raise HTTPException(status_code=404, detail="Collecte introuvable")
    if collecte.statut != "en_attente":
        raise HTTPException(status_code=400, detail="Le montant ne peut plus être modifié après confirmation")

    # Vérifier : exécutif ou saisi_par
    est_exec = await _est_tresorier(membre.id, membre.groupe_id, db)
    if collecte.saisi_par != membre.id and not est_exec:
        raise HTTPException(status_code=403, detail="Seul un exécutif ou la personne qui a saisi peut modifier")

    if req.montant is not None:
        collecte.montant = req.montant
    await db.flush()
    return await _to_out(collecte, db)


@router.post("/{collecte_id}/confirmer", response_model=CollecteOut)
async def confirmer_collecte(
    collecte_id: str,
    membre=Depends(get_current_membre),
    db: AsyncSession = Depends(get_db),
):
    """Un second membre confirme le montant. Si le trésorier est impliqué → réception auto."""
    result = await db.execute(
        select(Collecte).where(
            Collecte.id == collecte_id,
            Collecte.groupe_id == membre.groupe_id,
        )
    )
    collecte = result.scalar_one_or_none()
    if not collecte:
        raise HTTPException(status_code=404, detail="Collecte introuvable")
    if collecte.statut != "en_attente":
        raise HTTPException(status_code=400, detail="Cette collecte a déjà été confirmée")
    if collecte.saisi_par == membre.id:
        raise HTTPException(status_code=400, detail="Le montant doit être confirmé par un autre membre")

    collecte.confirme_par = membre.id
    collecte.date_confirmation = datetime.now(timezone.utc)

    # Si le trésorier est celui qui confirme OU celui qui a saisi → réception auto
    confirmateur_est_tres = await _est_tresorier(membre.id, membre.groupe_id, db)
    saisisseur_est_tres = await _est_tresorier(collecte.saisi_par, collecte.groupe_id, db)

    if confirmateur_est_tres or saisisseur_est_tres:
        tresorier_id = membre.id if confirmateur_est_tres else collecte.saisi_par
        collecte.statut = "recu"
        collecte.recu_par = tresorier_id
        collecte.date_reception = date.today()
    else:
        collecte.statut = "confirmee"

    await db.flush()
    return await _to_out(collecte, db)


@router.post("/{collecte_id}/reception", response_model=CollecteOut)
async def accuser_reception(
    collecte_id: str,
    membre=Depends(_require_tresorier),
    db: AsyncSession = Depends(get_db),
):
    """Le trésorier accuse réception (pour les cas sans trésorier impliqué)."""
    result = await db.execute(
        select(Collecte).where(
            Collecte.id == collecte_id,
            Collecte.groupe_id == membre.groupe_id,
        )
    )
    collecte = result.scalar_one_or_none()
    if not collecte:
        raise HTTPException(status_code=404, detail="Collecte introuvable")
    if collecte.statut == "recu":
        raise HTTPException(status_code=400, detail="Cette collecte a déjà été reçue")

    # Si en_attente, confirme aussi
    if collecte.statut == "en_attente":
        collecte.confirme_par = membre.id
        collecte.date_confirmation = datetime.now(timezone.utc)

    collecte.statut = "recu"
    collecte.recu_par = membre.id
    collecte.date_reception = date.today()
    await db.flush()
    return await _to_out(collecte, db)


@router.get("/", response_model=list[CollecteOut])
async def liste_collectes(
    statut: str | None = None,
    mois: int | None = None,
    annee: int | None = None,
    limite: int = 20,
    membre=Depends(get_current_membre),
    db: AsyncSession = Depends(get_db),
):
    query = select(Collecte).where(Collecte.groupe_id == membre.groupe_id)
    if statut:
        query = query.where(Collecte.statut == statut)
    if mois and annee:
        query = query.where(
            extract("month", Collecte.date_collecte) == mois,
            extract("year", Collecte.date_collecte) == annee,
        )
    elif annee:
        query = query.where(extract("year", Collecte.date_collecte) == annee)
    query = query.order_by(desc(Collecte.date_collecte)).limit(limite)
    result = await db.execute(query)
    return [await _to_out(c, db) for c in result.scalars().all()]


@router.get("/soldes")
async def soldes_tresorerie(
    membre=Depends(get_current_membre),
    db: AsyncSession = Depends(get_db),
):
    """Soldes détaillés : relevé bancaire, sommes engagées, réserves, disponible."""
    from app.models.vente_litterature import VenteLitterature

    gid = membre.groupe_id

    # ── Dernier relevé bancaire ──
    result = await db.execute(
        select(OperationBancaire).where(
            OperationBancaire.groupe_id == gid,
            OperationBancaire.type == "releve",
        ).order_by(desc(OperationBancaire.date_operation)).limit(1)
    )
    dernier_releve = result.scalar_one_or_none()
    solde_releve = float(dernier_releve.montant) if dernier_releve else 0.0
    date_releve = str(dernier_releve.date_operation) if dernier_releve else None

    # ── Dépôts et retraits depuis le dernier relevé ──
    filtre_depuis = dernier_releve.date_operation if dernier_releve else None

    # Dépôts après relevé
    q = select(func.coalesce(func.sum(OperationBancaire.montant), 0)).where(
        OperationBancaire.groupe_id == gid,
        OperationBancaire.type == "depot",
    )
    if filtre_depuis:
        q = q.where(OperationBancaire.date_operation > filtre_depuis)
    result = await db.execute(q)
    depots_depuis = float(result.scalar())

    # Retraits après relevé
    q = select(func.coalesce(func.sum(OperationBancaire.montant), 0)).where(
        OperationBancaire.groupe_id == gid,
        OperationBancaire.type == "retrait",
    )
    if filtre_depuis:
        q = q.where(OperationBancaire.date_operation > filtre_depuis)
    result = await db.execute(q)
    retraits_depuis = float(result.scalar())

    # Contributions débitées après relevé
    q = select(func.coalesce(func.sum(EnvoiContribution.montant), 0)).where(
        EnvoiContribution.groupe_id == gid,
        EnvoiContribution.debitee == True,
    )
    if filtre_depuis:
        q = q.where(EnvoiContribution.date_envoi > filtre_depuis)
    result = await db.execute(q)
    contributions_debitees_depuis = float(result.scalar())

    # Dépenses bancaires débitées après relevé
    q = select(func.coalesce(func.sum(Depense.montant), 0)).where(
        Depense.groupe_id == gid,
        Depense.paye == True,
        Depense.methode.in_(["VIREMENT", "CHEQUE"]),
    )
    if filtre_depuis:
        q = q.where(Depense.date_confirmation > filtre_depuis)
    result = await db.execute(q)
    depenses_bancaires_depuis = float(result.scalar())

    solde_banque = solde_releve + depots_depuis - retraits_depuis - contributions_debitees_depuis - depenses_bancaires_depuis

    # ── Dépenses engagées non payées (chèque/virement votés mais pas encore débités) ──
    result = await db.execute(
        select(func.coalesce(func.sum(Depense.montant), 0)).where(
            Depense.groupe_id == gid,
            Depense.paye == False,
            Depense.methode.in_(["VIREMENT", "CHEQUE"]),
        )
    )
    engagements_non_debites = float(result.scalar())

    # ── Contributions engagées non débitées ──
    result = await db.execute(
        select(func.coalesce(func.sum(EnvoiContribution.montant), 0)).where(
            EnvoiContribution.groupe_id == gid,
            EnvoiContribution.engagee == True,
            EnvoiContribution.debitee == False,
        )
    )
    contributions_non_debitees = float(result.scalar())
    engagements_non_debites += contributions_non_debitees

    # ── Réserves ──
    result = await db.execute(
        select(Reserve).where(
            Reserve.groupe_id == gid,
            Reserve.active == True,
        ).order_by(Reserve.nom)
    )
    reserves = result.scalars().all()
    reserves_details = [
        {
            "id": str(r.id),
            "nom": r.nom,
            "montant": float(r.montant),
            "note": r.note,
        }
        for r in reserves
    ]
    total_reserves = sum(r["montant"] for r in reserves_details)

    # ── Somme disponible ──
    disponible = solde_banque - engagements_non_debites - total_reserves

    # ── Encaisse (cash reçu par le trésorier, pas déposé) ──
    result = await db.execute(
        select(func.coalesce(func.sum(Collecte.montant), 0)).where(
            Collecte.groupe_id == gid, Collecte.statut == "recu"))
    total_collectes_recues = float(result.scalar())

    result = await db.execute(
        select(func.coalesce(func.sum(OperationBancaire.montant), 0)).where(
            OperationBancaire.groupe_id == gid, OperationBancaire.type == "depot"))
    total_depots = float(result.scalar())

    result = await db.execute(
        select(func.coalesce(func.sum(OperationBancaire.montant), 0)).where(
            OperationBancaire.groupe_id == gid, OperationBancaire.type == "retrait"))
    total_retraits = float(result.scalar())

    result = await db.execute(
        select(func.coalesce(func.sum(Depense.montant), 0)).where(
            Depense.groupe_id == gid, Depense.paye == True, Depense.methode == "COLLECTE"))
    depenses_cash = float(result.scalar())

    # Ventes de littérature remises au trésorier
    result = await db.execute(
        select(func.coalesce(func.sum(VenteLitterature.montant), 0)).where(
            VenteLitterature.groupe_id == gid, VenteLitterature.remis_tresorier == True))
    ventes_recues = float(result.scalar())

    encaisse = total_collectes_recues + ventes_recues + total_retraits - total_depots - depenses_cash

    # ── Argent en circulation (collectes non remises au trésorier) ──
    result = await db.execute(
        select(Collecte).where(
            Collecte.groupe_id == gid, Collecte.statut.in_(["en_attente", "confirmee"])))
    en_circulation = result.scalars().all()
    details_circulation = []
    total_en_circulation = 0.0
    for c in en_circulation:
        det = await db.get(Membre, c.detenteur_id) if c.detenteur_id else None
        total_en_circulation += float(c.montant)
        details_circulation.append({
            "date": str(c.date_collecte),
            "montant": float(c.montant),
            "detenteur": det.prenom if det else "?",
            "statut": c.statut,
        })

    # ── Ventes de littérature non remises ──
    result = await db.execute(
        select(VenteLitterature).where(
            VenteLitterature.groupe_id == gid,
            VenteLitterature.remis_tresorier == False,
        )
    )
    from app.models.litterature import Litterature
    ventes_non_remises = result.scalars().all()
    details_ventes = []
    total_ventes_non_remises = 0.0
    for v in ventes_non_remises:
        vendeur = await db.get(Membre, v.vendu_par) if v.vendu_par else None
        item = await db.get(Litterature, v.litterature_id) if v.litterature_id else None
        total_ventes_non_remises += float(v.montant)
        details_ventes.append({
            "id": str(v.id),
            "date": str(v.date_vente),
            "montant": float(v.montant),
            "titre": item.titre if item else "?",
            "vendu_par": vendeur.prenom if vendeur else "?",
        })

    return {
        "solde_banque": round(solde_banque, 2),
        "date_releve": date_releve,
        "encaisse": round(encaisse, 2),
        "disponible": round(disponible, 2),
        "engagements_non_debites": round(engagements_non_debites, 2),
        "reserve_prudente": 0,
        "reserve_anniversaire": 0,
        "total_reserves": round(total_reserves, 2),
        "reserves_details": reserves_details,
        "en_possession": round(total_en_circulation, 2),
        "en_possession_details": details_circulation,
        "ventes_non_remises": round(total_ventes_non_remises, 2),
        "ventes_non_remises_details": details_ventes,
    }


@router.get("/registre")
async def registre_transactions(
    mois: int | None = None,
    annee: int | None = None,
    type_transaction: str | None = None,
    membre=Depends(get_current_membre),
    db: AsyncSession = Depends(get_db),
):
    """Registre détaillé de toutes les transactions financières du groupe."""
    from app.models.vente_litterature import VenteLitterature
    from app.models.litterature import Litterature

    gid = membre.groupe_id
    transactions = []

    # Filtres date
    def filtre_mois(d):
        if mois and annee:
            return d.month == mois and d.year == annee
        if annee:
            return d.year == annee
        return True

    def ajouter_transaction(transaction):
        if type_transaction and transaction["type"] != type_transaction:
            return
        transactions.append(transaction)

    # 1. Collectes reçues
    result = await db.execute(
        select(Collecte).where(Collecte.groupe_id == gid, Collecte.statut == "recu")
        .order_by(Collecte.date_collecte)
    )
    for c in result.scalars().all():
        if filtre_mois(c.date_collecte):
            saisi = await db.get(Membre, c.saisi_par) if c.saisi_par else None
            ajouter_transaction({
                "date": str(c.date_collecte),
                "type": "collecte",
                "description": f"Collecte 7e Tradition",
                "entree": float(c.montant),
                "sortie": 0,
                "par": saisi.prenom if saisi else "?",
            })

    # 2. Ventes de littérature remises
    result = await db.execute(
        select(VenteLitterature).where(
            VenteLitterature.groupe_id == gid,
            VenteLitterature.remis_tresorier == True,
        )
    )
    for v in result.scalars().all():
        if filtre_mois(v.date_vente):
            item = await db.get(Litterature, v.litterature_id)
            ajouter_transaction({
                "date": str(v.date_vente),
                "type": "vente_litterature",
                "description": f"Vente : {item.titre if item else '?'} (x{v.quantite})",
                "entree": float(v.montant),
                "sortie": 0,
                "par": "Littérature",
            })

    # 3. Dépenses payées
    result = await db.execute(
        select(Depense).where(Depense.groupe_id == gid, Depense.paye == True)
        .order_by(Depense.date_depense)
    )
    for d in result.scalars().all():
        if filtre_mois(d.date_depense):
            qui = await db.get(Membre, d.qui)
            ajouter_transaction({
                "date": str(d.date_depense),
                "type": "depense",
                "description": f"{d.quoi} ({d.methode})",
                "entree": 0,
                "sortie": float(d.montant),
                "par": qui.prenom if qui else "?",
            })

    # 4. Envois de contributions
    result = await db.execute(
        select(EnvoiContribution).where(
            EnvoiContribution.groupe_id == gid,
            EnvoiContribution.debitee == True,
        )
        .order_by(EnvoiContribution.date_envoi)
    )
    for e in result.scalars().all():
        if filtre_mois(e.date_envoi):
            ajouter_transaction({
                "date": str(e.date_envoi),
                "type": "contribution",
                "description": f"Contribution {e.destination} ({e.methode})",
                "entree": 0,
                "sortie": float(e.montant),
                "par": "Trésorier",
            })

    # 5. Opérations bancaires (dépôts/retraits)
    result = await db.execute(
        select(OperationBancaire).where(
            OperationBancaire.groupe_id == gid,
            OperationBancaire.type.in_(["depot", "retrait"]),
        ).order_by(OperationBancaire.date_operation)
    )
    for op in result.scalars().all():
        if filtre_mois(op.date_operation):
            m = await db.get(Membre, op.effectue_par)
            is_depot = op.type == "depot"
            ajouter_transaction({
                "date": str(op.date_operation),
                "type": f"banque_{op.type}",
                "description": f"{'Dépôt' if is_depot else 'Retrait'} bancaire{(' — ' + op.note) if op.note else ''}",
                "entree": float(op.montant) if is_depot else 0,
                "sortie": float(op.montant) if not is_depot else 0,
                "par": m.prenom if m else "?",
            })

    transactions.sort(key=lambda t: t["date"])
    return transactions