import random
 
class Jeu:
    def __init__(self, nombre_joueur):
        self.NBR_JOUEUR = nombre_joueur
        self.TAS_DE_CARTE = []
        self.LISTE_DES_TAS_DES_Joueurs = []
        self.PIOCHE = []
 
    def générer_cartes(self):
        liste_pour_génération_de_carte = [
            ["+20", "Valeur", 20, 30],
            ["+50", "Valeur", 50, 30],
            ["+100", "Valeur", 100, 20],
            ["+200", "Valeur", 200, 10],
            ["Max200", "Malus", 0, 3],
            ["Passe", "Malus", 0, 6],
            ["/2", "Malus", 0, 6],
            ["/5", "Malus", 0, 3],
            ["NoMax", "Bonus", 0, 6],
            ["Continue", "Bonus", 0, 6],
            ["+300", "Bonus", 300, 3],
            ["x2", "Bonus", 0, 6],
            ["x5", "Bonus", 0, 6]
        ]
 
        for element_carte in liste_pour_génération_de_carte:
            self.TAS_DE_CARTE += [Carte(element_carte[0], element_carte[1], element_carte[2]) for _ in range(element_carte[3])]
 
        random.shuffle(self.TAS_DE_CARTE)
 
    def génération_tas_et_pioche(self):
        self.LISTE_DES_TAS_DES_Joueurs = [[] for _ in range(self.NBR_JOUEUR)]
 
        for tas in self.LISTE_DES_TAS_DES_Joueurs:
            for i in range(6):
                tas.append(self.TAS_DE_CARTE.pop(0))
 
        self.PIOCHE = self.TAS_DE_CARTE
        return self.LISTE_DES_TAS_DES_Joueurs, self.PIOCHE
 
class Carte:
    def __init__(self, nom, statut, valeur):
        self.NOM = nom
        self.STATUT = statut
        self.VALEUR = valeur
 
    def __str__(self):
        return f"{self.NOM}"
 
class Joueur:
    def __init__(self, nom_j, tas):
        self.NOM_J = nom_j
        self.TAS = tas
        self.POINTS = 0
        self.effet_actif = {"max": None, "multiplicateur": 1}
 
    def afficher_jeu(self):
        return "Main de " + self.NOM_J + ": " + "  ".join(str(carte) for carte in self.TAS)
 
 
    def jouer_carte(self, nom_de_la_carte):
        for carte in self.TAS:
            if carte.NOM == nom_de_la_carte:
                self.TAS.remove(carte)
                return carte
        return False
 
    def ajouter_des_points(self, nb_point):
        if self.effet_actif["max"] != None:
            if self.POINTS+nb_point*self.effet_actif["multiplicateur"]>=200:
                self.POINTS=200
            else:
                self.POINTS+=nb_point*self.effet_actif["multiplicateur"]
        else:
            self.POINTS+=nb_point*self.effet_actif["multiplicateur"]
        self.effet_actif["multiplicateur"]=1
        print(self.NOM_J, "a maintenant :", self.POINTS, "points")
 
    def appliquer_bonus(self, carte):
        if carte.NOM == "NoMax":
            self.effet_actif["max"] = None
            print(f"{self.NOM_J} n'a plus de maximum de points.")
        elif carte.NOM == "x2":
            self.effet_actif["multiplicateur"] = 2
            print(f"{self.NOM_J} a un multiplicateur de points x2 pour la prochaine carte qu'il va jouer")            
        elif carte.NOM == "x5":
            self.effet_actif["multiplicateur"] = 5
            print(f"{self.NOM_J} a un multiplicateur de points x5 pour la prochaine carte qu'il va jouer")
 
    def appliquer_malus(self, carte, joueur_cible):
        if carte.NOM == "Max200":
            joueur_cible.effet_actif["max"] = 200
            print(f"{joueur_cible.NOM_J} a maintenant un maximum de 200 points.")
            print(joueur_cible.POINTS)
            if joueur_cible.POINTS>=200:
                joueur_cible.POINTS==200
        elif carte.NOM == "/2":
            joueur_cible.effet_actif["multiplicateur"] = 0.5 # car 2**-1 = 0,5
            print(f"{joueur_cible.NOM_J} a un multiplicateur de points x0.5.")
            print(type(joueur_cible))
        elif carte.NOM == "/5":
            joueur_cible.effet_actif["multiplicateur"] = 0.2 # car 5**-1 = 0,2
            print(f"{joueur_cible.NOM_J} a un multiplicateur de points x0.2.")
            print(joueur_cible.POINTS)
        elif carte.NOM == "Passe":
            print(f"{joueur_cible.NOM_J} passe son tour.")
        else:
            joueur_cible.ajouter_des_points(-carte.VALEUR)
 
    def piocher(self, pioche):
        if pioche:
            self.TAS.append(pioche.pop(0))
    
    def choisir_cible(self,joueur_actuel, joueurs):
        cibles_possibles = [j for j in joueurs if j != joueur_actuel] #liste de tous les autres joueurs
        print("Joueurs disponibles pour appliquer le malus :")
        for idx, joueur in enumerate(cibles_possibles): # pour chaque joueur dans la liste cible_possible avec un numéro appliqué à chaque joueur
            print(f"{idx + 1}. {joueur.NOM_J} (Points: {joueur.POINTS})")
        choix = int(input("Sélectionnez un joueur pour appliquer le malus : ")) - 1
        return cibles_possibles[choix]
 

 
def boucle_de_jeu(joueurs, pioche):
    tour = 1
    while pioche and any(joueur.TAS for joueur in joueurs):
        print(f"\n--- Tour {tour} ---")
 
        for joueur in joueurs:
            if joueur.TAS:
                print(joueur.afficher_jeu())
 
                choix = input(f"{joueur.NOM_J}, Choisissez une carte à jouer : ")

                # while joueur.jouer_carte(choix) == False:
                #     print("Pas la bonne carte")
                #     choix = input(f"{joueur.NOM_J}, Choisissez une carte à jouer : ")
                
                
                carte_jouée=joueur.jouer_carte(choix)
                print(carte_jouée,type(carte_jouée))
                if carte_jouée==False:
                    print("Il n'y a pas cette carte dans votre tas de carte")
                elif carte_jouée.STATUT == "Bonus":
                    joueur.appliquer_bonus(carte_jouée)
                elif carte_jouée.STATUT == "Malus":
                    joueur_cible = joueur.choisir_cible(joueur, joueurs)
                    print(joueur_cible.POINTS)
                    joueur.appliquer_malus(carte_jouée, joueur_cible)
                elif carte_jouée.STATUT == "Valeur":
                    joueur.ajouter_des_points(carte_jouée.VALEUR)
                
                joueur.piocher(pioche)
 
        tour += 1
 
# Initialisation du jeu
nombre_de_joueur = int(input("Entrez le nombre de joueurs entre 2 et 4: "))
while nombre_de_joueur < 2 or nombre_de_joueur > 4:
    nombre_de_joueur = int(input("Veuillez entrer un nombre entre 2 et 4: "))
 
jeu = Jeu(nombre_de_joueur)
jeu.générer_cartes()
tas_des_joueurs, pioche = jeu.génération_tas_et_pioche()
 
noms_joueurs = ["Joueur 1", "Joueur 2", "Joueur 3", "Joueur 4"]
joueurs = [Joueur(noms_joueurs[i], tas_des_joueurs[i]) for i in range(nombre_de_joueur)]
 
boucle_de_jeu(joueurs, pioche)