import tkinter as tk
from tkinter import PhotoImage
from numpy import zeros, array
import random

def ajouter_a_liste():
    contenu = champ_saisie.get()  # Obtenir le contenu du champ de saisie
    if contenu not in liste_perso and contenu in autre_liste:
        liste_perso.append(contenu)  # Ajouter le contenu à la liste
        champ_saisie.delete(0, tk.END)  # Effacer le contenu du champ de saisie
        afficher_liste()  # Mettre à jour l'affichage de la liste
        if len(liste_perso) == 4:
            fenetre.destroy()  # Fermer la fenêtre lorsque la liste contient 4 éléments
    else:
        label.config(text="Ce joueur existe déjà dans une autre liste.")
        fenetre.after(2000, reset_label)  # Réinitialiser le texte après 2000 millisecondes (2 secondes)

def reset_label():
    label.config(text="Bonjour, Tkinter !")  # Réinitialiser le texte du label après affichage du message d'erreur

def afficher_liste():
    liste_box.delete(0, tk.END)  # Effacer le contenu actuel de la liste
    for joueur in liste_perso:
        liste_box.insert(tk.END, joueur)  # Insérer chaque joueur dans la liste

# Création de la fenêtre principale
fenetre = tk.Tk()
fenetre.title("Ma Fenêtre Tkinter")  # Titre de la fenêtre
fenetre.attributes('-fullscreen', False)  # Ouvrir la fenêtre en mode plein écran
fenetre.geometry("1920x1080")  # Dimensions de la fenêtre (largeur x hauteur)

# Chargement de l'image de fond
image_fond = PhotoImage(file="fond.png")

# Création d'un Canvas pour afficher l'image de fond
canvas = tk.Canvas(fenetre, width=1920, height=1080)
canvas.pack(fill="both", expand=True)
canvas.create_image(0, 0, image=image_fond, anchor="nw")

# Ajout d'un label
label = tk.Label(canvas, text="Bonjour, Tkinter !")
label.pack()

# Ajout d'un champ de saisie
champ_saisie = tk.Entry(canvas)
champ_saisie.pack()

# Ajout d'un bouton
bouton = tk.Button(canvas, text="Ajouter à la liste", command=ajouter_a_liste)
bouton.pack()

# Listebox pour afficher la liste des joueurs
liste_box = tk.Listbox(canvas)
liste_box.pack()

# Liste pour stocker les éléments ajoutés
liste_perso = []

# Autre liste existante
autre_liste = ["Kotori", "Leopold", "Simeon", "Eleonore", "Camille", "Haley", "Konami","k", "l", "s", "e", "c", "h"]

# Lancement de la boucle principale
fenetre.mainloop()

#################################################################################################

nb_j = 4

# Définition des valeurs pour les personnages
kotori = array([0, -1, 1, 0, -1, 1, 0, 1, -1, 0, 0, 0, 0])
leopold = array([0, 0, -1, -1, 0, 1, 1, 1, -1, 0, 0, 0, 0])
simeon = array([0, 1, 1, 1, -1, -1, -1, 0, 0, 0, 0, 0, 0])
eleonore = array([0, 0, -1, -1, 1, 1, 1, 0, -1, 0, 0, 0, 0])
camille = array([0, 1, 1, 0, -1, -1, -1, 0, 1, 0, 0, 0, 0])
haley = array([0, -1, 0, -1, 1, 1, 1, -1, 0, 0, 0, 0, 0])
konami = array([0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0])


tableau = zeros((nb_j, 13))

# Boucle if pour parcourir la liste et affecter les valeurs en fonction des clics
for i in range(nb_j):
    if liste_perso[i] == 'k' or liste_perso[i] == 'Kotori':
        tableau[i] = kotori
    elif liste_perso[i] == 'l' or liste_perso[i] == 'Leopold':
        tableau[i] = leopold
    elif liste_perso[i] == 's' or liste_perso[i] == 'Simeon':
        tableau[i] = simeon
    elif liste_perso[i] == 'e' or liste_perso[i] == 'Eleonore':
        tableau[i] = eleonore
    elif liste_perso[i] == 'c' or liste_perso[i] == 'Camille':
        tableau[i] = camille
    elif liste_perso[i] == 'h' or liste_perso[i] == 'Haley':
        tableau[i] = haley
    elif liste_perso[i] == 'Konami':
        tableau[i] = konami
print(tableau)

#################################################################################################

#tenue
pts_tenue = 40
pts_chaussure = 20
pts_coiffure = 20
pts_queue = 10

