import uuid
from django.db import models
from django.conf import settings
from django.utils.translation import gettext_lazy as _

class Evenement(models.Model):
    """Représente un événement unique pour lequel des tickets sont vendus."""
    nom = models.CharField(_("Nom de l'événement"), max_length=200)
    description = models.TextField(_("Description"), blank=True)
    date = models.DateTimeField(_("Date et heure de l'événement"))
    image_background = models.ImageField(
        _("Image de fond"), 
        upload_to='evenements_bg/', 
        blank=True, null=True,
        help_text="Image qui apparaîtra sur le site et potentiellement sur le ticket."
    )
    est_actif = models.BooleanField(
        _("Actif / Visible"), 
        default=True,
        help_text="Décocher pour cacher l'événement du site public."
    )
    date_creation = models.DateTimeField(auto_now_add=True)
    date_modification = models.DateTimeField(auto_now=True)
    
    class Meta:
        verbose_name = "Événement"
        verbose_name_plural = "Événements"
        ordering = ['-date']

    def __str__(self):
        return f"{self.nom} (le {self.date.strftime('%d/%m/%Y')})"

class TypeTicket(models.Model):
    """Définit une catégorie de ticket pour un événement (ex: VIP, Standard)."""
    evenement = models.ForeignKey(
        Evenement, 
        on_delete=models.CASCADE, 
        related_name='types_tickets',
        verbose_name=_("Événement associé")
    )
    nom = models.CharField(_("Nom du type"), max_length=100, help_text="Ex: Standard, VIP, Pass Famille")
    prix = models.PositiveIntegerField(_("Prix (en FCFA)"))
    avantages = models.TextField(_("Avantages inclus"), blank=True, help_text="Liste des avantages, séparés par des retours à la ligne.")
    usage_unique = models.BooleanField(
        _("Ticket à usage unique"), 
        default=True, 
        help_text="Si décoché, peut être configuré pour plusieurs passages."
    )

    class Meta:
        verbose_name = "Type de Ticket"
        verbose_name_plural = "Types de Ticket"
        unique_together = ('evenement', 'nom') # Empêche d'avoir deux 'VIP' pour le même événement

    def __str__(self):
        return f"{self.nom} - {self.evenement.nom}"

class Ticket(models.Model):
    """Représente un ticket unique, vendu à un client."""
    class Statut(models.TextChoices):
        VALIDE = 'VALIDE', _('Valide')
        SCANNE = 'SCANNE', _('Déjà scanné')
        ANNULE = 'ANNULE', _('Annulé')

    code_unique = models.UUIDField(default=uuid.uuid4, editable=False, unique=True)
    qr_code = models.ImageField(upload_to='qr_codes/', blank=True, null=True, editable=False)
    type_ticket = models.ForeignKey(
        TypeTicket, 
        on_delete=models.PROTECT, # Empêche la suppression d'un type de ticket si des tickets ont été vendus
        related_name='tickets_vendus',
        verbose_name=_("Type de ticket")
    )
    client_nom = models.CharField(_("Nom du client"), max_length=150)
    client_contact = models.CharField(_("Contact du client"), max_length=100, blank=True)
    date_emission = models.DateTimeField(auto_now_add=True)
    statut = models.CharField(
        _("Statut"),
        max_length=10, 
        choices=Statut.choices, 
        default=Statut.VALIDE
    )
    nb_scans_autorises = models.PositiveIntegerField(default=1)
    nb_scans_effectues = models.PositiveIntegerField(default=0)
    
    class Meta:
        verbose_name = "Ticket"
        ordering = ['-date_emission']

    def __str__(self):
        return f"Ticket pour {self.client_nom} ({self.type_ticket.nom})"

class ScanLog(models.Model):
    """Enregistre chaque tentative de scan d'un ticket pour audit."""
    class Resultat(models.TextChoices):
        SUCCES = 'SUCCES', _('Succès - Entrée autorisée')
        DEJA_UTILISE = 'DEJA_UTILISE', _('Avertissement - Déjà scanné')
        INVALIDE = 'INVALIDE', _('Erreur - Ticket non reconnu ou annulé')

    ticket = models.ForeignKey(Ticket, on_delete=models.CASCADE, related_name='scan_logs')
    date_scan = models.DateTimeField(auto_now_add=True)
    agent_scan = models.ForeignKey(
        settings.AUTH_USER_MODEL, 
        on_delete=models.SET_NULL, # On garde l'historique même si l'agent est supprimé
        null=True, blank=True
    )
    resultat = models.CharField(_("Résultat du scan"), max_length=20, choices=Resultat.choices)

    class Meta:
        verbose_name = "Journal de Scan"
        verbose_name_plural = "Journaux de Scan"
        ordering = ['-date_scan']

    def __str__(self):
        return f"Scan de {self.ticket.client_nom} le {self.date_scan.strftime('%d/%m %H:%M')}"