#définition de 2 classes : Interface_graphique() et Resultats_recherche()
#raccourci entrée = rechercher, modifier
#fenetres de confirmation pour suppression/modification
#mode sans confirmation (case à cocher depuis la 1e fenetre)
#appuyer sur echap, depuis n'importe quelle fenêtre, fait quitter tout le programme
#après avoir modifié un individu, ce dernier reste en sélection dans l'affichage des résultats recherche
#controle la saisie, renvoie message d'erreur si variables importantes non renseignées ou si variables remplies de manière incohérente
file_name = "test.csv"
#todo : l.215, l.239 (j'ai désactivé ces 2 lignes, elles buguent, j'y ai ajouté un mini descriptif)
#todo : idées à la con : mettre en "avant-plan", implémenter raccourci ctrl+q & ctrl+w

##modules
from tkinter		import *	# GUI
from tkinter import messagebox
from tkinter.ttk	import *	# Widgets avec thèmes
import csv
from random import choice, randint
from string import ascii_lowercase
from datetime import *

##liste_de_var
#L'ensemble des variables de chaque fichier est représenté par une liste, dont chaque élément est une variable dudit fichier.
#Cette variable est elle-même une liste, de la forme suivante :
#["nom de la variable", "type de la variable", **paramètres supplémentaires, suivant le type de la variable**, "booleen:variable importante"]
#Les différents types sont les suivants :

#"d" : date  ; on précisera en paramètre supplémentaire si la date est une date de début ("dd"),
#si c'est une date de fin ("df"), ou si c'est une simple date ("d")
#"int" : entier
#"str" : chaîne de caractères
#"ld" : liste déroulante

#Par exemple, la variable "Situation de la demande" sera codée de la façon suivante :
#["Situation de la demande", "ld", ["", "Active", "Annulée", "Fermée", "Pourvue"]]
#Ici, le troisième élément de la liste représente donc les modalités de la variable.

#En revanche, la variable "Nom du stagiaire" sera codée de la façon suivante :
#["Nom du stagiaire", "str"]
#Ici, il n'y a pas de paramètre supplémentaire à ajouter, la liste ne comprend donc que 2 éléments et non 3.


Var_stages=[["Situation de la demande","ld",["","Active","Annulée","Fermée","Pourvue"],True],
                  ["Nombre stagiaire","int",True],
                  ["Nom du stagiaire","str",True],
                  ["Prénom du stagiaire","str",True],
                  ["Rémunération","ld",["","Oui","Non"],True],
                  ["Site","ld",["","Paris","Arcueil","Angers"],True],
                  ["Structure","str",True],
                  ["Unité","str",True],
                  ["Niveau études","ld",["","Collège","Lycée","Bac +1","Bac +2","Licence","Master 1","Master 2","Master Spécialisé"],True],
                  ["Domaine études","str",True],
                  ["Durée","int"],
                  ["Date de début","d","dd",True],
                  ["Date de fin","d","df",True],
                  ["CHR","str",False],
                  ["Indemnités de stage (brut)","int",False],
                  ["N°TS","str",False],
                  ["Nom responsable hierarchique","str",False],
                  ["Nom tuteur","str",False],
                  ["Demande validée","str",False],
                  ["Transmission Dossier Paie/GA","str",False],
                  ["Convention","str",False],
                  ["Centre de formation","str",False],
                  ["Adresse","str",False],
                  ["Demande de badge","str",False],
                  ["Commentaires","str",False]]
Var_CDD = []
Var_alternants = []
Var_interim = []
from openpyxl import load_workbook, Workbook
def recuperer_liste_de_var():
    debut_nom_fichier = ["CCD_2016.xls", "alternants_2016.xlsx", "stages_2016.xlsx"]
    for file_name in debut_nom_fichier:
        wb = load_workbook(filename = filename)
        #for colum
    return None

def test():
    wb = load_workbook("alternants_2016.xlsx")
#    ws = wb.sheet(0)
 #   print(ws[0][0])

