# ############################################################################
#
# P R O J E T   D E   T E R M I N A L E   N S I
#
# ############################################################################
#
# Thème : Mastermind
# Version : 1
# Date : Mai 2025
# Tâche de chacun :
#
# Damien :
# - def dessiner_carres
# - def dessiner_cercles
# - def gerer_clic
# - def verifier_tentative
# - def initialiser_combinaison_secrete
#
# Rayan :
# - traduction des couleurs
# - nombre de tours
# - longueur_combinaison
# - niveaux de difficulté
# - Message d'erreur si couleur erronée
# - Bouton Afficher/Masquer + Rejouer
# - Affichage de la combinaison en fin de partie
#
# Antonin :
# - utilisation des couleurs
# - def gerer_clic (if couleur)
# - def texte
# - dessiner_feedback
# - success
#
# Fonctions réalisées par cette version du programme :
# - Mastermind fonctionnel
# - Plusieurs modes de difficulté
# - Boutons Rejouer et Afficher/Masquer la combinaison
# - Affichage de la combinaison en fin de partie
#
# Fonctions pas encore réalisées par cette version du programme :
# - Mode de sauvegarde de partie
#
# ############################################################################

from random import *
from turtle import *
from turtle import Turtle, ontimer
title("Mastermind")
hideturtle()
speed(0)

bgcolor("#f5f5dc")  # Couleur en fond


pensize(2)
color("black")
up()
goto(-400, 400)
setup(1000, 1000)
down()

# Dictionnaire de traduction des couleurs
couleurs_traduction = {  
    'rouge': 'red',
    'jaune': 'yellow',
    'bleu': 'blue',
    'orange': 'orange',
    'vert': 'green',
    'cyan': 'cyan',
    'violet': 'purple',
    'rose': 'pink'
}

# Liste des couleurs en anglais
couleurs = ['red', 'yellow', 'blue', 'orange', 'green', 'cyan', 'purple', 'pink']

combinaison_secrete = []
tentatives = []
tour_actuel = 0
combinaison = []

# ############################################################################
#
# Définition des fonctions :
#
# ############################################################################

def dessiner_carres():
    for i in range(10):
        for _ in range(longueur_combinaison):
            for _ in range(4):
                right(90)
                forward(50)
            up()
            forward(60)
            down()
        up()
        right(180)
        forward(60 * longueur_combinaison)
        left(90)
        forward(70)
        left(90)
        down()

    up()
    goto(150, -100)
    down()

    for i, couleur in enumerate(couleurs[:nb_couleurs_max]):
        fillcolor(couleur)
        pencolor('black')
        begin_fill()
        for _ in range(4):
            right(90)
            forward(50)
        end_fill()
        up()
        forward(60)
        if (i + 1) % 4 == 0:
            backward(60 * 4)
            right(90)
            forward(60)
            left(90)
        down()


def dessiner_cercles():
    up()
    
    decalage_x = -450 + (60 * longueur_combinaison)+10
    goto(decalage_x, 362)
    down()

    for _ in range(10):
        for _ in range(longueur_combinaison):
            circle(15)
            up()
            forward(30)
            down()
        right(180)
        up()
        forward(30 * longueur_combinaison)
        left(90)
        forward(70)
        left(90)
        down()
    up()


def texte():
    goto(0, 420)
    write('VOUS JOUEZ À MASTERMIND, BONNE PARTIE!', font=("Arial", 12, "bold"))
    goto(0, 380)
    write('JOUEUR 1 : Entrez une combinaison secrète.', font=("Arial", 8, "normal"))
    goto(0, 360)
    write('JOUEUR 2 : Essayez de trouver la combinaison secrète.', font=("Arial", 8, "normal"))
    goto(105, -80)
    write('Cliquez sur les couleurs ci-dessous pour jouer.', font=("Arial", 8, "normal"))

    print('BIENVENUE SUR MASTERMIND')
    print('Essayez de gagner.')