# BnW
BnW_tenue = array([0, 1, 0, 0, 0, 0, 0, 0, 0, pts_tenue, 0, 0, 0])
BnW_chaussure = array([0, 1, 0, 0, 0, 0, 0, 0, 0, 0, pts_chaussure, 0, 0])
BnW_coiffure = array([0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, pts_coiffure, 0])
BnW_queue = array([0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, pts_queue])

# RnR
RnR_tenue = array([0, 0, 1, 0, 0, 0, 0, 0, 0, pts_tenue, 0, 0, 0])
RnR_chaussure = array([0, 0, 1, 0, 0, 0, 0, 0, 0, 0, pts_chaussure, 0, 0])
RnR_coiffure = array([0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, pts_coiffure, 0])
RnR_queue = array([0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, pts_queue])

# Pirate
Pirate_tenue = array([0, 0, 0, 1, 0, 0, 0, 0, 0, pts_tenue, 0, 0, 0])
Pirate_chaussure = array([0, 0, 0, 1, 0, 0, 0, 0, 0, 0, pts_chaussure, 0, 0])
Pirate_coiffure = array([0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, pts_coiffure, 0])
Pirate_queue = array([0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, pts_queue])

# Pastel
Pastel_tenue = array([0, 0, 0, 0, 1, 0, 0, 0, 0, pts_tenue, 0, 0, 0])
Pastel_chaussure = array([0, 0, 0, 0, 1, 0, 0, 0, 0, 0, pts_chaussure, 0, 0])
Pastel_coiffure = array([0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, pts_coiffure, 0])
Pastel_queue = array([0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, pts_queue])

# Gala
Gala_tenue = array([0, 0, 0, 0, 0, 1, 0, 0, 0, pts_tenue, 0, 0, 0])
Gala_chaussure = array([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, pts_chaussure, 0, 0])
Gala_coiffure = array([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, pts_coiffure, 0])
Gala_queue = array([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, pts_queue])

# Fée
Fee_tenue = array([0, 0, 0, 0, 0, 0, 1, 0, 0, pts_tenue, 0, 0, 0])
Fee_chaussure = array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, pts_chaussure, 0, 0])
Fee_coiffure = array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, pts_coiffure, 0])
Fee_queue = array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, pts_queue])

# Jap
Jap_tenue = array([0, 0, 0, 0, 0, 0, 0, 1, 0, pts_tenue, 0, 0, 0])
Jap_chaussure = array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, pts_chaussure, 0, 0])
Jap_coiffure = array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, pts_coiffure, 0])
Jap_queue = array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, pts_queue])

# Noel
Noel_tenue = array([0, 0, 0, 0, 0, 0, 0, 0, 1, pts_tenue, 0, 0, 0])
Noel_chaussure = array([0, 0, 0, 0, 0, 0, 0, 0, 1, 0, pts_chaussure, 0, 0])
Noel_coiffure = array([0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, pts_coiffure, 0])
Noel_queue = array([0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, pts_queue])


# Définition des quatre listes
Liste_tenue = [BnW_tenue, RnR_tenue, Pirate_tenue, Pastel_tenue, Gala_tenue, Fee_tenue, Jap_tenue, Noel_tenue]
Liste_chaussure = [BnW_chaussure, RnR_chaussure, Pirate_chaussure, Pastel_chaussure, Gala_chaussure, Fee_chaussure, Jap_chaussure, Noel_chaussure]
Liste_coiffure = [BnW_coiffure, RnR_coiffure, Pirate_coiffure, Pastel_coiffure, Gala_coiffure, Fee_coiffure, Jap_coiffure, Noel_coiffure]
Liste_queue = [BnW_queue, RnR_queue, Pirate_queue, Pastel_queue, Gala_queue, Fee_queue, Jap_queue, Noel_queue]

############################################################################

import tkinter as tk

