from heuristiquesOthello import *

class MinMax:
    def __init__(self, prof_max, heuristique):
        self.prof_max = prof_max
        self.heuristique = heuristique
        self.nb_situations_examinees = 0

    def tour_joueur_courant(self, prof_courante):
        return prof_courante % 2 == 1

    def prof_max_atteinte(self, prof_courante):
        return prof_courante > self.prof_max

    def get_nb_situations_examinees(self):
        return self.nb_situations_examinees

    def executer(self, situation):
        self.joueur = situation.joueur_courant
        self.nb_situations_examinees = 0
        return self.min_max(situation, 1)
        
    def min_max(self, situation, prof_courante):
        self.nb_situations_examinees += 1
        if self.prof_max_atteinte(prof_courante):
            retour = ([], self.heuristique(situation, self.joueur))
        else:
            possibilites = situation.liste_coups()
            if len(possibilites) == 0:
                retour = self.evaluer_passer_son_tour(situation, prof_courante)
            else:
                situations_possibles = map(lambda coup: (coup, situation.tenter_coup(coup)), possibilites)
                coups_evalues = []
                if self.tour_joueur_courant(prof_courante):
                    retour = self.retenir_meilleur_coup(situations_possibles, prof_courante)
                else:
                    retour = self.retenir_pire_coup(situations_possibles, prof_courante)
        return retour
            
    def evaluer_passer_son_tour(self, situation, prof_courante):
        nouvelle_situation = Othello(situation)
        nouvelle_situation.changer_joueur()
        enchainement, recompense = self.min_max(nouvelle_situation, prof_courante+1)
        retour = (([None] + enchainement), recompense)
        return retour

    def retenir_meilleur_coup(self, situations_possibles, prof_courante):
        meilleure_recompense = None
        enchainement_retenu = None
        for (coup, situation) in situations_possibles:
            liste_coups, recompense = self.min_max(situation, prof_courante+1)
            if meilleure_recompense is None or recompense > meilleure_recompense:
                meilleure_recompense = recompense
                enchainement_retenu = [coup] + liste_coups
        retour = enchainement_retenu, meilleure_recompense
        return retour
    
    def retenir_pire_coup(self, situations_possibles, prof_courante):
        pire_recompense = None
        enchainement_retenu = None
        for (coup, situation) in situations_possibles:
            liste_coups, recompense = self.min_max(situation, prof_courante+1)
            if pire_recompense is None or recompense < pire_recompense:
                pire_recompense = recompense
                enchainement_retenu = [coup] + liste_coups
        retour = enchainement_retenu, pire_recompense
        return retour