import numpy as np
import pandas as pd

from app import comp
from app.comp.moy_sem import comp_ranks_series
from app.pe import pe_affichage


class Moyenne:
    CRITERES = [
        "note",
        "classement",
        "rang",
        "min",
        "max",
        "moy",
        "nb_etuds",
        "nb_inscrits",
    ]

    def __init__(self, notes: pd.Series):
        """Classe centralisant la synthèse des moyennes/classements d'une série
        de notes :

        * des "notes" : la Serie pandas des notes (float),
        * des "classements" : la Serie pandas des classements (float),
        * des "min" : la note minimum,
        * des "max" : la note maximum,
        * des "moy" : la moyenne,
        * des "nb_inscrits" : le nombre d'étudiants ayant une note,
        """
        self.notes = notes
        """Les notes"""
        self.etudids = list(notes.index)  # calcul à venir
        """Les id des étudiants"""
        self.inscrits_ids = notes[notes.notnull()].index.to_list()
        """Les id des étudiants dont la note est non nulle"""
        self.df: pd.DataFrame = self.comp_moy_et_stat(self.notes)
        """Le dataframe retraçant les moyennes/classements/statistiques"""
        self.synthese = self.to_dict()
        """La synthèse (dictionnaire) des notes/classements/statistiques"""

    def comp_moy_et_stat(self, notes: pd.Series) -> dict:
        """Calcule et structure les données nécessaires au PE pour une série
        de notes (pouvant être une moyenne d'un tag à une UE ou une moyenne générale
        d'un tag) dans un dictionnaire spécifique.

        Partant des notes, sont calculés les classements (en ne tenant compte
        que des notes non nulles).

        Args:
            notes: Une série de notes (avec des éventuels NaN)

        Returns:
            Un dictionnaire stockant les notes, les classements, le min,
            le max, la moyenne, le nb de notes (donc d'inscrits)
        """
        df = pd.DataFrame(
            np.nan,
            index=self.etudids,
            columns=Moyenne.CRITERES,
        )

        # Supprime d'éventuelles chaines de caractères dans les notes
        notes = pd.to_numeric(notes, errors="coerce")
        df["note"] = notes

        # Les nb d'étudiants & nb d'inscrits
        df["nb_etuds"] = len(self.etudids)
        # Les étudiants dont la note n'est pas nulle
        inscrits_ids = notes[notes.notnull()].index.to_list()
        df.loc[inscrits_ids, "nb_inscrits"] = len(inscrits_ids)

        # Le classement des inscrits
        notes_non_nulles = notes[inscrits_ids]
        (class_str, class_int) = comp_ranks_series(notes_non_nulles)
        df.loc[inscrits_ids, "classement"] = class_int

        # Le rang (classement/nb_inscrit)
        df["rang"] = df["rang"].astype(str)
        df.loc[inscrits_ids, "rang"] = (
            df.loc[inscrits_ids, "classement"].astype(int).astype(str)
            + "/"
            + df.loc[inscrits_ids, "nb_inscrits"].astype(int).astype(str)
        )

        # Les stat (des inscrits)
        df.loc[inscrits_ids, "min"] = notes.min()
        df.loc[inscrits_ids, "max"] = notes.max()
        df.loc[inscrits_ids, "moy"] = notes.mean()

        return df

    def to_dict(self) -> dict:
        """Renvoie un dictionnaire de synthèse des moyennes/classements/statistiques générale (but)"""
        synthese = {
            "notes": self.df["note"],
            "classements": self.df["classement"],
            "min": self.df["min"].mean(),
            "max": self.df["max"].mean(),
            "moy": self.df["moy"].mean(),
            "nb_inscrits": self.df["nb_inscrits"].mean(),
        }
        return synthese

    def get_notes(self):
        """Série des notes, arrondies à 2 chiffres après la virgule"""
        return self.df_gen["note"].round(2)

    def get_rangs_inscrits(self) -> pd.Series:
        """Série des rangs classement/nbre_inscrit"""
        return self.df_gen["rang"]

    def get_min(self) -> pd.Series:
        """Série des min"""
        return self.df_gen["min"].round(2)

    def get_max(self) -> pd.Series:
        """Série des max"""
        return self.df_gen["max"].round(2)

    def get_moy(self) -> pd.Series:
        """Série des moy"""
        return self.df_gen["moy"].round(2)

    def get_note_for_df(self, etudid: int):
        """Note d'un étudiant donné par son etudid"""
        return round(self.df_gen["note"].loc[etudid], 2)

    def get_min_for_df(self) -> float:
        """Min renseigné pour affichage dans un df"""
        return round(self.synthese["min"], 2)

    def get_max_for_df(self) -> float:
        """Max renseigné pour affichage dans un df"""
        return round(self.synthese["max"], 2)

    def get_moy_for_df(self) -> float:
        """Moyenne renseignée pour affichage dans un df"""
        return round(self.synthese["moy"], 2)

    def get_class_for_df(self, etudid: int) -> str:
        """Classement ramené au nombre d'inscrits,
        pour un étudiant donné par son etudid"""
        classement = self.df_gen["rang"].loc[etudid]
        if not pd.isna(classement):
            return classement
        else:
            return pe_affichage.SANS_NOTE

    def is_significatif(self) -> bool:
        """Indique si la moyenne est significative (c'est-à-dire à des notes)"""
        return self.synthese["nb_inscrits"] > 0


