import logging
import re
import string
import pypandoc
import ruamel.yaml

from config import Config

from modeles import get_modele, TemplateLatex
from officiel import *
from ressourcedocx import remove_ligne_vide
from tools import caracteres_recalcitrants

__LOGGER = logging.getLogger(__name__)


def nettoie_latex(chaine):
    """Purge certains éléments de la chaine latex générée par pypandoc"""
    chaine = chaine.replace("\\tightlist\n", "")
    chaine = ajoute_abbr_latex(chaine) # détecte les abréviations

    # detecte les espaces insécables
    chaine = chaine.replace(" :", "~:")
    m = re.findall(r"(\w\w:)", chaine)
    m += re.findall(r"(\w}:)", chaine)
    for marq in m:
        if marq != "ex:" and marq != "ps:" and marq != "tp:": # les ex et les liens
            chaine = chaine.replace(marq, marq[0:2] + "~:")
    m = re.findall(r"(:\w)", chaine) # les : suivis d'une lettre
    m += re.findall(r"(:\\)", chaine)
    for marq in m:
        chaine = chaine.replace(marq, ": " + marq[-1])
    chaine = chaine.replace(" ;", "\,;")
    m = re.findall(r"(\w;)", chaine)
    m += re.findall(r"(\);)", chaine)
    for marq in m:
        chaine = chaine.replace(marq, marq[0] + "\,;")

    # Ajoute les topsep
    lignes = chaine.split("\n")
    nbre_itemize = 0
    for (i, ligne) in enumerate(lignes):
        if "\\begin{itemize}" in ligne:  # on rencontre un itemize
            nbre_itemize += 1
            if nbre_itemize == 1 and i != 0: # si c'est le 1er itemize et que ce n'est pas la 1ère ligne
                lignes[i] = lignes[i].replace("\\begin{itemize}", "\\begin{itemize}[topsep=5pt]")
        elif "\\end{itemize}" in ligne:
            nbre_itemize -= 1
    chaine = "\n".join(lignes)

    return chaine


class Ressource:
    """Modélise une ressource lorsqu'elle est extraite d'un yaml"""

    __LOGGER = logging.getLogger(__name__)

    def __init__(self, fichieryaml):
        with open(fichieryaml, "r", encoding="utf8") as fid:
            yaml = ruamel.yaml.YAML()
            try:
                self.ressource = yaml.load(fid.read())
            except:
                Ressource.__LOGGER.warning(f"Pb de chargement de {fichieryaml}")

    def to_latex(self, modele=Config.ROOT + "/python/pn/modele_ressource.tex"):
        """Génère le code latex décrivant la ressource"""
        modlatex = get_modele(modele)  # "pn/modele_ressource.tex")

        # if self.ressource["code"] == "R107":
        #    print("ici")

        # Préparation des coeffs
        ajoutcoeff = "\\ajoutRcoeff{%s}"
        coeffRT = []
        for comp in ["RT1", "RT2", "RT3"]:
            if comp in self.ressource["coeffs"]:
                coeffRT.append(ajoutcoeff % (str(self.ressource["coeffs"][comp])))
            else:
                coeffRT.append("")

        # Préparation des ac
        ajoutac = "\\ajoutRac{%s}{%s}"
        compRT = []
        for accomp in ["RT1", "RT2", "RT3"]:
            comps = []
            if accomp in self.ressource["acs"]:
                for no_ac in range(
                    len(self.ressource["acs"][accomp])
                ):  # les ac de la comp
                    code_ac = self.ressource["acs"][accomp][no_ac]
                    comps.append(ajoutac % (code_ac, DATA_ACS[accomp][code_ac]))
            compRT.append("\n".join(comps))

        # Préparation des sae
        ajoutsaes = "\\ajoutRsae{%s}{%s}"  # nom, intitule, code_latex
        saesRT = []
        for (i, sae) in enumerate(
            self.ressource["sae"]
        ):  # in range(len(self.apprentissages)):
            code_latex = (
                string.ascii_uppercase[int(sae[-2]) - 1]
                + string.ascii_uppercase[int(sae[-1]) - 1]
            )
            saesRT.append(
                ajoutsaes % (sae, get_officiel_sae_name_by_code(sae))
            )  # , code_latex))
        saes = "\n".join(saesRT)

        if self.ressource["code"] == "R110":
            print("ici")
        prerequis = ""
        if self.ressource["prerequis"] == AUCUN_PREREQUIS:
            prerequis = ""
        else:
            # est-une liste de ressources
            if not self.ressource["prerequis"][0].startswith("R"):
                prerequis = "\\ajoutRprerequislycee{%s}" % (self.ressource["prerequis"])
            else:
                ajoutprerequis = "\\ajoutRprerequis{%s}{%s}"
                liste = []
                for (no, mod) in enumerate(self.ressource["prerequis"]):
                    liste.append(
                        ajoutprerequis % (mod, get_officiel_ressource_name_by_code(mod))
                    )
                prerequis = "\n".join(liste)

        # préparation du contexte
        contexte = self.ressource["contexte"]
        if contexte == "Aucun":
            contexte = ""
            Ressource.__LOGGER.warning(f"{self.ressource['nom']} n'a pas de contexte")

        else:
            contexte = md_to_latex(contexte)

        # contexte = remove_ligne_vide(contexte)
        # préparation du contenu

        contenu = self.ressource["contenu"]  # supprime les passages à la ligne

        if contenu:
            if self.ressource["code"] == "R112":
                print("ici")
            contenu = md_to_latex(contenu)

        chaine = ""
        chaine = TemplateLatex(modlatex).substitute(
            code=self.ressource["code"],
            nom=self.ressource["nom"],
            heures_formation=self.ressource["heures_formation"],
            heures_tp=self.ressource["heures_tp"],
            coeffRT1=coeffRT[0],
            coeffRT2=coeffRT[1],
            coeffRT3=coeffRT[2],
            compRT1=compRT[0],
            compRT2=compRT[1],
            compRT3=compRT[2],
            saes=saes,
            motscles=self.ressource["motscles"] + ".",
            prerequis=prerequis,
            contexte=contexte,
            contenu=contenu,
        )
        # chaine = chaine.replace("&", "\&")
        chaine = nettoie_latex(chaine)

        # Insère les abbréviations
        return chaine

    def getInfo(self):
        return self.ressource


