#Tp_6 TIC-TAC-TOE
#GAPINSKI Antoine

HUMAIN='X'        # Le symbole de l’humain.
ORDI='O'          # Le symbole de l’ordinateur.
VIDE=' '          # Le symbole de case vide.
T_PLATEAU=3       # Taille du plateau de jeu.

import random

def init_plateau():
    '''
        Fonction qui créée le plateau de jeu où les cases sont vides.
        Entrée  Rien
        Retour liste de listes
    '''
    return [[' ', ' ', ' '], [' ', ' ', ' '], [' ', ' ', ' ']]


def print_plateau(plateau):
    '''
        Fonction qui affiche le plateau sous la forme utilisée pour le jeu.
        Arg Liste de liste
        Retour Rien
    '''
    print(plateau[0][0],'|',plateau[0][1],'|',plateau[0][2])
    print('---------')
    print(plateau[1][0],'|',plateau[1][1],'|',plateau[1][2])
    print('---------')
    print(plateau[2][0],'|',plateau[2][1],'|',plateau[2][2])


def input_humain(plateau):
    '''
        Fonction qui demande a quelles coordonées l'utilisateur veut jouer son coup et vérifie si les coordonnées sont valides
        Arg liste de listes
        Retour coordonéés tuple
    '''
    terminer=False
    while terminer==False:
        coup=input("A vous de jouer, où voulez-vous placer votre coup ('q' pour abandonner) ? : ")
        y=int(coup[0])
        x=int(coup[1])
        if coup=='q':
            terminer=True
            print("Vous avez quitté la partie en cours.")
        if plateau[y][x]!=VIDE:
            print("La case a déjà été jouée ! Retentez votre coup. ")
        elif y<0 and x<0 and y>=T_PLATEAU and x>=T_PLATEAU:
            print("Coordonées non valide.")

        else :
            return y , x
    
            
def coords_vides(plateau):
    '''
        Donne la liste des coordonnées des cases vides
        Arg liste de listes
        Retour liste des coordonnées tuple
    '''
    liste_c_v = []
    for i in range(T_PLATEAU) :         
        for j in range(T_PLATEAU) :     
            if plateau[i][j]==VIDE :   
                liste_c_v+=[(i, j)]
    return liste_c_v
    
            
        
def input_ordi(plateau):
    '''
        Fonction qui tire au hasard une position vide pour le coup de l'ordinateur
        Arg liste de listes
        Retour tuple contenant les coordonnées
    '''
    coords_ordi=coords_vides(plateau)
    choix=random.randint(0,len(coords_ordi)-1)
    return coords_ordi[choix]
      
        
#On vérifie la victoire sur les lignes.
def victoire_ligne(symbole, plateau):
    '''
        Fonction qui permet de savoir si la ligne est remplie par les symboles 'x' ou 'o'
        Argument:
            symbole -- str
            plateau -- liste
        Retour:
            booleen:si la colonne est remplie renvoie True sinon renvoie False
    '''
    nb_carac=0
    for i in range(T_PLATEAU):
        for j in range(T_PLATEAU):
            if plateau[i][j]==symbole:
                nb_carac+=1
                if nb_carac==T_PLATEAU:
                    return True
        nb_carac=0
    return False

#On vérifie les colonnes.
def victoire_colonne(symbole,plateau):
    '''
        Fonction qui permet de savoir si la colonne est remplie par les symboles 'x' ou 'o'.
        Argument:
            symbole -- str
            plateau -- liste
        Retour:
            booleen:si la colonne est remplie renvoie True sinon renvoie False
    '''
    nb_carac=0
    for i in range(T_PLATEAU):
        for j in range(T_PLATEAU):
            if plateau[i][j]==symbole:
                nb_carac+=1
                if nb_carac==T_PLATEAU:
                    return True
        nb_carac=0
    return False

