from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from sqlalchemy import Column, Integer, String, Date, Text, DateTime
from datetime import datetime
from app.database import get_db, Base
from pydantic import BaseModel
from typing import Optional

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


class Engin(Base):
    __tablename__ = "engins_vgp"
    id = Column(Integer, primary_key=True, index=True)
    nom = Column(String(100), nullable=False)
    type_engin = Column(String(50), nullable=True)  # pont, grue, chariot, nacelle...
    numero_serie = Column(String(100), nullable=True)
    prochaine_echeance = Column(Date, nullable=True)
    periodicite_mois = Column(Integer, default=12)  # périodicité en mois
    notes = Column(Text, nullable=True)
    date_creation = Column(DateTime, default=datetime.utcnow)


class EnginCreate(BaseModel):
    nom: str
    type_engin: Optional[str] = None
    numero_serie: Optional[str] = None
    prochaine_echeance: Optional[str] = None
    periodicite_mois: Optional[int] = 12
    notes: Optional[str] = None


class EnginUpdate(BaseModel):
    nom: Optional[str] = None
    type_engin: Optional[str] = None
    numero_serie: Optional[str] = None
    prochaine_echeance: Optional[str] = None
    periodicite_mois: Optional[int] = None
    notes: Optional[str] = None


def _fmt(e):
    return {
        "id": e.id,
        "nom": e.nom,
        "type_engin": e.type_engin,
        "numero_serie": e.numero_serie,
        "prochaine_echeance": str(e.prochaine_echeance) if e.prochaine_echeance else None,
        "periodicite_mois": e.periodicite_mois,
        "notes": e.notes,
    }


@router.get("/")
def get_engins(db: Session = Depends(get_db)):
    return [_fmt(e) for e in db.query(Engin).order_by(Engin.prochaine_echeance).all()]


@router.post("/", status_code=201)
def create_engin(data: EnginCreate, db: Session = Depends(get_db)):
    from datetime import date
    e = Engin(
        nom=data.nom,
        type_engin=data.type_engin,
        numero_serie=data.numero_serie,
        prochaine_echeance=date.fromisoformat(data.prochaine_echeance) if data.prochaine_echeance else None,
        periodicite_mois=data.periodicite_mois,
        notes=data.notes,
    )
    db.add(e); db.commit(); db.refresh(e)
    return _fmt(e)


@router.put("/{engin_id}")
def update_engin(engin_id: int, data: EnginUpdate, db: Session = Depends(get_db)):
    from datetime import date
    e = db.query(Engin).filter(Engin.id == engin_id).first()
    if not e:
        raise HTTPException(404, "Engin non trouvé")
    if data.nom is not None: e.nom = data.nom
    if data.type_engin is not None: e.type_engin = data.type_engin
    if data.numero_serie is not None: e.numero_serie = data.numero_serie
    if data.prochaine_echeance is not None:
        e.prochaine_echeance = date.fromisoformat(data.prochaine_echeance)
    if data.periodicite_mois is not None: e.periodicite_mois = data.periodicite_mois
    if data.notes is not None: e.notes = data.notes
    db.commit(); db.refresh(e)
    return _fmt(e)


@router.delete("/{engin_id}")
def delete_engin(engin_id: int, db: Session = Depends(get_db)):
    e = db.query(Engin).filter(Engin.id == engin_id).first()
    if not e:
        raise HTTPException(404, "Engin non trouvé")
    db.delete(e); db.commit()
    return {"ok": True}