def contient_abbr(chaine):
    """Détecte les abréviations présentes dans la chaine
    (dont la liste est fournie par DATA_ABBREVIATIONS lues depuis le .yml) et
    les renvoie sous forme d'une liste par abréviations de nombre de caractères décroissants"""
    mots = []
    for lettre in DATA_ABBREVIATIONS:
        for mot in DATA_ABBREVIATIONS[lettre]:
            if mot in chaine:
                mots.append(mot)
    mots = sorted(
        mots, key=lambda m: len(m), reverse=True
    )  # les mots triés par nbre de carac décroissant
    return mots


def ajoute_abbr_latex(chaine):
    """
    Parse la chaine latex pour ajouter les abbréviations et les remplacer par
    \\textabbrv{abreviation}
    """
    mots = chaine.split(" ")
    for (i, mot) in enumerate(mots):
        abbrs = contient_abbr(mot)
        if abbrs:
            mots[i] = mots[i].replace(abbrs[0], "\\textabbrv{" + abbrs[0] + "}")
    chaine = " ".join(mots)
    if "/IP" in chaine:
        chaine = chaine.replace("/IP", "/\\textabbrv{IP}")
    return chaine

def contient_commandes(chaine):
    """Détecte si la chaine est une commande (éventuellement avec un caractère
    de ponctuation final)"""
    chaine_texte = ""
    for car in chaine:
        if car in string.ascii_lowercase + "-":
            chaine_texte += car
    if "ipc" in chaine:
        print("ici")
    if chaine_texte in DATA_MOTSCLES["commandes"]:
        return chaine_texte
    return None

def ajoute_cmd_latex(chaine):
    """
    Parse la chaine latex pour ajouter les abbréviations et les remplacer par
    \\textabbrv{abreviation}
    """
    mots = chaine.split(" ")
    for (i, mot) in enumerate(mots):
        champs = mot.split("\n")
        for (j, champ) in enumerate(champs):
            cmd = contient_commandes(champ)
            if cmd:
                champs[j] = champs[j].replace(cmd, "\\texttt{" + cmd + "}")
        mots[i] = "\n".join(champs)
    chaine = " ".join(mots)
    return chaine