#On vérifie en diagonal.
def victoire_diagonale_a(symbole,plateau):
    '''
        Fonction qui permet de savoir si la diagonale gauche est remplie par 'x' ou 'o'
        Argument:
            symbole -- str
            plateau -- liste
        Retour:
            booleen:si la diagonale est remplie, renvoie True, sinon renvoie False
    '''
    nb_carac=0
    for i in range(T_PLATEAU):
        if plateau[i][i]==symbole:
            nb_carac+=1
            if nb_carac==T_PLATEAU:
                return True
    return False

def victoire_diagonale_b(symbole,plateau):
    '''
        Fonction qui permet de savoir si la diagonale droite est remplie par 'x' ou 'o'
        Argument:
            symbole -- str
            plateau -- liste
        Retour :
            booleen:si la diagonale est remplie renvoie True sinon renvoie False
    '''
    nb_carac=0
    for i in range(T_PLATEAU):
        if plateau[(T_PLATEAU-1)-i][i]==symbole:
            nb_carac+=1
            if nb_carac == T_PLATEAU:
                return True
    return False

def victoire(symbole,plateau):
    '''
        Fonction qui indique si quelqu'un à gagné
        Arguments :
            symbole -- str : HUMAIN ou ORDI
            plateau -- liste
        Retour :
            Booleen:True si la colonne ou la ligne ou la diagonale est remplie, False sinon.
    '''
    gagne_ligne=victoire_ligne(symbole,plateau)
    gagne_colonne=victoire_colonne(symbole,plateau)
    gagne_diagonale_a=victoire_diagonale_a(symbole,plateau)
    gagne_diagonale_b=victoire_diagonale_b(symbole,plateau)

    if gagne_ligne or gagne_colonne or gagne_diagonale_a or gagne_diagonale_b:
        return True
    return False

def joue_partie():
    '''
        Fonction qui lance la partie
        Argument :
            Aucun
        Retour :
            Aucun
    '''
    print("================================= TIC-TAC-TOE =================================\n")
    plateau=init_plateau()
    print_plateau(plateau)
    print()
    score=0
    terminer=False
    while not terminer:
        choix_joueur=input_humain(plateau)
        if choix_joueur==False:
            fin=True
        else:
            plateau[choix_joueur[0]][choix_joueur[1]]=HUMAIN
            print_plateau(plateau)
            print()
            victoire_humain=victoire(HUMAIN,plateau)
            if victoire_humain:
                score+=1
                print("Bravo vous avez gagné ",score,"parties !")
                terminer=True
            else:
                choix_ordi=input_ordi(plateau)
                plateau[choix_ordi[0]][choix_ordi[1]]=ORDI
                print("Coup de l'ordinateur : ",choix_ordi)
                print_plateau(plateau)
                print()
                victoire_ordi=victoire(ORDI,plateau)
                if victoire_ordi:
                    print("Vous avez perdu !")
                    terminer=True
                #En cas de macth nul.
                case=0
                for i in range(T_PLATEAU):
                    for j in range(T_PLATEAU):
                        if plateau[i][j]==HUMAIN or plateau[i][j]==ORDI:
                            case+=1
                            if case==T_PLATEAU**2:
                                print("Matche nul !")
                                terminer = True

def input_rejouer():
    '''
        Fonction qui demande si l'utilisateur souhaite rejouer
        Argument :
            Aucun
        Retour :
            booleen '''
    terminer=False
    while not terminer:
        rejoue=input("Voulez vous jouer une autre partie ? oui/non : ")
        rejoue=rejoue.lower()
        if rejoue=='oui':
            terminer=True
            return True
        elif rejoue=='non':
            terminer=True
            return False
        else:
            print("La valeur indiquée n'est pas valide !")

def main():
    '''
        Fonction qui lance le jeu
        Argument :
            Aucun
        Retour :
            Aucun
    '''
    recommencer=True
    while recommencer:
        joue_partie()
        recommencer=input_rejouer()

main()