def init_wb():
    """à éxécuter sans modération"""
    global wb_alt, wb_cdd, wb_int
    try:
        wb_alt
    except NameError:
        wb_alt = load_workbook("alternants_2016.xlsx")
        wb_cdd = load_workbook("CDD_2016.xlsx")
        wb_int = load_workbook("Int_2016.xlsx")

def ebauche_liste_de_var(wb):
    """renvoie ebauche de var_fichier"""
    ebauche_var = []
    for col in range(1,wb.worksheets[0].max_column):
        ebauche_var.append([wb.worksheets[0].cell(row = 2, column = col).value])
    for var in ebauche_var:
        if est_inclus("date", var[0]):
            if est_inclus("début", var[O]):
                var.append("d","dd")
            elif est_inclus("fin", var[0]):
                var.append("d","df")
            else:
                var.append("d","d")
        else:
            var.append("str")
    return ebauche_var

def valeurs_ld(wb):
    if False:
        valeurs = []
        for col in range(1,wb.worksheets[0].max_column):
            if wb.worksheets[1].cell(row = 2, column = col).value != None:
                if wb.worksheets[1].cell(row = 2, column = col).value != "":
                    return None


##ne pas appeler ce module csv
def read_line(line_id):
    with open(file_name,'r') as myfile:
        r = csv.reader(myfile, delimiter=';', quotechar='"', lineterminator='\n')
        lines=[l for l in r]
    return lines[line_id]

def add_line(new_line):
    """ajoute ligne à la fin du csv"""
    #on lit le fichier en mode "append"
    with open(file_name,'a') as myfile:
        w = csv.writer(myfile, delimiter=';', quotechar='"', lineterminator='\n')
        w.writerow(new_line)
    return None

def mod_line(line_id, new_line):
    """remplace la ligne d'indice line_id par new_line"""
    #on lit le fichier en mémoire
    with open(file_name,'r') as myfile:
        r = csv.reader(myfile, delimiter=';', quotechar='"', lineterminator='\n')
        lines=[l for l in r]
        lines[line_id]=new_line
    # puis on le modifie (toujours en mémoire), avant d'en réécrire toutes les lignes.
    with open(file_name,'w') as myfile:
        w = csv.writer(myfile, delimiter=';', quotechar='"', lineterminator='\n')
        w.writerows(lines)
    return None

def del_line(line_id):
    """supprime la ligne d'indice line_id"""
    # on lit le fichier en mémoire
    with open(file_name,'r') as myfile:
        r = csv.reader(myfile, delimiter=';', quotechar='"', lineterminator='\n')
        lines=[l for l in r]
        lines.pop(line_id)
    # puis on le modifie (toujours en mémoire), avant d'en réécrire toutes les lignes.
    with open(file_name,'w') as myfile:
        w = csv.writer(myfile, delimiter=';', quotechar='"', lineterminator='\n')
        w.writerows(lines)
    return None

##outils de test
def randomword(length):
   return ''.join(choice(ascii_lowercase) for i in range(length))

def creer_exemples(n_indiv, liste_de_var, annee):
    """retourne n_indiv individus : séquences 'relativement correctes' (de valeurs) stockées sous forme de listes à 25 éléments"""
    L = []
    for i in range(n_indiv): #juste un bête *n_indiv
        indiv = []
        #cette boucle remplit indiv avec des valeurs suffisamment cohérentes pour faire tourner tout le programme
        for variable in liste_de_var: #(i+1)-eme variable[j] = Lvar_stage[i][j]
            if variable[1] == "str":
                indiv.append(randomword(8))
            elif variable[1] == "int":
                indiv.append(randint(1,180))
            elif variable[1] == "ld":
                indice_aleatoire = randint(0,len(variable[2])-1)
                indiv.append(variable[2][indice_aleatoire])
            elif variable[1] == "d":
                indiv.append(str(randint(1,28))+"/"+str(randint(1,12))+"/"+str(annee))
        if not(datetime.strptime(indiv[11], '%d/%m/%Y')<datetime.strptime(indiv[12], '%d/%m/%Y')):
            indiv[12], indiv[11] = indiv[11], indiv[12]
        L.append(indiv)
    L.append(["exemple" for i in range(len(liste_de_var))])
    return L

