### MASTERMIND

import random

COULEURS = ["J", "B", "R", "V", "O", "N"]
NB_PIONS = 4
NB_MAX_ESSAIS = 10
SYMBOLE_BIEN_PLACE = "#"
SYMBOLE_MAL_PLACE = "X"
SYMBOLE_ABSENT = "0"


def genere_combinaison_secrete():
    """Génération d'une combinaison secrète de NB_PIONS couleurs choisies dans COULEURS.

    Retourne:
        list: la combinaison secrète.
    """
    return


def saisir_combinaison():
    return


def combi_to_str(combinaison):
    """Conversion de la proposition en une chaîne de caractères.

    Paramèares:
        combinaison (list): la combinaison à convertir.
    Retourne:
        str: les éléments de la liste côte à côte sans espace.
    """
    return


def nb_occurrences(element, combinaison):
    """Compte le nombre de fois où element apparait dans la combinaison.

    Paramètres:
        element (str): un élément potentiel de la combinaison.
        combinaison (list): une combinaison.
    Retourne:
        int: le nombre de fois où element apparait dans la combinaison.
    """
    return


def trouve(element, combinaison):
    return


def evalue_proposition(proposition, secret):
    """Compare la proposition avec la combinaison secrète
    pour évaluer les pions bien placés et les mal placés dans la proposition.

    Paramètres:
        proposition (list): la combinaison proposée par le joueur.
        secret (list): la combinaison secrète à deviner.
    Retourne:
        list: une liste représentant, pour chaque pion, s'il est bien placé, mal placé, ou absent,
              en respectant les symboles choisis en constantes.
    """
    return


def manche_de_mastermind():
    """Jeu complet d'une manche de Mastermind joueur contre l'ordinateur.

    Retourne:
        int: le nombre d'essais du joueur avant de trouver (NB_MAX_ESSAIS + 1 s'il n'a pas trouvé).
    """
    return


### tests des fonctions à ne pas modifier :
def tests_genere_combinaison_secrete():
    combi = genere_combinaison_secrete()
    if type(combi) is not list:
        return False
    if len(combi) != 4:
        return False
    for element in combi:
        if element not in COULEURS:
            return False
    return True


def tests_saisir_combinaison():
    # pas automatisé
    combi = saisir_combinaison()
    print(combi)


def tests_combi_to_str():
    tests_reussis = 0
    if combi_to_str(["J", "R", "B", "N"]) == "JRBN":
        tests_reussis += 1
    return tests_reussis


def tests_nb_occurrences():
    tests_reussis = 0
    if nb_occurrences("J", ["J", "R", "B", "N"]) == 1:
        tests_reussis += 1
    if nb_occurrences("V", ["J", "R", "B", "N"]) == 0:
        tests_reussis += 1
    if nb_occurrences("R", ["J", "R", "B", "R"]) == 2:
        tests_reussis += 1
    if nb_occurrences("R", ["J", "V", "B", "R"]) == 1:
        tests_reussis += 1
    return tests_reussis


def tests_trouve():
    tests_reussis = 0
    if trouve("J", ["J", "R", "B", "N"]) == 0:
        tests_reussis += 1
    if trouve("V", ["J", "R", "B", "N"]) == -1:
        tests_reussis += 1
    if trouve("R", ["J", "R", "B", "R"]) == 1:
        tests_reussis += 1
    if trouve("R", ["J", "V", "B", "R"]) == 3:
        tests_reussis += 1
    return tests_reussis


def tests_evalue_proposition():
    tests_reussis = 0
    if evalue_proposition(["J", "R", "B", "N"], ["J", "R", "V", "O"]) == [
        "#",
        "#",
        "0",
        "0",
    ]:
        tests_reussis += 1
    if evalue_proposition(["J", "O", "R", "N"], ["J", "R", "V", "O"]) == [
        "#",
        "X",
        "X",
        "0",
    ]:
        tests_reussis += 1
    if evalue_proposition(["J", "O", "R", "N"], ["J", "O", "V", "O"]) == [
        "#",
        "#",
        "0",
        "0",
    ]:
        tests_reussis += 1
    if evalue_proposition(["J", "O", "J", "N"], ["J", "R", "V", "O"]) == [
        "#",
        "X",
        "0",
        "0",
    ]:
        tests_reussis += 1
    if evalue_proposition(["N", "O", "J", "J"], ["J", "R", "V", "O"]) == [
        "0",
        "X",
        "X",
        "0",
    ]:
        tests_reussis += 1
    if evalue_proposition(["N", "O", "J", "J"], ["J", "N", "J", "O"]) == [
        "X",
        "X",
        "#",
        "X",
    ]:
        tests_reussis += 1
    return tests_reussis


### décommenter les tests des fonctions au fur et à mesure :
print(f"tests genere_combinaison_secrete() : {tests_genere_combinaison_secrete()}")
# tests_saisir_combinaison()
print(f"tests combi_to_str() : {tests_combi_to_str()} tests réussis sur 1")
print(f"tests nb_occurrences() : {tests_nb_occurrences()} tests réussis sur 4")
print(f"tests trouve() : {tests_trouve()} tests réussis sur 4")
print(f"tests evalue_proposition() : {tests_evalue_proposition()} tests réussis sur 6")

# Lancement du jeu :
manche_de_mastermind()