import copy

class LogiqueEchecs:

    CASES_COTE = 8

    MVT_INCONNU = 'Cause inconnue'
    MVT_OK = 'Valide'
    MVT_ROQUE = 'Roque'
    MVT_SELECTION = 'Mauvais tour'
    MVT_SUR_PLACE = 'Immobile'
    MVT_SAUT_AMI = 'Saut ami'
    MVT_PION_INC = 'Pion inconnu'
    MVT_N_AUTORISE = 'Non-autorisé'
    MVT_OBSTRUCTION = 'Pion en chemin'
    MVT_ECHEC = 'Échec au roi'

    def __init__(self):

        self.grille = []
        self.cGrille()
        self.remplirGrille()
        self.joueur = True
        self.partieFinie = False
        self.victorieux = None

    @staticmethod
    def eNoir(xD, yD):
        return xD % 2 != yD % 2

    def cGrille(self):
        for x in range(LogiqueEchecs.CASES_COTE):
            colonne = []
            for y in range(LogiqueEchecs.CASES_COTE):
                colonne.append(0)
            self.grille.append(colonne)

    def remplirGrille(self):
        speciales = [2, 3, 4, 6, 5, 4, 3, 2]
        for i in range(0, 8):
            self.grille[i][0] = speciales[i] + 10
            self.grille[i][1] = 11
            self.grille[i][6] = 1
            self.grille[i][7] = speciales[i]

    def cPion(self, x, y, piece):
        """
        """
        self.grille[x][y] = piece
        return True

    @staticmethod
    def ePionBlanc(pion):
        return pion in range(1, 7)

    @staticmethod
    def ePionNoir(pion):
        return pion in range(11, 17)


    def aSonTour(self, pion):
        return (self.ePionNoir(pion) and self.joueur == False) or \
                (self.ePionBlanc(pion) and self.joueur == True)

    def mvtPossibleSansEchecPion(self, x1, y1, x2, y2):
        if x1 == x2 and self.grille[x2][y2] <= 0: # Avance
            if self.joueur:
                if y2 == y1 - 1:
                    return LogiqueEchecs.MVT_OK
                elif y1 == 6 and y2 == 4 and self.grille[x1][5] == 0:
                    return LogiqueEchecs.MVT_OK
                else:
                    return LogiqueEchecs.MVT_N_AUTORISE
            else:
                if y2 == y1 + 1:
                    return LogiqueEchecs.MVT_OK
                elif y1 == 1 and y2 == 3 and self.grille[x1][2] == 0:
                    return LogiqueEchecs.MVT_OK
                else:
                    return LogiqueEchecs.MVT_N_AUTORISE
        elif abs(x1-x2) == 1: # Saut
            if self.joueur:
                if y2 == y1 - 1 and \
                self.ePionNoir(self.grille[x2][y2]):
                    return LogiqueEchecs.MVT_OK
                else:
                    return LogiqueEchecs.MVT_N_AUTORISE
            else:
                if y2 == y1 + 1 and \
                self.ePionBlanc(self.grille[x2][y2]):
                    return LogiqueEchecs.MVT_OK
                else:
                    return LogiqueEchecs.MVT_N_AUTORISE
        else:
            return LogiqueEchecs.MVT_N_AUTORISE

    def mvtPossibleSansEchecTour(self, x1, y1, x2, y2):
        if y1 == y2:
            sens = (x2-x1)//abs(x2-x1)
            for x in range(x1+sens, x2, sens):
                if self.grille[x][y1] > 0:
                    return LogiqueEchecs.MVT_OBSTRUCTION
        elif x1 == x2:
            sens = (y2-y1)//abs(y2-y1)
            for y in range(y1+sens, y2, sens):
                if self.grille[x1][y] > 0:
                    return LogiqueEchecs.MVT_OBSTRUCTION
        else:
            return LogiqueEchecs.MVT_N_AUTORISE
        return LogiqueEchecs.MVT_OK

    def mvtPossibleSansEchecFou(self, x1, y1, x2, y2):
        if abs(x2-x1) == abs(y2-y1):
            sensX = (x2-x1)//abs(x2-x1)
            sensY = (y2-y1)//abs(y2-y1)
            x = x1
            y = y1
            dist = 0
            distTot = abs(x2-x1)
            while dist < distTot:
                dist += 1
                x += sensX
                y += sensY
                if self.grille[x][y] > 0:
                    if dist == distTot:
                        return LogiqueEchecs.MVT_OK # Saut
                    else:
                        return LogiqueEchecs.MVT_OBSTRUCTION
            return LogiqueEchecs.MVT_OK # Vide
        else:
            return LogiqueEchecs.MVT_N_AUTORISE

    def mvtPossibleSansEchecCavalier(self, x1, y1, x2, y2):
        if (abs(x2-x1) == 2 and abs(y2-y1) == 1) or (abs(y2-y1) == 2 and abs(x2-x1) == 1):
            return LogiqueEchecs.MVT_OK
        else:
            return LogiqueEchecs.MVT_N_AUTORISE

    def mvtPossibleSansEchec(self, x1, y1, x2, y2):
        pion = self.grille[x1][y1]
        if self.aSonTour(pion):
            if (x1 != x2 or y1 != y2):
                if not self.aSonTour(self.grille[x2][y2]):
                    tPion = pion % 10
                    if tPion == 1: # Pion
                        return self.mvtPossibleSansEchecPion(x1, y1, x2, y2)
                    elif tPion == 2: # Tour
                        return self.mvtPossibleSansEchecTour(x1, y1, x2, y2)
                    elif tPion == 3: # Cavalier
                        return self.mvtPossibleSansEchecCavalier(x1, y1, x2, y2)
                    elif tPion == 4: # Fou
                        return self.mvtPossibleSansEchecFou(x1, y1, x2, y2)
                    elif tPion == 5: # Dame
                        tour = self.mvtPossibleSansEchecTour(x1, y1, x2, y2)
                        fou = self.mvtPossibleSansEchecFou(x1, y1, x2, y2)
                        if tour == LogiqueEchecs.MVT_OK or fou == LogiqueEchecs.MVT_OK:
                            return LogiqueEchecs.MVT_OK
                        elif tour == LogiqueEchecs.MVT_OBSTRUCTION or fou == LogiqueEchecs.MVT_OBSTRUCTION:
                            return LogiqueEchecs.MVT_OBSTRUCTION
                        else:
                            return LogiqueEchecs.MVT_N_AUTORISE 
                    elif tPion == 6: # Roi
                        if abs(x2-x1) <= 1 and abs(y2-y1) <= 1:
                                return LogiqueEchecs.MVT_OK
                        else:
                            return LogiqueEchecs.MVT_N_AUTORISE
                    else:
                        return LogiqueEchecs.MVT_PION_INC
                else:
                    return LogiqueEchecs.MVT_SAUT_AMI
            else:
                return LogiqueEchecs.MVT_SUR_PLACE
        else:
            return LogiqueEchecs.MVT_SELECTION
        return LogiqueEchecs.MVT_INCONNU
    
    def mvtPossible(self, x1, y1, x2, y2):
        test = self.mvtPossibleSansEchec(x1, y1, x2, y2)
        if test == LogiqueEchecs.MVT_OK:
            # On copie la partie actuelle pour tester le mouvement et vérifier l'échec
            copie = copy.deepcopy(self);
            copie.dPionSansEchec(x1, y1, x2, y2)
            mvtsPossiblesTousAdverses = []
            pionRoi = 6
            if not self.joueur:
                pionRoi += 10
            roi = [-1, -1]
            for x in range(0, LogiqueEchecs.CASES_COTE):
                for y in range(0, LogiqueEchecs.CASES_COTE):
                    mvtsPossiblesTousAdverses += copie.mvtsPossiblesSansEchec(x, y)
                    if copie.grille[x][y] == pionRoi:
                        roi = [x, y]
            if roi in mvtsPossiblesTousAdverses:
                return LogiqueEchecs.MVT_ECHEC
            else:
                return test
        else:
            return test
        
    def mvtsPossiblesSansEchec(self, x1, y1):
        tableau = []
        for x2 in range(0, LogiqueEchecs.CASES_COTE):
            for y2 in range(0, LogiqueEchecs.CASES_COTE):
                if self.mvtPossibleSansEchec(x1, y1, x2, y2) == LogiqueEchecs.MVT_OK:
                    tableau.append([x2, y2])
        return tableau

    def mvtsPossibles(self, x1, y1):
        tableau = []
        for x2 in range(0, LogiqueEchecs.CASES_COTE):
            for y2 in range(0, LogiqueEchecs.CASES_COTE):
                if self.mvtPossible(x1, y1, x2, y2) == LogiqueEchecs.MVT_OK:
                    tableau.append([x2, y2])
        return tableau

    def dPionSansEchec(self, x1, y1, x2, y2):
        test = self.mvtPossibleSansEchec(x1, y1, x2, y2)
        if test == LogiqueEchecs.MVT_OK:
            self.grille[x1][y1], self.grille[x2][y2] = 0, self.grille[x1][y1]
            self.joueur = not self.joueur

    def vEchecMat(self):
        """
        Vérifie si le joueur actuel est en échec et mat et prend les mesures nécessiares.
        (CÀD Le joueur actuel ne peut effectuer aucun mouvement)
        """
        for x in range(0, LogiqueEchecs.CASES_COTE):
            for y in range(0, LogiqueEchecs.CASES_COTE):
                if len(self.mvtsPossibles(x, y)) > 0:
                    return False
        self.partieFinie = True
        self.victorieux = not self.joueur
        return True

    def dPion(self, x1, y1, x2, y2):
        test = self.mvtPossible(x1, y1, x2, y2)
        retour = {
            'valide': False,
            'message': test,
            'deplacer': [], # Pions à déplacer
            'supprimer': [], # Pions à supprimer
        }
        if test == LogiqueEchecs.MVT_OK:
            retour['valide'] = True
            if self.grille[x2][y2] > 0:
                retour['supprimer'].append([x2, y2])
            retour['deplacer'].append([x1, y1, x2, y2])
            self.grille[x1][y1], self.grille[x2][y2] = 0, self.grille[x1][y1]
            self.joueur = not self.joueur
            self.vEchecMat()
        return retour