import random
import matplotlib.pyplot as plt

#####################
#creation simulation#
#####################

def simulation():
    """
    entrée: rien
    sortie: rien
    cette fonction est une procédure ou ici on implémentera les différent effet visuel et c'est a partir d'ici que l'on lancera la simulation
    """


    # input
    limite = int(input("nombre de génération que l'on veut = "))

    a = int(input("population a = "))
    b = int(input("population b = "))
    c = int(input("population c = "))

    naissance_a = int(input("pourcentage de chance de crée un desendent pour a = "))
    naissance_b = int(input("pourcentage de chance de crée un desendent pour b = "))
    naissance_c = int(input("pourcentage de chance de crée un desendent pour c = "))

    print("mutation pour a")
    mutationa_b = int(input("pourcentage de chance de mutation b = "))
    mutationa_c = int(input("pourcentage de chance de mutation c = "))

    print("mutation pour b")
    mutationb_a = int(input("pourcentage de chance de mutation a = "))
    mutationb_c = int(input("pourcentage de chance de mutation c = "))

    print("mutation pour c")
    mutationc_a = int(input("pourcentage de chance de mutation a = "))
    mutationc_b = int(input("pourcentage de chance de mutation b = "))

    liste_mutation = [mutationa_b,mutationa_c,mutationb_a,mutationb_c,mutationc_a,mutationc_b]
    #input


    #creation des dico
    pop = {}
    pop["a"] = a
    pop["b"] = b
    pop["c"] = c

    genetic_naissance = {}
    genetic_naissance["a"] =  naissance_a
    genetic_naissance["b"] =  naissance_b
    genetic_naissance["c"] =  naissance_c
    #creation des dico

    #génération simulation
    taille_caneva = a+b+c
    generation_finale = generation_n_fois (liste_mutation,limite, pop, taille_caneva, genetic_naissance)
    #pour l'instant on ne s'occupe que de regarder la population finale mais cela changera dans les futures versions
    return cree_graph(generation_finale, limite)
    #génération simulation




#####################
#creation generation#
#####################

def generation_n_fois (liste_mutation,limite, pop, taille_caneva, genetic_naissance,valeurs_cle,taux_adaptation,time):
    """
    entrée: une liste d'entier represente les coef de mutation
            un entier nombre de foi ou l'on veut faire des generation
            un dictionnaire d'entier avec des clé de population
            un entier taille que la population doit faire
    sortie: le dictionnaire finale
    permet de faire n fois nouvelle generation
    """
    generation_finales = pop
    liste_generation = []
    cpt = 0
    while cpt <= limite: # tourne la simulation le nombre de fois que limite
        generation_finales = nouvelle_generation (liste_mutation,generation_finales, taille_caneva, genetic_naissance)
        liste_generation = liste_generation+ [generation_finales]
        cpt = cpt + 1
    return liste_generation

def nouvelle_generation (liste_mutation, pop, taille_caneva, genetic_naissance,):
    """
    entrée : liste d'entier representes le scoef de mutation
             dictionnaire d'entier avec des clé de population,
             entier taille que la population doit faire
             un dictionnaire d'entier avec des clé de génétique sur les naissances
<    sortie: ce meme dictionnaire d'entier avec des clé de population mais valeurs différente
    cette fonction vas modifier les valeur de la population d'origine
    """
    return echantillonage(mutation(naissance(pop, genetic_naissance), liste_mutation ), taille_caneva)

def echantillonage (population_nfixe, taille_caneva):
    """
    entrée: dictionnaire d'entiier avec des clé de population
            entier taille que la population doit faire
    sortie: dictionnaire d'entier avec des clé de population
    echantillonne la population donné pour retrouvé la taille d'origine
    """
    liste = ["a"]*population_nfixe["a"]+["b"]*population_nfixe["b"]+["c"]*population_nfixe["c"]
    liste_choisi = []
    for i in range(0,taille_caneva):
        choix = random.choice(liste)
        liste = nv_list(liste, choix)
        liste_choisi = liste_choisi + [choix]
    dico_echantillon = creedico(liste_choisi)
    return dico_echantillon

def creedico (liste):
    """
    entree: liste de caractere
    sorite: dictionnaire
    """
    cpt_a2 = 0
    cpt_b2 = 0
    cpt_c2 = 0
    for i in range(0,len(liste)):
        if liste[i] == 'a':
            cpt_a2 = cpt_a2+1
        elif liste[i] == 'b':
            cpt_b2 = cpt_b2+1
        else:
            cpt_c2 = cpt_c2+1

    nv_dico = {}
    nv_dico["a"] = cpt_a2
    nv_dico["b"] = cpt_b2
    nv_dico["c"] = cpt_c2
    return nv_dico

def nv_list (liste, carac):
    """
    entrée = liste de caractere rpz les individu
             au caractère ( individu ) a enlevé
    sortie = une liste de caractere rpz les individu restant
    le but de cette fonction est d'enlevé l'individu choisi de la liste des individu restant
    """
    nvliste = []
    cpt = 0
    while liste[cpt] != carac:
        nvliste = nvliste + [liste[cpt]]
        cpt = cpt+1
    for i in range(cpt+1,len(liste)):
        nvliste = nvliste + [liste[i]]
    return nvliste

def naissance (pop, genetic_naissance):
    """
    entrée: dictionnaire d'entiier avec des clé de population
            un dictionnaire d'entier avec des clé de génétique sur les naissances
    sortie: un dictionnaire d'entier avec des clé de population(sans taille caneva)
    crée un dicionnaire avec toute les naissances possible
    """
    nv_population = {}
    nv_population["a"] = int(pop["a"])+ int(for_de_naissance(pop, genetic_naissance,'a'))
    nv_population["b"] = int(pop["b"])+ int(for_de_naissance(pop, genetic_naissance,'b'))
    nv_population["c"] = int(pop["c"])+ int(for_de_naissance(pop, genetic_naissance,'c'))
    return nv_population

