# -*- mode: python -*-
# -*- coding: utf-8 -*-

"""
Tests unitaires vérifiant le bon fonctionnement du modèle Assiduité et de
ses fonctions liées

Ecrit par HARTMANN Matthias (en s'inspirant de tests.unit.test_abs_count.py par Fares Amer )
"""

from tests.unit import sco_fake_gen

from app import db

from app.scodoc import sco_formsemestre
import app.scodoc.sco_assiduites as scass
from app.models import Assiduite, Identite, FormSemestre, ModuleImpl
from app.scodoc.sco_exceptions import ScoValueError
import app.scodoc.sco_utils as scu


def test_general(test_client):
    """tests général du modèle assiduite"""

    g_fake = sco_fake_gen.ScoFake(verbose=False)

    # Création d'une formation (1)

    formation_id = g_fake.create_formation()
    ue_id = g_fake.create_ue(
        formation_id=formation_id, acronyme="T1", titre="UE TEST 1"
    )
    matiere_id = g_fake.create_matiere(ue_id=ue_id, titre="test matière")
    module_id_1 = g_fake.create_module(
        matiere_id=matiere_id, code="Mo1", coefficient=1.0, titre="test module"
    )
    module_id_2 = g_fake.create_module(
        matiere_id=matiere_id, code="Mo2", coefficient=1.0, titre="test module2"
    )

    # Création semestre (2)

    formsemestre_id_1 = g_fake.create_formsemestre(
        formation_id=formation_id,
        semestre_id=1,
        date_debut="01/09/2022",
        date_fin="31/12/2022",
    )
    formsemestre_id_2 = g_fake.create_formsemestre(
        formation_id=formation_id,
        semestre_id=2,
        date_debut="01/01/2023",
        date_fin="31/07/2023",
    )
    formsemestre_id_3 = g_fake.create_formsemestre(
        formation_id=formation_id,
        semestre_id=3,
        date_debut="01/01/2024",
        date_fin="31/07/2024",
    )

    formsemestre_1 = sco_formsemestre.get_formsemestre(formsemestre_id_1)
    formsemestre_2 = sco_formsemestre.get_formsemestre(formsemestre_id_2)
    formsemestre_3 = sco_formsemestre.get_formsemestre(formsemestre_id_3)

    # Création des modulesimpls (4, 2 par semestre)

    moduleimpl_1_1 = g_fake.create_moduleimpl(
        module_id=module_id_1,
        formsemestre_id=formsemestre_id_1,
    )
    moduleimpl_1_2 = g_fake.create_moduleimpl(
        module_id=module_id_2,
        formsemestre_id=formsemestre_id_1,
    )

    moduleimpl_2_1 = g_fake.create_moduleimpl(
        module_id=module_id_1,
        formsemestre_id=formsemestre_id_2,
    )
    moduleimpl_2_2 = g_fake.create_moduleimpl(
        module_id=module_id_2,
        formsemestre_id=formsemestre_id_2,
    )

    moduleimpls = [
        moduleimpl_1_1,
        moduleimpl_1_2,
        moduleimpl_2_1,
        moduleimpl_2_2,
    ]

    moduleimpls = [
        ModuleImpl.query.filter_by(id=mi_id).first() for mi_id in moduleimpls
    ]

    # Création des étudiants (3)

    etuds_dict = [
        g_fake.create_etud(code_nip=None, prenom=f"etud{i}") for i in range(3)
    ]

    etuds = []
    for etud in etuds_dict:
        g_fake.inscrit_etudiant(formsemestre_id=formsemestre_id_1, etud=etud)
        g_fake.inscrit_etudiant(formsemestre_id=formsemestre_id_2, etud=etud)

        etuds.append(Identite.query.filter_by(id=etud["id"]).first())

    assert None not in etuds, "Problème avec la conversion en Identite"

    # Etudiant faux

    etud_faux_dict = g_fake.create_etud(code_nip=None, prenom="etudfaux")
    etud_faux = Identite.query.filter_by(id=etud_faux_dict["id"]).first()

    ajouter_assiduites(etuds, moduleimpls, etud_faux)
    verifier_comptage_et_filtrage(
        etuds, moduleimpls, (formsemestre_1, formsemestre_2, formsemestre_3)
    )
    editer_supprimer_assiduiter(etuds, moduleimpls)