def nouveau_fichier_test(n_indiv, liste_de_var, annee):
    nom_fichier = "stages_" + str(annee) + ".csv"
    """crée 'test.csv' : données aléatoires d'individus"""
    with open(nom_fichier,'w') as file:
        writer = csv.writer(file, delimiter=";",lineterminator='\n')
        writer.writerow([liste_de_var[i][0] for i in range(len(liste_de_var))])
        writer.writerows(creer_exemples(n_indiv, liste_de_var, annee))
    return None

##main
def est_inclus(str1, str2):
    """True si str1 est inclus dans str2, False sinon"""
    diff = len(str2) - len(str1)
    if diff < 0:
        return False
    elif diff == 0:
        return (str1 == str2)
    elif diff > 0:
        return(est_inclus(str1,str2[1:]) or est_inclus(str1,str2[:-1]))

def est_dans(elem_candidat,list):
    """True si elem_candidat est dans list, False sinon"""
    reponse = False
    for elem in list:
        if elem == elem_candidat:
            reponse = True
            break
    return reponse

def reponse_recherche(criteres):
    """Renvoie les résultats de la recherche"""
    "Liste dont les éléments sont de la forme [[val1, ... , val25], line_id]"
    Lindiv_et_nligne = []
    with open(file_name,'r') as myfile:
        reader = csv.reader(myfile, delimiter=';', quotechar='"', lineterminator='\n')
        lines=[l for l in reader]
        for i in range(1,len(lines)): #on commence à 1 pour écarter la ligne des intitulés de variables
            for j in range(len(liste_de_var)): #j comptera presque le nombre de critères remplis
                if not(est_inclus(criteres[j],lines[i][j])) and (criteres[j] != ""): #(match critère ou critère inactif)
                    j = 0
                    break
                if j == len(liste_de_var) - 1:
                    Lindiv_et_nligne.append([lines[i],i])
    return Lindiv_et_nligne

def pop_up_confirmer():
    """renvoie True si l'utilisateur clique sur 'OK', False sinon"""
    return messagebox.askokcancel("Demande de confirmation", "Êtes-vous sûr de vouloir continuer ?")

def est_entier(s):
    """Verifier qu'un string est un entier ou est vide"""
    if s == "":
        return True
    else:
        try:
            int(s)
            return True
        except Exception:
            return False

def est_date(d):
    """Verifier qu'un string est soit vide soit un date sous la forme jour/mois/annee"""
    if d == "":
        return True
    else:
        try:
            datetime.strptime(d, '%d/%m/%Y')
            return True
        except Exception:
            return False

def controle_type(indiv, liste_de_var):
    """vérifie la cohérence des valeurs de l'individu 'indiv' conformément à la liste de variables 'liste_var'"""
    Erreurs=[] #liste de booléens : Erreurs[i] vaut True s'il y a une erreur de saisie sur indiv[i], False sinon.
    dates_inversees = False #vaut True si la date de fin est antérieure à la date de début
    #on teste toutes les variables suivant leur type :
    for i in range(len(liste_de_var)):
        if est_dans(liste_de_var[i][1], ["str", "ld"]):
            Erreurs.append(False)
        elif liste_de_var[i][1]=="int":
            Erreurs.append(not(est_entier(indiv[i])))
        elif liste_de_var[i][1]=="d":
            Erreurs.append(not(est_date(indiv[i])))
            if liste_de_var[i][2]=="dd":
                date_debut=indiv[i]
            elif liste_de_var[i][2]=="df":
                date_fin=indiv[i]
    #on teste ensuite si la date de début est bien antérieure à la date de fin
    try:
        dates_inversees = datetime.strptime(date_debut, "%d/%m/%Y") > datetime.strptime(date_fin, "%d/%m/%Y")
    except ValueError:
        pass
    return (Erreurs,dates_inversees)