class SAE:
    """Modélise une saé (chapeau) lorsqu'elle est extraite d'un yaml"""

    __LOGGER = logging.getLogger(__name__)

    def __init__(self, fichieryaml):
        with open(fichieryaml, "r", encoding="utf8") as fid:
            yaml = ruamel.yaml.YAML()
            try:
                self.sae = yaml.load(fid.read())
            except:
                Ressource.__LOGGER.warning(f"Pb de chargement de {fichieryaml}")

    def to_latex(self, modele=Config.ROOT + "/python/pn/modele_sae.tex"):
        """Génère le code latex décrivant la ressource"""
        modlatex = get_modele(modele)  # "pn/modele_ressource.tex")

        # Préparation des coeffs
        ajoutcoeff = "\\ajoutScoeff{%s}"
        coeffRT = []
        for comp in ["RT1", "RT2", "RT3"]:
            if comp in self.sae["coeffs"]:
                coeffRT.append(ajoutcoeff % (str(self.sae["coeffs"][comp])))
            else:
                coeffRT.append("")

        # Préparation des ac
        ajoutac = "\\ajoutSac{%s}{%s}"  # nom, intitule, code latex
        compRT = []
        for accomp in ["RT1", "RT2", "RT3"]:
            comps = []
            if accomp in self.sae["acs"]:
                for no_ac in range(len(self.sae["acs"][accomp])):  # les ac de la comp
                    code_ac = self.sae["acs"][accomp][no_ac]
                    comps.append(ajoutac % (code_ac, DATA_ACS[accomp][code_ac]))

            compRT.append("\n".join(comps))

        # Préparation des ressources
        ajoutressources = "\\ajoutSressources{%s}{%s}"
        resRT = []
        for (i, res) in enumerate(
            self.sae["ressources"]
        ):  # in range(len(self.apprentissages)):
            resRT.append(
                ajoutressources % (res, get_officiel_ressource_name_by_code(res))
            )
        ressources = "\n".join(resRT)

        # préparation du descriptif
        descriptif = self.sae["description"]
        if descriptif == "Aucun":
            descriptif = ""
            SAE.__LOGGER.warning(f"{self.sae['titre']} n'a pas de description")
        else:
            descriptif = md_to_latex(descriptif)

        # préparation des livrables
        livrables = self.sae["livrables"]
        if livrables == "Aucun":
            livrables = ""
            SAE.__LOGGER.warning(f"{self.sae['titre']} n'a pas de livrables")
        else:
            livrables = md_to_latex(livrables)

        chaine = ""
        chaine = TemplateLatex(modlatex).substitute(
            code=self.sae["code"],
            titre=self.sae["titre"],
            heures_encadrees=self.sae["heures_encadrees"],
            heures_tp=self.sae["tp"],
            heures_projet=self.sae["projet"],
            coeffRT1=coeffRT[0],
            coeffRT2=coeffRT[1],
            coeffRT3=coeffRT[2],
            compRT1=compRT[0],
            compRT2=compRT[1],
            compRT3=compRT[2],
            description=descriptif,
            ressources=ressources,
            livrables=livrables,
            motscles=self.sae["motscles"] + ".",
        )
        # chaine = chaine.replace("&", "\&")

        chaine = nettoie_latex(chaine)
        return chaine

    def getInfo(self):
        return self.sae


class ExempleSAE:
    """Modélise un exemple de SAE lorsqu'elle est extraite d'un yaml"""

    __LOGGER = logging.getLogger(__name__)

    def __init__(self, fichieryaml):
        with open(fichieryaml, "r", encoding="utf8") as fid:
            yaml = ruamel.yaml.YAML()
            try:
                self.exemple = yaml.load(fid.read())
            except:
                Ressource.__LOGGER.warning(f"Pb de chargement de {fichieryaml}")

    def to_latex(self, modele=Config.ROOT + "/python/pn/modele_exemple_sae.tex"):
        """Génère le code latex décrivant la ressource"""
        modlatex = get_modele(modele)  # "pn/modele_ressource.tex")

        # préparation du descriptif
        description = self.exemple["description"]
        if not description:
            description = ""
            ExempleSAE.__LOGGER.warning(
                f"{self.exemple['titre']} n'a pas de description"
            )
        else:
            description = md_to_latex(description)


        # préparation de la forme
        formes = self.exemple["formes"]
        if not formes:
            formes = ""
            ExempleSAE.__LOGGER.warning(f"{self.exemple['titre']} n'a pas de formes")
        else:
            formes = md_to_latex(formes)

        # préparation de la problématique
        problematique = self.exemple["problematique"]
        if not problematique:
            problematique = ""
            ExempleSAE.__LOGGER.warning(
                f"{self.exemple['titre']} n'a pas de problematique"
            )
        else:
            problematique = md_to_latex(problematique)
            if "15" in self.exemple["code"]:
                # supprime le \\[3pt]
                problematique = problematique[:-7]

        # préparation des modalites
        modalite = self.exemple["modalite"]
        if not modalite:
            modalite = ""
            ExempleSAE.__LOGGER.warning(f"{self.exemple['titre']} n'a pas de modalite")
        else:
            modalite = md_to_latex(modalite)

        chaine = ""
        chaine = TemplateLatex(modlatex).substitute(
            titre=self.exemple["titre"],
            description=description,
            formes=formes,
            problematique=problematique,
            modalite=modalite,
        )
        # chaine = chaine.replace("&", "\&")
        chaine = nettoie_latex(chaine)

        return chaine

class Competences:
    """ Modélise une liste de compétences lorsqu'elle est extraite d'un dictionnaire """

    __LOGGER = logging.getLogger(__name__)

    def __init__(self, fichieryaml):
        with open(fichieryaml, "r", encoding="utf8") as fid:
            yaml = ruamel.yaml.YAML()
            try:
                self.competences = yaml.load(fid.read())
            except:
                Competences.__LOGGER.warning(f"Pb de chargement de {fichieryaml}")

    def getInfo(self):
        return self.competences

