# -*- coding: UTF-8 -*
"""Gestion de l'assiduité (assiduités + justificatifs)
"""
from app import db
from app.models import ModuleImpl, ModuleImplInscription
from app.models.etudiants import Identite
from app.scodoc.sco_utils import EtatAssiduite, localize_datetime, verif_interval

from datetime import datetime


class Assiduite(db.Model):
    """
    Représente une assiduité:
        - une plage horaire lié à un état et un étudiant
        - un module si spécifiée
    """

    __tablename__ = "assiduites"

    id = db.Column(db.Integer, primary_key=True)
    assiduiteid = db.synonym("id")

    date_debut = db.Column(
        db.DateTime(timezone=True), server_default=db.func.now(), nullable=False
    )
    date_fin = db.Column(
        db.DateTime(timezone=True), server_default=db.func.now(), nullable=False
    )

    moduleimpl_id = db.Column(
        db.Integer,
        db.ForeignKey("notes_moduleimpl.id", ondelete="SET NULL"),
    )
    etudid = db.Column(
        db.Integer,
        db.ForeignKey("identite.id", ondelete="CASCADE"),
        index=True,
        nullable=False,
    )
    etat = db.Column(db.Integer, nullable=False)

    def to_dict(self) -> dict:
        data = {
            "assiduiteid": self.assiduiteid,
            "etudid": self.etudid,
            "moduleimpl_id": self.moduleimpl_id,
            "date_debut": self.date_debut,
            "date_fin": self.date_fin,
            "etat": self.etat,
        }
        return data

    @classmethod
    def create_assiduite(
        cls,
        etud: Identite,
        date_debut: datetime,
        date_fin: datetime,
        etat: EtatAssiduite,
        module: int or None = None,
    ) -> object or int:
        """Créer une nouvelle assiduité pour l'étudiant
        Documentation des codes d'erreurs renvoyés:
            1: Duplication des assiduités (la période rentrée rentre en conflit avec une assiduité enregistrée)
            2: l'ID du module_impl n'existe pas.
        """
        # Vérification de non duplication des périodes
        assiduites: list[Assiduite] = etud.assiduites.all()

        date_debut = localize_datetime(date_debut)
        date_fin = localize_datetime(date_fin)
        assiduites = [
            ass
            for ass in assiduites
            if verif_interval(
                (date_debut, date_fin),
                (ass.date_debut, ass.date_fin),
            )
        ]
        if len(assiduites) != 0:
            return 1

        if module is not None:
            # Vérification de l'existance du module pour l'étudiant
            if cls.verif_moduleimpl(module, etud):
                nouv_assiduite = Assiduite(
                    date_debut=date_debut,
                    date_fin=date_fin,
                    etat=etat,
                    etudiant=etud,
                    moduleimpl_id=module,
                )
            else:
                return 2
        else:
            nouv_assiduite = Assiduite(
                date_debut=date_debut,
                date_fin=date_fin,
                etat=etat,
                etudiant=etud,
            )

        return nouv_assiduite

    @staticmethod
    def verif_moduleimpl(moduleimpl_id: int, etud: Identite or int) -> bool:
        """
        Vérifie si l'étudiant est bien inscrit au moduleimpl

        Retourne Vrai si c'est le cas, faux sinon
        """
        output = True
        module: ModuleImpl = ModuleImpl.query.filter_by(
            moduleimpl_id=moduleimpl_id
        ).first()
        if module is None:
            output = False

        if output:
            search_etudid: int = etud.id if type(etud) == Identite else etud
            is_module: int = ModuleImplInscription.query.filter_by(
                etudid=search_etudid, moduleimpl_id=moduleimpl_id
            ).count()

            output = is_module > 0

        return output


class Justificatif(db.Model):
    """
    Représente un justificatif:
        - une plage horaire lié à un état et un étudiant
        - une raison si spécifiée
        - un fichier si spécifié
    """

    __tablename__ = "justificatifs"

    justifid = db.Column(db.Integer, primary_key=True)

    date_debut = db.Column(
        db.DateTime(timezone=True), server_default=db.func.now(), nullable=False
    )
    date_fin = db.Column(
        db.DateTime(timezone=True), server_default=db.func.now(), nullable=False
    )

    etudid = db.Column(
        db.Integer,
        db.ForeignKey("identite.id", ondelete="CASCADE"),
        index=True,
        nullable=False,
    )
    etat = db.Column(
        db.Integer,
    )

    raison = db.Column(db.Text())
    fichier = db.Column(db.Integer())

    def to_dict(self) -> dict:
        data = {
            "justifid": self.assiduiteid,
            "etudid": self.etudid,
            "date_debut": self.date_debut,
            "date_fin": self.date_fin,
            "etat": self.etat,
            "raison": self.raison,
            "fichier": self.fichier,
        }
        return data