lancer_tests_automatiques = False ##Mettez à False pour ne pas lancer les tests
lancer_tests_interface = False ##Mettez à True pour lancer les tests semi-automatiques
afficher_traces = False ##Mettez a True pour afficher la trace complète des erreurs dans les tests

def allumettes(n):
    """
    n un entier > 0
    retourne une chaîne composée de n barres | 
    
    allumettes(5) vaut '|||||'
    """
    return "|" * n

def plateau(n):
    """
    n un entier > 0
    retourne une chaîne composée de n barres | , suivi de n entre ()
    
    plateau(5) vaut `||||| (5)`
    """
    return allumettes(n) + " (" + str(n) + ")"
    
def coup_basique_pc(a):
    """
    a un entier > 0, représente le nombre d'allumettes
    retourne toujours 1
    
    coup_basique_pc(10000) vaut 1
    """
    return 1
    
def autre_joueur(joueur):
    """
    joueur une chaine qui contient de nom "Joueur" ou "PC".
    retourne l'autre chaine
    
    autre_joueur("Joueur") vaut "PC"
    """
    if joueur == "PC":
        return "Joueur"
    else :
        return "PC"
    
def afficher_victoire(joueur):
    """
    joueur une chaine qui contient le nom ("Joueur" ou "PC") du vainqueur.
    Affiche une chaîne qui annonce la victoire de ce joueur !
    """
    print("\n### VICTOIRE DU " + joueur + " ###")    
    
def demander_coup_joueur():
    """
    Demande au joueur combien d'allumettes il veut retirer (entier de 1 a 3)
    retourne la valeur saisie par le joueur (type int).
    """
    coup = input("Combien d'allumettes (1-3)? ") 
    return int(coup)

def derouler_tour(joueur, al):
    """
    joueur une chaine qui contient le nom ("Joueur" ou "PC") du joueur en cours.
    al un entier, le nombre d'allumettes au debut du tour
    
    Affiche le nombre d'allumettes, s'enquiert du coup du joueur en cours,
    puis retourne le nouveau nombre d'allumettes
    """
    print() #les prints vides sont là pour sauter une lignes de formattage
    print(plateau(al))
    if joueur == "Joueur":
        print()
        coup = demander_coup_joueur()
    else:
        coup = coup_basique_pc(al)
        print() 
        print("PC : " + str(coup))
    return al - coup

def main():
    """
    demande un nombre d'allumettes au joueur, puis lance la partie avec ce nombre d'allumettes,
    jusqu'à qu'un joueur gagne. Ensuite, affiche la victoire.
    """
    al = int(input("Choisissez un nombre d'allumettes pour cette partie : "))
    joueur = "Joueur"
    
    while al > 0:
        al = derouler_tour(joueur, al)
        joueur = autre_joueur(joueur)
    
    afficher_victoire(joueur)


if __name__=="__main__":
    main()
    
############################################
#############   PARTIE TESTS   ############# 
############################################

import unittest
if not afficher_traces:
    __unittest = True

def checktype(expr, res, exp):
    assert type(res) == exp, expr + " doit retourner une valeur de type " + exp.__name__ + ", mais a retourné une valeur de type " + type(res).__name__
    
def checkval_equal(expr, res, exp):
    str_exp = "'" +exp+ "'" if type(exp) == str else str(exp) 
    str_res = "'" +res+ "'" if type(res) == str else str(res) 
    assert res == exp, expr + " doit retourner " + str_exp + ", mais a retourné " + str_res
    
class Test_allumettes(unittest.TestCase):

    def test_1(self):
        res = allumettes(1)        
        checktype("allumettes(1)", res, str)
        checkval_equal("allumettes(1)", res, "|")

    def test_10(self):
        res = allumettes(10)
        checktype("allumettes(10)", res, str)
        checkval_equal("allumettes(10)", res, "||||||||||")
        
class Test_plateau(unittest.TestCase):

    def test_1(self):
        res = plateau(1)        
        checktype("plateau(1)", res, str)
        checkval_equal("plateau(1)", res, "| (1)")

    def test_10(self):
        res = plateau(10)
        checktype("plateau(10)", res, str)
        checkval_equal("plateau(10)", res, "|||||||||| (10)")
        