class ACs:
    """ Modélise une liste de acs lorsqu'elle est extraite d'un fichier yaml """

    __LOGGER = logging.getLogger(__name__)

    def __init__(self, fichieryaml):
        with open(fichieryaml, "r", encoding="utf8") as fid:
            yaml = ruamel.yaml.YAML(typ="safe")
            try:
                self.acs = yaml.load(fid.read())
            except:
                ACs.__LOGGER.warning(f"Pb de chargement de {fichieryaml}")

    def getInfo(self):
        return self.acs

def md_to_latex(contenu):
    """Réalise la conversion markdown to latex avec pypandoc"""
    contenu = contenu.replace(
        "\n", "\n\n"
    )  # corrige les suppressions de ligne à la relecture du yaml

    contenu = pypandoc.convert_text(
        contenu, "tex", format="md", extra_args=["--atx-headers"]
    )
    contenu = contenu.replace("\r\n", "\n")
    lignes = contenu.split("\n\n")  # Détecte les sauts de ligne
    for (i, ligne) in enumerate(lignes):
        if i < len(lignes) - 1:
            if (
                lignes[i].strip().startswith("\\") == False
                and lignes[i].startswith(" ") == False
                and lignes[i + 1].strip().startswith("\\") == False
                and lignes[i + 1].startswith(" ") == False
                and lignes[i].strip().endswith("\\\\") == False
            ):
                lignes[i] = lignes[i] + "\\\\"  # ajoute un passage à la ligne latex
    contenu = "\n\n".join(lignes)

    # contenu = caracteres_recalcitrants(contenu)
    contenu = remove_ligne_vide(contenu)
    lignes = contenu.split("\n")  # pour debug

    if contenu.startswith("\\begin{itemize}"):
        contenu = (
            "\\vspace{-10pt}\n" + contenu
        )  # ajout d'un offset en cas de liste à puces
    contenu = contenu.replace("\\\\" * 2, "\\\\[25pt]")
    if not contenu.endswith("\\end{itemize}"):
        contenu += "\\\\[3pt]"

    contenu = ajoute_cmd_latex(contenu)  # détecte les commandes

    return contenu


def get_matrices_ac_ressource(saes, ressources, sem):
    """Calcule la matrice AC vs sae + ressource pour un sem donné et la renvoie"""
    les_codes_acs = [code for comp in DATA_ACS for code in DATA_ACS[comp]]
    nbre_acs = len(les_codes_acs)

    saesem = saes[sem]  # les saé du semestre
    ressem = ressources[sem]  # les ressources du semestre

    nbre_saes = len(DATA_SAES[sem])
    nbre_ressources = len(DATA_RESSOURCES[sem])
    if len(saesem) != nbre_saes or len(ressem) != nbre_ressources:
        __LOGGER.warning(f"Pb => il manque des saes/ressources au {sem}")

    matrice = [[False] * (nbre_saes + nbre_ressources) for i in range(nbre_acs)]

    for (i, s) in enumerate(saesem):  # pour chaque SAE
        for comp in s.sae["acs"]:  # pour chaque comp
            for (j, ac) in enumerate(DATA_ACS[comp]):  # pour chaque ac
                if ac in s.sae["acs"][comp]:  # si l'ac est prévue dans la ressource
                    k = les_codes_acs.index(ac)
                    matrice[k][i] = True

    for (i, r) in enumerate(ressem):  # pour chaque ressource
        for comp in r.ressource["acs"]:  # pour chaque comp
            for (j, ac) in enumerate(DATA_ACS[comp]):  # pour chaque ac
                if (
                    ac in r.ressource["acs"][comp]
                ):  # si l'ac est prévue dans la ressource
                    k = les_codes_acs.index(ac)
                    matrice[k][i + nbre_saes] = True
    return matrice


def get_matrices_coeffs(saes, ressources, sem):
    """Calcule la matrice AC vs sae + ressource pour un sem donné et la renvoie"""
    comps = ["RT1", "RT2", "RT3"]

    saesem = saes[sem]  # les saé du semestre
    ressem = ressources[sem]  # les ressources du semestre

    nbre_saes = len(DATA_SAES[sem])
    nbre_ressources = len(DATA_RESSOURCES[sem])
    if len(saesem) != nbre_saes or len(ressem) != nbre_ressources:
        __LOGGER.warning(f"Pb => il manque des saes/ressources au {sem}")

    matrice = [[None] * (len(comps)) for i in range(nbre_saes + nbre_ressources)]

    for (i, s) in enumerate(saesem):  # pour chaque SAE
        for (j, comp) in enumerate(comps):  # pour chaque comp
            if comp in s.sae["coeffs"]:
                matrice[i][j] = s.sae["coeffs"][comp]

    for (i, r) in enumerate(ressem):  # pour chaque ressource
        for (j, comp) in enumerate(comps):  # pour chaque comp
            if comp in r.ressource["coeffs"]:  # pour chaque ac
                matrice[i + nbre_saes][j] = r.ressource["coeffs"][comp]
    return matrice


