##############################################################################
# ScoDoc
# Copyright (c) 1999 - 2022 Emmanuel Viennet.  All rights reserved.
# See LICENSE
##############################################################################

"""Jury BUT: table recap annuelle et liens saisie
"""

import time
import numpy as np
from flask import g, url_for

from app.but import jury_but
from app.but.jury_but import (
    DecisionsProposeesAnnee,
    DecisionsProposeesRCUE,
    DecisionsProposeesUE,
)
from app.comp.res_but import ResultatsSemestreBUT
from app.comp import res_sem
from app.models.etudiants import Identite
from app.models.formsemestre import FormSemestre
from app.scodoc import html_sco_header
from app.scodoc.sco_codes_parcours import (
    BUT_BARRE_RCUE,
    BUT_BARRE_UE,
    BUT_BARRE_UE8,
    BUT_RCUE_SUFFISANT,
)
from app.scodoc import sco_formsemestre_status
from app.scodoc import sco_pvjury
from app.scodoc import sco_utils as scu
from app.scodoc.sco_exceptions import ScoValueError


def formsemestre_saisie_jury_but(
    formsemestre2: FormSemestre,
    read_only: bool = False,
    selected_etudid: int = None,
    mode="jury",
) -> str:
    """formsemestre est un semestre PAIR
    Si readonly, ne montre pas le lien "saisir la décision"

    => page html complète

    Si mode == "recap", table recap des codes, sans liens de saisie.
    """
    # Quick & Dirty
    # pour chaque etud de res2 trié
    #   S1: UE1, ..., UEn
    #   S2: UE1, ..., UEn
    #
    #   UE1_s1, UE1_s2, moy_rcue, UE2...   , Nbrcue_validables, Nbrcue<8, passage_de_droit, valide_moitie_rcue
    #
    # Pour chaque etud de res2 trié
    #   DecisionsProposeesAnnee(etud, formsemestre2)
    #      Pour le 1er etud, faire un check_ues_ready_jury(self) -> page d'erreur
    #   -> rcue .ue_1, .ue_2 -> stroe moy ues, rcue.moy_rcue,  etc
    # XXX if formsemestre2.semestre_id % 2 != 0:
    #    raise ScoValueError("Cette page ne fonctionne que sur les semestres pairs")

    if formsemestre2.formation.referentiel_competence is None:
        raise ScoValueError(
            """
        <p>Pas de référentiel de compétences associé à la formation !</p>
        <p>Pour associer un référentiel, passer par le menu <b>Semestre /
        Voir la formation... </b> et suivre le lien <em>"associer à un référentiel
        de compétences"</em>
        """
        )

    rows, titles, column_ids = get_jury_but_table(
        formsemestre2, read_only=read_only, mode=mode
    )
    if not rows:
        return (
            '<div class="table_recap"><div class="message">aucun étudiant !</div></div>'
        )
    filename = scu.sanitize_filename(
        f"""jury-but-{formsemestre2.titre_num()}-{time.strftime("%Y-%m-%d")}"""
    )
    klass = "table_jury_but_bilan" if mode == "recap" else ""
    table_html = build_table_jury_but_html(
        filename, rows, titles, column_ids, selected_etudid=selected_etudid, klass=klass
    )
    H = [
        html_sco_header.sco_header(
            page_title=f"{formsemestre2.sem_modalite()}: jury BUT annuel",
            no_side_bar=True,
            init_qtip=True,
            javascripts=["js/etud_info.js", "js/table_recap.js"],
        ),
        sco_formsemestre_status.formsemestre_status_head(
            formsemestre_id=formsemestre2.id
        ),
    ]
    if mode == "recap":
        H.append(
            f"""<h3>Décisions de jury enregistrées pour les étudiants de ce semestre</h3>
            <div class="table_jury_but_links">
                <div>
                    <ul>
                    <li><a href="{url_for(
                        "notes.pvjury_table_but",
                        scodoc_dept=g.scodoc_dept, formsemestre_id=formsemestre2.id)
                    }" class="stdlink">Tableau PV de jury</a>
                    </li>
                    <li><a href="{url_for(
                        "notes.formsemestre_lettres_individuelles",
                        scodoc_dept=g.scodoc_dept, formsemestre_id=formsemestre2.id)
                    }" class="stdlink">Courriers individuels (classeur pdf)</a>
                    </li>
                </div>
            </div>
            """
        )
    H.append(
        f"""

    {table_html}

    <div class="table_jury_but_links">
    """
    )

    if (mode == "recap") and not read_only:
        H.append(
            f"""
    <p><a class="stdlink" href="{url_for(
        "notes.formsemestre_saisie_jury",
        scodoc_dept=g.scodoc_dept, formsemestre_id=formsemestre2.id)
    }">Saisie des décisions du jury</a>
    </p>"""
        )
    else:
        H.append(
            f"""
    <p><a class="stdlink" href="{url_for(
        "notes.formsemestre_validation_auto_but",
        scodoc_dept=g.scodoc_dept, formsemestre_id=formsemestre2.id)
    }">Calcul automatique des décisions du jury</a>
    </p>
    <p><a class="stdlink" href="{url_for(
        "notes.formsemestre_jury_but_recap",
        scodoc_dept=g.scodoc_dept, formsemestre_id=formsemestre2.id)
    }">Tableau récapitulatif des décisions du jury</a>
    </p>
    """
        )
    H.append(
        f"""
    </div>

    {html_sco_header.sco_footer()}
    """
    )
    return "\n".join(H)


