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

    #création selection
    demande_selection = input("voulez vous inclure une selection o/n:")
    if demande_selection == 'o':
        taux_adaptation = cree_taux_selection()
        time = cree_liste_time()
        valeurs_cle = int(input("la valeurs z:"))
    else:
        taux_adaptation = [0]
        time = []
        valeurs_cle = 0
    #création selection

    #génération simulation
    taille_caneva = a+b+c
    generation_finale = generation_n_fois (liste_mutation,limite, pop, taille_caneva, genetic_naissance,valeurs_cle,taux_adaptation,time)
    #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

def cree_taux_selection():
    """
    entrée: rien
    sortie: liste d'entier taux selmection a b c
    """
    taux_a = int(input("taux de selection de a:"))
    taux_b = int(input("taux de selection de b:"))
    taux_c = int(input("taux de selection de c:"))

    liste = [taux_a]+[taux_b]+[taux_c]

    return liste

def cree_liste_time():
    """
    entrée: rien
    sortie: liste dde tupple, temps apparition slection
    """
    liste_res = []
    cpt_time = int(input("combien de foix la selection apparait:"))
    for i in range(0,cpt_time):
        liste_res = liste_res + [debut_fin_time(i)]
    return liste_res

def debut_fin_time(cpt):
    """
    entree: entier compteur
    sortie: liste debut fin date
    """
    print("c'estla date n°", cpt )

    debut = int(input("date de debut:"))
    fin = int(input("date de fin:"))
    return [debut,fin]


#####################
#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
            un dictionnaire d'entier avec des clé de génétique sur les naissances
            un entier, valeurs de z sdoit limite pour selection
            un dictionnaire d'entiet, les taux d'adaptqtion
            une liste d'entier, les apparition de la selection
    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, cpt, valeurs_cle,taux_adaptation,time)
        liste_generation = liste_generation+ [generation_finales]
        cpt = cpt + 1
    return liste_generation

def nouvelle_generation (liste_mutation, pop, taille_caneva, genetic_naissance, cpt, valeurs_cle,taux_adaptation,time):
    """
    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
             un entier, compte a quelle generation nous somme
             une entier, z
             liste entier, taux adaptation a selection de a b c
             liste de tupple, temps adaptation
<    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(selection(mutation(naissance(pop, genetic_naissance), liste_mutation ), valeurs_cle, taux_adaptation, time, cpt), 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 selection #
#####################
def selection(dictionnaire_pop,valeurs_clé,taux_adaptation,time, cpt):
    """
    entree: dictionnaire d'entier, individu par population
            entier, valeurs Z
            entier, valeurs Y pour a
            entier, valeurs Y pour b
            entier, valeurs Y pour c
            liste de tuple, temp de selection
            entier, compteur generation
    sortie: dictionnaire d'entier, individu par population
    """
    if time != [] and dans_temp_impartie(time, cpt) == True :

        #taux adaptation
        taux_adaptation_a = valeurs_dans_list(taux_adaptation,0)
        taux_adaptation_b = valeurs_dans_list(taux_adaptation,1)
        taux_adaptation_c = valeurs_dans_list(taux_adaptation,2)
        #taux adaptation

        #depart
        liste_cle = ['a']*dictionnaire_pop['a']+['b']*dictionnaire_pop['b']+['c']*dictionnaire_pop['c']
        liste_finale = []
        #depart

        #for de selection
        for i in range(0,len(liste_cle)):
            test = selection_pour_un(valeurs_clé,liste_cle[i],taux_adaptation_a,taux_adaptation_b,taux_adaptation_c)
            if test == True:
                liste_finale = liste_finale + [liste_cle[i]]

        dictionnaire_cle = creedico(liste_finale)
        #for de selection

    else:
        dictionnaire_cle = dictionnaire_pop

    return dictionnaire_cle

def selection_pour_un(val_z,entite,val_y_a,val_y_b,val_y_c):
    """
    entree: entier, valeurs Z
            charactère, population de l'individu
            entier, valeurs Y pour a
            entier, valeurs Y pour b
            entier, valeurs Y pour c
    sortie: dictionnaire d'entier, individu par population
    """
    val_x = random.randint(0,100)
    res= False
    if entite == 'a':
        if (val_x - val_y_a) <= val_z:
            res = True
    elif entite == 'b':
        if (val_x - val_y_b) <= val_z:
            res = True
    else:
        if (val_x - val_y_c) <= val_z:
            res = True
    return res

def dans_temp_impartie(time, nbgeneration):
    """
    entree: liste de tupple, les temps de selection
            un entier, génération actuel
    sortie: booleen
    """
    res = False
    cpt = 0
    while res == False and cpt < len(time):

        if est_dans_tupple(time[cpt],nbgeneration) == True:
            res = True

        cpt = cpt + 1

    return res

def est_dans_tupple(tupple,entier):
    """
        entree: tupple
                entier
        sortie: un booleen
    """

    res = False
    if entier >= tupple[0] and entier <= tupple[1]:
        res = True
    return res

####################
#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#
#########################