import uuid
from fastapi import APIRouter, Depends, HTTPException, status
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession

from app.core.dependencies import GESTIONNAIRE_PLUS, get_current_user, require_role
from app.core.responses import api_response
from app.db.database import get_async_session
from app.models.contact_urgence import ContactUrgence
from app.models.faq import Faq
from app.schemas.aide import (
    FaqCreate,
    FaqUpdate,
    ContactUrgenceCreate,
    ContactUrgenceUpdate,
)

router = APIRouter(prefix="/aide", tags=["Aide"])


@router.get("/faqs")
async def get_faqs(
    db: AsyncSession = Depends(get_async_session),
    _user=Depends(get_current_user),
):
    rows = (
        await db.execute(
            select(Faq).where(Faq.est_publie == True).order_by(Faq.ordre, Faq.date_creation)
        )
    ).scalars().all()
    data = [
        {
            "id": str(f.id),
            "question": f.question,
            "reponse": f.reponse,
            "categorie": f.categorie,
            "ordre": f.ordre,
        }
        for f in rows
    ]
    return api_response(data, message="FAQ récupérée")


@router.post("/faqs", status_code=201)
async def creer_faq(
    body: FaqCreate,
    db: AsyncSession = Depends(get_async_session),
    _user=Depends(require_role(*GESTIONNAIRE_PLUS)),
):
    faq = Faq(
        question=body.question,
        reponse=body.reponse,
        categorie=body.categorie,
        ordre=body.ordre,
        est_publie=True,
    )
    db.add(faq)
    await db.commit()
    await db.refresh(faq)
    data = {
        "id": str(faq.id),
        "question": faq.question,
        "reponse": faq.reponse,
        "categorie": faq.categorie,
        "ordre": faq.ordre,
    }
    return api_response(data, message="FAQ créée", status_code=201)


@router.put("/faqs/{faq_id}")
async def modifier_faq(
    faq_id: uuid.UUID,
    body: FaqUpdate,
    db: AsyncSession = Depends(get_async_session),
    _user=Depends(require_role(*GESTIONNAIRE_PLUS)),
):
    faq = await db.get(Faq, faq_id)
    if not faq:
        raise HTTPException(status_code=404, detail="FAQ non trouvée")
    
    if body.question is not None:
        faq.question = body.question
    if body.reponse is not None:
        faq.reponse = body.reponse
    if body.categorie is not None:
        faq.categorie = body.categorie
    if body.ordre is not None:
        faq.ordre = body.ordre

    await db.commit()
    await db.refresh(faq)
    data = {
        "id": str(faq.id),
        "question": faq.question,
        "reponse": faq.reponse,
        "categorie": faq.categorie,
        "ordre": faq.ordre,
    }
    return api_response(data, message="FAQ modifiée")


@router.delete("/faqs/{faq_id}", status_code=204)
async def supprimer_faq(
    faq_id: uuid.UUID,
    db: AsyncSession = Depends(get_async_session),
    _user=Depends(require_role(*GESTIONNAIRE_PLUS)),
):
    faq = await db.get(Faq, faq_id)
    if not faq:
        raise HTTPException(status_code=404, detail="FAQ non trouvée")
    
    await db.delete(faq)
    await db.commit()
    return None


@router.get("/contacts-urgence")
async def get_contacts_urgence(
    db: AsyncSession = Depends(get_async_session),
    _user=Depends(get_current_user),
):
    rows = (
        await db.execute(
            select(ContactUrgence)
            .where(ContactUrgence.est_actif == True)
            .order_by(ContactUrgence.ordre, ContactUrgence.date_creation)
        )
    ).scalars().all()
    data = [
        {
            "id": str(c.id),
            "nom": c.nom,
            "telephone": c.telephone,
            "email": c.email,
            "description": c.description,
            "categorie": c.categorie,
            "ordre": c.ordre,
        }
        for c in rows
    ]
    return api_response(data, message="Contacts d'urgence récupérés")


@router.post("/contacts-urgence", status_code=201)
async def creer_contact_urgence(
    body: ContactUrgenceCreate,
    db: AsyncSession = Depends(get_async_session),
    _user=Depends(require_role(*GESTIONNAIRE_PLUS)),
):
    contact = ContactUrgence(
        nom=body.nom,
        telephone=body.telephone,
        email=body.email,
        description=body.description,
        categorie=body.categorie,
        ordre=body.ordre,
        est_actif=True,
    )
    db.add(contact)
    await db.commit()
    await db.refresh(contact)
    data = {
        "id": str(contact.id),
        "nom": contact.nom,
        "telephone": contact.telephone,
        "email": contact.email,
        "description": contact.description,
        "categorie": contact.categorie,
        "ordre": contact.ordre,
    }
    return api_response(data, message="Contact d'urgence créé", status_code=201)


@router.put("/contacts-urgence/{contact_id}")
async def modifier_contact_urgence(
    contact_id: uuid.UUID,
    body: ContactUrgenceUpdate,
    db: AsyncSession = Depends(get_async_session),
    _user=Depends(require_role(*GESTIONNAIRE_PLUS)),
):
    contact = await db.get(ContactUrgence, contact_id)
    if not contact:
        raise HTTPException(status_code=404, detail="Contact d'urgence non trouvé")
    
    if body.nom is not None:
        contact.nom = body.nom
    if body.telephone is not None:
        contact.telephone = body.telephone
    if body.email is not None:
        contact.email = body.email
    if body.description is not None:
        contact.description = body.description
    if body.categorie is not None:
        contact.categorie = body.categorie
    if body.ordre is not None:
        contact.ordre = body.ordre

    await db.commit()
    await db.refresh(contact)
    data = {
        "id": str(contact.id),
        "nom": contact.nom,
        "telephone": contact.telephone,
        "email": contact.email,
        "description": contact.description,
        "categorie": contact.categorie,
        "ordre": contact.ordre,
    }
    return api_response(data, message="Contact d'urgence modifié")


@router.delete("/contacts-urgence/{contact_id}", status_code=204)
async def supprimer_contact_urgence(
    contact_id: uuid.UUID,
    db: AsyncSession = Depends(get_async_session),
    _user=Depends(require_role(*GESTIONNAIRE_PLUS)),
):
    contact = await db.get(ContactUrgence, contact_id)
    if not contact:
        raise HTTPException(status_code=404, detail="Contact d'urgence non trouvé")
    
    await db.delete(contact)
    await db.commit()
    return None