def get_matrices_volumes(saes, ressources, sem):
    """Calcule la matrice AC vs sae + ressource pour un sem donné et la renvoie"""
    format = ["CM/TD", "TP", "Projet"]

    saesem = saes[sem]  # les saé du semestre
    ressem = ressources[sem]  # les ressources du semestre

    nbre_saes = len(DATA_SAES[sem])
    nbre_ressources = len(DATA_RESSOURCES[sem])
    if len(saesem) != nbre_saes or len(ressem) != nbre_ressources:
        __LOGGER.warning(f"Pb => il manque des saes/ressources au {sem}")

    matrice = [[0] * (len(format)) for i in range(nbre_saes + nbre_ressources)]

    for (i, s) in enumerate(saesem):  # pour chaque SAE
        formation = (
            s.sae["heures_encadrees"]
            if not isinstance(s.sae["heures_encadrees"], str)
            else 0
        )
        tp = s.sae["tp"] if not isinstance(s.sae["tp"], str) else 0
        matrice[i][0] = formation - tp
        matrice[i][1] = tp
        matrice[i][2] = s.sae["projet"] if not isinstance(s.sae["projet"], str) else 0

    for (i, r) in enumerate(ressem):  # pour chaque ressource
        formation = (
            r.ressource["heures_formation"]
            if not isinstance(r.ressource["heures_formation"], str)
            else 0
        )
        tp = (
            r.ressource["heures_tp"]
            if not isinstance(r.ressource["heures_tp"], str)
            else 0
        )
        matrice[i + nbre_saes][0] = formation - tp
        matrice[i + nbre_saes][1] = tp

    return matrice


def str_matrice(matrice, saes, ressources, sem):
    """Renvoie une chaine de caractère affichant la matrice"""
    les_codes_acs = [code for comp in DATA_ACS for code in DATA_ACS[comp]]
    nbre_acs = len(les_codes_acs)

    saesem = saes[sem]  # les saé du semestre
    ressem = ressources[sem]  # les ressources du semestre

    nbre_saes = len(DATA_SAES[sem])
    nbre_ressources = len(DATA_RESSOURCES[sem])

    chaine = ""
    ligne = "{:20s} | " + "{:5s} | " * (nbre_saes + nbre_ressources)
    valeurs = ("" for i in range(nbre_saes + nbre_ressources + 1))
    trait = "-" * len(ligne.format(*valeurs))

    valeurs = (
        [""]
        + [s.sae["code"] if s.sae["code"] else "????" for s in saesem]
        + [r.ressource["code"] if r.ressource["code"] else "????" for r in ressem]
        + [""] * (nbre_saes - len(saesem) + nbre_ressources - len(ressem))
    )
    valeurs = tuple(valeurs)
    chaine += ligne.format(*valeurs) + "\n" + trait + "\n"
    for (j, ac) in enumerate(les_codes_acs):
        valeurs = [ac] + [
            ("X" if matrice[j][i] == True else "")
            for i in range(nbre_saes + nbre_ressources)
        ]
        valeurs = tuple(valeurs)
        chaine += ligne.format(*valeurs) + "\n"
    chaine += trait + "\n"
    return chaine


def cesure_contenu(contenu, long_max=30):
    chaine = "\\rotatebox[origin=c]{90}{\n"
    chaine += "\\begin{tabular}{ll}\n"
    contenu_cesure = []
    while contenu:
        indice_espace = contenu.find(" ", long_max)
        if indice_espace < 0:
            contenu_cesure.append(contenu)
            contenu = ""
        else:
            contenu_cesure.append(contenu[:indice_espace])
            contenu = contenu[indice_espace + 1 :]
    chaine += " \\\\ ".join(contenu_cesure)
    chaine += "\\end{tabular} }"
    return chaine


def rotation_entete_colonne(contenu, pos="l"):
    chaine = "\\rotatebox[origin=" + pos + "]{90}{"
    chaine += contenu + "}"
    return chaine