class MoyennesTag:
    def __init__(
        self,
        tag: str,
        matrice_notes: pd.DataFrame,  # etudids x colonnes
        matrice_coeffs: pd.DataFrame,  # etudids x colonnes
    ):
        """Classe centralisant la synthèse des moyennes/classements d'une série
        d'étudiants à un tag donné, en différenciant les notes
        obtenues aux UE et au général (toutes UEs confondues)


        Args:
            tag: Un tag
            matrice_notes: Les moyennes (etudid x acronymes_ues ou etudid x compétences) aux différentes UEs ou compétences
            matrice_coeffs: Les coeff à appliquer pour le calcul de la moyenne générale
            # notes_gen: Une série de notes (moyenne) sous forme d'un ``pd.Series`` (toutes UEs confondues)
        """
        self.tag = tag
        """Le tag associé aux moyennes"""

        # Les moyennes par UE
        self.matrice_notes: pd.DataFrame = matrice_notes
        """Les notes aux UEs ou aux compétences (DataFrame)"""

        self.matrice_coeffs_moy_gen: pd.DataFrame = matrice_coeffs
        """Les coeffs à appliquer pour le calcul des moyennes générales 
        (toutes UE ou compétences confondues). NaN si étudiant non inscrit"""

        self.moyennes: dict[int, pd.DataFrame] = {}
        """Les dataframes retraçant les moyennes/classements/statistiques des étudiants aux UEs"""
        colonnes = self.matrice_notes.columns
        for col in colonnes:  # if ue.type != UE_SPORT:
            notes = matrice_notes[col]
            self.moyennes[col] = Moyenne(notes)

        # Les moyennes générales
        notes_gen = pd.Series(np.nan, index=self.matrice_notes.index)
        """Les notes générales (moyenne toutes UEs confonudes)"""
        if self.has_notes():
            notes_gen = self.compute_moy_gen(
                self.matrice_notes, self.matrice_coeffs_moy_gen
            )
            self.notes_gen = notes_gen
        self.moyenne_gen = Moyenne(notes_gen)
        """Le dataframe retraçant les moyennes/classements/statistiques général"""

    def has_notes(self):
        """Détermine si les moyennes (aux UEs ou aux compétences)
        ont des notes

        Returns:
            True si la moytag a des notes, False sinon
        """
        notes = self.matrice_notes
        nbre_nan = notes.isna().sum().sum()
        nbre_notes_potentielles = len(notes.index) * len(notes.columns)
        if nbre_nan == nbre_notes_potentielles:
            return False
        else:
            return True

    def compute_moy_gen(self, moys: pd.DataFrame, coeffs: pd.DataFrame) -> pd.Series:
        """Calcule la moyenne générale (toutes UE/compétences confondus)
        pour le tag considéré, en pondérant les notes obtenues au UE
        par les coeff (généralement les crédits ECTS).

        Args:
            moys: Les moyennes etudids x acronymes_ues/compétences
            coeff: Les coeff etudids x ueids/compétences
        """

        # Calcule la moyenne générale dans le semestre (pondérée par le ECTS)
        try:
            moy_gen_tag = comp.moy_sem.compute_sem_moys_apc_using_ects(
                moys,
                coeffs.fillna(0.0),
                # formation_id=self.formsemestre.formation_id,
                skip_empty_ues=True,
            )
        except TypeError as e:
            raise TypeError(
                "Pb dans le calcul de la moyenne toutes UEs/compétences confondues"
            )

        return moy_gen_tag