from django.db import models
from django.utils.text import slugify
from traduction.helpers import TranslatableMixin
from cms.mixins import CMSPageableMixin


class Person(CMSPageableMixin, TranslatableMixin, models.Model):
    """
    Modele de base pour tous les membres de l'equipe.

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

    PERSON_TYPES = [
        ('professor', 'Professeur'),
        ('phd', 'Doctorant'),
        ('master', 'Etudiant Master'),
    ]

    first_name = models.CharField('Prenom', max_length=100)
    last_name = models.CharField('Nom', max_length=100)
    slug = models.SlugField('Slug', max_length=200, unique=True, blank=True)
    email = models.EmailField('Email')
    phone = models.CharField('Telephone', max_length=30, blank=True)

    photo = models.ImageField('Photo', upload_to='team/photos/', blank=True, null=True)
    bio = models.TextField('Biographie', blank=True)

    person_type = models.CharField('Type', max_length=20, choices=PERSON_TYPES)
    university = models.ForeignKey(
        'universities.University',
        on_delete=models.SET_NULL,
        null=True,
        related_name='members',
        verbose_name='Universite'
    )

    country = models.ForeignKey(
        'config.Country',
        on_delete=models.SET_NULL,
        null=True,
        blank=True,
        related_name='members',
        verbose_name='Pays d\'origine'
    )

    research_interests = models.TextField('Interets de recherche', blank=True)

    # Liens
    website = models.URLField('Site personnel', blank=True)
    linkedin_url = models.URLField('LinkedIn', blank=True)
    github_url = models.URLField('GitHub', blank=True)
    google_scholar_url = models.URLField('Google Scholar', blank=True)
    orcid = models.CharField('ORCID', max_length=20, blank=True)

    # Roles
    is_director = models.BooleanField('Directeur', default=False)
    is_coordinator = models.BooleanField('Coordinateur', default=False)

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

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

    class Meta:
        verbose_name = 'Membre'
        verbose_name_plural = 'Membres'
        ordering = ['order', 'last_name', 'first_name']

    def __str__(self):
        return f"{self.first_name} {self.last_name}"

    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(f"{self.first_name}-{self.last_name}")
        super().save(*args, **kwargs)

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

    def get_cms_page_identifier(self):
        """Utilise le slug du membre comme identifiant."""
        return self.slug

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

    def get_cms_page_name(self):
        """Retourne le nom interne de la page CMS."""
        return f"Membre: {self.full_name}"

    @property
    def full_name(self):
        return f"{self.first_name} {self.last_name}"

    def get_role_display(self):
        if self.is_director:
            return "Directeur"
        if self.is_coordinator:
            return "Coordinateur"
        return self.get_person_type_display()


class Professor(TranslatableMixin, models.Model):
    """Extension pour les professeurs"""
    TITLE_CHOICES = [
        ('prof', 'Prof.'),
        ('dr', 'Dr.'),
        ('prof_dr', 'Prof. Dr.'),
    ]

    person = models.OneToOneField(
        Person,
        on_delete=models.CASCADE,
        related_name='professor',
        verbose_name='Personne'
    )
    title = models.CharField('Titre', max_length=20, choices=TITLE_CHOICES, default='prof')
    position = models.CharField('Poste', max_length=200, blank=True, help_text='Ex: Professeur des Universites')
    department = models.CharField('Departement', max_length=200, blank=True)
    specialization = models.CharField('Specialisation', max_length=200, blank=True)

    office_location = models.CharField('Bureau', max_length=100, blank=True)
    office_phone = models.CharField('Tel. bureau', max_length=30, blank=True)
    office_hours = models.CharField('Heures de permanence', max_length=200, blank=True)

    academic_credentials = models.TextField('Parcours academique', blank=True)
    years_experience = models.PositiveIntegerField('Annees d\'experience', blank=True, null=True)

    class Meta:
        verbose_name = 'Professeur'
        verbose_name_plural = 'Professeurs'

    def __str__(self):
        return f"{self.get_title_display()} {self.person.full_name}"


class PhDStudent(TranslatableMixin, models.Model):
    """Extension pour les doctorants"""
    person = models.OneToOneField(
        Person,
        on_delete=models.CASCADE,
        related_name='phd_student',
        verbose_name='Personne'
    )
    thesis_title = models.CharField('Titre de these', max_length=300)
    thesis_description = models.TextField('Resume de these', blank=True)

    supervisor = models.ForeignKey(
        Person,
        on_delete=models.SET_NULL,
        null=True,
        blank=True,
        related_name='phd_supervised',
        verbose_name='Directeur de these'
    )
    co_supervisor = models.ForeignKey(
        Person,
        on_delete=models.SET_NULL,
        null=True,
        blank=True,
        related_name='phd_co_supervised',
        verbose_name='Co-directeur'
    )

    start_date = models.DateField('Date de debut')
    expected_end_date = models.DateField('Date de fin prevue', blank=True, null=True)
    defense_date = models.DateField('Date de soutenance', blank=True, null=True)

    funding_source = models.CharField('Source de financement', max_length=200, blank=True)

    class Meta:
        verbose_name = 'Doctorant'
        verbose_name_plural = 'Doctorants'

    def __str__(self):
        return f"{self.person.full_name} (PhD)"


class MasterStudent(TranslatableMixin, models.Model):
    """Extension pour les etudiants master"""
    person = models.OneToOneField(
        Person,
        on_delete=models.CASCADE,
        related_name='master_student',
        verbose_name='Personne'
    )

    cohort_year = models.PositiveIntegerField('Annee de promotion', help_text='Ex: 2024')
    specialization = models.ForeignKey(
        'program.Specialization',
        on_delete=models.SET_NULL,
        null=True,
        blank=True,
        verbose_name='Specialisation'
    )

    current_semester = models.PositiveIntegerField('Semestre actuel', default=1)

    semester1_university = models.ForeignKey(
        'universities.University',
        on_delete=models.SET_NULL,
        null=True,
        blank=True,
        related_name='semester1_students',
        verbose_name='Universite S1'
    )
    semester2_university = models.ForeignKey(
        'universities.University',
        on_delete=models.SET_NULL,
        null=True,
        blank=True,
        related_name='semester2_students',
        verbose_name='Universite S2'
    )

    thesis_title = models.CharField('Titre du memoire', max_length=300, blank=True)
    thesis_description = models.TextField('Resume du memoire', blank=True)

    advisor = models.ForeignKey(
        Person,
        on_delete=models.SET_NULL,
        null=True,
        blank=True,
        related_name='master_advised',
        verbose_name='Tuteur'
    )

    has_scholarship = models.BooleanField('Boursier', default=False)
    graduation_date = models.DateField('Date de diplomation', blank=True, null=True)
    is_alumni = models.BooleanField('Ancien etudiant', default=False)

    class Meta:
        verbose_name = 'Etudiant Master'
        verbose_name_plural = 'Etudiants Master'

    def __str__(self):
        return f"{self.person.full_name} (M{self.current_semester})"
