from davistk import *
from random import randint


def affiche_temps(temps):
    """
    Affiche le temps restant pour faire un choix sachant que le joueur a 3 secondes et que l'on veut afficher un entier.

    Args:
        temps (float): Le temps écoulé depuis le début du choix.

    Returns:
        None
    """
    efface_tout()
    ... # A compléter
    texte(400, 550, "Appuyez sur 'P' pour Pierre, 'F' pour Feuille, 'C' pour Ciseaux", ancrage="center", taille=16, couleur="gray")

def choisir():
    """ Ne pas modifier. Permet de gérer le choix du joueur. Le joueur a 3 secondes pour faire son choix.
    Si le joueur appuie sur 'P', 'F' ou 'C' (majuscule ou minuscule) avant la fin du temps, la fonction retourne
    respectivement 0, 1 ou 2. Si le temps est écoulé, la fonction retourne None.

    Returns:
        int or None: 0 pour Pierre, 1 pour Feuille, 2 pour Ciseaux, None si le temps est écoulé
    """
    temps = 0
    while temps < 3:
        affiche_temps(temps)
        ev = donne_ev() # récupère un événement
        ty = type_ev(ev) # récupère le type de l'événement
        if ty == 'Quitte': # vérifie si l'événement est de type Quitte
            break # sort de la boucle
        elif ty == 'Touche': # vérifie si l'événement est de type Touche
            t = touche(ev) # récupère la touche appuyée
            if t in ['p', 'P']:
                return 0 # Pierre
            elif t in ['f', 'F']:
                return 1 # Feuille
            elif t in ['c', 'C']:
                return 2 # Ciseaux
        attente(0.1)
        temps += 0.1
    return None


def choix_ordinateur():
    """ Permet de faire choisir un coup à l'ordinateur de manière aléatoire.
    
    Returns:
        int: 0 pour Pierre, 1 pour Feuille, 2 pour Ciseaux
    
    """
    ... # A compléter
    return ... # à modifier

def choix_vers_texte(choix):
    """ Permet de convertir un choix (0, 1 ou 2) en texte ("Pierre", "Feuille" ou "Ciseaux").

    Args:
        choix (int): Le choix à convertir (0, 1 ou 2).

    Returns:
        str: Le choix en texte ("Pierre", "Feuille" ou "Ciseaux").

    >>> choix_vers_texte(0)
    'Pierre'
    >>> choix_vers_texte(1)
    'Feuille'
    >>> choix_vers_texte(2)
    'Ciseaux'
    >>> choix_vers_texte(3)
    'Choix invalide'
    """
    ... # A compléter

def qui_gagne(choix, choix_ordinateur):
    """ Permet de déterminer le gagnant d'une manche de Pierre-Feuille-Ciseaux.

    Args:
        choix (int): Le choix du joueur (0, 1 ou 2).
        choix_ordinateur (int): Le choix de l'ordinateur (0, 1 ou 2).

    Returns:
        str: "joueur" si le joueur gagne, "ordinateur" si l'ordinateur gagne, "égalité" en cas d'égalité.
    
    >>> qui_gagne(0, 2)
    'joueur'
    >>> qui_gagne(1, 0)
    'joueur'
    >>> qui_gagne(1, 2)
    'ordinateur'
    >>> qui_gagne(2, 2)
    'égalité'
    """
    if ...: # à modifier
        return "égalité"
    elif (choix == 0 and choix_ordinateur == 2) or (choix == 1 and choix_ordinateur == 0) or (choix == 2 and choix_ordinateur == 1):
        return "joueur"
    else:
        return ... # à modifier


def comptage_des_points(resultat, score_joueur, score_ordinateur):
    """ Permet de compter les points du joueur et de l'ordinateur en fonction du résultat d'une manche.

    Args:
        resultat (str): Le résultat de la manche ("joueur", "ordinateur" ou "égalité").
        score_joueur (int): Le score actuel du joueur.
        score_ordinateur (int): Le score actuel de l'ordinateur.

    Returns:
        tuple: Le nouveau score du joueur et de l'ordinateur.
    """
    ... # A compléter
    return score_joueur, score_ordinateur

def affiche_temps_ecoule():
    """ Na pas modifier. Affiche un message indiquant que le temps est écoulé. """
    texte(400, 300, "Temps écoulé !", ancrage="center", taille=20, couleur="red")
    attente(2)
    efface_tout()
    texte(400, 50, "Jeu de Pierre-Feuille-Ciseaux", ancrage="center", taille=24, couleur="black")

def affiche_resultat(choix, choix_ordi, resultat, score_joueur, score_ordinateur):
    """ Permet d'afficher le résultat d'une manche.

    Args:
        choix (int): Le choix du joueur (0, 1 ou 2).
        choix_ordi (int): Le choix de l'ordinateur (0, 1 ou 2).
        resultat (str): Le résultat de la manche ("joueur", "ordinateur" ou "égalité"). 
        score_joueur (int): Le score actuel du joueur.
        score_ordinateur (int): Le score actuel de l'ordinateur.

    Returns:
        None
    """
    efface_tout() # permet d'effacer l'écran
    ... # A compléter
    attente(3) # attente de 3 secondes pour laisser le temps de lire le message

def affiche_victoire(victoire, score_joueur, score_ordinateur):
    efface_tout() # permet d'effacer l'écran
    ... # A compléter
    attente(5) # attente de 5 secondes pour laisser le temps de lire le message

def a_gagne(score_joueur):
    """ Permet de déterminer si le joueur a gagné la partie.
    
    Args:
        score_joueur (int): Le score actuel du joueur.

    Returns:
        bool: True si le joueur a gagné, False sinon.

    >>> a_gagne(3)
    True
    >>> a_gagne(2)
    False
    """
    ... # A compléter
    return ... # A modifier

def fin_de_jeu(score_joueur, score_ordinateur):
    """ Permet de déterminer si la partie est terminée (un des joueurs a atteint 3 points).

    Args:
        score_joueur (int): Le score actuel du joueur.
        score_ordinateur (int): Le score actuel de l'ordinateur.
        
    Returns:
        bool: True si la partie est terminée, False sinon.
    """
    ... # A compléter
    return False # A modifier

# Programme principal
cree_fenetre(800, 600)
score_joueur = 0
score_ordinateur = 0
while not fin_de_jeu(score_joueur, score_ordinateur): # tant que personne n'a gagné
    choix = choisir() # choix du joueur
    if choix is None: # si le temps est écoulé
        affiche_temps_ecoule() # affiche le message du temps écoulé
        continue
    choix_ordi = choix_ordinateur() # choix de l'ordinateur
    resultat = qui_gagne(choix, choix_ordi) # détermine le gagnant
    score_joueur, score_ordinateur = comptage_des_points(resultat, score_joueur, score_ordinateur) # met à jour les scores
    affiche_resultat(choix, choix_ordi, resultat, score_joueur, score_ordinateur) # affiche le résultat de la manche
victoire = a_gagne(score_joueur) # vérifie si le joueur a gagné
affiche_victoire(victoire, score_joueur, score_ordinateur) # affiche le message de victoire ou de défaite
ferme_fenetre()