"""
Routes FastAPI pour le planning Gantt
"""
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from pydantic import BaseModel
from typing import Optional
from datetime import datetime

from app.database import get_db
from app.models.tache_planning import TachePlanning
from app.models.projet import Projet, Niveau, Piece
from app.models.client import Client
from app.models.operateur import Operateur
from app.models.type_piece import TypePiece

router = APIRouter(prefix="/api/planning", tags=["planning"])


class TacheCreate(BaseModel):
    projet_id: int
    niveau_id: Optional[int] = None
    piece_id: Optional[int] = None
    operateur_id: Optional[int] = None
    date_debut: str
    date_fin: str
    statut: Optional[str] = "planifie"
    commentaire: Optional[str] = None


@router.get("/taches")
def liste_taches(db: Session = Depends(get_db)):
    taches = db.query(TachePlanning).all()
    result = []
    for t in taches:
        projet = db.query(Projet).filter(Projet.id == t.projet_id).first()
        client = db.query(Client).filter(Client.id == projet.client_id).first() if projet and projet.client_id else None
        piece = db.query(Piece).filter(Piece.id == t.piece_id).first() if t.piece_id else None
        niveau = db.query(Niveau).filter(Niveau.id == t.niveau_id).first() if t.niveau_id else None
        operateur = db.query(Operateur).filter(Operateur.id == t.operateur_id).first() if t.operateur_id else None
        result.append({
            "id": t.id,
            "projet_id": t.projet_id,
            "projet_nom": projet.nom if projet else "—",
            "client_nom": client.raison_sociale if client else None,
            "niveau_id": t.niveau_id,
            "niveau_nom": niveau.nom if niveau else None,
            "piece_id": t.piece_id,
            "piece_ref": piece.reference if piece else None,
            "piece_type": piece.type_piece if piece else None,
            "piece_quantite": piece.quantite if piece else None,
            "piece_volume_unitaire": piece.volume_unitaire if piece else None,
            "piece_volume_total": piece.volume_total if piece else None,
            "piece_type_beton": piece.type_beton if piece else None,
            "piece_epaisseur": piece.epaisseur if piece else None,
            "piece_largeur": piece.largeur if piece else None,
            "piece_longueur": piece.longueur if piece else None,
            "operateur_id": t.operateur_id,
            "operateur_nom": f"{operateur.prenom} {operateur.nom}" if operateur else None,
            "operateur_couleur": operateur.couleur if operateur else "#4facfe",
            "date_debut": t.date_debut,
            "date_fin": t.date_fin,
            "statut": t.statut,
            "commentaire": t.commentaire,
            "piece_temps_unitaire": (lambda tp: tp.temps_unitaire if tp else 0)(db.query(TypePiece).filter(TypePiece.nom == piece.type_piece).first()) if piece else None,
            "piece_statut_realisation": piece.statut_realisation if piece else None,
            "piece_plans_fabriques": piece.plans_fabriques if piece else False,
            "piece_heures_budgetees": piece.heures_budgetees if piece else None,
            "piece_heures_reelles": piece.heures_reelles if piece else None,
            "piece_heures_reelles_verrouillee": piece.heures_reelles_verrouillee if piece else 0,
        })
    return result


@router.get("/taches/jour/{date}")
def taches_du_jour(date: str, db: Session = Depends(get_db)):
    taches = db.query(TachePlanning).filter(
        TachePlanning.date_debut <= date,
        TachePlanning.date_fin >= date
    ).all()
    return taches


@router.post("/taches")
def creer_tache(data: TacheCreate, db: Session = Depends(get_db)):
    tache = TachePlanning(
        projet_id=data.projet_id,
        niveau_id=data.niveau_id,
        piece_id=data.piece_id,
        operateur_id=data.operateur_id,
        date_debut=data.date_debut,
        date_fin=data.date_fin,
        statut=data.statut,
        commentaire=data.commentaire,
        date_creation=datetime.utcnow().isoformat()
    )
    db.add(tache)
    db.commit()
    db.refresh(tache)
    return tache


@router.put("/taches/{tache_id}")
def modifier_tache(tache_id: int, data: TacheCreate, db: Session = Depends(get_db)):
    tache = db.query(TachePlanning).filter(TachePlanning.id == tache_id).first()
    if not tache:
        raise HTTPException(404, "Tâche introuvable")
    tache.projet_id = data.projet_id
    tache.niveau_id = data.niveau_id
    tache.piece_id = data.piece_id
    tache.operateur_id = data.operateur_id
    tache.date_debut = data.date_debut
    tache.date_fin = data.date_fin
    tache.statut = data.statut
    tache.commentaire = data.commentaire
    db.commit()
    return tache


@router.delete("/taches/{tache_id}")
def supprimer_tache(tache_id: int, db: Session = Depends(get_db)):
    tache = db.query(TachePlanning).filter(TachePlanning.id == tache_id).first()
    if not tache:
        raise HTTPException(404, "Tâche introuvable")
    db.delete(tache)
    db.commit()
    return {"ok": True}


@router.get("/projets-valides")
def projets_valides(db: Session = Depends(get_db)):
    """Retourne les projets validés avec leurs niveaux et pièces pour le Gantt"""
    projets = db.query(Projet).filter(Projet.statut == "valide").all()
    result = []
    for p in projets:
        niveaux = db.query(Niveau).filter(Niveau.projet_id == p.id).all()
        niveaux_data = []
        for n in niveaux:
            pieces = db.query(Piece).filter(Piece.niveau_id == n.id).all()
            niveaux_data.append({
                "id": n.id,
                "nom": n.nom,
                "date_reception_armatures": n.date_reception_armatures,
                "date_livraison_chantier": n.date_livraison_chantier,
                "pieces": [{
                    "id": pc.id,
                    "reference": pc.reference,
                    "type_piece": pc.type_piece,
                    "quantite": pc.quantite,
                    "statut_realisation": pc.statut_realisation,
                    "epaisseur": pc.epaisseur,
                    "largeur": pc.largeur,
                    "longueur": pc.longueur
                } for pc in pieces]
            })
        client = db.query(Client).filter(Client.id == p.client_id).first() if p.client_id else None
        result.append({
            "id": p.id,
            "nom": p.nom,
            "client": p.client_id,
            "client_nom": client.raison_sociale if client else None,
            "niveaux": niveaux_data
        })
    return result