from fastapi import APIRouter, Depends, HTTPException, status, Query
from sqlalchemy.orm import Session
from typing import List, Optional
from app.database import get_db
from app.crud.donation import donation_crud, donation_request_crud
from app.schemas.donation import (
    DonationCreate, DonationUpdate, DonationResponse, 
    DonationRequestCreate, DonationRequestResponse,
    DonationSearchParams, DonationSearchResponse
)
from app.core.deps import get_current_active_user, get_optional_user
from app.models.user import User

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


@router.get("/", response_model=DonationSearchResponse)
def get_donations(
    search: Optional[str] = Query(None, description="Terme de recherche"),
    category: Optional[str] = Query(None, description="Catégorie"),
    status: Optional[str] = Query(None, description="Statut"),
    page: int = Query(1, ge=1, description="Numéro de page"),
    per_page: int = Query(10, ge=1, le=100, description="Éléments par page"),
    db: Session = Depends(get_db)
):
    """Obtenir tous les dons avec pagination et filtres"""
    result = donation_crud.search(db, search, category, status, page, per_page)
    return result


@router.post("/", response_model=DonationResponse)
def create_donation(
    donation_create: DonationCreate,
    current_user: User = Depends(get_current_active_user),
    db: Session = Depends(get_db)
):
    """Créer un nouveau don"""
    donation = donation_crud.create(db, donation_create, current_user.id)
    return donation


@router.get("/{donation_id}", response_model=DonationResponse)
def get_donation(
    donation_id: int,
    db: Session = Depends(get_db),
    current_user: Optional[User] = Depends(get_optional_user)
):
    """Obtenir un don par ID"""
    donation = donation_crud.get_by_id(db, donation_id)
    if not donation:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="Don non trouvé"
        )
    
    # Incrémenter les vues si l'utilisateur n'est pas le propriétaire
    if not current_user or current_user.id != donation.user_id:
        donation_crud.increment_views(db, donation_id)
    
    return donation


@router.put("/{donation_id}", response_model=DonationResponse)
def update_donation(
    donation_id: int,
    donation_update: DonationUpdate,
    current_user: User = Depends(get_current_active_user),
    db: Session = Depends(get_db)
):
    """Mettre à jour un don"""
    donation = donation_crud.get_by_id(db, donation_id)
    if not donation:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="Don non trouvé"
        )
    
    # Vérifier que l'utilisateur est le propriétaire ou un admin
    if donation.user_id != current_user.id and not current_user.is_admin:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Vous n'avez pas la permission de modifier ce don"
        )
    
    updated_donation = donation_crud.update(db, donation_id, donation_update)
    return updated_donation


@router.delete("/{donation_id}")
def delete_donation(
    donation_id: int,
    current_user: User = Depends(get_current_active_user),
    db: Session = Depends(get_db)
):
    """Supprimer un don"""
    donation = donation_crud.get_by_id(db, donation_id)
    if not donation:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="Don non trouvé"
        )
    
    # Vérifier que l'utilisateur est le propriétaire ou un admin
    if donation.user_id != current_user.id and not current_user.is_admin:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Vous n'avez pas la permission de supprimer ce don"
        )
    
    success = donation_crud.delete(db, donation_id)
    if not success:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail="Erreur lors de la suppression"
        )
    
    return {"message": "Don supprimé avec succès"}


@router.get("/{donation_id}/requests", response_model=List[DonationRequestResponse])
def get_donation_requests(
    donation_id: int,
    current_user: User = Depends(get_current_active_user),
    db: Session = Depends(get_db)
):
    """Obtenir les demandes pour un don spécifique"""
    donation = donation_crud.get_by_id(db, donation_id)
    if not donation:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="Don non trouvé"
        )
    
    # Vérifier que l'utilisateur est le propriétaire ou un admin
    if donation.user_id != current_user.id and not current_user.is_admin:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Vous n'avez pas la permission de voir ces demandes"
        )
    
    requests = donation_request_crud.get_by_donation(db, donation_id)
    return requests


@router.post("/{donation_id}/requests", response_model=DonationRequestResponse)
def create_donation_request(
    donation_id: int,
    request_create: DonationRequestCreate,
    db: Session = Depends(get_db)
):
    """Créer une demande pour un don"""
    # Vérifier que le don existe
    donation = donation_crud.get_by_id(db, donation_id)
    if not donation:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="Don non trouvé"
        )
    
    # Vérifier que le don est actif
    if donation.status != "active":
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="Ce don n'accepte plus de demandes"
        )
    
    # S'assurer que donation_id est correct
    request_create.donation_id = donation_id
    
    request = donation_request_crud.create(db, request_create)
    return request


@router.put("/requests/{request_id}/status")
def update_request_status(
    request_id: int,
    status: str,
    current_user: User = Depends(get_current_active_user),
    db: Session = Depends(get_db)
):
    """Mettre à jour le statut d'une demande de don"""
    request = donation_request_crud.get_by_id(db, request_id)
    if not request:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="Demande non trouvée"
        )
    
    # Vérifier que l'utilisateur est le propriétaire du don ou un admin
    donation = donation_crud.get_by_id(db, request.donation_id)
    if donation.user_id != current_user.id and not current_user.is_admin:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Vous n'avez pas la permission de modifier cette demande"
        )
    
    updated_request = donation_request_crud.update_status(db, request_id, status)
    return updated_request


@router.get("/my-donations", response_model=List[DonationResponse])
def get_my_donations(
    current_user: User = Depends(get_current_active_user),
    db: Session = Depends(get_db)
):
    """Obtenir les dons de l'utilisateur actuel"""
    donations = donation_crud.get_by_user(db, current_user.id)
    return donations