"""
Routes API pour la gestion des clients
"""
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy.orm import Session
from typing import List, Optional
from app.database import get_db
from app.models import Client
from app.schemas.client import ClientCreate, ClientUpdate, ClientResponse

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


@router.get("/", response_model=List[ClientResponse])
def lire_clients(
    skip: int = Query(0, ge=0),
    limit: int = Query(100, ge=1, le=1000),
    actif: Optional[int] = None,
    recherche: Optional[str] = None,
    db: Session = Depends(get_db)
):
    """
    Récupère la liste des clients avec filtres optionnels
    """
    query = db.query(Client)
    
    # Filtres
    if actif is not None:
        query = query.filter(Client.actif == actif)
    if recherche:
        query = query.filter(
            (Client.raison_sociale.ilike(f"%{recherche}%")) |
            (Client.ville.ilike(f"%{recherche}%")) |
            (Client.nom_contact.ilike(f"%{recherche}%"))
        )
    
    clients = query.offset(skip).limit(limit).all()
    return clients
 

@router.get("/{client_id}", response_model=ClientResponse)
def lire_client(client_id: int, db: Session = Depends(get_db)):
    """
    Récupère un client spécifique par son ID
    """
    client = db.query(Client).filter(Client.id == client_id).first()
    if not client:
        raise HTTPException(status_code=404, detail="Client non trouvé")
         
    return client


@router.post("/", response_model=ClientResponse, status_code=201)
def creer_client(client: ClientCreate, db: Session = Depends(get_db)):
    """
    Crée un nouveau client
    """
    # Vérifier que le SIRET n'existe pas déjà (si fourni)
    if client.siret:
        if db.query(Client).filter(Client.siret == client.siret).first():
            raise HTTPException(status_code=400, detail="Ce SIRET existe déjà")
    
    # Créer le client
    db_client = Client(**client.model_dump())
    db.add(db_client)
    db.commit()
    db.refresh(db_client)
           
    return db_client


@router.put("/{client_id}", response_model=ClientResponse)
def modifier_client(
    client_id: int,
    client_update: ClientUpdate,
    db: Session = Depends(get_db)
):
    """
    Modifie un client existant
    """
    db_client = db.query(Client).filter(Client.id == client_id).first()
    if not db_client:
        raise HTTPException(status_code=404, detail="Client non trouvé")
    
    # Mettre à jour uniquement les champs fournis
    update_data = client_update.model_dump(exclude_unset=True)
    for field, value in update_data.items():
        setattr(db_client, field, value)
    
    db.commit()
    db.refresh(db_client)
       
    return db_client


@router.delete("/{client_id}", status_code=204)
def archiver_client(client_id: int, db: Session = Depends(get_db)):
    """
    Archive un client (soft delete)
    """
    db_client = db.query(Client).filter(Client.id == client_id).first()
    if not db_client:
        raise HTTPException(status_code=404, detail="Client non trouvé")
    
    # Archiver au lieu de supprimer
    db_client.actif = 0
    db.commit()
    
    return None


@router.post("/{client_id}/restaurer", response_model=ClientResponse)
def restaurer_client(client_id: int, db: Session = Depends(get_db)):
    """
    Restaure un client archivé
    """
    db_client = db.query(Client).filter(Client.id == client_id).first()
    if not db_client:
        raise HTTPException(status_code=404, detail="Client non trouvé")
    
    db_client.actif = 1
    db.commit()
    db.refresh(db_client)
    
    # Enrichir
    db_client.nom_complet_contact = db_client.nom_complet_contact
    db_client.ville_complete = db_client.ville_complete
    
    return db_client