def to_latex_matrice_acs(matrice, saes, ressources, sem):
    """Renvoie le tableau latex affichant la matrice"""

    les_codes_acs = [code for comp in DATA_ACS for code in DATA_ACS[comp]]
    nbre_acs = len(les_codes_acs)

    lettresem = "A" if sem == "S1" else "B"

    saesem = saes[sem]  # les saé du semestre
    ressem = ressources[sem]  # les ressources du semestre

    nbre_saes = len(DATA_SAES[sem])
    nbre_ressources = len(DATA_RESSOURCES[sem])
    nbre_colonnes = nbre_saes + nbre_ressources + 2
    longueur = 4
    chaine = (
        "\\begin{tabular}[c]{|lp{%scm}|" % str(longueur)
        + "c|" * (nbre_saes)
        + "c|" * (nbre_ressources)
        + "}"
        + "\n"
    )
    chaine += "\\hline \n"  # % (nbre_saes + nbre_ressources+1)+ "\n"
    # l'entete
    chaine += " & & "
    chaine += (
        "\multicolumn{%d}{c|}{\\textcolor{saeC}{\\bfseries SAÉs}}" % (nbre_saes) + "\n"
    )
    chaine += " & "
    chaine += (
        "\multicolumn{%d}{c|}{\\textcolor{ressourceC}{\\bfseries Ressources}}"
        % (nbre_ressources)
        + "\\\\ \n"
    )
    chaine += "\\cline{3-%d}" % (nbre_colonnes)
    chaine += " & & "
    # les noms des SAE et des ressources
    noms_saes = []
    for (i, s) in enumerate(saesem):  # pour chaque SAE
        # saecode = "Scode" + lettresem + string.ascii_uppercase[i]
        # contenu = "\\xdef\saecode{\csname " + saecode + "\endcsname}"
        # contenu += "\\tiny{\\hyperlink{sae:\\saecode}{" + s.sae["titre"] + "~}}"
        contenu = "\\tiny{" + s.sae["titre"] + "~}"
        noms_saes.append(rotation_entete_colonne(contenu) + "\n")
    chaine += " & ".join(noms_saes) + "\n"
    chaine += " & "
    noms_ressources = []
    for (i, r) in enumerate(ressem):  # pour chaque SAE
        # contenu = r.ressource["code"] + " | " + r.ressource["nom"]
        # noms_ressources.append(rotation_entete_colonne(contenu) + "\n")
        contenu = "\\tiny{" + r.ressource["nom"] + "~}"
        noms_ressources.append(rotation_entete_colonne(contenu) + "\n")
    chaine += " & ".join(noms_ressources) + "\n"
    chaine += "\\\\ \n"

    # les codes des SAE et des ressources
    noms_saes = []
    chaine += " & & \n"
    for (i, s) in enumerate(saesem):  # pour chaque SAE
        contenu = "~\\hyperlink{sae:" + s.sae["code"] + "}{"
        contenu += "\\textcolor{saeC}{" + s.sae["code"] + "}"
        contenu += "}"
        noms_saes.append(rotation_entete_colonne(contenu, pos="r") + "\n")
    chaine += " & ".join(noms_saes) + "\n"
    chaine += " & "
    noms_ressources = []
    for (i, r) in enumerate(ressem):  # pour chaque SAE
        contenu = "~\\hyperlink{res:" + r.ressource["code"] + "}{"
        contenu += "\\textcolor{ressourceC}{" + r.ressource["code"] + "}"
        contenu += "}"
        noms_ressources.append(rotation_entete_colonne(contenu, pos="r") + "\n")
    chaine += " & ".join(noms_ressources) + "\n"
    chaine += "\\\\ \n"
    chaine += "\\hline \n"

    # Les ACS et les croix
    for (noc, comp) in enumerate(DATA_ACS):
        nom_comp = DATA_COMPETENCES[comp]["nom"]
        niveau = list(DATA_COMPETENCES[comp]["niveaux"].keys())[0]
        couleur = "\\textcolor{compC" + string.ascii_uppercase[noc] + "}"
        chaine += (
            "\\multicolumn{%d}{|l|}{\hyperlink{comp:%s}{%s{\\bfseries %s - %s }}} \\\\"
            % (nbre_colonnes, comp, couleur, comp, nom_comp.replace("&", "\&"))
        )
        chaine += "\\multicolumn{%d}{|l|}{\small Niveau 1 - %s} \\\\" % (
            nbre_colonnes,
            niveau.replace("&", "\&"),
        )
        chaine += "\\hline \n"
        for (k, ac) in enumerate(DATA_ACS[comp]):
            chaine += couleur + "{" + ac + "}" + " & " + "\n"
            chaine += "\\begin{tabular}{p{%scm}} " % (str(longueur - 0.2))
            chaine += "\\tiny{" + DATA_ACS[comp][ac] + "}"
            chaine += "\\end{tabular} & \n"

            croix = []
            indice_ac = les_codes_acs.index(ac)
            for (i, s) in enumerate(saesem):  # pour chaque SAE
                croix.append("$\\times$" if matrice[indice_ac][i] == True else "")
            chaine += " & ".join(croix) + "\n"
            chaine += " & "
            croix = []
            for (j, r) in enumerate(ressem):  # pour chaque SAE
                croix.append(
                    "$\\times$" if matrice[indice_ac][nbre_saes + j] == True else ""
                )
            chaine += " & ".join(croix) + "\\\\ \n"
            # if k < len(DATA_ACS[comp]) -1:
            #    chaine += "\\cline{2-%d}" % (nbre_saes+ nbre_ressources+3)
            chaine += "\\hline \n"
        chaine += "\\hline \n"

    chaine += "\\end{tabular}"
    return chaine


