from Outils.Moteur_de_jeu import Joueur
from Outils.Moteur_de_jeu.Joueur import *

from Outils.Moteur_de_jeu import Conversion
from Outils.Moteur_de_jeu.Conversion import *

from Outils.Symetries import *
from random import choice


class IA_stats(Joueur) :
    def __init__(self, nom, nom_fichier, adjoint) :
        """
            nom_fichier est le nom du fichier de statistiques que l'I.A. utilise
            adjoint est l'I.A. utilisée en cas d'absence d'occurence de la situation
        """
        Joueur.__init__(self,"O",nom)

        self.adjoint = adjoint
        self.tab_reussites = []     # Tableau dont la case n vaut True si l'I.A. a trouvé une occurence au n^e coup et 0 sinon. Utile pour l'analyse des résultats

        fichier = open(nom_fichier, "r")
        self.stats = fichier.readlines()
        fichier.close()
        
        self.tab_p = [l[:l.find(" ")] for l in self.stats]
            





    def coups_pour_situation(self, plateau) :
        """ Retourne la liste des coups proposés pour cette situation """
        code_p = code_from_plateau(plateau)
        (trouve, id_p) = recherche(self.tab_p, code_p)

        if trouve :
            ligne = self.stats[id_p]
            tab_c = ligne[ligne.find(" ") + 1:].split(",")

            lcp = []    # Liste de coups pondérés (couples (coup, nb))
            for l in tab_c :
                i = l.find(":")
                lcp.append( (coup_from_code(l[:i]) , int(l[i+1:])) )

            return lcp
                            
        else :
            return []
        

    def calculer_coup(self, plateau, liste_coups) :
        lcp = self.coups_pour_situation(plateau)

        # Symétries verticales :
        lcp_v = self.coups_pour_situation(plateau_symetrie_verticale(plateau))
        for c in lcp_v :
            (coup,nb) = c
            lcp.append((coup_symetrie_verticale(plateau, coup),nb))
            

        # Symétries horizontales :
        lcp_h = self.coups_pour_situation(plateau_symetrie_horizontale(plateau))
        for c in lcp_h :
            (coup,nb) = c
            lcp.append((coup_symetrie_horizontale(plateau, coup),nb))


        # Composées des deux :
        lcp_hv = self.coups_pour_situation(plateau_symetrie_verticale(plateau_symetrie_horizontale(plateau)))
        for c in lcp_hv :
            (coup,nb) = c
            lcp.append((coup_symetrie_horizontale(plateau, coup_symetrie_verticale(plateau, coup)),nb))

        
        # Analyse :
        if lcp == [] :
            #print("Pas d'occurence")
            self.adjoint.num = self.num

            self.tab_reussites.append(0)
            return self.adjoint.calculer_coup(plateau, liste_coups)
        
        else :
            # Recherche du nombre d'occurences maximal :
            n_max = 0
            for c in lcp :
                if c[1] > n_max :
                    n_max = c[1]


            liste_meilleurs_coups = [c[0] for c in lcp if c[1] == n_max]
            coup = choice(liste_meilleurs_coups)

            self.tab_reussites.append(1)

            n = len(liste_coups)
            for i in range(n) :
                if  liste_coups[i] == coup :
                    return i
            return 0
                           
            
        



# Pour les tests :
"""sym = plateau_symetrie_horizontale(plateau)
affichage = Affichage(sym,False)
partie = Partie(Humain(""),Humain(""),True,"")
partie.plateau = sym
affichage.afficher_canevas(partie)"""