def gerer_clic(x, y):
    global tour_actuel
    couleur = None

    # Ligne 1 de couleurs (y entre -150 et -100)
    if -150 <= y <= -100:
        if 100 <= x <= 150:
            couleur = couleurs[0]
        elif 160 <= x <= 210:
            couleur = couleurs[1]
        elif 220 <= x <= 270:
            couleur = couleurs[2]
        elif 280 <= x <= 330:
            couleur = couleurs[3]

    # Ligne 2 de couleurs (y entre -210 et -160)
    elif -210 <= y <= -160:
        if 100 <= x <= 150:
            couleur = couleurs[4]
        elif 160 <= x <= 210:
            couleur = couleurs[5]
        elif 220 <= x <= 270:
            couleur = couleurs[6]
        elif 280 <= x <= 330:
            couleur = couleurs[7]

    if couleur:
        if len(tentatives) < 10 * longueur_combinaison:
            x_pos = -400 + (len(tentatives) % longueur_combinaison) * 60
            y_pos = 400 - (len(tentatives) // longueur_combinaison) * 70
            
            up()
            goto(x_pos, y_pos)
            down()
            fillcolor(couleur)
            begin_fill()
            for _ in range(4):
                right(90)
                forward(50)
            end_fill()
            tentatives.append(couleur)
            if len(tentatives) % longueur_combinaison == 0:
                verifier_tentative()


def dessiner_feedback(bien_place, mal_place):
    up()
    
    x_start = -450 + (60 * longueur_combinaison) + 10
    y_start = 362 - (tour_actuel - 1) * 70
    goto(x_start, y_start)
    down()

    for _ in range(bien_place):
        fillcolor('green')
        begin_fill()
        circle(15)
        end_fill()
        up()
        forward(30)
        down()

    for _ in range(mal_place):
        fillcolor('orange')
        begin_fill()
        circle(15)
        end_fill()
        up()
        forward(30)
        down()


success = True
for i, couleur in enumerate(combinaison):
    # Retourne None si la couleur en français n'existe pas
    traduit = couleurs_traduction.get(couleur)
    if traduit is None:
        print(f"Erreur: Couleur {couleur} n'existe pas.")
        success = false
    else:
        combinaison[i] = traduit

# Check qu'il n'y a pas eu d'erreur dans la boucle précedente
if not success:
    print("Error")
    

def initialiser_combinaison_secrete():
    global combinaison_secrete, couleurs

    success = True
    couleurs_possibles = couleurs[:nb_couleurs_max]  

    print(f"JOUEUR 1 : Entrez une combinaison secrète ({longueur_combinaison} couleurs parmi : " + ", ".join([c for c in couleurs_traduction if couleurs_traduction[c] in couleurs_possibles]) + ")")
    print("Ou appuyez sur Entrée pour que le robot la choisisse.")

    combinaison = input("Combinaison : ").split()

    for i, couleur in enumerate(combinaison):
        traduit = couleurs_traduction.get(couleur)
        if traduit is None or traduit not in couleurs_possibles:
            print(f"Erreur : Couleur '{couleur}' invalide ou non autorisée.")
            success = False
        else:
            combinaison[i] = traduit

    if not success:
        print("Erreur de saisie. Veuillez recommencer.")
        initialiser_combinaison_secrete()
        return

    if len(combinaison) < 1:
        combinaison = sample(couleurs_possibles, longueur_combinaison) 
        combinaison_secrete = combinaison
        print("Combinaison secrète générée par le robot.")
    elif len(combinaison) != longueur_combinaison:
        print(f"La combinaison doit contenir exactement {longueur_combinaison} couleurs.")
        initialiser_combinaison_secrete()
    else:
        combinaison_secrete = combinaison
        print("Combinaison secrète enregistrée.")

afficher_combinaison = False

def dessiner_bouton_combinaison():
    up()
    goto(350, 420)
    down()
    fillcolor("lightgray")
    begin_fill()
    for _ in range(2):
        forward(120)
        right(90)
        forward(40)
        right(90)
    end_fill()

    up()
    goto(360, 395)
    down()
    pencolor("black")
    write("Afficher/Masquer", font=("Arial", 10, "bold"))
    up()
    
    
def afficher_ou_masquer_combinaison():
    up()
    goto(150, -250)
    down()

    
    current_pencolor = pencolor()
    current_fillcolor = fillcolor()

    if afficher_combinaison:
        for couleur in combinaison_secrete:
            fillcolor(couleur)
            pencolor('black')
            begin_fill()
            for _ in range(4):
                forward(50)
                right(90)
            end_fill()
            up()
            forward(60)
            down()
    else:
        for _ in combinaison_secrete:
            fillcolor("white")
            pencolor("white")
            begin_fill()
            for _ in range(4):
                forward(50)
                right(90)
            end_fill()
            up()
            forward(60)
            down()

    
    fillcolor(current_fillcolor)
    pencolor(current_pencolor)


def gerer_bouton_combinaison(x, y):
    global afficher_combinaison
    if 350 <= x <= 470 and 380 <= y <= 420:
        afficher_combinaison = not afficher_combinaison
        afficher_ou_masquer_combinaison()


def gerer_clic_global(x, y):
    if 350 <= x <= 470 and 380 <= y <= 420:
        gerer_bouton_combinaison(x, y)
    elif 350 <= x <= 470 and 260 <= y <= 300:
        gerer_bouton_rejouer(x, y)
    elif 350 <= x <= 470 and 180 <= y <= 220:  
        effacer_derniere_tentative()
    else:
        gerer_clic(x, y)



def afficher_combinaison_finale(x, y):
    up()
    goto(x, y)
    down()
    
    # Sauvegarde des couleurs actuelles
    current_pencolor = pencolor()
    current_fillcolor = fillcolor()

    for couleur in combinaison_secrete:
        fillcolor(couleur)
        pencolor("black")
        begin_fill()
        for _ in range(4):
            forward(50)
            right(90)
        end_fill()
        up()
        forward(60)
        down()

    
    pencolor(current_pencolor)
    fillcolor(current_fillcolor)


def dessiner_bouton_rejouer():
    up()
    goto(350, 300)
    down()
    fillcolor("lightblue")
    begin_fill()
    for _ in range(2):
        forward(120)
        right(90)
        forward(40)
        right(90)
    end_fill()

    up()
    goto(365, 275)
    down()
    pencolor("black")
    write("Rejouer", font=("Arial", 12, "bold"))
    up()


def gerer_bouton_rejouer(x, y):
    if 350 <= x <= 470 and 260 <= y <= 300:
        rejouer()
        
        
def gerer_clic_global(x, y):
    if 350 <= x <= 470 and 380 <= y <= 420:
        gerer_bouton_combinaison(x, y)
    elif 350 <= x <= 470 and 260 <= y <= 300:
        gerer_bouton_rejouer(x, y)
    elif 350 <= x <= 470 and 180 <= y <= 220:  
        effacer_derniere_tentative()
    else:
        gerer_clic(x, y)



def rejouer():
    clear()  
    reset()  

    # Réinitialiser les variables globales
    global combinaison_secrete, tentatives, tour_actuel, combinaison, afficher_combinaison
    combinaison_secrete = []
    tentatives = []
    tour_actuel = 0
    combinaison = []
    afficher_combinaison = False

    # Réinitialiser les propriétés graphiques
    hideturtle()
    speed(0)
    pensize(2)
    color("black")
    up()
    goto(-400, 400)
    setup(1000, 1000)
    down()

    initialiser_combinaison_secrete()
    dessiner_carres()
    dessiner_cercles()
    dessiner_bouton_combinaison()
    texte()
    listen()


def afficher_tour():
    tour_writer.clear()  # Efface le texte précédent
    tour_writer.goto(260, 380)
    tour_writer.write(f"Tour {tour_actuel}/10", font=("Arial", 14, "bold"))


def verifier_tentative():
    global tour_actuel
    bien_place = 0
    mal_place = 0
    tentative = tentatives[-longueur_combinaison:]
    verification = combinaison_secrete[:]

    for i in range(longueur_combinaison):
        if tentative[i] == verification[i]:
            bien_place += 1
            verification[i] = None
            tentative[i] = None

    for i in range(longueur_combinaison):
        if tentative[i] is not None and tentative[i] in verification:
            mal_place += 1
            verification[verification.index(tentative[i])] = None

    tour_actuel += 1
    dessiner_feedback(bien_place, mal_place)

    afficher_tour()

    if bien_place == longueur_combinaison:
        up()
        goto(170, 310)
        write('FÉLICITATIONS ! VOUS AVEZ GAGNÉ !', align="center", font=("Arial", 16, "bold"))
        afficher_combinaison_finale(50, 230)
        dessiner_bouton_rejouer()
        down()
        return
    if tour_actuel == 10:
        up()
        goto(170, 310)
        write('DOMMAGE ! VOUS AVEZ PERDU !', align="center", font=("Arial", 16, "bold"))
        afficher_combinaison_finale(50, 230)
        dessiner_bouton_rejouer()
        down()
        return


def choisir_difficulte():
    global longueur_combinaison, nb_couleurs_max

    print("Choisissez un niveau de difficulté :")
    print("1 - Facile    (4 couleurs parmi 6)")
    print("2 - Moyen     (4 couleurs parmi 8)")
    print("3 - Difficile (5 couleurs parmi 8)")
    print("4 - Extrême   (4 couleurs parmi 8 + 60s de timer)")

    while True:
        choix = input("Votre choix (1, 2, 3 ou 4) : ")
        if choix == '1':
            longueur_combinaison = 4
            nb_couleurs_max = 6
            return
        elif choix == '2':
            longueur_combinaison = 4
            nb_couleurs_max = 8
            return
        elif choix == '3':
            longueur_combinaison = 5
            nb_couleurs_max = 8
            return
        elif choix == '4':
            longueur_combinaison = 4
            nb_couleurs_max = 8
            activer_mode_extreme()  # Lance le compte à rebours
            return
        else:
            print("Entrée invalide. Choisissez 1, 2, 3 ou 4.")

def mettre_a_jour_timer():
    global temps_restant
    timer_turtle.clear()
    if temps_restant > 0:
        timer_turtle.write(f"Temps restant : {temps_restant}s", font=("Arial", 12, "bold"))
        temps_restant -= 1
        ontimer(mettre_a_jour_timer, 1000)
    else:
        timer_turtle.write("⏰ TEMPS ÉCOULÉ !", font=("Arial", 14, "bold"))
        afficher_combinaison_finale(50, 230)
        dessiner_bouton_rejouer()

def activer_mode_extreme():
    global temps_restant
    temps_restant = 75
    mettre_a_jour_timer()




def effacer_derniere_tentative():
    global tentatives

    if len(tentatives) == 0:
        return

    
    if len(tentatives) % longueur_combinaison == 0:
        return

    index = len(tentatives) - 1
    col = index % longueur_combinaison
    row = index // longueur_combinaison

    x_pos = -400 + col * 60
    y_pos = 400 - row * 70

    up()
    goto(x_pos, y_pos)
    down()
    fillcolor(bgcolor())   
    pencolor("black")      
    begin_fill()
    for _ in range(4):
        right(90)
        forward(50)
    end_fill()

    tentatives.pop()



def dessiner_bouton_effacer():
    up()
    goto(350, 220)  
    down()
    fillcolor("mistyrose")
    begin_fill()
    for _ in range(2):
        forward(120)     
        right(90)
        forward(40)      
        right(90)
    end_fill()

    up()
    goto(365, 195)  
    down()
    pencolor("black")
    write("Effacer", font=("Arial", 12, "bold"))
    up()




# ############################################################################
#
# Programme principal :
#
# ############################################################################
temps_restant = 75
timer_turtle = Turtle()
timer_turtle.hideturtle()
timer_turtle.penup()
timer_turtle.goto(260, 340)

tour_writer = Turtle()
tour_writer.hideturtle()
tour_writer.penup()
tour_writer.goto(260, 380)

longueur_combinaison = 4
nb_couleurs_max = 6

onkeypress(bye, "Escape")



choisir_difficulte()
initialiser_combinaison_secrete()

onscreenclick(gerer_clic_global)  

dessiner_carres()
dessiner_cercles()
dessiner_bouton_combinaison()
dessiner_bouton_effacer()
texte()

listen()
done()