def build_table_jury_but_html(
    filename: str, rows, titles, column_ids, selected_etudid: int = None, klass=""
) -> str:
    """assemble la table html"""
    footer_rows = []  # inutilisé pour l'instant
    H = [
        f"""<div class="table_recap"><table class="table_recap apc jury table_jury_but {klass}"
            data-filename="{filename}">"""
    ]
    # header
    H.append(
        f"""
    <thead>
        {scu.gen_row(column_ids, titles, "th")}
    </thead>
    """
    )
    # body
    H.append("<tbody>")
    for row in rows:
        H.append(f"{scu.gen_row(column_ids, row, selected_etudid=selected_etudid)}\n")
    H.append("</tbody>\n")
    # footer
    H.append("<tfoot>")
    idx_last = len(footer_rows) - 1
    for i, row in enumerate(footer_rows):
        H.append(f'{scu.gen_row(column_ids, row, "th" if i == idx_last else "td")}\n')
    H.append(
        """
    </tfoot>
    </table>
    </div>
    """
    )
    return "".join(H)


class RowCollector:
    """Une ligne de la table"""

    def __init__(
        self,
        cells: dict = None,
        titles: dict = None,
        convert_values=True,
        column_classes: dict = None,
    ):
        self.titles = titles
        self.row = cells or {}  # col_id : str
        self.column_classes = column_classes  # col_id : str, css class
        self.idx = 0
        self.last_etud_cell_idx = 0
        if convert_values:
            self.fmt_note = scu.fmt_note
        else:
            self.fmt_note = lambda x: x

    def __setitem__(self, key, value):
        self.row[key] = value

    def __getitem__(self, key):
        return self.row[key]

    def get_row_dict(self):
        "La ligne, comme un dict"
        # create empty cells
        for col_id in self.titles:
            if col_id not in self.row:
                self.row[col_id] = ""
                klass = self.column_classes.get(col_id)
                if klass:
                    self.row[f"_{col_id}_class"] = klass
        return self.row

    def add_cell(
        self,
        col_id: str,
        title: str,
        content: str,
        classes: str = "",
        idx: int = None,
        column_class="",
    ):
        """Add a row to our table. classes is a list of css class names"""
        self.idx = idx if idx is not None else self.idx
        self.row[col_id] = content
        if classes:
            self.row[f"_{col_id}_class"] = classes + f" c{self.idx}"
        if not col_id in self.titles:
            self.titles[col_id] = title
            self.titles[f"_{col_id}_col_order"] = self.idx
            if classes:
                self.titles[f"_{col_id}_class"] = classes
        self.column_classes[col_id] = column_class
        self.idx += 1

    def add_etud_cells(
        self, etud: Identite, formsemestre: FormSemestre, with_links=True
    ):
        "Les cells code, nom, prénom etc."
        # --- Codes (seront cachés, mais exportés en excel)
        self.add_cell("etudid", "etudid", etud.id, "codes")
        self.add_cell("code_nip", "code_nip", etud.code_nip or "", "codes")
        # --- Identité étudiant (adapté de res_common/get_table_recap, à factoriser XXX TODO)
        self.add_cell("civilite_str", "Civ.", etud.civilite_str, "identite_detail")
        self.add_cell("nom_disp", "Nom", etud.nom_disp(), "identite_detail")
        self["_nom_disp_order"] = etud.sort_key
        self.add_cell("prenom", "Prénom", etud.prenom, "identite_detail")
        self.add_cell("nom_short", "Nom", etud.nom_short, "identite_court")
        if with_links:
            self["_nom_short_order"] = etud.sort_key
            self["_nom_short_target"] = url_for(
                "notes.formsemestre_bulletinetud",
                scodoc_dept=g.scodoc_dept,
                formsemestre_id=formsemestre.id,
                etudid=etud.id,
            )
            self["_nom_short_target_attrs"] = f'class="etudinfo" id="{etud.id}"'
            self["_nom_disp_target"] = self["_nom_short_target"]
            self["_nom_disp_target_attrs"] = self["_nom_short_target_attrs"]
        self.last_etud_cell_idx = self.idx

    def add_ue_cells(self, dec_ue: DecisionsProposeesUE):
        "cell de moyenne d'UE"
        col_id = f"moy_ue_{dec_ue.ue.id}"
        note_class = ""
        val = dec_ue.moy_ue
        if isinstance(val, float):
            if val < BUT_BARRE_UE:
                note_class = " moy_inf"
            elif val >= BUT_BARRE_UE:
                note_class = " moy_ue_valid"
            if val < BUT_BARRE_UE8:
                note_class = " moy_ue_warning"  # notes très basses
        self.add_cell(
            col_id,
            dec_ue.ue.acronyme,
            self.fmt_note(val),
            "col_ue" + note_class,
            column_class="col_ue",
        )
        self.add_cell(
            col_id + "_code",
            dec_ue.ue.acronyme,
            dec_ue.code_valide or "",
            "col_ue_code recorded_code",
            column_class="col_ue",
        )

    def add_rcue_cells(self, dec_rcue: DecisionsProposeesRCUE):
        "2 cells: moyenne du RCUE, code enregistré"
        rcue = dec_rcue.rcue
        col_id = f"moy_rcue_{rcue.ue_1.niveau_competence_id}"  # le niveau_id
        note_class = ""
        val = rcue.moy_rcue
        if isinstance(val, float):
            if val < BUT_BARRE_RCUE:
                note_class = " moy_ue_inf"
            elif val >= BUT_BARRE_RCUE:
                note_class = " moy_ue_valid"
            if val < BUT_RCUE_SUFFISANT:
                note_class = " moy_ue_warning"  # notes très basses
        self.add_cell(
            col_id,
            f"<div>{rcue.ue_1.acronyme}</div><div>{rcue.ue_2.acronyme}</div>",
            self.fmt_note(val),
            "col_rcue" + note_class,
            column_class="col_rcue",
        )
        self.add_cell(
            col_id + "_code",
            f"<div>{rcue.ue_1.acronyme}</div><div>{rcue.ue_2.acronyme}</div>",
            dec_rcue.code_valide or "",
            "col_rcue_code recorded_code",
            column_class="col_rcue",
        )

    def add_nb_rcues_cell(self, deca: DecisionsProposeesAnnee):
        "cell avec nb niveaux validables / total"
        klass = " "
        if deca.nb_rcues_under_8 > 0:
            klass += "moy_ue_warning"
        elif deca.nb_validables < deca.nb_competences:
            klass += "moy_ue_inf"
        else:
            klass += "moy_ue_valid"
        self.add_cell(
            "rcues_validables",
            "RCUEs",
            f"""{deca.nb_validables}/{deca.nb_competences}"""
            + ((" " + scu.EMO_WARNING) if deca.nb_rcues_under_8 > 0 else ""),
            "col_rcue col_rcues_validables" + klass,
        )
        self["_rcues_validables_data"] = {
            "etudid": deca.etud.id,
            "nomprenom": deca.etud.nomprenom,
        }
        if len(deca.rcues_annee) > 0:
            # permet un tri par nb de niveaux validables + moyenne gen indicative S_pair
            if deca.res_pair and deca.etud.id in deca.res_pair.etud_moy_gen:
                moy = deca.res_pair.etud_moy_gen[deca.etud.id]
                if np.isnan(moy):
                    moy_gen_d = "x"
                else:
                    moy_gen_d = f"{int(moy*1000):05}"
            else:
                moy_gen_d = "x"
            self["_rcues_validables_order"] = f"{deca.nb_validables:04d}-{moy_gen_d}"
        else:
            # etudiants sans RCUE: pas de semestre impair, ...
            # les classe à la fin
            self[
                "_rcues_validables_order"
            ] = f"{deca.nb_validables:04d}-00000-{deca.etud.sort_key}"