def controle_est_vide(indiv, liste_de_var):
    """vérifie que les variables importantes ne sont pas vides"""
    est_vide = [] #est_vide[i] = True si indiv[i] = "" (champ laissé vide)
    for i in range(len(liste_de_var)):
        if liste_de_var[i][-1]:
            est_vide.append(indiv[i] == "")
        elif not(liste_de_var[i][-1]):
            est_vide.append(False) #on considère que pour les variables non importantes, laisser vide leurs champs respectifs n'est pas une erreur
    return est_vide


class Menu_principal(Tk):
    dic_var = {"":None, "CDD":Var_CDD, "Alternants":Var_alternants, "Stages":Var_stages, "Intérim":Var_interim }
    dic_code_fichier = {"CDD":"CCD_", "Alternants":"alternants_", "Stages":"stages_", "Intérim":"Int_"}
    annees = [str(i) for i in range(2016, 2051)]
    """Affiche le menu principal"""
    dev = False
    def __init__(self, dev = False):
        self.dev = dev
        self.root = Tk()
        self.root.title("Menu principal")

        #Widgets
        self.choix_fichier = Combobox(self.root,exportselection=0, state="readonly")
        self.choix_fichier["values"] = list(self.dic_var.keys())
        self.choix_fichier.pack()

        self.choix_annee = Combobox(self.root, exportselection = 0, state = "readonly")
        self.choix_annee["values"] = self.annees
        self.choix_annee.set(2017)
        self.choix_annee.pack()


        Button(self.root, text="Ajouter un individu", command = lambda : self.bouton_ig_ajout()).pack()
        Button(self.root, text="Modifier un individu", command = lambda : self.bouton_ig_rech()).pack()

        if self.dev == True:
            self.brouillon_dev()

        self.root.mainloop()

    def init_var(self):
        """charge les variables sous la forme d'une liste"""
        self.liste_de_var = self.dic_var[self.choix_fichier.get()]
        return None

    def brouillon_dev(self):
        #Button(self.root, text = "test : cree fichier csv avec valeurs aléatoires selon saisie", command = lambda nouveau_fichier_test(30, )
        return None

    def code_fichier(self):
        """renvoie le code fichier en fonction du choix de l'utilisateur ; exemple : CDD_"""
        return self.dic_code_fichier[self.choix_fichier.get()]

    def file_name(self):
        """renvoie le nom du fichier associé à la saisie"""
        annee = self.choix_annee.get()
        return (self.code_fichier() + annee + ".csv")

    def bouton_ig_ajout(self):
        self.init_var()
        utilisateur_veut_nouveau_fichier = self.pop_up_fichier_inexistant()
        if utilisateur_veut_nouveau_fichier == None:
            Interface_graphique(fichier = self.file_name(), which = "a", lowertk = self)
        elif utilisateur_veut_nouveau_fichier:
            self.nouveau_fichier()
            Interface_graphique(fichier = self.file_name(), which = "a", lowertk = self)
        return None

    def bouton_ig_rech(self):
        self.init_var()
        utilisateur_veut_nouveau_fichier = self.pop_up_fichier_inexistant()
        if utilisateur_veut_nouveau_fichier == None:
            Interface_graphique(fichier = self.file_name(), which = "r", lowertk = self)
        elif utilisateur_veut_nouveau_fichier:
            self.nouveau_fichier()
        return None

    def fichier_existe(self):
        try:
            with open(self.file_name()):
                return True
        except IOError:
            return False

    def pop_up_fichier_inexistant(self):
        if self.fichier_existe():
            return None
        elif not(self.fichier_existe()):
            return messagebox.askyesnocancel("Information", "Le fichier sélectionné n'existe pas. Voulez-vous en initialiser un nouveau ?")

    def nouveau_fichier(self):
        """crée fichier csv vide (avec variables en 1e ligne)"""
        with open(self.file_name(),'w') as file:
            writer = csv.writer(file, delimiter=";",lineterminator='\n')
            writer.writerow([self.liste_de_var[i][0] for i in range(len(self.liste_de_var))])
        return messagebox.showinfo("Information", "Fichier créé")


