from mycolors import *
from pieces import *

from copy import deepcopy
from math import sqrt,atan,cos,sin

import pygame
import random
import time


sign=lambda x:x>=0

class Board:
    def __init__(self):
        self.orientation=1 #Off
        self.flipping=0 #Off
        self.size=(8,8)
        self.state=0
        self.won=False
        self.draw=False
        self.winner=None
        self.historic=[]
        self.grid_historic=[]
        self.action=None
        self.moves_selecter=[]
        self.piece_selecter=None
        self.message=""
        self.promoted=[Queen,Tower,Bishop,Horse]
        self.alphabet="abcdefghijklmnopqrstuvwxyz"
        self.last_action_shown=True
        self.colors=["White","Black"]
        self.time=time.time()
        self.moving_shown=False
        self.moving=None
        self.moving_time=0
        self.moving_max_time=2
        self.moving_position=None
        self.wait=False
        self.generate()

    def generate(self):
        self.grid= [["t1","h1","b1","g1","q1","b1","h1","t1"],
                    ["k1","k1","k1","k1","k1","k1","k1","k1"],
                    ["nn","nn","nn","nn","nn","nn","nn","nn"],
                    ["nn","nn","nn","nn","nn","nn","nn","nn"],
                    ["nn","nn","nn","nn","nn","nn","nn","nn"],
                    ["nn","nn","nn","nn","nn","nn","nn","nn"],
                    ["k2","k2","k2","k2","k2","k2","k2","k2"],
                    ["t2","h2","b2","g2","q2","b2","h2","t2"]]
        sx,sy=self.size
        for y in range(sy):
            for x in range(sx):
                p=(x,y)
                small_id=self.grid[y][x]
                if small_id=="k1":
                    entity=Pawn(1,p)
                elif small_id=="k2":
                    entity=Pawn(2,p)
                elif small_id=="h1":
                    entity=Horse(1,p)
                elif small_id=="h2":
                    entity=Horse(2,p)
                elif small_id=="b1":
                    entity=Bishop(1,p)
                elif small_id=="b2":
                    entity=Bishop(2,p)
                elif small_id=="b1":
                    entity=Bishop(1,p)
                elif small_id=="b2":
                    entity=Bishop(2,p)
                elif small_id=="t1":
                    entity=Tower(1,p)
                elif small_id=="t2":
                    entity=Tower(2,p)
                elif small_id=="g1":
                    entity=King(1,p)
                elif small_id=="g2":
                    entity=King(2,p)
                elif small_id=="q1":
                    entity=Queen(1,p)
                elif small_id=="q2":
                    entity=Queen(2,p)
                else:
                    entity=None
                self.grid[y][x]=entity

    def __repr__(self):
        sx,sy=self.size
        presentation=""
        for y in range(sy):
            presentation+="|"
            for x in range(sx):
                entity=self.grid[y][x]
                if not entity:
                    presentation+="       "
                else:
                    nature=entity.id
                    nature=nature+str(entity.side)+" "*(6-len(nature))
                    presentation+=nature
                presentation+="|"
            presentation+="\n"
        return presentation


    def debug(self):
        pass
        #print("DEBUG:")
        #print(self.state)
        #print(self.piece_selecter)
        #print(self.moves_selecter)
        #print("")

    def getPresentation(self,state,action):
        sx,sy=self.size
        piece,position,move=action
        name=piece.name
        side=piece.side
        x,y=move
        spot=self.alphabet[x%sx]+str(sy-y)
        text="|"+str(state)+"| : "+str(self.colors[side-1])+" "+name+" moved in "+spot
        return text


    def summarize(self,historic):
        for state in range(len(historic)):
            action=historic[state]
            self.message+=self.getPresentation(state,action)

    def isAlive(self,id,side):
        if self.locateById(id,side) is not None:
            return True
        else:
            return False

    def locateChoices(self,side):
        ##print(side)
        output=[]
        sx,sy=self.size
        for y in range(sy):
            for x in range(sx):
                entity=self.grid[y][x]
                if entity is None:
                    continue
                if entity.side!=side:
                    continue
                moves=self.getMoves(entity,(x,y))
                if len(moves)==0:
                    continue
                for move in moves:
                    output.append((entity,(x,y),move))
        #print(output)
        return output




    def locateById(self,id,side):
        sx,sy=self.size
        for y in range(sy):
            for x in range(sx):
                entity=self.grid[y][x]
                if entity is not None:
                    if entity.side is side and entity.id is id:
                        return (x,y)
        return None

    def locateByEntity(self,piece):
        sx,sy=self.size
        for y in range(sy):
            for x in range(sx):
                if self.grid[y][x] is piece:
                    return (x,y)
        return None

    def locateSidePieces(self,side):
        positions=[]
        sx,sy=self.size
        for y in range(sy):
            for x in range(sx):
                entity=self.grid[y][x]
                if entity:
                    if entity.side==side:
                        positions.append((x,y))
        return positions

    def locateAllPieces(self):
        positions=[]
        sx,sy=self.size
        for y in range(sy):
            for x in range(sx):
                entity=self.grid[y][x]
                if entity:
                    positions.append((x,y))
        return positions

    def getSidePieces(self,side):
        pieces=[]
        sx,sy=self.size
        for y in range(sy):
            for x in range(sx):
                entity=self.grid[y][x]
                if entity:
                    if entity.side==side:
                        pieces.append(entity)
        return pieces

    def getAllPieces(self):
        pieces=[]
        sx,sy=self.size
        for y in range(sy):
            for x in range(sx):
                entity=self.grid[y][x]
                if entity:
                    pieces.append(entity)
        return pieces

    def correctMoves(self,moves):
        new_moves=[]
        for move in moves:
            x,y=move
            if self.inGrid(x,y):
                new_moves.append(move)
        return new_moves

    def getSideMoves(self,side,raw=True):
        pieces=self.getSidePieces(side)
        moves=[]
        for piece in pieces:
            moves+=self.getMoves(piece,piece.position,raw)
        return moves

    def removeFromSets(self,set1,set2):
        #Remove all the elements of set1 that are in set2
        new_set=[]
        for e1 in set1:
            if not e1 in set2:
                new_set.append(e1)
        return new_set

    def getSuicideMoves(self,piece,moves):
        enemy_side=self.otherSide(piece.side)
        all_enemy_moves=self.getSideMoves(enemy_side)
        new_moves=[]
        for move in moves:
            if move in all_enemy_moves:
                new_moves.append(move)
        return new_moves

    def oldRemoveSuicideMoves(self,piece,moves):
        #Prevent the king's player from dying on the next turn by removing moves that will get it killed
        enemy_side=self.otherSide(piece.side)
        all_enemy_moves=self.getSideMoves(enemy_side)
        moves=self.removeFromSets(moves,all_enemy_moves)
        return moves

    def removeSuicideMoves(self,dying_piece,choosed_piece,moves):
        new_moves=[]
        #print("In removeSuicideMoves:")
        #print("moves:",moves)
        #print("dying:",dying)
        #print("dying_piece:",dying_piece)
        #print("choosed_piece:",choosed_piece)
        #print("")
        for move in moves:
            dying=self.canDieNextTurn(dying_piece,choosed_piece,move)
            if not dying:
                new_moves.append(move)
        return new_moves

    def canDieNextTurn(self,dying_piece,choosed_piece,choosed_move):
        new_board=deepcopy(self)
        new_board.choose(choosed_piece,choosed_piece.position,choosed_move)
        enemy_side=new_board.otherSide(dying_piece.side)
        all_enemy_moves=new_board.getSideMoves(enemy_side,1)
        #print("In canDieNextTurn:")
        #print("choosed_piece and choosed_move:",choosed_piece,choosed_move)
        #print("dying_piece:",dying_piece)
        #print("enemy_move:",all_enemy_moves)
        #print("new_board:")
        #print(new_board)
        #print("")
        for enemy_move in all_enemy_moves:
            if enemy_move==dying_piece.position:
                return True
        return False



    def otherSide(self,side):
        return side%2+1



    def getMoves(self,piece,position,raw=False):
        #print("In getMoves")
        #print("piece:",piece)
        #print("position:",position)
        moves=self.extractMoves(piece,position)
        #print("normal moves",normal_moves)
        if isinstance(piece,King) or isinstance(piece,Pawn):
            moves+=self.extractSpecialMoves(piece,position)
        #print("special moves",special_moves)
        #print("")
        #moves=normal_moves+special_moves
        #moves=self.correctMoves(moves)
        if not raw: king=self.getById("King",piece.side)
            #moves=self.removeSuicideMoves(king,piece,moves)
        random.shuffle(moves)
        print(moves)
        return moves

    def getRawMoves(self,piece):
        moves=self.extractMoves(piece,piece.position)
        if isinstance(piece,King) or isinstance(piece,Pawn):
            moves+=self.extractSpecialMoves(piece,position)
        random.shuffle(moves)
        return moves

    def extractMoves(self,piece,position):
        vectors,norm=piece.moves
        px,py=position
        sx,sy=self.size
        moves=[]
        orientation=piece.side%2*2-1
        for vector in vectors:
            vx,vy=vector
            n=1
            while n<=norm:
                x=px+vx*n
                y=py+orientation*vy*n
                if 0<=x and x<sx and 0<=y and y<sy:
                    if self.grid[y][x] is None:
                        moves.append((x,y))
                    else:
                        entity=self.grid[y][x]
                        if (entity.side is not piece.side) and piece.direct_kill:
                            moves.append((x,y))
                        break
                n=n+1
        return moves

    def extractSpecialMoves(self,piece,position):
        px,py=position
        sx,sy=self.size
        moves=[]
        if isinstance(piece,Pawn):
            moves+=self.getDiagonalKillMoves(piece)
            moves+=self.getEnPassantMoves(piece)
            moves+=self.getTwoStepsMoves(piece)
        if isinstance(piece,King):
            moves+=self.getRoqueMoves(piece)
        return moves

    def getDiagonalKillMoves(self,piece):
        o=((self.state+1)%2)*2-1
        moves=[]
        px,py=piece.position
        x,y=(px-1,py+o)
        if self.inGrid(x,y):
            entity=self.grid[y][x]
            if entity is not None:
                if entity.side is not piece.side:
                    moves.append((x,y))
        x,y=(px+1,py+o)
        if self.inGrid(x,y):
            entity=self.grid[y][x]
            if entity is not None:
                if entity.side is not piece.side:
                    moves.append((x,y))
        return moves



    def getTwoStepsMoves(self,piece):
        o=((self.state+1)%2)*2-1
        moves=[]
        px,py=piece.position
        if piece.state==0:
            if not self.grid[py+o][px] and not self.grid[py+2*o][px]:
                move=(px,py+2*o)
                moves.append(move)
        return moves


    def getEnPassantMoves(self,piece):
        o=((self.state+1)%2)*2-1
        moves=[]
        px,py=piece.position
        x,y=(px,py+o)
        if len(self.historic)>0:
            piece,position,move=self.historic[-1]
            if isinstance(piece,Pawn):
                ex,ey=position
                emx,emy=move
                x,y=(px-1,py)
                if self.inGrid(x,y):
                    if (x,y)==(emx,emy) and (ex,ey-o)==(emx,emy):
                        moves.append((x,y+o))
                x,y=(px+1,py)
                if self.inGrid(x,y):
                    if (x,y)==(emx,emy) and (ex,ey-o)==(emx,emy):
                        moves.append((x,y+o))
        return moves

    def getRoqueMoves(self,piece):
        o=((self.state+1)%2)*2-1
        moves=[]
        px,py=piece.position
        if piece.state==0 and not piece.check:
            neighbours=self.getNeighbours(piece)
            for neighbour in neighbours:
                if isinstance(neighbour,Tower):
                    if neighbour.state==0:
                        if neighbour.side is piece.side:
                            nx,ny=neighbour.position
                            px,py=piece.position
                            dx=int((nx-px)/abs(nx-px))
                            position=(px+2*dx,py)
                            moves.append(position)
        return moves

    def getTowerMoveFromRoque(self,piece,move):
        px,py=piece.position
        mx,my=move
        if abs(mx-px)!=2:
            return None
        else:
            o=int((mx-px)/(abs(mx-px)))
            print("o:",o)
            tower_move=(px+o,py)
            x=px+o
            while abs(x)<10:
                print("x:",x)
                print("entity:",self.grid[py][x])
                tower=self.grid[py][x]
                if tower:
                    return (tower,tower_move)
                x+=o
            return None





    def getNeighbours(self,piece):
        vectors,norm=piece.moves
        sx,sy=self.size
        m=max(sx,sy)
        norm=m
        px,py=piece.position
        neighbours=[]
        orientation=((self.state+1)%2)*2-1
        for vector in vectors:
            vx,vy=vector
            n=1
            while n<=norm:
                x=px+vx*n
                y=py+orientation*vy*n
                if self.inGrid(x,y):
                    if self.grid[y][x]:
                        entity=self.grid[y][x]
                        if entity.side is piece.side:
                            neighbours.append(entity)
                        break
                else:
                    break
                n=n+1
        return neighbours


    def getById(self,id,side):
        position=self.locateById(id,side)
        if position:
            x,y=position
            entity=self.grid[y][x]
            return entity
        else:
            return None

    def updateCheck(self):
        player_side=(self.state+1)%2+1
        enemy_side=self.state%2+1
        #print("State and sides:",self.state,player_side,enemy_side)
        king=self.getById("King",player_side)
        king.check=self.isInCheck(king)

    def isInCheck(self,king):
        enemy_side=king.side%2+1
        pieces=self.getSidePieces(enemy_side)
        for piece in pieces:
            if king in self.canKill(piece):
                return True
        return False


    def canKill(self,killer):
        moves=self.getMoves(killer,killer.position)
        #print("moves:",moves)
        victims=[]
        for move in moves:
            x,y=move
            #print("canKill move:",move)
            entity=self.grid[y][x]
            if entity:
                victims.append(entity)
        #print("killer:",killer)
        #print("victims:",victims)
        #print("")
        return victims


    def inGrid(self,x,y):
        sx,sy=self.size
        return (0<=x and x<sx and 0<=y and y<sy)

    def move(self,piece,position,move):
        self.choose(piece,position,move)
        self.state+=1
        self.checkPromotion(self.action) #Here "check" means verify
        enemy_side=self.otherSide(piece.side)
        if self.isAlive("King",enemy_side):
            self.updateCheck() #Here "check" is the techical chess term
        #self.state+=1

    def choose(self,piece,position,move):
        mx,my=move
        px,py=position
        self.action=[piece,position,move]
        o=((self.state+1)%2)*2-1
        #print("In choose:")
        #print("piece:",piece)
        #print("position:",position)
        #print("move:",move)
        if not isinstance(piece,Pawn) and not isinstance(piece,King):
            piece.position=move
            self.grid[py][px]=None
            piece.state+=1
            self.grid[my][mx]=piece
        elif isinstance(piece,Pawn):
            #prise en passant
            if mx==px+1 and my==py+o:
                self.grid[py][mx]=None
            if mx==px-1 and my==py+o:
                self.grid[py][mx]=None
            piece.position=move
            self.grid[py][px]=None
            piece.state+=1
            self.grid[my][mx]=piece
        else:
            #The piece is a king
            #print("In choose:")
            #print("piece:",piece)
            if move in self.getRoqueMoves(piece):
                tower,tower_move=self.getTowerMoveFromRoque(piece,move)
                tpx,tpy=tower.position
                tx,ty=tower_move
                tower.position=tower_move
                self.grid[tpy][tpx]=None
                tower.state+=1
                self.grid[ty][tx]=tower
                #print("tower move:")
                #print(tx,ty)
                #print(tpx,tpy)
            print(move,self.getRoqueMoves(piece))
            print("")
            piece.position=move
            self.grid[py][px]=None
            piece.state+=1
            self.grid[my][mx]=piece




    def reverseMove(self):
        if len(self.historic)>1 and len(self.grid_historic)>1:
            self.state-=1
            del self.historic[-1]
            self.action=self.historic[-1]
            del self.grid_historic[-1]
            self.grid=self.grid_historic[-1]
            piece,position,move=self.historic[-1]
            x,y=position
            self.piece_selecter=self.grid[y][x]

    def updateHistoric(self):
        #self.state+=1
        self.historic.append(self.action)
        self.grid_historic.append(deepcopy(self.grid))
        self.piece_selecter=None
        self.moves_selecter=[]
        self.moving=self.action[0]
        self.moving_time=0
        self.time=time.time()


    def check(self):
        sx,sy=self.size
        player1_alive=self.isAlive(King,1)
        player2_alive=self.isAlive(King,2)
        if player1_alive and player2_alive:
            self.won=False
        else:
            self.won=True

    def checkPromotion(self,action):
        sx,sy=self.size
        piece,position,move=action
        x,y=move
        orientation=((self.state+1)%2)*2-1
        if isinstance(piece,Pawn):
            if orientation==1 and y==sy-1:
                self.promote(piece,move)
            if orientation==-1 and y==0:
                self.promote(piece,move)

    def promote(self,piece,move):
        x,y=move
        self.grid[y][x]=self.promoted[0](piece.side,move)

    def point(self,window):
        sx,sy=self.size
        wsx,wsy=window.size
        wx,wy=window.point()
        x,y=int(sx*wx/wsx),int(sy*wy/wsy)
        return (x,y)

    def getEntity(self,position):
        sx,sy=self.size
        x,y=position
        if 0<=x and x<sx and 0<=y and y<sy:
            return self.grid[y][x]
        else:
            return None

    def getShownItems(self,grid,moves):
        sx,sy=self.size
        shown_grid=[[None for x in range(sx)] for y in range(sy)]
        moves=[None for i in range(len(self.moves_selecter))]
        if self.orientation:
            for y in range(sy):
                for x in range(sx):
                    shown_grid[x][y]=self.grid[y][x]
            for i in range(len(self.moves_selecter)):
                x,y=self.moves_selecter[i]
                moves=[(y,x)]
        if self.flipping and self.state%2==1:
            for y in range(sy):
                for x in range(sx):
                    shown_grid[sy-1-y][sx-1-x]=self.grid[y][x]
            for i in range(len(self.moves_selecter)):
                x,y=self.moves_selecter[i]
                moves=[(sy-1-y,sx-1-x)]
        return (shown_grid,moves)

    def show(self,window,colors):
        self.pieces_colors,self.grid_colors,self.selecters_colors=colors
        self.case_colors,self.line_color=self.grid_colors
        self.piece_selecter_colors,self.moves_selecter_colors,self.last_piece_selecter_colors,self.last_move_selecter_colors=self.selecters_colors
        grid,moves=self.grid,self.moves_selecter
        self.showGrid(window)
        if self.state>0 and self.last_action_shown:
            self.showLastPieceSelecter(window)
            self.showLastMoveSelecter(window)
        if self.piece_selecter is not None:
            self.showPieceSelecter(window)
        if self.moves_selecter!=[]:
            self.showMovesSelecter(window)
        self.showPieces(grid,window)
        if self.moving_shown and self.moving is not None and self.moving_position is not None:
            ##print(self.moving_shown,self.moving,self.moving_position)
            self.showMovingPiece(window)
            window.flip()

    def showGrid(self,window):
        i=1
        wsx,wsy=window.size
        sx,sy=self.size
        for y in range(sy):
            i=(i+1)%len(self.case_colors)
            for x in range(sx):
                i=(i+1)%len(self.case_colors)
                coordonnates=[float(x*wsx)/sx,float(y*wsy)/sy,float(wsx)/sx+1,float(wsy)/sy+1]
                pygame.draw.rect(window.screen,self.case_colors[i],coordonnates,0)
        for x in range(sx+1):
            start= (float(x*wsx)/sx,0)
            end=   (float(x*wsx)/sx,wsx)
            pygame.draw.line(window.screen,self.line_color,start,end,1)
        for y in range(sy+1):
            start= (0,float(y*wsy)/sy)
            end=   (wsy,float(y*wsy)/sy)
            pygame.draw.line(window.screen,self.line_color,start,end,1)


    def showPieces(self,grid,window):
        wsx,wsy=window.size
        sx,sy=self.size
        for y in range(sy):
            for x in range(sx):
                entity=grid[y][x]
                if entity is not None:
                    if entity is not self.moving or not self.moving_shown:
                        position=[x*wsx/sx,y*wsy/sy]
                        size=[wsx/sx,wsy/sy]
                        coordonnates=position+size
                        entity.show(window,coordonnates,self.pieces_colors)

    def showMovingPiece(self,window):
        x,y=self.moving_position
        wsx,wsy=window.size
        sx,sy=self.size
        position=[int(x*wsx/sx),(y*wsy/sy)]
        size=[wsx/sx,wsy/sy]
        coordonnates=position+size
        self.moving.show(window,coordonnates,self.pieces_colors)

    def showMovesSelecter(self,window):
        moves=self.moves_selecter
        wsx,wsy=window.size
        sx,sy=self.size
        sm=min(sx,sy)
        wsm=min(wsx,wsy)
        raw_radius=int(wsm/(sm*4))
        for move in moves:
            x,y=move
            raw_position=(int(wsx*(x+0.5)/sx),int(wsy*(y+0.5)/sy))
            pygame.draw.circle(window.screen, self.moves_selecter_colors[1], raw_position, raw_radius+2, 0)
            pygame.draw.circle(window.screen, self.moves_selecter_colors[0], raw_position, raw_radius, 0)

    def showLastMoveSelecter(self,window):
        pawn,position,move=self.historic[-1]
        wsx,wsy=window.size
        sx,sy=self.size
        sm=min(sx,sy)
        wsm=min(wsx,wsy)
        raw_radius=int(wsm/(sm*4))
        x,y=position
        raw_position=(int(wsx*(x+0.5)/sx),int(wsy*(y+0.5)/sy))
        pygame.draw.circle(window.screen, self.last_move_selecter_colors[1], raw_position, raw_radius+2, 0)
        pygame.draw.circle(window.screen, self.last_move_selecter_colors[0], raw_position, raw_radius, 0)

    def showPieceSelecter(self,window):
        x,y=self.locateByEntity(self.piece_selecter)
        wsx,wsy=window.size
        sx,sy=self.size
        sm=min(sx,sy)
        wsm=min(wsx,wsy)
        raw_radius=int(wsm/(sm*3))
        raw_position=(int(wsx*(x+0.5)/sx),int(wsy*(y+0.5)/sy))
        pygame.draw.circle(window.screen, self.piece_selecter_colors[1], raw_position, raw_radius+2, 0)
        pygame.draw.circle(window.screen, self.piece_selecter_colors[0], raw_position, raw_radius, 0)

    def showLastPieceSelecter(self,window):
        pawn,position,move=self.historic[-1]
        self.time
        x,y=move
        wsx,wsy=window.size
        sx,sy=self.size
        sm=min(sx,sy)
        wsm=min(wsx,wsy)
        raw_radius=int(wsm/(sm*3))
        raw_position=(int(wsx*(x+0.5)/sx),int(wsy*(y+0.5)/sy))
        pygame.draw.circle(window.screen, self.last_piece_selecter_colors[1], raw_position, raw_radius+2, 0)
        pygame.draw.circle(window.screen, self.last_piece_selecter_colors[0], raw_position, raw_radius, 0)

    def getOldTrajectory(self,A,B,moving_time,moving_max_time):
        xa,ya=A
        xb,yb=B
        height=yb-ya
        width=xb-xa
        angle=atan(height/width)
        delta=moving_max_time
        c=moving_time/moving_max_time
        ##print(1-c**2,c,moving_time,moving_max_time)
        z=sqrt((1-c**2))
        x=width*z*cos(angle)
        y=height*z*sin(angle)
        return (x,y)

    def getTrajectory(self):
        piece,old_position,new_position=self.historic[-1]
        xa,ya=old_position
        xb,yb=new_position
        height=yb-ya
        width=xb-xa
        t=self.moving_time
        mt=self.moving_max_time
        ##print("time: ",t,mt)
        x=xa+width*t/mt
        y=ya+height*t/mt
        ##print("trajectory:",x,y)
        return (x,y)

    def updateMoving(self,window,colors):
        piece,old_position,new_position=self.historic[-1]
        dt=time.time()-self.time
        self.moving_time=dt
        ox,oy=old_position
        nx,ny=new_position
        x,y=self.getTrajectory()
        if min(ox,nx)<=x and x<=max(ox,nx) and min(oy,ny)<=y and y<=max(oy,ny) and self.moving_time<self.moving_max_time:
            self.moving_position=(x,y)
            self.show(window,colors)
        else:
            self.moving_position=(nx,ny)
            self.show(window,colors)
            self.moving=None
            self.moving_position=None
            self.moving_time=0


    def end(self):
        #self.summarize(self.historic)
        self.message+="\n\n"
        self.message+="|=====================|\n"
        if self.won is True:
            self.message+="|   Congratulations   |\n|Player"+str(self.winner.side)+" won the game.|\n"
        else:
            self.message+="|         Tie         |\n"
        self.message+="|=====================|\n"
        #print(self.message)