"""
LABYRINTHE :
Il y a une zone de depart et une zone d'arrivee (2 carres)
Il y a un objet que l'on peut deplacer (un cercle)
Il y a des obstaces (des carres)
Les fleches permettent de se deplacer
Le 1er enfoncement d'une touche memorise l'instant de depart
Une fois dans la zone d'arrivee l'instant d'arrivee est memorise
puis la duree est determinee et un score est affiche

Le fait de toucher des obstacle ou le bord engendre des penalites.
Un bouton reset permet de recommencer
"""

from time import strftime
from Tkinter import *

# les chaines key.keysym.lower() pour les touches de deplacement 
HAUT = 'up'
BAS = 'down'
GAUCHE = 'left'
DROITE = 'right'

#dimensions de la zone de dessin
LARGEUR_CANVAS = 400
HAUTEUR_CANVAS = 100

# dimensions des zones (depart et arrivee) et du rayon de l'element
DIM_ZONE = 30               
RAYON = 10                  

# constantes de la zone de depart (coordonnées du centre et couleur)
X_D = DIM_ZONE
Y_D = HAUTEUR_CANVAS / 2        
COL_D = 'green'             

# constantes de la zone d'arrivee (coordonnées du centre et couleur)
X_A = LARGEUR_CANVAS - DIM_ZONE
Y_A = HAUTEUR_CANVAS / 2       
COL_A = 'blue'              

# les boites definissent les zones d'encombrement des elements de la zone de dessin
# on precise Xmin, Ymin, Xmax, Ymax
BOX_D = (X_D-DIM_ZONE/2, Y_D-DIM_ZONE/2, X_D+DIM_ZONE/2, Y_D+DIM_ZONE/2)
BOX_A = (X_A-DIM_ZONE/2, Y_A-DIM_ZONE/2, X_A+DIM_ZONE/2, Y_A+DIM_ZONE/2)

# variables globales
col = 'white'           #couleur de l'objet
x, y = X_D, Y_D         #coordonnees de l'objet initialise dans la zone de depart
penalites_canvas = 0

#les StringVar() qui seront utilises comme variabletext d'un label
str_var_moment_depart = ''          
str_var_moment_arrivee = ''         
str_var_penalites_canvas = ''   
str_var_duree_parcours = ''
str_var_score = ''

def renvoie_box_cercle(x, y, rayon):
    box = (x-rayon, y-rayon, x+rayon, y+rayon)
    return box

def box_hors_canvas(box):
    hors_canvas = False
    x_min = box[0]
    y_min = box[1]
    x_max = box[2]
    y_max = box[3]
    if x_min < 0 or y_min < 0:
        hors_canvas = True
    elif x_max > LARGEUR_CANVAS:
        hors_canvas = True
    elif y_max > HAUTEUR_CANVAS:
        hors_canvas = True
    return hors_canvas

def determine_duree(string_arrivee, string_depart):
    #le format est %H:%M:%S pour les string
    h_a = int(string_arrivee[:2])
    m_a = int(string_arrivee[3:5])
    s_a = int(string_arrivee[6:])
    h_d = int(string_depart[:2])
    m_d = int(string_depart[3:5])
    s_d = int(string_depart[6:])

    s_tot_a = s_a + 60 * m_a + 3600 * h_a
    s_tot_d = s_d + 60 * m_d + 3600 * h_d
    duree_en_sec = s_tot_a - s_tot_d
    if duree_en_sec < 0 :  #cas particulier avec un changement de jour
        duree_en_sec = 60  #disons 60s dans ce cas
    return duree_en_sec

def calcule_score(duree, penalites_canvas):
    #la duree est en secondes
    score = 1000 - 4*duree - 50*penalites_canvas
    if score < 0:
        score = 0
    return score