def editer_supprimer_assiduiter(etuds: list[Identite], moduleimpls: list[int]):
    """
    Troisième Partie:
        - Vérification de l'édition des assiduitées
        - Vérification de la suppression des assiduitées
    """

    ass1: Assiduite = etuds[0].assiduites.first()
    ass2: Assiduite = etuds[1].assiduites.first()
    ass3: Assiduite = etuds[2].assiduites.first()

    # Modification de l'état
    ass1.etat = scu.EtatAssiduite.RETARD
    db.session.add(ass1)
    # Modification du moduleimpl
    ass2.moduleimpl_id = moduleimpls[0].id
    db.session.add(ass2)
    db.session.commit()

    # Vérification du changement
    assert (
        scass.filter_by_etat(etuds[0].assiduites, "retard").count() == 3
    ), "Edition d'assiduité mauvais"
    assert (
        scass.filter_by_module_impl(etuds[1].assiduites, moduleimpls[0].id).count() == 2
    ), "Edition d'assiduité mauvais"

    # Supression d'une assiduité

    db.session.delete(ass3)
    db.session.commit()

    assert etuds[2].assiduites.count() == 5, "Supression d'assiduité mauvais"


def ajouter_assiduites(
    etuds: list[Identite], moduleimpls: list[ModuleImpl], etud_faux: Identite
):
    """
    Première partie:
        - Ajoute 6 assiduités à chaque étudiant
            - 2 présence (semestre 1 et 2)
            - 2 retard (semestre 2)
            - 2 absence (semestre 1)
        - Vérifie la création des assiduités
    """

    for etud in etuds:
        obj_assiduites = [
            {
                "etat": scu.EtatAssiduite.PRESENT,
                "deb": "2022-09-03T08:00+01:00",
                "fin": "2022-09-03T10:00+01:00",
                "moduleimpl": None,
                "desc": None,
            },
            {
                "etat": scu.EtatAssiduite.PRESENT,
                "deb": "2023-01-03T08:00+01:00",
                "fin": "2023-01-03T10:00+01:00",
                "moduleimpl": moduleimpls[2],
                "desc": None,
            },
            {
                "etat": scu.EtatAssiduite.ABSENT,
                "deb": "2022-09-03T10:00:01+01:00",
                "fin": "2022-09-03T11:00+01:00",
                "moduleimpl": moduleimpls[0],
                "desc": None,
            },
            {
                "etat": scu.EtatAssiduite.ABSENT,
                "deb": "2022-09-03T14:00:00+01:00",
                "fin": "2022-09-03T15:00+01:00",
                "moduleimpl": moduleimpls[1],
                "desc": "Description",
            },
            {
                "etat": scu.EtatAssiduite.RETARD,
                "deb": "2023-01-03T11:00:01+01:00",
                "fin": "2023-01-03T12:00+01:00",
                "moduleimpl": moduleimpls[3],
                "desc": None,
            },
            {
                "etat": scu.EtatAssiduite.RETARD,
                "deb": "2023-01-04T11:00:01+01:00",
                "fin": "2023-01-04T12:00+01:00",
                "moduleimpl": moduleimpls[3],
                "desc": "Description",
            },
        ]

        assiduites = [
            Assiduite.create_assiduite(
                etud,
                ass["deb"],
                ass["fin"],
                ass["etat"],
                ass["moduleimpl"],
                ass["desc"],
            )
            for ass in obj_assiduites
        ]

        # Vérification de la création des assiduités
        assert [
            ass for ass in assiduites if not isinstance(ass, Assiduite)
        ] == [], "La création des assiduités de base n'est pas OK"

    # Vérification de la gestion des erreurs

    test_assiduite = {
        "etat": scu.EtatAssiduite.RETARD,
        "deb": "2023-01-04T11:00:01+01:00",
        "fin": "2023-01-04T12:00+01:00",
        "moduleimpl": moduleimpls[3],
        "desc": "Description",
    }

    try:
        Assiduite.create_assiduite(
            etuds[0],
            test_assiduite["deb"],
            test_assiduite["fin"],
            test_assiduite["etat"],
            test_assiduite["moduleimpl"],
            test_assiduite["desc"],
        )
    except ScoValueError as excp:
        assert (
            excp.args[0]
            == "Duplication des assiduités (la période rentrée rentre en conflit avec une assiduité enregistrée)"
        )
    try:
        Assiduite.create_assiduite(
            etud_faux,
            test_assiduite["deb"],
            test_assiduite["fin"],
            test_assiduite["etat"],
            test_assiduite["moduleimpl"],
            test_assiduite["desc"],
        )
    except ScoValueError as excp:
        assert excp.args[0] == "L'étudiant n'est pas inscrit au moduleimpl"