def for_de_naissance(population, genetic_naissance,pop):
    """
    entrée: dictionnaire d'entiier avec des clé de population
            un dictionnaire d'entier avec des clé de génétique sur les naissances
            caractere qui est la population choisi
    sortie: un entier nomlbre de naissance
    """
    cpt_pop = 0

    for i in range(0, population[pop]):
        aleatoire = random.randint(0,100)
        if aleatoire <= genetic_naissance[pop] :
            cpt_pop = cpt_pop+1
    return cpt_pop

####################
#creation mutation #
####################

def mutation(dico_pop, liste_mutation):
    """
    entree: dicotionnaire d'entier sur les population
            liste d'entier represente les coef de mutation
    sortie: dictionnaire d'entier sur les population mutée
    cette fonction sert a faire mutéee la pop qui vien de naitre
    """
    pop_total_a = dico_pop["a"]
    pop_total_b = dico_pop["b"]
    pop_total_c = dico_pop["c"]
    liste = liste_mutation

    pop_mute_a_vers_b = mutater(pop_total_a,0,liste[0])
    pop_mute_a_vers_c = mutater(pop_total_a,pop_mute_a_vers_b,liste[1])
    pop_mute_b_vers_a = mutater(pop_total_b,0,liste[2])
    pop_mute_b_vers_c = mutater(pop_total_b,pop_mute_b_vers_a,liste[3])
    pop_mute_c_vers_a = mutater(pop_total_c,0,liste[4])
    pop_mute_c_vers_b = mutater(pop_total_c,pop_mute_c_vers_a,liste[5])

    dico_muter = {}
    dico_muter["a"] = pop_total_a - pop_mute_a_vers_b - pop_mute_a_vers_c + pop_mute_b_vers_a + pop_mute_c_vers_a
    dico_muter["b"] = pop_total_b - pop_mute_b_vers_a - pop_mute_b_vers_c + pop_mute_a_vers_b + pop_mute_c_vers_b
    dico_muter["c"] = pop_total_c - pop_mute_c_vers_a - pop_mute_c_vers_b + pop_mute_a_vers_c + pop_mute_b_vers_c

    return  dico_muter

def mutater(population,nb_enlever,coef):
    """
    entree: entier nb individu, eniter nb individu a lenlever du total, entier coeficient mutation
    sortie: entier nb individu muter
    """
    nb_individu_muter = 0
    total = population - nb_enlever
    for i in range(0,total):
        cpt = random.randint(0,100)
        if cpt < coef:
            nb_individu_muter += 1
    return nb_individu_muter


####################
#creation graphique#
####################

def cree_graph(dico_generation, nb_generation):
    """entrée: une liste de dictionnaire, valeurs des pop a chaque rang
               un entier, nombre de génération au total
       sortie: rein, procédure
       cette fonction crée un graphique"""
    #creation des données
    #liste d'entier allant de 0 a nb_generation
    liste_generation = []
    liste_generation = cree_liste_entier(nb_generation)
    #liste de la valeurs de la population a chaque generation
    valeurs_pop_a = cree_liste_pop(dico_generation, 'a')
    valeurs_pop_b = cree_liste_pop(dico_generation, 'b')
    valeurs_pop_c = cree_liste_pop(dico_generation, 'c')
    #graphique en ligne

    #plt.subplot(400)
    print(liste_generation)
    print(valeurs_pop_a)
    plt.title("nombre d'individu dans chaque population au cour du temp")
    #population a
    plt.plot(liste_generation, valeurs_pop_a)
    #population b
    plt.plot(liste_generation, valeurs_pop_b)
    #population c
    plt.plot(liste_generation, valeurs_pop_c)

    plt.ylabel("nombre d'individu")
    plt.xlabel("génération")
    plt.legend()

    #diagramme circulaire

    #plt.subplot(200)
    #name = ['population a', 'population b', 'population c',]
    #data = [ valeurs_pop_a[-1], valeurs_pop_a[-1], valeurs_pop_a[-1]]
    #explode=( 0.15, 0.15, 0.15,)
    #plt.pie(data, explode=explode, labels=name, autopct='%1.1f%%', startangle=90, shadow=True)
    #plt.axis('equal')

    plt.show()

def cree_liste_entier(entier):
    """
    entree: un entier
    sortie: une liste d'entier, allant de 0 a entier
    """
    liste_entier = []
    for i in range(0,entier + 1):
        liste_entier = liste_entier + [i]
    return liste_entier

def cree_liste_pop(dico_valeurs_pop, nompop):
    """
    entree: liste de dicotionnaire d'entier, les valeurs des pop a chaque generation
            string, nom de la population
    sortie: une liste d'entier, la liste des individu a chaque génération de la population
    """
    liste_valeurs_pop =[]
    for i in range(0,len(dico_valeurs_pop)):
        liste_valeurs_pop = liste_valeurs_pop + [valeurs_dans_dico(dico_valeurs_pop[i], nompop)]
    return liste_valeurs_pop

def valeurs_dans_dico(dictionnaire, classe):
    """
    entree: dictionnaire d'entier
    sortie: attribu a dans le dico
    """
    return dictionnaire.get(classe)

def valeurs_dans_list(liste, valeurs):
    """
    entree:
    sortie:
    """
    return liste[valeurs]
#########################
#creation simulation vie#
#########################