class Test_coup_basique_pc(unittest.TestCase):

    def test_1(self):
        res = coup_basique_pc(1)        
        checktype("coup_basique_pc(1)", res, int)
        checkval_equal("coup_basique_pc(1)", res, 1)

    def test_10(self):
        res = coup_basique_pc(10)
        checktype("coup_basique_pc(10)", res, int)
        checkval_equal("coup_basique_pc(10)", res, 1)
    
    def test_10934(self):
        res = coup_basique_pc(10934)
        checktype("coup_basique_pc(10934)", res, int)
        checkval_equal("coup_basique_pc(10934)", res, 1)     
        
class Test_autre_joueur(unittest.TestCase):

    def test_Joueur(self):
        res = autre_joueur("Joueur")        
        checktype("autre_joueur('Joueur')", res, str)
        checkval_equal("autre_joueur('Joueur')", res, "PC")


    def test_PC(self):
        res = autre_joueur("PC")        
        checktype("autre_joueur('PC')", res, str)
        checkval_equal("autre_joueur('PC')", res, "Joueur")
        
if __name__ == '__main__' and lancer_tests_automatiques:
    s = unittest.TestSuite()
    s.addTests(unittest.TestLoader().loadTestsFromTestCase(Test_allumettes))
    s.addTests(unittest.TestLoader().loadTestsFromTestCase(Test_plateau))
    s.addTests(unittest.TestLoader().loadTestsFromTestCase(Test_coup_basique_pc))
    s.addTests(unittest.TestLoader().loadTestsFromTestCase(Test_autre_joueur))
    unittest.TextTestRunner().run(s)
    
    
def check_interface_afficher_victoire():
    print("\nTEST INTERFACE : afficher_victoire")
    afficher_victoire("PC")
    res = input("TEST INTERFACE : la victoire du PC est-elle correctement affichée (oui/non) ? ")
    if(res != "oui"):
        assert False, "ECHEC"
        
def check_interface_demander_coup_joueur():
    print("\nTEST INTERFACE : demander_coup_joueur")
    print("TEST INTERFACE : A la prochaine question, répondez 3 !")
    res = demander_coup_joueur()
    checktype("demander_coup_joueur()", res, int)
    checkval_equal("demander_coup_joueur()", res, 3)
    res = input("TEST INTERFACE : la question affichait que la réponse était entre 1 et 3 (oui/non) ? ")
    if(res != "oui"):
        assert False, "ECHEC"
    
def check_interface_derouler_tour_PC():
    print("\nTEST INTERFACE : derouler_tour('PC')")
    r = derouler_tour("PC", 4)
    checktype("derouler_tour('PC', 4)", r, int)
    checkval_equal("derouler_tour('PC', 4)", r, 3)
    res = input("TEST INTERFACE : C'est le PC qui a joué (oui/non) ? ")
    if(res != "oui"):
        assert False, "ECHEC"    
    res = input("TEST INTERFACE : Il y avait 4 allumettes à la base (oui/non) ? ")
    if(res != "oui"):
        assert False, "ECHEC"
    res = input("TEST INTERFACE : Il a retiré 1 allumette, celà a été affiché (oui/non) ? ")
    if(res != "oui"):
        assert False, "ECHEC"
        
def check_interface_derouler_tour_Joueur():
    print("\nTEST INTERFACE : derouler_tour('Joueur')")
    print("TEST INTERFACE : A la prochaine question, répondez 2 !")
    r = derouler_tour("Joueur", 5)
    checktype("derouler_tour('Joueur', 5)", r, int)
    checkval_equal("derouler_tour('Joueur', 5)", r, 3)
    res = input("TEST INTERFACE : C'est le Joueur qui a joué (oui/non) ? ")
    if(res != "oui"):
        assert False, "ECHEC" 
    res = input("TEST INTERFACE : Il y avait 5 allumettes à la base (oui/non) ? ")
    if(res != "oui"):
        assert False, "ECHEC"

if __name__ == '__main__' and lancer_tests_interface:
    print("LES TESTS D'INTERFACE COMMENCENT")
    check_interface_afficher_victoire() 
    check_interface_demander_coup_joueur()
    check_interface_derouler_tour_PC()
    check_interface_derouler_tour_Joueur()
    print("\nSUCCES")