class Interface_graphique(Tk): #dans la suite : ig correspondra à interface graphique
    """Affiche une interface graphique"""
    dev = False
    def __init__(self, fichier = file_name, which = "r", lowertk = None, line_id_a_modif = None, index_liste = None):
        """Interface de recherche ou interface de modification"""
        if lowertk != None:
            self.lowertk = lowertk #permet d'appeler le Tk "master"
            self.dev = self.lowertk.dev
            self.root = Toplevel()
            self.liste_de_var = self.lowertk.liste_de_var
        elif lowertk == None: #ne devrait jamais arriver
            messagebox.showerror("Erreur critique", "lowertk == None")

        if which == "r" :          #charge ig de recherche
            self.ig_rech()
        elif which == "a" :        #charge ig d'ajout
            self.ig_ajout()
        elif which == "m" :        #charge ig de modification
            self.ig_modif(line_id_a_modif, index_liste)

        for i in range(len(liste_de_var)): #on a déjà grid les labels avec self.creer_Tkobjets()
            self.Tkobjets[i].grid(row=i,column=1)
        self.root.bind('<Return>', lambda e: self.raccourci_entree())
        self.root.mainloop()

    def creer_Tkobjets(self):
        """Retourne les différents objets de saisie + grid les labels associes"""
        L = []
        for i in range(len(self.liste_de_var)):
            Label(self.root,text=self.liste_de_var[i][0]).grid(row=i,column=0,sticky=W)
            if self.liste_de_var[i][1]=="ld":
                L.append(Combobox(self.root,exportselection=0, width = 17 ,state="readonly"))
                L[i]["values"] = self.liste_de_var[i][2]
                L[i].set(self.liste_de_var[i][2][0])
            else: #on aurait pu utiliser elif est_dans(self.liste_de_var[i][1], ["str","int","d"]):
                L.append(Entry(self.root))
        return L

    def saisie(self): #fusion de criteres et saisie_modif
        """Renvoie valeurs saisies par l'utilisateur sous le format [val1, ... , val25]"""
        return [objet.get() for objet in self.Tkobjets]

    def afficher_erreur(self,erreur):
        """Affiche message d'erreur si saisie incohérente ; retourne True si erreur, False sinon"""
        msg = ""
        if erreur == "type":
            Erreurs, dates_inversees = controle_type(self.saisie(), self.liste_de_var)
            if  dates_inversees: #on remet dans le bon sens
                val11 = self.Tkobjets[11].get()
                val12 = self.Tkobjets[12].get()
                self.Tkobjets[11].delete(0, END)
                self.Tkobjets[12].delete(0, END)
                self.Tkobjets[11].insert(0, val12)
                self.Tkobjets[12].insert(0, val11)
        elif erreur =="rempli":
            Erreurs = controle_est_vide(self.saisie(),self.liste_de_var)
        n_erreurs = sum(Erreurs) #Erreurs = [True/False, ... , True/False] avec : True = 1, False = 0
        if n_erreurs == 0:
            return False
        elif n_erreurs == 1:
            msg = "La variable " + self.liste_de_var[Erreurs.index(True)][0] + " est mal renseignée."
        elif n_erreurs > 1:
            msg_var = "" #stocke les noms des variables présentant des valeurs incohérentes
            for i in range(len(self.liste_de_var)):
                if Erreurs[i]:
                    if n_erreurs > 1:
                        msg_var = msg_var + " " + self.liste_de_var[i][0] + ","
                        n_erreurs -= 1 #après cette ligne, il reste encore n_erreurs variables à ajouter à msg_var
                    elif n_erreurs == 1: # il reste une seule variable
                        msg_var = msg_var + " et " + self.liste_de_var[i][0]
            msg = "Les variables" + msg_var + " sont mal renseignées."
        if erreur == "rempli":
            n_erreurs = sum(Erreurs)
            if n_erreurs == 1:
                msg = msg + " (Cette variable ne peut être laissée vide)"
            elif n_erreurs > 1:
                msg = msg + " (Ces variables ne peuvent être laissées vides)"
        messagebox.showerror('Erreur',msg)
        return True

    def raccourci_entree(self):
        """Doit déterminer s'il faut lancer bouton_modif ou bouton_rech ou bouton_ajout lorsque l'utilisateur appuie sur la touche entree"""
        if self.root.title() == "Saisie de recherche":
            self.bouton_rech()
        elif self.root.title() == "Saisie de modification":
            self.bouton_modif()
        elif self.root.title() == "Saisie d'ajout":
            self.bouton_ajout()
        return None

    ##interface de recherche
    def ig_rech(self):
        self.root.title("Saisie de recherche")
        self.root.bind('<Escape>', lambda e: self.root.destroy()) #s'execute lorsqu'on appuie sur Echap
        self.hardcore = IntVar() #création de "variable-retour" pour Checkbutton

        #Widgets
        self.Tkobjets = self.creer_Tkobjets()
        Button(self.root, text="Rechercher",command = lambda : self.bouton_rech()).grid(row=0,column=3)
        Checkbutton(self.root, variable = self.hardcore, text = "Ne pas demander de confirmation").grid(row = 1, column = 3)
        return None

    def bouton_rech(self):
        self.root.withdraw() #fait disparaître self.root (et tous ses widgets) ; pour le faire réapparaître, utiliser self.deiconify() ; le pb : quand utiliser self.deiconify() ??
        erreur_types = self.afficher_erreur(erreur = "type")
        if not(erreur_types):
            Resultats_recherche(saisie_recherche = self)
        return None

    def elem_list(self):
        """Retourne iterable pour remplir la listbox de Resultats_recherche, recalcule resultats recherche"""
        a_afficher = reponse_recherche(self.saisie()) #est une liste dont les éléments sont de la forme [[val1, ... , val25], nligne]
        elem_list=[]
        for i in range(len(a_afficher)):
            elem="| "
            for j in range(len(self.liste_de_var)):
                elem=elem+a_afficher[i][0][j]+" | " # a_afficher[i][0][j] = val(j+1)
            elem_list.append(elem)
        return elem_list

    ##interface d'ajout
    def ig_ajout(self):
        self.root.title("Saisie d'ajout")
        self.root.bind('<Escape>', lambda e: self.root.destroy())
        self.hardcore = IntVar() #création de "variable-retour" pour Checkbutton

        #Widgets
        self.Tkobjets = self.creer_Tkobjets()
        Checkbutton(self.root, variable = self.hardcore, text = "Ne pas demander de confirmation").grid(row = 1, column = 3)
        Button(self.root, text="Ajouter",command = lambda : self.bouton_ajout()).grid(row=0,column=3)
        Button(self.root,text="pour test : valeurs aléatoires quasi-cohérentes", command = lambda : self.preremplir_formulaire_modif()).grid(row = 5, column = 3)
        return None

    def bouton_ajout(self):
        """Si confirmation, rend effectif la saisie de l'utilisateur"""
        erreur_rempli = self.afficher_erreur(erreur = "rempli")
        if not(erreur_rempli):
            erreur_types = self.afficher_erreur(erreur = "type")
            if not(erreur_types):
                if self.hardcore.get() or pop_up_confirmer():
                    add_line(self.saisie())
        return None

    ##interface de modification
    def ig_modif(self, line_id_a_modif, index_liste):
        #ces valeurs sont constantes dans interface de modif
        self.line_id_a_modif = line_id_a_modif
        self.index_liste = index_liste
        self.root.title("Saisie de modification")
        self.root.bind('<Escape>', lambda e: self.lowertk.lowertk.root.destroy())
        #todo : self.protocol("WM_DELETE_WINDOW", self.confirmer_sortie()) #permet de lancer self.confirmer_sortie() lorsqu'une fenêtre se ferme ; le pb c'est qu'elles se ferment toutes fréquemment

        #Widgets
        self.Tkobjets = self.creer_Tkobjets()
        self.preremplir_formulaire_modif() #charge les données du csv quant à l'individu ciblé
        Button(self.root, text="Modifier",command = lambda : self.bouton_modif()).grid(row=0,column=3)
        return None

    def bouton_modif(self):
        """Si confirmation, rend effectif la saisie de l'utilisateur"""
        erreur_rempli = self.afficher_erreur(erreur = "rempli")
        if not(erreur_rempli):
            erreur_types = self.afficher_erreur(erreur = "type")
            if not(erreur_types):
                    if self.lowertk.lowertk.hardcore.get() or pop_up_confirmer():
                        mod_line(self.line_id_a_modif, self.saisie())
                        self.lowertk.update_liste()
                        self.lowertk.liste.selection_set(self.index_liste)
        return None

    def preremplir_formulaire_modif(self):
        """Preremplit avec valeurs du csv"""
        ligne_select = read_line(self.line_id_a_modif)
        for i in range(len(self.liste_de_var)):
            if self.liste_de_var[i][1]=="ld":
                for item in self.liste_de_var[i][2]:
                    if est_dans(ligne_select[i],self.liste_de_var[i][2]): #pour éviter bug (sur Listbox) si données mal renseignées dans le csv
                        self.Tkobjets[i].set(ligne_select[i]) #on fixe à la valeur du csv
            else:
                self.Tkobjets[i].insert(0,ligne_select[i]) #idem
        return None

    def confirmer_sortie(self):
        if self.saisie() != read_line(self.line_id_a_modif):
            messagebox.askokcancel("Confirmation", "Êtes-vous sûr de vouloir quitter sans enregistrer les modifications ?")


