import numpy as np
import pandas as pd

from app import comp
from app.comp.moy_sem import comp_ranks_series
from app.pe.moys import pe_moy
from app.pe.moys.pe_moy import get_colonne_df
import re

CODE_MOY_UE = "UEs"
CODE_MOY_COMPETENCES = "Compétences"
CHAMP_GENERAL = "Général"  # Nom du champ de la moyenne générale
CHAMP_GROUPE = "groupe"
CHAMP_PROMO = "promo"


class MoyennesTag:
    def __init__(
        self,
        tag: str,
        type_moyenne: str,
        matrice_notes: pd.DataFrame,  # etudids x UEs|comp
        matrice_coeffs: pd.DataFrame,  # etudids x UEs|comp
        infos: dict,
    ):
        """Classe centralisant un ensemble de moyennes/class/stat,
        obtenu par un groupe d'étudiants, à un tag donné,
        en stockant les moyennes aux UEs|Compétences
        et la moyenne générale (toutes UEs confondues).



        Args:
            tag: Un tag
            matrice_notes: Les moyennes (etudid x acronymes_ues|compétences)
                           aux différentes UEs ou compétences
            matrice_coeffs: Les coeffs (etudid x acronymes_ues|compétences)
                            aux différentes UEs ou compétences
            infos: Informations (aggrégat, cohorte ayant servi à calculer les moyennes)
        """
        self.tag = tag
        """Le tag associé aux moyennes"""

        self.type = type_moyenne
        """Le type de moyennes (par UEs ou par compétences)"""

        self.infos = {
            "aggregat": infos["aggregat"],
            "tag": tag,
            "cohorte": infos["cohorte"],
        }
        """Info sur les éléments (aggrégat, cohorte) ayant servi à calculer les moyennes"""

        # Les moyennes par UE/compétences (ressources/SAEs confondues)
        self.matrice_notes: pd.DataFrame = matrice_notes
        """Les notes par UEs ou Compétences (DataFrame etudids x UEs|comp)"""

        self.matrice_coeffs: 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.intitules: list[str] = list(self.matrice_notes.columns)
        """Les intitules (acronymes d'UE ou compétences) renseignés dans les moyennes"""
        assert len(self.intitules) == len(
            set(self.intitules)
        ), "Des champs de moyennes en doublons"

        self.etudids: list[int] = list(self.matrice_notes.index)
        """Les étudids renseignés dans les moyennes"""

        self.moyennes_dict: dict[str, pe_moy.Moyenne] = {}
        """Dictionnaire associant à chaque UE|Compétence ses données moyenne/class/stat"""
        for col in self.intitules:  # if ue.type != UE_SPORT:
            # Les moyennes tous modules confondus
            notes = matrice_notes[col]
            infos = self.infos | {"intitule": col}
            self.moyennes_dict[col] = pe_moy.Moyenne(notes, infos)

        # Les moyennes générales (toutes UEs confondues)
        self.notes_gen = pd.Series(np.nan, index=self.matrice_notes.index)
        """Notes de la moyenne générale (toutes UEs|Comp confondues)"""
        if self.has_notes():
            self.notes_gen = self.compute_moy_gen(
                self.matrice_notes, self.matrice_coeffs
            )
        infos = self.infos | {"intitule": CHAMP_GENERAL}
        self.moyenne_gen = pe_moy.Moyenne(self.notes_gen, infos)
        """Dataframe retraçant les moyennes/classements/statistiques général (toutes UESs confondues et modules confondus)"""

    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
        """
        for col, moy in self.moyennes_dict.items():
            if not moy.has_notes():
                return False
        return True
        # 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), en pondérant
        les notes obtenues aux UEs|Compétences par les coeff (ici les crédits ECTS).

        Args:
            moys: Les moyennes (etudids x acronymes_ues/compétences)
            coeff: Les coeff (etudids x acronymes_ues/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,
            )
            return moy_gen_tag
        except TypeError as e:
            raise TypeError(
                "Pb dans le calcul de la moyenne toutes UEs/compétences confondues"
            )

    def to_df(self, options={"min_max_moy": True}) -> pd.DataFrame:
        """Renvoie le df synthétisant l'ensemble des données connues.

        Adapte :
        * les noms des colonnes aux données fournies dans l'attribut
          ``infos`` (nom d'aggrégat, type de cohorte).
        * à l'option ``min_max_moy`` (limitant les colonnes)
        """
        if "min_max_moy" not in options or options["min_max_moy"]:
            with_min_max_moy = True
        else:
            with_min_max_moy = False

        # Les étudiants triés par etudid
        etudids_sorted = sorted(self.etudids)

        # Le dataFrame à générer
        df = pd.DataFrame(index=etudids_sorted)

        # Ajout des notes pour tous les champs
        champs = list(self.intitules)
        for champ in champs:
            moy: pe_moy.Moyenne = self.moyennes_dict[champ]
            df_champ = moy.to_df(
                with_min_max_moy=with_min_max_moy
            )  # le dataframe (les colonnes ayant été renommées)
            colonnes_renommees = ajout_numero_a_colonnes(
                list(df.columns), list(df_champ.columns)
            )
            if colonnes_renommees:
                df_champ.columns = colonnes_renommees
            df = df.join(df_champ)

        # Ajoute la moy générale
        df_moy_gen = self.moyenne_gen.to_df(with_min_max_moy=with_min_max_moy)
        colonnes_renommees = ajout_numero_a_colonnes(
            list(df.columns), list(df_moy_gen.columns)
        )
        if colonnes_renommees:
            df_moy_gen.columns = colonnes_renommees
        df = df.join(df_moy_gen)

        return df


def ajout_numero_a_colonnes(colonnes, colonnes_a_ajouter):
    """Partant d'une liste de noms de colonnes, vérifie si les noms des colonnes_a_ajouter
    n'entre pas en conflit (aka ne sont pas déjà présent dans colonnes).
    Si nom, renvoie `None`.
    Si oui, propose une liste de noms de colonnes_a_ajouter dans laquelle chaque nom
    est suivi d'un `"(X)"` (où X est un numéro choisi au regard des noms de colonnes).
    Les noms des colonnes sont de la forme "S1|maths|UE|Groupe|note (1)"

    Devrait être supprimé à terme, car les noms des colonnes sont théoriquement prévus pour être
    unique/sans doublons.
    """
    assert len(colonnes) == len(set(colonnes)), "Il y a déjà des doublons dans colonnes"
    colonnes_sans_numero = [col.split(" (")[0] for col in colonnes]

    conflits = set(colonnes_sans_numero).intersection(colonnes_a_ajouter)
    if not conflits:
        # Pas de conflit
        return None

    pattern = r"\((\d*)\)"
    p = re.compile(pattern)
    numeros = []
    for col in colonnes:
        numeros.extend(p.findall(col))

    if numeros:
        numeros = [int(num) for num in numeros]
        num_max = max(numeros)
    else:
        num_max = 0

    ajouts = [f"{col} ({num_max+1})" for col in colonnes_a_ajouter]
    return ajouts