# Définition de la classe InterfaceCadena
class InterfaceCadena:
    def __init__(self, root, ordre):
        self.root = root
        self.root.title("Interface Cadena à Chiffres")

        self.valeurs = [1, 2, 3, 4]  # Les valeurs à afficher dans les boîtes

        self.cadre_principal = tk.Frame(root)
        self.cadre_principal.pack(padx=20, pady=20)

        self.afficheurs = []  # Liste pour stocker les labels
        self.ordre = ordre  # Utiliser la variable ordre passée en paramètre

        for valeur in self.valeurs:
            afficheur = tk.Button(self.cadre_principal, text="Joueur " + str(valeur), width=10, height=2, font=("Helvetica", 14), relief=tk.RAISED)
            afficheur.config(command=lambda v=valeur: self.afficher_chiffre(v))
            afficheur.pack(side=tk.LEFT, padx=10)
            self.afficheurs.append(afficheur)

        self.bouton_reset = tk.Button(self.root, text="Réinitialiser", command=self.reinitialiser)
        self.bouton_reset.pack(side=tk.LEFT, padx=5, pady=10)

        self.bouton_valider = tk.Button(self.root, text="Valider", command=self.valider, state=tk.DISABLED)
        self.bouton_valider.pack(side=tk.LEFT, padx=5, pady=10)

        self.label_ordre = tk.Label(self.root, text="Ordre:", font=("Helvetica", 12))
        self.label_ordre.pack()

        self.label_liste_ordre = tk.Label(self.root, text="", font=("Helvetica", 12))
        self.label_liste_ordre.pack()

    def afficher_chiffre(self, chiffre):
        if chiffre not in self.ordre:
            print("Chiffre cliqué :", chiffre)
            self.ordre.append(chiffre)
            print("Ordre des derniers clics :", self.ordre)

            for afficheur in self.afficheurs:
                if int(afficheur["text"].split()[1]) == chiffre:
                    afficheur.config(bg="green", state=tk.DISABLED)
                else:
                    afficheur.config(bg="white")

            if len(self.ordre) == 4:
                self.bouton_valider.config(state=tk.NORMAL)
            else:
                self.bouton_valider.config(state=tk.DISABLED)

            self.afficher_liste_ordre()

    def afficher_liste_ordre(self):
        liste_ordre_texte = " ".join(["Joueur " + str(chiffre) for chiffre in self.ordre])
        self.label_liste_ordre.config(text=liste_ordre_texte)

    def reinitialiser(self):
        self.ordre = []
        for afficheur in self.afficheurs:
            afficheur.config(bg="SystemButtonFace", state=tk.NORMAL)
        self.bouton_valider.config(state=tk.DISABLED)
        self.afficher_liste_ordre()

    def valider(self):
        print("Liste ordre validée :", self.ordre)
        self.root.destroy()

# Création de la fenêtre principale
root = tk.Tk()

# Initialisation de la variable ordre
ordre = []

# Création de l'interface avec la variable ordre
interface = InterfaceCadena(root, ordre)

# Démarrage de la boucle principale de l'interface graphique
root.mainloop()

# Maintenant, la variable "ordre" contient les valeurs sélectionnées par l'utilisateur.

############################################################################
############################################################################
############################################################################
############################################################################
############################################################################

indices_aleatoires = random.sample(range(8), 4)