def get_jury_but_table(
    formsemestre2: FormSemestre, read_only: bool = False, mode="jury", with_links=True
) -> tuple[list[dict], list[str], list[str]]:
    """Construit la table des résultats annuels pour le jury BUT"""
    res2: ResultatsSemestreBUT = res_sem.load_formsemestre_results(formsemestre2)
    titles = {}  # column_id : title
    column_classes = {}
    rows = []
    for etudid in formsemestre2.etuds_inscriptions:
        etud: Identite = Identite.query.get(etudid)
        deca = jury_but.DecisionsProposeesAnnee(etud, formsemestre2)
        row = RowCollector(titles=titles, column_classes=column_classes)
        row.add_etud_cells(etud, formsemestre2, with_links=with_links)
        row.idx = 100  # laisse place pour les colonnes de groupes
        # --- Nombre de niveaux
        row.add_nb_rcues_cell(deca)
        # --- Les RCUEs
        for rcue in deca.rcues_annee:
            dec_rcue = deca.dec_rcue_by_ue.get(rcue.ue_1.id)
            if dec_rcue is not None:  # None si l'UE n'est pas associée à un niveau
                row.add_ue_cells(deca.decisions_ues[rcue.ue_1.id])
                row.add_ue_cells(deca.decisions_ues[rcue.ue_2.id])
                row.add_rcue_cells(dec_rcue)
        # --- Les ECTS validés
        ects_valides = 0.0
        if deca.res_impair:
            ects_valides += deca.res_impair.get_etud_ects_valides(etudid)
        if deca.res_pair:
            ects_valides += deca.res_pair.get_etud_ects_valides(etudid)
        row.add_cell(
            "ects_annee",
            "ECTS",
            f"""{int(ects_valides)}""",
            "col_code_annee",
        )
        # --- Le code annuel existant
        row.add_cell(
            "code_annee",
            "Année",
            f"""{deca.code_valide or ''}""",
            "col_code_annee",
        )
        # --- Le lien de saisie
        if mode != "recap" and with_links:
            row.add_cell(
                "lien_saisie",
                "",
                f"""
                    <a href="{url_for(
                    'notes.formsemestre_validation_but',
                    scodoc_dept=g.scodoc_dept,
                    etudid=etud.id,
                    formsemestre_id=formsemestre2.id,
                )}" class="stdlink">
                    {"voir" if read_only else ("modif." if deca.code_valide else "saisie")}
                    décision</a>
                """
                if deca.inscription_etat == scu.INSCRIT
                else deca.inscription_etat,
                "col_lien_saisie_but",
            )
        rows.append(row)
    rows_dict = [row.get_row_dict() for row in rows]
    if len(rows_dict) > 0:
        res2.recap_add_partitions(rows_dict, titles, col_idx=row.last_etud_cell_idx + 1)
    column_ids = [title for title in titles if not title.startswith("_")]
    column_ids.sort(key=lambda col_id: titles.get("_" + col_id + "_col_order", 1000))
    rows_dict.sort(key=lambda row: row["_nom_disp_order"])
    return rows_dict, titles, column_ids