def gestion_touche(key):
    ma_touche = key.keysym.lower()
    #print key.keysym.lower()                                               #on active pour le debugg
    #print "key.char : " + key.char + " repr(key.char) : " + repr(key.char) #on active pour le debugg
    global col, x, y
    global penalites_canvas
    x_avant_deplacement = x
    y_avant_deplacement = y
    
    pas_px = 5                  #nombre de pixels pour chaque deplacement
    
    #le 1er enfoncement d'une touche est le moment de depart
    if str_var_moment_depart.get() == '':
        str_var_moment_depart.set(strftime("%H:%M:%S"))

    #la touche 'c' modifie la couleur de l'objet
    elif ma_touche == 'c':
        if col =='white':
            col = 'red'
        else:
            col = 'white'
        zone_dessin.itemconfig(balle, fill=col)

    #on regarde les touches que si on n'est pas arrive
    elif str_var_moment_arrivee.get() =='':
        #une touche de deplacement deplace ou donne une penalite
        if ma_touche == BAS or ma_touche == HAUT or ma_touche == GAUCHE or ma_touche == DROITE:
            #on memorise l'emplacement et on prepare le deplacement
            x_avant_deplacement = x
            y_avant_deplacement = y    
            if ma_touche == BAS:
                y += pas_px           
            elif ma_touche == HAUT:        
                y -= pas_px
            elif ma_touche == GAUCHE:
                x -= pas_px
            elif ma_touche == DROITE:
                x += pas_px 

            #on cree le box qu'aurait l'objet si deplace
            box_obj = renvoie_box_cercle(x, y, RAYON)

            #on remet l'emplacement initial si on sortait du canvas
            if box_hors_canvas(box_obj):
                penalites_canvas += 1
                str_var_penalites_canvas.set(str(penalites_canvas))
                x = x_avant_deplacement
                y = y_avant_deplacement
                box_obj = renvoie_box_cercle(x, y, RAYON)
                    
            #on met a jour l'objet
            zone_dessin.coords(balle, box_obj)
        
            #l'element dans la zone d'arrivee termine le labyrinthe
            if x == X_A and y == Y_A :
                str_var_moment_arrivee.set(strftime("%H:%M:%S"))
                str_dep = str_var_moment_depart.get()
                str_arr = str_var_moment_arrivee.get()
                nb_sec = determine_duree(str_arr, str_dep)
                str_var_duree_parcours.set(nb_sec)
                score = calcule_score(nb_sec, penalites_canvas)
                str_var_score.set(score)

#creation de la fenetre 
my_tk = Tk()
my_tk.title("labyrinthe")
my_tk.minsize(400, 400)

#ecoute d'un enfoncement clavier
my_tk.bind("<Key>", gestion_touche)

#les lignes d'indice 0 et 1 contiennent les instants de depart et arrivee
Label(text="moment de depart ").grid(row=0, column=0, sticky=W)
Label(text="moment d'arrivee ").grid(row=0, column=2, sticky=W)
str_var_moment_depart = StringVar()
Label(textvariable = str_var_moment_depart, height = 2).grid(row=1, column=0, columnspan=2, sticky=W)
str_var_moment_depart.set('')
str_var_moment_arrivee = StringVar()
Label(textvariable = str_var_moment_arrivee, height = 2).grid(row=1, column=2, columnspan=2, sticky=W)
str_var_moment_arrivee.set('')

#la ligne d'indice 2 est la zone de dessin
zone_dessin = Canvas(my_tk, width=LARGEUR_CANVAS, height=HAUTEUR_CANVAS, bg = 'black')
zone_dessin.grid(row=2, column=0, columnspan=4)
zone_dessin.focus_set()
zone_dessin.create_rectangle(BOX_D, fill=COL_D) #depart
zone_dessin.create_rectangle(BOX_A, fill=COL_A) #arrivee

#la balle
balle = zone_dessin.create_oval(renvoie_box_cercle(x, y, RAYON), fill=col)

#les lignes d'indice 3 et 4 indiquent les penalites
Label(text="penalites contour ").grid(row=3, column=0, sticky=W)
str_var_penalites_canvas = StringVar()
Label(textvariable = str_var_penalites_canvas, height = 2).grid(row=4, column=0, sticky=W)
str_var_penalites_canvas.set(penalites_canvas)

#la ligne d'indice 5 est vide
Label(text="").grid(row=5, column=0, sticky=W) #une ligne vide

#la ligne d'indice 6 indique le temps total mis
Label(text="duree : ").grid(row=6, column=0, sticky=W)
str_var_duree_parcours = StringVar()
Label(textvariable = str_var_duree_parcours, height = 2).grid(row=6, column=1, sticky=W)
str_var_duree_parcours.set('')

#la ligne d'indice 7 indique le score
Label(text="score : ").grid(row=7, column=0, sticky=W)
str_var_score = StringVar()
Label(textvariable = str_var_score, height = 2).grid(row=7, column=1, sticky=W)
str_var_score.set('')

#la ligne d'indice 9 explique a l'utilisateur
Label(text = " Utilisez les fleches pour vous deplacer ").grid(row=9, column=0, columnspan=4)

my_tk.mainloop()