def to_latex_matrice_coeffs(matrice_vols, matrice_coeffs, saes, ressources, sem):
    """Renvoie le tableau latex affichant la matrice"""

    def str_coeff(val):
        if val == None:
            return ""
        else:
            return str(val)

    def str_volume(val):
        if val:
            return str(val) + "h"
        else:
            return " "

    comps = ["RT1", "RT2", "RT3"]
    lettresem = "A" if sem == "S1" else "B"
    sem_id = int(sem[1:])
    saesem = saes[sem]  # les saé du semestre
    ressem = ressources[sem]  # les ressources du semestre

    nbre_saes = len(saesem)
    nbre_colonnes = len(comps) + 2

    chaine = (
        "\\begin{tabular}[c]{|rp{6cm}|"
        + "c|" * 2
        + "c|"
        + "c|" * (len(comps))
        + "}"
        + "\n"
    )
    chaine += "\\hline \n"  # % (nbre_saes + nbre_ressources+1)+ "\n"
    # le début
    chaine += " & & " + "\\multicolumn{3}{c|}{\\bfseries Volumes} \n"
    chaine += " & " + "\\multicolumn{3}{c|}{\\bfseries Coefficients} \n"
    chaine += " \\\\ \\hline \n"
    # l'entete
    chaine += " & & "
    # Volume
    chaine += rotation_entete_colonne("\\bfseries Heures de formation encadrée") + " & "
    chaine += rotation_entete_colonne("\\bfseries Heures de TPs") + " & "
    chaine += rotation_entete_colonne("\\bfseries Heures de projets") + " & "
    # les noms des comps
    noms = []
    for (i, comp) in enumerate(comps):  # pour chaque compétence
        contenu = "\\begin{tabular}{p{5cm}}\n"
        couleur = "\\textcolor{compC" + string.ascii_uppercase[i] + "}"
        contenu += (
            "\\hyperlink{comp:" + comp + "}{"
            + couleur
            + "{\\bfseries "
            + comp
            + "}} - "
            + DATA_COMPETENCES[comp]["nom"].replace("&", "\&")
            + "\\\\ \n"
        )
        niveau = list(DATA_COMPETENCES[comp]["niveaux"].keys())[0]
        contenu += " \\small Niveau 1 - " + niveau.replace("&", "\&") + "\n"
        contenu += "\\end{tabular}\n"
        noms.append(rotation_entete_colonne(contenu) + "\n")
    chaine += " & ".join(noms) + "\n"
    chaine += "\\\\ \n"

    chaine += "\\hline"
    chaine += "\\hline"

    chaine += (
        "\multicolumn{%d}{|l}{\\textcolor{saeC}{\\bfseries SAÉs}}" % (nbre_colonnes)
        + "\n"
    )
    chaine += "\\\\ \n"
    chaine += "\\hline "
    # le nom des SAE
    for (i, s) in enumerate(saesem):  # pour chaque SAE
        chaine += "\\hyperlink{sae:" + s.sae["code"] + "}{"
        chaine += "\\textcolor{saeC}{" + s.sae["code"] + "}"
        chaine += "}"
        chaine += " & " + "\n"
        chaine += (
            "\\begin{tabular}{p{5.7cm}} \\tiny{"
            + s.sae["titre"]
            + "} \\end{tabular} & \n"
        )
        chaine += str_volume(matrice_vols[i][0]) + " & "
        chaine += str_volume(matrice_vols[i][1]) + " & "
        chaine += str_volume(matrice_vols[i][2]) + " & "
        chaine += " & ".join(
            [str_coeff(matrice_coeffs[i][j]) for j in range(len(comp))]
        )
        chaine += "\\\\ \n"
        chaine += "\\hline "
    # Les ressources et les coeff
    chaine += (
        "\multicolumn{%d}{|l}{\\textcolor{ressourceC}{\\bfseries Ressources}}"
        % (nbre_colonnes)
        + "\n"
    )
    chaine += "\\\\ \n"
    chaine += "\\hline "

    for (i, r) in enumerate(ressem):  # pour chaque SAE
        chaine += "\hyperlink{res:" + r.ressource["code"] + "}{"
        chaine += "\\textcolor{ressourceC}{" + r.ressource["code"] + "}"
        chaine += "}"
        chaine += " & " + "\n"

        chaine += "\\begin{tabular}{p{5.7cm}}"
        chaine += "\\tiny{" + r.ressource["nom"] + "}"
        chaine += " \\end{tabular} & \n"
        chaine += str_volume(matrice_vols[i + nbre_saes][0]) + " & "
        chaine += str_volume(matrice_vols[i + nbre_saes][1]) + " & "
        chaine += " & "
        chaine += " & ".join(
            [str_coeff(matrice_coeffs[i + nbre_saes][j]) for j in range(len(comp))]
        )
        chaine += "\\\\ \n"
        chaine += "\\hline "

    # Total
    total_heures = get_total_nbre_heures(matrice_vols)
    total_heures_sae = get_total_nbre_heures_saes(matrice_vols, sem)
    total_heures_ressources = get_total_nbre_heures_ressources(matrice_vols, sem)
    total_coeffs = get_total_coeffs(matrice_coeffs)
    total_coeffs_sae = get_total_coeffs_saes(matrice_coeffs, sem)
    total_coeffs_ressources = get_total_coeffs_ressources(matrice_coeffs, sem)

    chaine += "\\hline "
    chaine += "\multicolumn{%d}{|l|}{\\bfseries Total}" % (nbre_colonnes) + "\n"
    chaine += "\\\\ \n"
    chaine += "\\hline "
    # sous-total SAE
    chaine += "\multicolumn{2}{|r|}{\\textit{SAÉs}} "
    for i in range(3):
        chaine += " & \\textit{" + str(total_heures_sae[i]) + "h}"
    for i in range(3):
        chaine += " & \\textit{" + str(total_coeffs_sae[i]) + "}"
    chaine += "\\\\ \hline "
    chaine += "\multicolumn{2}{|r|}{\\textit{Ressources}} "
    for i in range(3):
        chaine += " & \\textit{" + str(total_heures_ressources[i]) + "h}"
    for i in range(3):
        chaine += " & \\textit{" + str(total_coeffs_ressources[i]) + "}"
    chaine += "\\\\ \hline "
    chaine += "\multicolumn{2}{|r|}{\\bfseries SAÉs + Ressources}"
    for i in range(3):
        chaine += " & {\\bfseries " + str(total_heures[i]) + "h}"
    for i in range(3):
        chaine += " & {\\bfseries " + str(total_coeffs[i]) + "}"
    chaine += "\\\\ \\hline"

    # ECTS
    chaine += r"""\multicolumn{5}{l}{~}\\
\multicolumn{5}{l}{\bfseries Crédits ECTS}\\
\hline
\multicolumn{5}{|l|}{} & RT1 & RT2 & \multicolumn{1}{c|}{RT3} \\
    \hline
\multicolumn{5}{|l|}{} & %d & %d & %d \\
    \hline
    """ % tuple(Config.ECTS[sem_id][ue] for ue in Config.ECTS[sem_id])
    chaine += "\\end{tabular}"
    return chaine


