import numpy
import scipy
import matplotlib
from pylab import *
from random import *


########## caractéristiques du labyrinthe

########## Dans tout ce qui suit, les cases du labytinthe sont indexées par (i,j) correspondant à la case délimitée par (i,j) et (i+c,j+c). La diagonale du damier est (0,0) et (largeur,hauteur)

######### petit labyrinthe

c=20
largeur=40
hauteur=20
  

Taille_largeur=c*largeur
Taille_hauteur=c*hauteur


############ mise en place graphique #############

from tkinter import *

######### initialisation du labyrinthe ###########

dico = {} #dictionnaire contenant les coordonnées de chaque cellule et une valeur 0 ou 1 si elles sont respectivement mortes ou vivantes

for i in range(largeur+1) :
    for j in range(hauteur+1) :
            dico[i,j]=0
            



def Voisins(M)  : 
    """ calcule la liste des voisins d'une position M relativement au labyrinthe"""
    global largeur, hauteur ,dico
    Liste_Voisins=[]
    if M[0]==0 : 
        A=[1]
    elif M[0]==largeur : 
        A=[-1]
    else :
        A=[-1,1]
        
    for i in A :
        if  dico[M[0]+i,M[1]]==0 :
                    Liste_Voisins.append([M[0]+i,M[1]])
                
    if M[1]==0 : 
        B=[1]
    elif M[1]==hauteur : 
        B=[-1]
    else :
        B=[-1,1]
        
    for j in B :
        if  dico[M[0],M[1]+j]==0 :
                    Liste_Voisins.append([M[0],M[1]+j])
    return Liste_Voisins


def Test_Adj(M,N) :  
    """teste si deux positions sont adjacentes"""
    return abs(M[0]-N[0])+abs(M[1]-N[1])==1


#print(Test_Adj([5,6],[6,6]))



def Suppression(L,objet) :   
    """enlève objet de L """ 
    return [x for x in L if x!=objet]
    


def click_depart(event): 
    """fonction qui choisit le point de départ"""
    global dico,Dep,Arr
    x=event.x
    y=event.y
    i=x//c
    j=y//c
    Dep=[i,j]
    canevas.create_rectangle(i*c, j*c, (i+1)*c, (j+1)*c, fill='green')
    
    
    text_arr=Label(fenetre,text="Choix de la case d'arrivée ",fg="red")
    text_arr.pack(side=LEFT)
    
    canevas.bind("<Button-1>", click_arrivee)
  
def click_arrivee(event): 
    """fonction qui choisit le point d'arrivée"""
    global dico,Dep,Arr
    x=event.x
    y=event.y
    i=x//c
    j=y//c
    if [i,j] != Dep :
        Arr=[i,j]
        canevas.create_rectangle(i*c, j*c, (i+1)*c, (j+1)*c, fill='red')
    
    
        text_obst=Label(fenetre,text="Choix des obstacles ",fg="black")
        text_obst.pack(side=LEFT)
    
        canevas.bind("<Button-1>", click_gauche)
        canevas.bind("<Button-3>", click_droit)
      
        b3 = Button(fenetre, text ='Recommencer', command =recommencer)
        
        b4 = Button(fenetre, text ='Quitter', command =fenetre.quit)
        b5 = Button(fenetre, text ='Obstacles aléatoires', command =laby_alea)
        b4.pack(side =RIGHT, padx =3, pady =3)
        b3.pack(side =RIGHT, padx =3, pady =3)
        b5.pack(side =RIGHT, padx =3, pady =3)
        dessiner()

def laby_alea() : 
    """créé un labyrinthe aléatoire"""
    canevas.delete(ALL)
    for i in range(largeur+1) :
        for j in range(hauteur+1) :
            if [i,j]!=Dep and [i,j]!=Arr :
                if randint(0,2) ==2 : # deux fois plus de cases blanches que de cases noires, en moyenne
                    dico[i,j]=1
                else :
                    dico[i,j]=0
    dessiner()
                
def click_gauche(event): 
    """fonction rendant vivante la cellule cliquée donc met la valeur 1 pour la cellule cliquée au dico"""
    global dico
    x=event.x
    y=event.y
    i=x//c
    j=y//c
    if [i,j]!=Dep and   [i,j]!=Arr :
        canevas.create_rectangle(i*c, j*c, (i+1)*c, (j+1)*c, fill='black')
        dico[i,j]=1

def click_droit(event): 
    """fonction tuant la cellule cliquée donc met la valeur 0 pour la cellule cliquée au dico"""
    global dico
    x=event.x
    y=event.y
    i=x//c
    j=y//c
    if [i,j]!=Dep and [i,j]!=Arr :
        canevas.create_rectangle(i*c, j*c, (i+1)*c, (j+1)*c, fill='white')
        dico[i,j]=0


def dessiner(): # dessins le tableau à partir des états
    global dico,Dep,Arr
    for i in range(largeur+2) :
        canevas.create_line(i*c,0,i*c,Taille_hauteur+c,width=1,fill='black')
    for j in range(hauteur+2) :
        canevas.create_line(0,j*c,Taille_largeur+c,j*c,width=1,fill='black')
    canevas.create_rectangle(Dep[0]*c,Dep[1]*c,Dep[0]*c+c,Dep[1]*c+c, fill='green') # case de départ
    canevas.create_rectangle(Arr[0]*c,Arr[1]*c,Arr[0]*c+c,Arr[1]*c+c, fill='red') # case d'arrivée
    for i in range(largeur+1) :
        for j in range(hauteur+1) :
            if dico[i,j]==1 :
                canevas.create_rectangle(i*c,j*c,(i+1)*c,(j+1)*c, fill='black')
    fenetre.update()

def recommencer() :
    global dico
    canevas.delete(ALL)
    dico = {} #dictionnaire contenant les coordonnées de chaque cellule et une valeur 0 ou 1 si elles sont respectivement mortes ou vivantes

    for i in range(largeur+1) :
        for j in range(hauteur+1) :
                dico[i,j]=0
    dessiner()
########## interface graphique ##########


fenetre = Tk()
canevas = Canvas(fenetre, width =Taille_largeur+c, height =Taille_hauteur+c, bg ='white')

canevas.bind("<Button-1>", click_depart)
    
canevas.pack(side =TOP, padx =5, pady =5)
for i in range(largeur+2) :
    canevas.create_line(i*c,0,i*c,Taille_hauteur+c,width=1,fill='black')
    for j in range(hauteur+2) :
        canevas.create_line(0,j*c,Taille_largeur+c,j*c,width=1,fill='black')

text_dep=Label(fenetre,text="Choix de la case de départ ",fg="green")
text_dep.pack(side=LEFT)

fenetre.mainloop()
fenetre.destroy()


#print(Algorithme(Dep,Arr))