import textwrap
import pickle
from random import randint
from colorama import init
init()
import colorama


def afficher_regle_pendu(width):
    """affiche les règles du pendu"""
    print_dotted_line()
    print_bold("Le jeu du pendu!!!")
    print_dotted_line()
    msg = ("l'ordinateur choisit un mot au hasard dans une liste, un mot de huit lettres maximum."
           "Le joueur tente de trouver les lettres composant le mot. À chaque coup, il saisit une lettre."
           "Si la lettre figure dans le mot, l'ordinateur affiche le mot avec les lettres déjà trouvées."
           "Celles qui ne le sont pas encore sont remplacées par des étoiles (*). Le joueur a 8 chances."
           "Au delà, il a perdu.)")
    print(textwrap.fill(msg, width=width))
    print_dotted_line()

def initialisation_pendu(path):
    """cree le fichier donnees.py avec la liste de mots. Les joueurs et leurs scores sont enregistrés
    sous la clef 'a' sous la forme d'un dictionnaire, les mots sous la clef 'b' sous la forme d'une liste"""
    data = {"a":{}, "b":["ABRUTI", "GUIGNOL", "CLOPORTE", "TRUFFE", "MOULE"]}
    with open(path, 'wb') as fichier:
            mon_pickler = pickle.Pickler(fichier)
            mon_pickler.dump(data) 

def enregistrer_fichier(path, data):
    """enregistrement de donnees.py"""
    with open(path, 'wb') as fichier:
        mon_pickler = pickle.Pickler(fichier)
        mon_pickler.dump(data)
    
   

def lire_fichier(path):
    """chargement du fichier donnees.py. Essaye de lire le fichier donnees.py. Si le fichier n'existe pas
    il est crée."""
    try :
        with open(path, 'rb') as fichier:
            mon_depickler = pickle.Unpickler(fichier)
            # Lecture des objets contenus dans le fichier
            return mon_depickler.load()
        
    #donnees.py est initialisé la premiere fois que le jeu est lancé   
    except FileNotFoundError:
        initialisation_pendu(path)
        lire_fichier(path)
                
def print_bold(msg, end='\n'):
    """Print a string in 'bold' font"""
    print("\033[1m" + msg + "\033[0m")

def print_dotted_line(width=72):
    """Print a dotted (rather 'dashed') line"""
    print('-'*width)       

def rechercher_joueur():
    """recherche le nom du joueur et affiche son score"""
    nom = input("Quel est votre nom ? : ")
    nom = nom.upper()
    #chargement du dictionnaire de donnees.py
    data = lire_fichier('donnees.py')

    #test si le dictionnaire des joueurs/scores existe
    try:
        dico = data["a"]
    #recupere le nom du joueur et son score enregistré
        print("Le joueur {} à un score de {}.".format \
              (nom,dico[nom]))
        score = dico[nom]
    #si le joueur n'existe pas son score est initialisé à 0   
    except TypeError:
        print("C'est la première fois que vous jouez au zpendu!")
        print("Le joueur {} a un score de {}.".format (nom,0))
        score = 0
    return nom, score

def choisir_mot():
    """choisi au hasard un mot dans la liste enregistrée dans donnees.py et retourne le mot sous forme
    de liste de caracteres et sa forme codée par des '*'"""
    data = lire_fichier('donnees.py')
    #recuperation de la liste contenant les mots
    liste = data['b']
    #generation aleatoire du mot 
    mot = liste[randint(0,len(liste)-1)]
    #creation du mot codé
    code = ["*"] * len(mot)
    return mot,code

def afficher_mot(mot):
    """affiche le mot à l'écran"""
    print_dotted_line()
    print_bold(mot)
    print_dotted_line()

def tester_lettre(lettre, mot, code):
    """verifie si la lettre choisi par le joueur est présente dans le mot. Affiche le resultat et retourne
    le mot codé"""
    #recupere dans une liste la position dans le mot ou il y a la lettre choisi par le joueur
    liste = [i for i,element in enumerate(mot) if element == lettre]
    #remplace à l'emplacement "i" ,dans le mot codé , le caractere '*' par la lettre
    for i in liste:
        code[i]= lettre
    #si la liste a au moins un element, c'est qu'une lettre est bien dans le mot
    if len(liste):
        print_bold("BRAVO! la lettre {} est presente {} fois dans le mot!".format(lettre,len(liste)))
    else:
        print_bold("PERDU! La lettre {} n'est pas présente dans le mot".format(lettre))
    #affiche le mot codé modifié
    afficher_mot(("".join(code)))
    return code

def choisir_lettre():
    """le joueur choisi une lettre"""
    lettre = input("Choisir une lettre de l'alphabet: ")
    lettre = lettre.upper()
    #si la lettre est alphabetique uniquement
    if lettre.isalpha():
        return lettre
    else:
        print("Merci de saisir une lettre de l'alphabet!")
        choisir_lettre()

def trouver_mot(code,i):
    """verifie si le mot comporte des "*" et affiche le nombre de coup"""
    #si il reste des caracteres '*', ils sont mis dans la liste
    code =  [element for element in code if element =='*']
    # il reste des lettres à trouver car il reste des '*'
    if len(code):
        afficher_nbr_coup(i)
        score = 8 - i
    # toutes les lettres ont été trouvées    
    else:
        score = 8 - i
    # i est mis à 8 pour arreter la boucle while
        i =8
    return score,i

def afficher_nbr_coup(i):
    """compteur du nombre de coups déjà joué"""
    print_bold("Vous avez joué {} coup(s) sur 8!".format(i))
                
def sauvegarder_score(score, joueur):
    """enregistre le score du joueur dans donnees.py"""
    data = lire_fichier('donnees.py')
    dico = data["a"]
    #si le joueur existe déjà son score est ajouté au score
    #precedent
    try:
        dico[joueur] = int(dico[joueur])+ score
    #sinon le joueur et son score sont enregistré
    except KeyError:
        dico[joueur] = int(score)
    data["a"] = dico
    enregistrer_fichier('donnees.py', data)