def get_jury_but_results(formsemestre: FormSemestre) -> list[dict]:
    """Liste des résultats jury BUT sous forme de dict, pour API"""
    if formsemestre.formation.referentiel_competence is None:
        # pas de ref. comp., donc pas de decisions de jury (ne lance pas d'exception)
        return []
    dpv = sco_pvjury.dict_pvjury(formsemestre.id)
    rows = []
    for etudid in formsemestre.etuds_inscriptions:
        rows.append(get_jury_but_etud_result(formsemestre, dpv, etudid))
    return rows


def get_jury_but_etud_result(
    formsemestre: FormSemestre, dpv: dict, etudid: int
) -> dict:
    """Résultats de jury d'un étudiant sur un semestre pair de BUT"""
    etud: Identite = Identite.query.get(etudid)
    dec_etud = dpv["decisions_dict"][etudid]
    if formsemestre.formation.is_apc():
        deca = jury_but.DecisionsProposeesAnnee(etud, formsemestre)
    else:
        deca = None
    row = {
        "etudid": etud.id,
        "code_nip": etud.code_nip,
        "code_ine": etud.code_ine,
        "is_apc": dpv["is_apc"],  # BUT ou classic ?
        "etat": dec_etud["etat"],  # I ou D ou DEF
        "nb_competences": deca.nb_competences if deca else 0,
    }
    # --- Les RCUEs
    rcue_list = []
    if deca:
        for rcue in deca.rcues_annee:
            dec_rcue = deca.dec_rcue_by_ue.get(rcue.ue_1.id)
            if dec_rcue is not None:  # None si l'UE n'est pas associée à un niveau
                dec_ue1 = deca.decisions_ues[rcue.ue_1.id]
                dec_ue2 = deca.decisions_ues[rcue.ue_2.id]
                rcue_dict = {
                    "ue_1": {
                        "ue_id": rcue.ue_1.id,
                        "moy": None
                        if (dec_ue1.moy_ue is None or np.isnan(dec_ue1.moy_ue))
                        else dec_ue1.moy_ue,
                        "code": dec_ue1.code_valide,
                    },
                    "ue_2": {
                        "ue_id": rcue.ue_2.id,
                        "moy": None
                        if (dec_ue2.moy_ue is None or np.isnan(dec_ue2.moy_ue))
                        else dec_ue2.moy_ue,
                        "code": dec_ue2.code_valide,
                    },
                    "moy": rcue.moy_rcue,
                    "code": dec_rcue.code_valide,
                }
                rcue_list.append(rcue_dict)
    row["rcues"] = rcue_list
    # --- Les UEs
    ue_list = []
    if dec_etud["decisions_ue"]:
        for ue_id, ue_dec in dec_etud["decisions_ue"].items():
            ue_dict = {
                "ue_id": ue_id,
                "code": ue_dec["code"],
                "ects": ue_dec["ects"],
            }
            ue_list.append(ue_dict)
    row["ues"] = ue_list
    # --- Le semestre (pour les formations classiques)
    if dec_etud["decision_sem"]:
        row["semestre"] = {"code": dec_etud["decision_sem"].get("code")}
    else:
        row["semestre"] = {}  # APC, ...
    # --- Autorisations
    row["autorisations"] = dec_etud["autorisations"]
    return row