# Fonction pour créer une nouvelle fenêtre avec une image de fond et des boutons en bas
def nouvelle_fenetre():
    
    # Création de la nouvelle fenêtre
    nouvelle_fenetre = tk.Tk()
    nouvelle_fenetre.title("Nouvelle Fenêtre avec Image de Fond et Boutons")  # Titre de la nouvelle fenêtre
    nouvelle_fenetre.attributes('-fullscreen', False)  # Ouvrir la fenêtre en mode plein écran
    nouvelle_fenetre.geometry("800x600")  # Dimensions de la nouvelle fenêtre

    # Chargement de l'image de fond
    image_fond = PhotoImage(file="fond.png")

    # Création d'un Canvas pour afficher l'image de fond
    canvas = tk.Canvas(nouvelle_fenetre, width=800, height=600)
    canvas.pack(fill="both", expand=True)
    canvas.create_image(0, 0, image=image_fond, anchor="nw")

    # Ajout d'un label dans la nouvelle fenêtre
    label_nouvelle = tk.Label(canvas, text="Nouvelle Fenêtre avec Image de Fond et Boutons")
    label_nouvelle.pack()

    # Création du cadre pour les boutons en bas
    cadre_boutons = tk.Frame(canvas)
    cadre_boutons.pack(side=tk.BOTTOM)

    # Configuration des boutons
    bouton_config = {
        "background": "lightblue",  # Couleur de fond
        "foreground": "black",  # Couleur du texte
        "font": ("Helvetica", 12),  # Police et taille
        "width": 10,  # Largeur du bouton
        "height": 2,  # Hauteur du bouton
        "borderwidth": 3,  # Largeur de la bordure
        "relief": "raised",  # Effet de relief
    }
    
    # Fonction pour choisir une option en fonction du bouton
    def choisir(choix):
        
        print("Option choisie :", choix)
        # Liste de vecteurs
        if choix == 1:
            vecteurs = Liste_tenue
        elif choix == 2:
            vecteurs = Liste_chaussure
        elif choix == 3:
            vecteurs = Liste_coiffure
        else:
            vecteurs = Liste_queue
    
        if len(vecteurs) >= 4:
            # Affichage de 4 vecteurs choisis aléatoirement
            vecteurs_aleatoires = [vecteurs[i] for i in indices_aleatoires]

            print("Vecteurs choisis aléatoirement :")
            for i, vecteur in enumerate(vecteurs_aleatoires):
                print(f"{i + 1}. {vecteur}")
                
    def choix_vetement():
        # Création de la matrice avec les vecteurs rangés selon l'ordre choisi
        matrice_shop = [vecteurs_aleatoires[int(i) - 1] for i in choix_vet]
        print("\nMatrice résultante :")
        for vecteur in matrice_shop:
            print(vecteur)
            
    # Vérification de la permutation
    def verifier_permutation(choix_vet):
        return len(choix_vet) == 4 and all(c.isdigit() and 1 <= int(c) <= 4 for c in choix_vet)

    # Fonction à appeler lors du clic sur le bouton "Valider"
    def validation_ok():
        contenu = champ_texte.get()  # Obtenir le contenu du champ de texte
        if verifier_permutation(contenu):
            global choix_vet
            choix_vet = contenu  # Stocker le contenu dans la variable choix_vet
            fenetre.destroy()  # Fermer la fenêtre
        else:
            print("Veuillez entrer une permutation valide des indices des vecteurs (chiffres de 1 à 4).")

    def fenetre_shop():
        
        # Création de la fenêtre principale
        fenetre = tk.Tk()
        fenetre.geometry("1920x1080")  # Définition de la taille de la fenêtre

        # Vecteur contenant les chemins des images disponibles
        all_image_paths = ["1.png", "2.png", "3.png", "4.png", "5.png", "6.png"]

        # Vecteur de 4 chiffres pour sélectionner les images
        selection_indices = [0, 2, 4, 5]  # Ces indices correspondent aux images choisies parmi toutes les images disponibles

        # Liste pour stocker les images des boutons
        images = []
        
        # Chargement des images et stockage dans la liste 'images'
        for index in selection_indices:
            image_path = all_image_paths[index]
            image = tk.PhotoImage(file=image_path)
            images.append(image)

        # Création des boutons avec les images sélectionnées
        boutons = []
        for i, image in enumerate(images):
            bouton = tk.Button(fenetre, image=image, command=lambda: None)  # Pas besoin de commande pour les boutons d'images
            bouton.grid(row=0, column=i, padx=10, pady=10)
            boutons.append(bouton)

        # Création du champ de texte
        champ_texte = tk.Entry(fenetre)
        champ_texte.grid(row=1, column=0, columnspan=4, pady=10)

        # Création du bouton "Valider"
        bouton_valider = tk.Button(fenetre, text="Valider", command=validation_ok)
        bouton_valider.grid(row=2, column=0, columnspan=4, pady=5)

        # Centrage des boutons horizontalement
        fenetre.grid_columnconfigure((0, 1, 2, 3), weight=1)

        # Centrage des boutons verticalement
        fenetre.grid_rowconfigure(0, weight=1)

        # Lancement de la boucle principale
        fenetre.mainloop()

        # Afficher le contenu de choix_vet après la fermeture de la fenêtre
        print("Choix validé:", choix_vet)
    
############################################################################
############################################################################
############################################################################
############################################################################
############################################################################
            
    def fonction_1():
        choisir(1)
        fenetre_shop()
        choix_vetement()

    def fonction_2():
        choisir(2)
        fenetre_shop()
        choix_vetement()

    def fonction_3():
        choisir(3)
        fenetre_shop()
        choix_vetement()

    def fonction_4():
        choisir(4)
        fenetre_shop()
        choix_vetement()

    bouton1 = tk.Button(cadre_boutons, text="Tenue", **bouton_config)
    bouton1.pack(side=tk.LEFT, padx=5, pady=5)
    bouton1.config(command=fonction_1)

    bouton2 = tk.Button(cadre_boutons, text="Coiffure", **bouton_config)
    bouton2.pack(side=tk.LEFT, padx=5, pady=5)
    bouton2.config(command=fonction_2)

    bouton3 = tk.Button(cadre_boutons, text="Chaussure", **bouton_config)
    bouton3.pack(side=tk.LEFT, padx=5, pady=5)
    bouton3.config(command=fonction_3)

    bouton4 = tk.Button(cadre_boutons, text="Queue", **bouton_config)
    bouton4.pack(side=tk.LEFT, padx=5, pady=5)
    bouton4.config(command=fonction_4)

    
    # Lancement de la boucle principale de la nouvelle fenêtre
    nouvelle_fenetre.mainloop()

# Lancement de la fonction pour créer la nouvelle fenêtre
nouvelle_fenetre()