def get_total_nbre_heures(matrice_heures):
    """Calcul le nombre d'heures total des SAé d'après la matrice"""
    sommes = [
        sum(
            [
                matrice_heures[i][j]
                for i in range(len(matrice_heures))
                if matrice_heures[i][j]
            ]
        )
        for j in range(3)
    ]
    return sommes


def get_total_nbre_heures_saes(matrice_heures, sem):
    """Calcul le nombre d'heures total des SAé d'après la matrice"""
    nbre_sae = len(DATA_SAES[sem])
    sommes = [
        sum([matrice_heures[i][j] for i in range(nbre_sae) if matrice_heures[i][j]])
        for j in range(3)
    ]
    return sommes


def get_total_nbre_heures_ressources(matrice_heures, sem):
    """Calcul le nombre d'heures total des SAé d'après la matrice"""
    nbre_sae = len(DATA_SAES[sem])
    sommes = [
        sum(
            [
                matrice_heures[i][j]
                for i in range(nbre_sae, len(matrice_heures))
                if matrice_heures[i][j]
            ]
        )
        for j in range(3)
    ]
    return sommes


def get_total_coeffs(matrice_coeffs):
    sommes = [
        sum(
            [
                matrice_coeffs[i][j]
                for i in range(len(matrice_coeffs))
                if matrice_coeffs[i][j]
            ]
        )
        for j in range(3)
    ]
    return sommes


def get_total_coeffs_saes(matrice_coeffs, sem):
    nbre_sae = len(DATA_SAES[sem])
    sommes = [
        sum([matrice_coeffs[i][j] for i in range(nbre_sae) if matrice_coeffs[i][j]])
        for j in range(3)
    ]
    return sommes


def get_total_coeffs_ressources(matrice_coeffs, sem):
    nbre_sae = len(DATA_SAES[sem])
    sommes = [
        sum(
            [
                matrice_coeffs[i][j]
                for i in range(nbre_sae, len(matrice_coeffs))
                if matrice_coeffs[i][j]
            ]
        )
        for j in range(3)
    ]
    return sommes


def str_latex_abbreviations():
    """Renvoie le code latex d'un tableau pour les abbréviations"""
    liste = [
        [cle, DATA_ABBREVIATIONS[lettre][cle]]
        for lettre in DATA_ABBREVIATIONS
        for cle in DATA_ABBREVIATIONS[lettre]
    ]
    nbre_abbreviations = len(liste)
    chaine = ""
    for i in range(nbre_abbreviations):
        chaine += "\\begin{tabular}{rp{6.5cm}} \n"
        chaine += (
            "\makebox[1.5cm][r]{\\textabbrv{"
            + liste[i][0]
            + "}} & "
            + liste[i][1]
            + "\\\\ \n"
        )
        chaine += "\\end{tabular}\n\n"
    return chaine