from django.db import models
from django.utils.text import slugify
from django.utils import timezone
from django.utils.html import strip_tags
from image_factory.models import Imageable
from colorfield.fields import ColorField
from config.models import Timestamped, Orderable
from django_ckeditor_5.fields import CKEditor5Field
from traduction.helpers import TranslatableMixin
from cms.mixins import CMSPageableMixin


class NewsCategory(TranslatableMixin, Orderable, Timestamped):
    """Categories d'actualites"""
    name = models.CharField('Nom', max_length=100)
    slug = models.SlugField('Slug', max_length=100, unique=True, blank=True)
    description = models.TextField('Description', blank=True)
    icon = models.ForeignKey(
        'config.Icon',
        on_delete=models.SET_NULL,
        null=True,
        blank=True,
        related_name='icone',
        verbose_name='Icone'
    )
    #icon = models.CharField('Icone', max_length=50, blank=True)
    color = ColorField(default='#2563eb') 
    #color = models.CharField('Couleur', max_length=7, default='#2563eb')
    #order = models.PositiveIntegerField('Ordre', default=0)
    is_active = models.BooleanField('Active', default=True)

    class Meta:
        verbose_name = 'Categorie'
        verbose_name_plural = 'Categories'
        ordering = ['order', 'name']

    def __str__(self):
        return self.get_translated('name') or self.name

    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(self.name)
        super().save(*args, **kwargs)


class NewsArticle(CMSPageableMixin, TranslatableMixin, Imageable, Timestamped):
    """
    Articles d'actualites.

    Chaque article peut avoir sa propre Page CMS pour personnaliser
    le template et les sections affichees.
    """
    # Configuration CMS
    CMS_PAGE_PREFIX = 'actualite'

    title = models.CharField('Titre', max_length=255)
    slug = models.SlugField('Slug', max_length=255, unique=True, blank=True)
    content = CKEditor5Field('Contenu', config_name='extends')

    category = models.ForeignKey(
        NewsCategory,
        on_delete=models.SET_NULL,
        null=True,
        related_name='articles',
        verbose_name='Categorie'
    )

    #image = models.ImageField('Image', upload_to='news/images/', blank=True, null=True)
    image_caption = models.CharField('Legende image', max_length=200, blank=True)

    author = models.ForeignKey(
        'team.Person',
        on_delete=models.SET_NULL,
        null=True,
        blank=True,
        related_name='articles',
        verbose_name='Auteur'
    )

    related_projects = models.ManyToManyField(
        'research.ResearchProject',
        related_name='news_articles',
        verbose_name='Projets lies',
        blank=True
    )

    related_people = models.ManyToManyField(
        'team.Person',
        related_name='mentioned_in_articles',
        verbose_name='Personnes mentionnees',
        blank=True
    )

    publication_date = models.DateTimeField('Date de publication', default=timezone.now)
    updated_at = models.DateTimeField('Mis a jour le', auto_now=True)

    is_featured = models.BooleanField('A la une', default=False)
    is_published = models.BooleanField('Publie', default=True)
    view_count = models.PositiveIntegerField('Nombre de vues', default=0)

    # SEO
    meta_description = models.CharField('Meta description', max_length=160, blank=True)


    image_sizes = [
        ("main", (1920, 1060)),  # Image principale
        ("mini", (160, 88)),  # Miniature
    ]
    class Meta:
        verbose_name = 'Article'
        verbose_name_plural = 'Articles'
        ordering = ['-is_featured', '-publication_date']

    def __str__(self):
        return self.get_translated('title') or self.title

    def get_cms_page_slug(self):
        """Genere le slug unique pour la page CMS de cet article."""
        return f"{self.CMS_PAGE_PREFIX}-{self.slug}"

    def get_cms_page_identifier(self):
        """Utilise le slug de l'article comme identifiant."""
        return self.slug

    def get_cms_page_title(self):
        """Retourne le titre de la page CMS."""
        return self.title

    def get_cms_page_name(self):
        """Retourne le nom interne de la page CMS."""
        return f"Article: {self.title[:50]}"

    def get_excerpt(self, length=150):
        """
        Retourne les premiers caractères du contenu (traduit si disponible).
        Utilise la traduction du contenu si elle existe.
        """
        content = self.content or ''
        if content:
            plain_text = strip_tags(content).strip()
            plain_text = ' '.join(plain_text.split())
            if len(plain_text) > length:
                return plain_text[:length] + '...'
            return plain_text
        return ''

    def save(self, *args, **kwargs):
        # 1. Gestion du slug automatique
        if not self.slug:
            self.slug = slugify(self.title)[:300]

        # 2. Détection de changement d'image
        is_new_image = False
        if self.pk:
            old_image = NewsArticle.objects.filter(pk=self.pk).values_list('image', flat=True).first()
            if old_image != self.image.name:
                is_new_image = True
        else:
            is_new_image = True if self.image else False

        # 3. Sauvegarde
        super().save(*args, **kwargs)

        # 4. Traitement image si nouvelle ou modifiée
        if is_new_image and self.image:
            self.create_resized_images()

