from otree.api import *
import random
import operator


doc = """
Simulateur de stratégies pour le choix des m meilleurs profils parmi n (m<n)
"""


class C(BaseConstants):
    NAME_IN_URL = 'simulateur'
    PLAYERS_PER_GROUP = None
    NUM_ROUNDS = 30

    @staticmethod
    def valeur_aleatoire(n):
        """
        Cette fonction renvoie un nombre entier aléatoirement compris entre 0 et n.
        """
        # On utilise la fonction randint de la bibliothèque random pour générer un nombre aléatoire
        valeur_aleatoire = random.randint(0, n)
        return valeur_aleatoire

    @staticmethod
    def dict_profils(cvtheque: int, nb_skills: int, score_max_skill: int):
        """
        Cette fonction renvoie une liste de 'nb_profils' dictionnaires de taille 'nb_skills'.
        Chaque dictionnaire contient comme éléments:
        'nb_skills-1' éléments ayant une valeur générée avec la fonction nombre_aléatoire,
        et un dernier élément étant la somme des éléments précédents.
        """
        # On crée un dictionnaire qui contiendra tous les profils
        profils = {}
        # Pour chaque profil, on va créer des scores pour chaque compétence
        for i in range(1, cvtheque+1):
            # On parcourt les profils un par un, que l'on va nommer profil_1, profil_2, etc
            profil = "profil_" + str(i)
            # On crée un dictionnaire des compétences qui vont être associées à chaque profil
            skills = {}
            # On crée une variable pour retenir le score global pour toutes les compétences
            somme = 0
            # On crée les compétences une par une selon le nombre de compétences choisi en paramètre de la fonction
            for j in range(1, nb_skills+1):
                # Chaque compétence aura comme clé un nom type skill_1, skill_2, etc
                skill = "skill_" + str(j)
                # Chaque compétence se voit attribue une valeur aléatoire entre 0 et la valeur_max choisie en paramètre
                valeur = C.valeur_aleatoire(score_max_skill)
                somme += valeur
                # Chaque compétence et la valeur associée sont ajoutés au dictionnaire de compétences
                skills[skill] = valeur
            # Lorsque toutes les compétences ont été créées, on ajoute le score total au dictionnaire de compétences
            skills["total"] = somme
            # Enfin, on met le profil et son dictionnaire de compétences associé dans le dictionnaire des profils
            profils[profil] = skills

        # On renvoie le dictionnaire de profils. Chaque profil est composé d'une clé type 'profil_X' et d'une valeur
        # étant un dictionnaire de compétences. Le dictionnaire des compétences est composé d'une clé type 'skill_X et
        # d'une valeur étant la valeur numérique associée à la compétence
        return profils

    @staticmethod
    def result_bests(nb_profils: int, profils: dict):
        """
        Methode qui permet de savoir quels sont les meilleurs profils de la liste
        :param nb_profils: Le nombre de profils qu'il faut garder au total
        :param profils: Le dictionnaire de profils à consulter
        :return: La liste des profils retenus
        """
        dict_total = {}
        for cle, valeur in profils.items():
            # dict_total[str(profil)] = profil["total"]
            dict_total.update({cle : valeur["total"]})

        # On trie dans une liste les éléments du dictionnaire par ordre décroissant en utilisant la fonction sorted et
        # le paramètre key
        classement = sorted(dict_total.items(), key=operator.itemgetter(1), reverse=True)
        # On récupère les 3 premiers éléments du dictionnaire trié
        bests = []
        if nb_profils < len(classement):
            bests = classement[:nb_profils]
        else:
            bests = classement[:]
        bests = [element[0] for element in bests]

        return bests, classement

    @staticmethod
    def strat_bests(nb_profils: int, profils: dict, niveaux: int, cut: int):
        """
        Stratégie consistant à regarder les scores du skill n+1 pour les profils ayant les scores n le plus élevé
        :param nb_profils : Le nombre de profils qu'il faut garder au total
        :param profils : Le dictionnaire de profils à consulter
        :param niveaux : Le nombre de skills à vérifier
        :param cut : Le nombre de candidats qu'on ne pourra pas voir au tour suivant
        :return : La liste des profils retenus et le classement total selon les scores vus
        """
        scores = {}
        leaders = {}
        for cle, valeur in profils.items():
            leaders[cle] = valeur
            scores[cle] = 0

        liste_leaders = []
        for niveau in range(1, niveaux+1):
            for cle, valeur in leaders.items():
                scores[cle] += profils[cle]["skill_"+str(niveau)]
            classement = sorted(scores.items(), key=operator.itemgetter(1), reverse=True)
            liste_leaders = classement[:len(profils) - niveau * cut]
            liste_leaders = [element[0] for element in liste_leaders]
            leaders = {}
            for cle, valeur in profils.items():
                if cle in liste_leaders:
                    leaders[cle] = valeur
        choix = classement[:nb_profils]
        choix = [element[0] for element in choix]

        return choix, classement

    @staticmethod
    def strat_worsts(nb_profils: int, profils: dict, niveaux: int, cut: int):
        """
        Stratégie consistant à regarder les scores du skill n+1 pour les profils ayant les scores n les plus faibles.
        :param nb_profils : Le nombre de profils qu'il faut garder au total
        :param profils : Le dictionnaire de profils à consulter
        :param niveaux : Le nombre de skills à vérifier
        :param cut : Le nombre de candidats qu'on ne pourra pas voir au tour suivant
        :return: La liste des profils retenus et le classement total selon les scores vus
        """
        scores = {}
        loosers = {}
        for cle, valeur in profils.items():
            loosers[cle] = valeur
            scores[cle] = 0

        liste_loosers = []
        for niveau in range(1, niveaux+1):
            for cle, valeur in loosers.items():
                scores[cle] += profils[cle]["skill_"+str(niveau)]
            classement = sorted(scores.items(), key=operator.itemgetter(1), reverse=True)
            liste_loosers = classement[niveau * cut:]
            liste_loosers = [element[0] for element in liste_loosers]
            loosers = {}
            for cle, valeur in profils.items():
                if cle in liste_loosers:
                    loosers[cle] = valeur
        choix = classement[:nb_profils]
        choix = [element[0] for element in choix]

        return choix, classement

    @staticmethod
    def strat_middle(nb_profils: int, profils: dict, niveaux: int, cut: int):
        """
        Stratégie consistant à regarder le score du skill n pour les profils ayant eu ni le meilleur ni le pire score n
        :param nb_profils : Le nombre de profils qu'il faut garder au total
        :param profils : Le dictionnaire de profils à consulter
        :param niveaux : Le nombre de skills à vérifier
        :param cut : Le nombre de candidats qu'on ne pourra pas voir au tour suivant
        :return : La liste des profils retenus et le classement total selon les scores vus
        """
        scores = {}
        middle = {}

        for cle, valeur in profils.items():
            middle[cle] = valeur
            scores[cle] = 0

        liste_middle = []
        for niveau in range(1, niveaux+1):
            for cle, valeur in middle.items():
                scores[cle] += profils[cle]["skill_" + str(niveau)]
            classement = sorted(scores.items(), key=operator.itemgetter(1), reverse=True)

            cut_spe = niveau * cut
            if cut_spe % 2 == 0:
                debut = int(cut_spe / 2)
                fin = int(cut_spe / 2)
            else:
                piece = random.randint(0, 1)
                debut = int((1 - piece) + cut_spe // 2)
                fin = int(piece + cut_spe // 2)
            if fin == 0:
                liste_middle = classement[debut:]
            else:
                liste_middle = classement[debut: -fin]
            liste_middle = [element[0] for element in liste_middle]
            middle = {}
            for cle, valeur in profils.items():
                if cle in liste_middle:
                    middle[cle] = valeur

        choix = classement[:nb_profils]
        choix = [element[0] for element in choix]

        return choix, classement

    @staticmethod
    def strat_random(nb_profils: int, profils: dict, niveaux: int, cut: int):
        """
        Stratégie consistant à regarder les scores du skill n+1 pour des profils choisis au hasard.
        :param nb_profils : Le nombre de profils qu'il faut garder au total
        :param profils : Le dictionnaire de profils à consulter
        :param niveaux : Le nombre de skills à vérifier
        :param cut : Le nombre de candidats qu'on ne pourra pas voir au tour suivant
        :return: La liste des profils retenus et le classement total selon les scores vus
        """
        scores = {}
        randoms = {}
        for cle, valeur in profils.items():
            randoms[cle] = valeur
            scores[cle] = 0

        liste_randoms = []
        for niveau in range(1, niveaux+1):
            for cle, valeur in randoms.items():
                scores[cle] += profils[cle]["skill_" + str(niveau)]
            classement = sorted(scores.items(), key=operator.itemgetter(1), reverse=True)
            liste_randoms = random.sample(classement, len(classement) - (niveau * cut))
            liste_randoms = [element[0] for element in liste_randoms]
            randoms = {}
            for cle, valeur in profils.items():
                if cle in liste_randoms:
                    randoms[cle] = valeur
        choix = classement[:nb_profils]
        choix = [element[0] for element in choix]

        return choix, classement

    @staticmethod
    def comparer_liste(liste1, liste2):
    # Calculer le nombre d'éléments communs entre les deux listes
        nb_elements_communs = len(set(liste1) & set(liste2))
        # Calculer le pourcentage d'éléments communs
        pourcentage_commun = nb_elements_communs / max(len(liste1), len(liste2)) * 100
        # Vérifier si les éléments sont dans le même ordre
        meme_ordre = liste1 == liste2
        return pourcentage_commun, meme_ordre

    @staticmethod
    def verif_strat(nb_profils: int, profils: dict, niveaux: int, cut: int):
        resultats = C.result_bests(nb_profils=nb_profils, profils=profils)
        strat_bests = C.strat_bests(nb_profils=nb_profils, profils=profils, niveaux=niveaux, cut=cut)
        strat_worsts = C.strat_worsts(nb_profils=nb_profils, profils=profils, niveaux=niveaux, cut=cut)
        strat_middles = C.strat_middle(nb_profils=nb_profils, profils=profils, niveaux=niveaux, cut=cut)
        strat_randoms = C.strat_random(nb_profils=nb_profils, profils=profils, niveaux=niveaux, cut=cut)
        dict_resultats = {"bests":
                                      {"pourcentage": C.comparer_liste(resultats[0], strat_bests[0])[0],
                                       "ordre": C.comparer_liste(resultats[0], strat_bests[0])[1],
                                       "choix": strat_bests[0],
                                       "classement": strat_bests[1]
                                       },
                                  "worsts":
                                      {"pourcentage": C.comparer_liste(resultats[0], strat_worsts[0])[0],
                                       "ordre": C.comparer_liste(resultats[0], strat_worsts[0])[1],
                                       "choix": strat_worsts[0],
                                       "classement": strat_worsts[1]
                                       },
                                  "middles":
                                      {"pourcentage": C.comparer_liste(resultats[0], strat_middles[0])[0],
                                       "ordre": C.comparer_liste(resultats[0], strat_middles[0])[1],
                                       "choix": strat_middles[0],
                                       "classement": strat_middles[1]
                                       },
                                  "randoms":
                                      {"pourcentage": C.comparer_liste(resultats[0], strat_randoms[0])[0],
                                       "ordre": C.comparer_liste(resultats[0], strat_randoms[0])[1],
                                       "choix": strat_randoms[0],
                                       "classement": strat_randoms[1]
                                       }
                                  }

        # Boucle sur les clés du dictionnaire de dictionnaires
        valeur_maximum = 0
        meilleure_strat = ''
        for key, value in dict_resultats.items():
            # Récupération de la valeur pour la clé "pourcentage" du dictionnaire imbriqué actuel
            valeur_pourcentage = value["pourcentage"]
            # Si la valeur pourcentage est supérieure à la valeur maximum actuelle
            if valeur_pourcentage > valeur_maximum:
                # Mise à jour de la valeur maximum
                valeur_maximum = valeur_pourcentage
                # Mise à jour de la clé correspondant à la valeur maximum
                meilleure_strat = key

        classement_strat = {}
        # créer un dictionnaire contenant la clé et son pourcentage
        for key, strat in dict_resultats.items():
            classement_strat[key] = strat["pourcentage"]

        # trier le dictionnaire par ordre décroissant de pourcentage
        # classement_strat.sort(key=lambda x: x[1], reverse=True)

        return dict_resultats, meilleure_strat, classement_strat

    @staticmethod
    def meilleure_strat(cvtheque: int, nb_skills: int, score_max_skill: int, tours: int, nb_profils: int, niveaux: int, cut: int):
        archives = []
        for i in range(tours):
            profils = C.dict_profils(cvtheque=cvtheque, nb_skills=nb_skills, score_max_skill=score_max_skill)
            issue = C.verif_strat(nb_profils=nb_profils, profils=profils, niveaux=niveaux, cut=cut)
            archives.append(issue)

        compteur_bests = 0
        compteur_worsts = 0
        compteur_middles = 0
        compteur_randoms = 0

        pourcent_bests = 0
        pourcent_worsts = 0
        pourcent_middles = 0
        pourcent_randoms = 0
        for essai in archives:
            if essai[1] == "bests":
                compteur_bests += 1
            elif essai[1] == "worsts":
                compteur_worsts += 1
            elif essai[1] == "middles":
                compteur_middles += 1
            elif essai[1] == "randoms":
                compteur_randoms += 1

            strategies = essai[2]
            pourcent_bests += strategies["bests"]
            pourcent_worsts += strategies["worsts"]
            pourcent_middles += strategies["middles"]
            pourcent_randoms += strategies["randoms"]

        diviseur = compteur_bests + compteur_worsts + compteur_middles + compteur_randoms
        compteur_bests = compteur_bests / diviseur * 100
        compteur_worsts = compteur_worsts / diviseur * 100
        compteur_middles = compteur_middles / diviseur * 100
        compteur_randoms = compteur_randoms / diviseur * 100

        pourcent_bests /= len(archives)
        pourcent_worsts /= len(archives)
        pourcent_middles /= len(archives)
        pourcent_randoms /= len(archives)

        classement = {
            "bests":
                {"choix":
                     pourcent_bests,
                 "strategie":
                     compteur_bests},
            "worsts":
                {"choix":
                     pourcent_worsts,
                 "strategie":
                     compteur_worsts},
            "middles":
                {"choix":
                     pourcent_middles,
                 "strategie":
                     compteur_middles},
            "randoms":
                {"choix":
                     pourcent_randoms,
                 "strategie":
                     compteur_randoms},
        }

        return classement


class Subsession(BaseSubsession):
    pass


class Group(BaseGroup):
    pass


class Player(BasePlayer):
    cvtheque = models.IntegerField(
        choices=[i for i in range(1, 101)],
        label="Nombre total de profil à consulter (0 à 100): "
    )
    nombre_competences = models.IntegerField(
        choices=[i for i in range(1, 6)],
        label="Nombre total de compétences dans le profil (1 à 5): "
    )
    score_max_competence = models.IntegerField(
        choices=[i for i in range(2, 11)],
        label="Score maximum que peut avoir une compétence (2 à 10): "
    )
    competences_vues = models.IntegerField(
        choices=[i for i in range(1, 6)],
        label="Nombre de compétences qui seront vues au total (doit être inférieur ou égal au nombre de compétences) : "
    )
    short_list = models.IntegerField(
        choices=[i for i in range(1, 100)],
        label="Taille de la shortlist à fournir à la fin (doit être inférieur au nombre de profils): "
    )
    cut = models.IntegerField(
        choices=[i for i in range(1, 11)],
        label="Nombre de profils qui ne pourront pas être vus au prochain tour (augmente de la même valeur à chaque "
              "tour): "
    )
    simulations = models.IntegerField(
        choices=[i for i in range(10, 1001, 10)],
        label="Nombre de simulations à faire (10 à 1 000): "
    )

    choix_best = models.FloatField()
    freq_best = models.FloatField()
    choix_worst = models.FloatField()
    freq_worst = models.FloatField()
    choix_middle = models.FloatField()
    freq_middle = models.FloatField()
    choix_random = models.FloatField()
    freq_random = models.FloatField()


# PAGES
class MyPage(Page):
    form_model = 'player'
    form_fields = [
        'cvtheque',
        'short_list',
        'cut',
        'nombre_competences',
        'competences_vues',
        'score_max_competence',
        'simulations'
    ]

    @staticmethod
    def error_message(player, values):
        print('values is', values)
        message = ''
        if values['competences_vues'] > values['nombre_competences']:
            message += 'Le nombre de compétences vues doit être inférieur ou égal au nombre total de compétences. \n'
        if values['short_list'] >= values['cvtheque']:
            message += 'Le nombre de candidats retenus doit être inférieur au nombre total de candidats. \n'
        if values['cut'] * values['competences_vues'] > values['cvtheque']:
            message += 'Le nombre de profils non visibles à chaque tour est trop élévé par rapport au nombre de compétences qui seront vues. \n'
        return message

    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        resultat = C.meilleure_strat(cvtheque=player.cvtheque, nb_skills=player.nombre_competences, score_max_skill=player.score_max_competence, niveaux=player.competences_vues, nb_profils=player.short_list, cut=player.cut, tours=player.simulations)

        player.choix_best = resultat["bests"]["choix"]
        player.freq_best = resultat["bests"]["strategie"]

        player.choix_worst = resultat["worsts"]["choix"]
        player.freq_worst = resultat["worsts"]["strategie"]

        player.choix_middle = resultat["middles"]["choix"]
        player.freq_middle = resultat["middles"]["strategie"]

        player.choix_random = resultat["randoms"]["choix"]
        player.freq_random = resultat["randoms"]["strategie"]

        """player.choix_best = choix_best
        player.freq_best = freq_best

        player.choix_worst = choix_worst
        player.freq_worst = freq_worst

        player.choix_middle = choix_middle
        player.freq_middle = freq_middle

        player.choix_random = choix_random
        player.freq_random = freq_random"""


class Results(Page):
    def vars_for_template(player: Player):
        choix_best = player.choix_best
        freq_best = player.freq_best

        choix_worst = player.choix_worst
        freq_worst = player.freq_worst

        choix_middle = player.choix_middle
        freq_middle = player.freq_middle

        choix_random = player.choix_random
        freq_random = player.freq_random

        nb_profils = player.cvtheque
        nb_competences = player.nombre_competences
        score_max = player.score_max_competence
        competences_vues = player.competences_vues
        short_list = player.short_list
        cut = player.cut
        simulations = player.simulations

        return dict(
            choix_best=choix_best,
            freq_best=freq_best,
            choix_worst=choix_worst,
            freq_worst=freq_worst,
            choix_middle=choix_middle,
            freq_middle=freq_middle,
            choix_random=choix_random,
            freq_random=freq_random,
            nb_profils=nb_profils,
            nb_competences=nb_competences,
            score_max=score_max,
            competences_vues=competences_vues,
            short_list=short_list,
            cut=cut,
            simulations=simulations
        )


page_sequence = [MyPage, Results]