def verifier_comptage_et_filtrage(
    etuds: list[Identite], moduleimpls: list[int], formsemestres: tuple[int]
):
    """
    Deuxième partie:
        - vérifier les valeurs du comptage (compte, heure, journée, demi-journée)
        - vérifier le filtrage des assiduites  (etat, debut, fin, module, formsemestre)

    """

    etu1, etu2, etu3 = etuds

    mod11, mod12, mod21, mod22 = moduleimpls

    # Vérification du comptage classique
    comptage = scass.get_assiduites_stats(etu1.assiduites)

    assert comptage["compte"] == 6, "la métrique 'Comptage' n'est pas bien calculée"
    assert comptage["journee"] == 3, "la métrique 'Journée' n'est pas bien calculée"
    assert comptage["demi"] == 4, "la métrique 'Demi-Journée' n'est pas bien calculée"
    assert comptage["heure"] == 8, "la métrique 'Heure' n'est pas bien calculée"

    # Vérification du filtrage classique

    # Etat
    assert (
        scass.filter_by_etat(etu2.assiduites, "present").count() == 2
    ), "Filtrage de l'état 'présent' mauvais"
    assert (
        scass.filter_by_etat(etu2.assiduites, "retard").count() == 2
    ), "Filtrage de l'état 'retard' mauvais"
    assert (
        scass.filter_by_etat(etu2.assiduites, "absent").count() == 2
    ), "Filtrage de l'état 'absent' mauvais"
    assert (
        scass.filter_by_etat(etu2.assiduites, "absent,retard").count() == 4
    ), "Filtrage de l'état 'absent,retard' mauvais"
    assert (
        scass.filter_by_etat(etu2.assiduites, "absent,retard,present").count() == 6
    ), "Filtrage de l'état 'absent,retard,present' mauvais"
    assert (
        scass.filter_by_etat(etu2.assiduites, "autre").count() == 0
    ), "Filtrage de l'état 'autre' mauvais"

    # Module
    assert (
        scass.filter_by_module_impl(etu3.assiduites, mod11.id).count() == 1
    ), "Filtrage par 'Moduleimpl' mauvais"
    assert (
        scass.filter_by_module_impl(etu3.assiduites, mod12.id).count() == 1
    ), "Filtrage par 'Moduleimpl' mauvais"
    assert (
        scass.filter_by_module_impl(etu3.assiduites, mod21.id).count() == 1
    ), "Filtrage par 'Moduleimpl' mauvais"
    assert (
        scass.filter_by_module_impl(etu3.assiduites, mod22.id).count() == 2
    ), "Filtrage par 'Moduleimpl' mauvais"
    assert (
        scass.filter_by_module_impl(etu3.assiduites, None).count() == 1
    ), "Filtrage par 'Moduleimpl' mauvais"
    assert (
        scass.filter_by_module_impl(etu3.assiduites, 152).count() == 0
    ), "Filtrage par 'Moduleimpl' mauvais"

    # Formsemestre
    formsemestres = [
        FormSemestre.query.filter_by(id=fms["id"]).first() for fms in formsemestres
    ]
    assert (
        scass.filter_by_formsemestre(etu1.assiduites, formsemestres[0]).count() == 3
    ), "Filtrage 'Formsemestre' mauvais"
    assert (
        scass.filter_by_formsemestre(etu1.assiduites, formsemestres[1]).count() == 3
    ), "Filtrage 'Formsemestre' mauvais"
    assert (
        scass.filter_by_formsemestre(etu1.assiduites, formsemestres[2]).count() == 0
    ), "Filtrage 'Formsemestre' mauvais"

    # Date début
    date = scu.localize_datetime("2022-09-01T10:00+01:00")
    assert (
        scass.filter_by_date(etu2.assiduites, date, sup=True).count() == 6
    ), "Filtrage 'Date début' mauvais"
    date = scu.localize_datetime("2022-09-03T10:00:00+01:00")
    assert (
        scass.filter_by_date(etu2.assiduites, date, sup=True).count() == 5
    ), "Filtrage 'Date début' mauvais"
    date = scu.localize_datetime("2022-09-03T10:00:01+01:00")
    assert (
        scass.filter_by_date(etu2.assiduites, date, sup=True).count() == 5
    ), "Filtrage 'Date début' mauvais"
    date = scu.localize_datetime("2022-09-03T10:00:02+01:00")
    assert (
        scass.filter_by_date(etu2.assiduites, date, sup=True).count() == 4
    ), "Filtrage 'Date début' mauvais"

    # Date fin
    date = scu.localize_datetime("2022-09-01T10:00+01:00")
    assert (
        scass.filter_by_date(etu2.assiduites, date, sup=False).count() == 0
    ), "Filtrage 'Date fin' mauvais"
    date = scu.localize_datetime("2022-09-03T10:00:00+01:00")
    assert (
        scass.filter_by_date(etu2.assiduites, date, sup=False).count() == 1
    ), "Filtrage 'Date fin' mauvais"
    date = scu.localize_datetime("2022-09-03T10:00:01+01:00")
    assert (
        scass.filter_by_date(etu2.assiduites, date, sup=False).count() == 1
    ), "Filtrage 'Date fin' mauvais"
    date = scu.localize_datetime("2023-01-04T13:00:01+01:00")
    assert (
        scass.filter_by_date(etu2.assiduites, date, sup=False).count() == 6
    ), "Filtrage 'Date fin' mauvais"
    date = scu.localize_datetime("2023-01-03T11:00:01+01:00")
    assert (
        scass.filter_by_date(etu2.assiduites, date, sup=False).count() == 4
    ), "Filtrage 'Date fin' mauvais"