class Resultats_recherche(Tk):
    """Affiche les resultats de la recherche dans une Listbox"""
    dev = False
    def __init__(self, saisie_recherche, dev = False):
        "Listbox + 2 boutons si resultats, messagebox sinon"
        self.lowertk = saisie_recherche
        self.dev = self.lowertk.dev
        if self.lowertk.elem_list() != []: #Listbox etc ne se lancent que si des individus correspondent à la requête
            self.liste_de_var = self.lowertk.liste_de_var
            self.root = Toplevel()
            self.root.title("Résultats de la recherche")

            #creation de la Listbox
            self.liste = self.remplir_listbox()
            self.liste.pack()

            #Widgets
            Button(self.root, text="Modifier",command=lambda:self.bouton_ig_modif()).pack()
            Button(self.root, text="Supprimer",command=lambda:self.bouton_suppr()).pack()
            self.root.bind('<Escape>', lambda e: self.lowertk.root.destroy())
            self.root.mainloop()
        else:
            messagebox.showinfo("Résultats de la recherche","Aucun individu ne répond à la requête")

    def remplir_listbox(self):
        """Cree la Listbox"""
        elem_list = self.lowertk.elem_list()
        listbox = Listbox(self.root, height=len(elem_list), width = max(len(ligne) for ligne in elem_list), exportselection=0)
        for item in elem_list:
            listbox.insert(END,item)
        return listbox

    def line_id(self):
        """Renvoie line_id dans csv de la selection"""
        choisi = self.liste.get(ACTIVE)
        n0 = self.lowertk.elem_list().index(choisi)                    #indice dans la listbox de la sélection
        line_id = reponse_recherche(self.lowertk.saisie())[n0][1]      #indice dans le csv
        return line_id

    def index_liste(self):
        """Renvoie index dans la liste de la selection"""
        return self.liste.curselection()

    def bouton_ig_modif(self):
        """Ouvre interface graphique pour modifier individu selectionne et renvoie line_id, index_liste"""
        Interface_graphique(which = "m", lowertk = self, line_id_a_modif = self.line_id(), index_liste = self.index_liste())
        return None

    def bouton_suppr(self):
        """Si confirmation, supprime la selection de la Listbox"""
        if self.lowertk.hardcore.get() or pop_up_confirmer():
            del_line(self.line_id())
            self.update_liste()
        return None

    def update_liste(self):
        """Actualise la Listbox"""
        elem_list = self.lowertk.elem_list()
        self.liste.delete(0,END)
        for item in elem_list:
            self.liste.insert(END,item)
        return None

    def fermeture_imminente(self):
        if messagebox.askokcancel("Quitter", "Voulez-vous quitter ?"):
            self.lowertk.root.destroy()
        return None



##exécution
liste_de_var = Var_stages
nouveau_fichier_test(30,liste_de_var, 2017)
Menu_principal(dev = True)