from django.shortcuts import render, get_object_or_404, redirect
from django.contrib.auth.decorators import login_required
from django.utils import timezone
from ballot.models import Vote

# Imports des modèles locaux et des autres apps
from nominations.models import Evenement
from .models import SiteSettings
from . import selectors

# Imports des services et sélecteurs de logique métier
from ballot.services import cast_vote, VoteError
from voters.selectors import get_voter_by_user
from nominations.models import Candidat # Ajout de l'import
from ballot.selectors import has_user_voted_in_category 


def index(request):
    """Page d'accueil : Liste des événements actifs."""
    events = selectors.get_active_events()
    return render(request, 'awards_vitrine/index.html', {
        'events': events,
        'now': timezone.now() # Ajout crucial pour les badges de statut
    })

def event_detail(request, event_id):
    """Détail de l'événement avec état des votes de l'utilisateur."""
    event = selectors.get_event_with_details(event_id)
    
    if timezone.now() > event.date_fin:
        return redirect('awards_vitrine:results', event_id=event.id)
    
    # Initialisation des données de vote pour l'utilisateur
    user_voted_categories = []
    
    if request.user.is_authenticated:
        voter = get_voter_by_user(request.user)
        if voter:
            # On récupère les IDs des catégories où l'utilisateur a déjà voté
            user_voted_categories = list(Vote.objects.filter(
                voter_hash=voter.voter_hash, 
                evenement=event
            ).values_list('categorie_id', flat=True))

    return render(request, 'awards_vitrine/event_detail.html', {
        'event': event,
        'user_voted_categories': user_voted_categories,
        # On passe les catégories via prefetch pour éviter les requêtes N+1
        'categories': event.categories.all() 
    })

def vote_interface(request, candidat_id):
    """Page de confirmation finale (Spotlight) avant scellement."""
    candidate = get_object_or_404(Candidat, id=candidat_id)
    voter = get_voter_by_user(request.user)

    # Sécurité : Vérification ultime avant d'afficher l'interface de confirmation
    if has_user_voted_in_category(voter.voter_hash, candidate.categorie.id):
        return redirect('/security-alert/?type=DoubleVote&msg=Vous avez déjà voté ici.')

    return render(request, 'awards_vitrine/vote_interface.html', {
        'candidate': candidate,
        'category': candidate.categorie,
        'event': candidate.categorie.evenement
    })

@login_required
def vote_submit(request):
    """Traitement sécurisé du vote."""
    if request.method == 'POST':
        candidat_id = request.POST.get('candidat_id')
        voter = get_voter_by_user(request.user)
        
        if not voter:
            return redirect('awards_vitrine:security_error')

        try:
            cast_vote(voter_hash=voter.voter_hash, candidat_id=candidat_id)
            return redirect('awards_vitrine:confirmation')
        except VoteError as e:
            return redirect(f'/security-alert/?type=DoubleVote&msg={e}')
            
    return redirect('awards_vitrine:index')

def confirmation_view(request):
    """Page de succès avec bouton de retour contextualisé."""
    event_id = request.session.get('last_voted_event_id')
    return render(request, 'awards_vitrine/confirmation.html', {
        'event_id': event_id
    })

def results(request, event_id):
    """Affichage du podium (Top 3) après clôture."""
    event = get_object_or_404(Evenement, id=event_id)
    
    # Sécurité : Résultats masqués avant la date de fin
    if timezone.now() < event.date_fin and not request.user.is_staff:
        return redirect('awards_vitrine:event_detail', event_id=event.id)
        
    podiums = selectors.get_event_results(event_id)
    return render(request, 'awards_vitrine/results.html', {
        'event': event,
        'podiums': podiums
    })

def legal_view(request):
    """Page des mentions légales gérées depuis l'admin."""
    settings = SiteSettings.objects.first()
    return render(request, 'awards_vitrine/legal.html', {'settings': settings})

def security_error_view(request):
    """Page d'alerte en cas d'anomalie."""
    context = {
        'error_type': request.GET.get('type', 'Sécurité'),
        'message': request.GET.get('msg', 'Action non autorisée ou suspecte.')
    }
    return render(request, 'awards_vitrine/security_error.html', context)