class EventType(TranslatableMixin, Orderable, Timestamped):
    """Types d'evenements (Conference, Seminaire, Atelier, etc.)"""
    name = models.CharField('Nom', max_length=100)
    slug = models.SlugField('Slug', max_length=100, unique=True, blank=True)
    description = models.TextField('Description', blank=True)
    icon = models.ForeignKey(
        'config.Icon',
        on_delete=models.SET_NULL,
        null=True,
        blank=True,
        related_name='event_types',
        verbose_name='Icone'
    )
    color = ColorField('Couleur', default='#007bff')
    is_active = models.BooleanField('Actif', default=True)

    class Meta:
        verbose_name = 'Type d\'evenement'
        verbose_name_plural = 'Types d\'evenements'
        ordering = ['order', 'name']

    def __str__(self):
        return self.get_translated('name') or self.name

    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(self.name)
        super().save(*args, **kwargs)
        
        
class Event(CMSPageableMixin, TranslatableMixin, Imageable, Timestamped):
    """
    Evenements.

    Chaque evenement peut avoir sa propre Page CMS pour personnaliser
    le template et les sections affichees.
    """
    # Configuration CMS
    CMS_PAGE_PREFIX = 'evenement'

    title = models.CharField('Titre', max_length=255)
    slug = models.SlugField('Slug', max_length=255, unique=True, blank=True)
    description = CKEditor5Field('Description', config_name='extends')
    short_description = models.CharField('Description courte', max_length=300, blank=True)

    event_type = models.ForeignKey(
        EventType, 
        on_delete=models.PROTECT, # PROTECT empêche de supprimer un type si des événements l'utilisent
        related_name='events',
        verbose_name='Type d\'événement'
    )

    event_date = models.DateTimeField('Date de debut')
    end_date = models.DateTimeField('Date de fin', blank=True, null=True)

    location = models.CharField('Lieu', max_length=300, blank=True)
    is_online = models.BooleanField('En ligne', default=False)
    online_url = models.URLField('Lien de connexion', blank=True)

    #image = models.ImageField('Image', upload_to='news/events/', blank=True, null=True)

    host_university = models.ForeignKey(
        'universities.University',
        on_delete=models.SET_NULL,
        null=True,
        blank=True,
        related_name='events',
        verbose_name='Universite organisatrice'
    )

    registration_url = models.URLField('Lien d\'inscription', blank=True)
    registration_deadline = models.DateTimeField('Date limite d\'inscription', blank=True, null=True)

    contact_email = models.EmailField('Email de contact', blank=True)

    is_featured = models.BooleanField('Mis en avant', default=False)
    is_active = models.BooleanField('Actif', default=True)

    #created_at = models.DateTimeField('Cree le', auto_now_add=True)

    class Meta:
        verbose_name = 'Evenement'
        verbose_name_plural = 'Evenements'
        ordering = ['event_date']

    def __str__(self):
        return self.get_translated('title') or self.title

    def get_cms_page_slug(self):
        """Genere le slug unique pour la page CMS de cet evenement."""
        return f"{self.CMS_PAGE_PREFIX}-{self.slug}"

    def get_cms_page_identifier(self):
        """Utilise le slug de l'evenement comme identifiant."""
        return self.slug

    def get_cms_page_title(self):
        """Retourne le titre de la page CMS."""
        return self.title

    def get_cms_page_name(self):
        """Retourne le nom interne de la page CMS."""
        return f"Evenement: {self.title[:50]}"

    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(self.title)[:300]

        # Generation automatique de la description courte
        if self.description:
            plain_text = strip_tags(self.description).strip()
            plain_text = ' '.join(plain_text.split())
            self.short_description = plain_text[:150]

        super().save(*args, **kwargs)

    @property
    def is_upcoming(self):
        return self.event_date > timezone.now()

    @property
    def is_past(self):
        return self.event_date < timezone.now()