import cv2  # OpenCV library 
import numpy as np
import time
 
from PIL import Image # Pillow library will be used to open and crop images
from CompareImages import compare_images  # This code compares and detects differences 
                                          # between images.
from mss import mss # will be used for grabbing screenshots
sct=mss() 
 
import chess #used for chess baord visualization, move generation, and move validation.
from stockfish import Stockfish # The Stockfish chess engine will be used to evaluate 
                                # a given position and identify the top moves.
stockfish = Stockfish(r"Enter Your Path Here//stockfish.exe")

def capture_board(y_coords=163,x_coords=585, box_widths=90):
    
    global y_coord, x_coord, box_width
    y_coord, x_coord, box_width = y_coords, x_coords, box_widths
    
    '''
    This functions grabs a screenshot of your monitor based on the specified parameters. 
    It then draws an 8x8 grid based on the specified box width parameter. Make sure that 
    each blue square aligns closely with the chessboard squares.
    
    x_coord: This x coordinate is for the top left corner of the board. You will need to 
    modify it for your monitor.
    
    y_coord: This y coordinate is for the top left corner of the board. You will need to 
    modify it for your monitor.
    
    box_width: This is the width of each square on the chessboard. You may need to modify 
    it based on the size of your board.
    '''
    with mss() as sct:       
        monitor = {"top": y_coord, "left": x_coord, 
                   "width": (box_width)*8, "height": box_width*8}
 
        while True:
            screenshot = np.array(sct.grab(monitor))
 
            for i in range(1,8):
                # Draw 7 vericle blue lines with thickness of 3 px
                cv2.line(screenshot,((box_width)*i,0),((box_width)*i,
                                                       y_coord+(box_width)*8),
                         (255,0,0),3)
 
                # Draw 7 horizontal blue lines with thickness of 3 px
                cv2.line(screenshot,(0,(box_width)*i),(x_coord+(box_width)*8,
                                                       (box_width)*i),
                         (255,0,0),3)
 
            cv2.imshow('Chess Board', screenshot)
            if cv2.waitKey(1) == ord('q'):   # press any key to quit.
                cv2.destroyAllWindows()
                break
 
## Run the above function
capture_board(y_coords=163,x_coords=585, box_widths=90)

def take_screenshot(filename):
    ## Screen shot and then crop image
    filename1 = sct.shot(output=filename)
    im = Image.open(filename1)
                 # (left, upper, right         , lower         )
    im1 = im.crop(( x_coord  ,    y_coord, x_coord+box_width*8, y_coord+box_width*8))
    
    # Saves image in local directory
    im1.save(filename1)[]()

def flipped_board():
    # Take a screenshot of the chessboard and save the image in local library.
    take_screenshot('InitialBoard.png')
    im = Image.open('InitialBoard.png')
    
    # Crop the upper left-hand sqaure and process it.
    im1 = im.crop((5, 5, 70, 70))
    im1.save('CurrentRook.png')
    image = cv2.imread('CurrentRook.png')
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    
    # Assume the rook is white if the upper left-hand square has more than 300 white pixels.
    # otherwise, the rook is black and the board is not flipped.
    is_board_flipped=True if np.sum(gray==255)>300 else False
    return is_board_flipped
 
is_board_flipped=flipped_board()
 
# is_board_flipped=True
# is_board_flipped=False
 
print('Is the board flipped?', is_board_flipped)

myList=[list(range(56,64)),
 list(range(48,56)),
 list(range(40,48)),
 list(range(32,40)),
 list(range(24,32)),
 list(range(16,24)),   
 list(range(8,16)),
 list(range(0,8))]
 
if is_board_flipped:
    myList.reverse()
    for i in range(8):
        myList[i].reverse()
myList

# The pieces are arranged by the total number of black pixels. The black king has 
# the fewest number of black pixels, and the black knight has the largest number 
# of black pixels.
BPieces=['BlackKing','BlackBishop','BlackPawn','BlackRook','BlackQueen','BlackKnight']
BPieceType=[6,3,1,4,5,2]
 
# The pieces are arranged by the total number of white pixels. The white bishop has 
# the smallest number of white pixels, and the white knight has the largest number 
# of white pixels.
WPieces=['WhiteBishop','WhiteQueen','WhiteRook','WhitePawn','WhiteKing','WhiteKnight']
WPieceType=[3,5,4,1,6,2]

BlackPixelList, WhitePixelList=[],[]
nn=0;
n=0
 
# Take a screenshot of the entire chessboard and save the image
take_screenshot('image1.png')
 
#Read the chessboard into memory
image = cv2.imread('image1.png')
 
# Convert the color image to a gray scale image and save it.
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cv2.imwrite('gray image.png', gray)
im = Image.open('gray image.png')
 
 
# Crop each squre of the chess board and save the 64 gray scale images. Each image 
# will align with a specific square on the chessboard.
for i in range(8):
    for j in range(8):
 
        im1=im.crop(
            (j*(box_width), 
             i*(box_width), 
             (j+1)*(box_width-0), 
             (i+1)*(box_width-0)))
        im1.save('pieces//'+str(nn)+'.png')
        n+=1        
 
        n=myList[i][j]
        image = cv2.imread('pieces//'+str(nn)+'.png')
        
        # count the number of black pixels per image
        BlackPiece=np.sum(image==0)
        BlackPixelList.append(BlackPiece)
        
        # count the number of white pixels per image
        WhitePiece=np.sum(image==255)
        WhitePixelList.append(WhitePiece)
        nn+=1

# Filter out values equal 0 and keep unique pixel values
# sort the list in ascending order
# keep the six largest pixel values
BlackPixelList=set(list(filter(lambda x: x > 0, BlackPixelList)))
BlackPixelList=list(BlackPixelList)
BlackPixelList.sort()
BlackPixelList=BlackPixelList[-6:]
 
WhitePixelList=set(list(filter(lambda x: x > 0, WhitePixelList)))
WhitePixelList=list(WhitePixelList)
WhitePixelList.sort()
WhitePixelList=WhitePixelList[-6:]
 
# Create a dictionary for each color and assign 
# pixel value to each chess piece, piece type,
# and piece color (False=Black, True=White).
BlackPieces={}
for i, val in enumerate(BPieces):
    BlackPieces[val] = (BlackPixelList[i],BPieceType[i],False)
 
WhitePieces={}
for i, val in enumerate(WPieces):
    WhitePieces[val] = (WhitePixelList[i],WPieceType[i],True)

BlackPieces=\
{'BlackKing': (5028, 6, False),
 'BlackBishop': (5052, 3, False),
 'BlackPawn': (5679, 1, False),
 'BlackRook': (6489, 4, False),
 'BlackQueen': (6495, 5, False),
 'BlackKnight': (7623, 2, False)}
 
WhitePieces=\
{'WhiteBishop': (2520, 3, True),
 'WhiteQueen': (3039, 5, True),
 'WhiteRook': (3741, 4, True),
 'WhitePawn': (3933, 1, True),
 'WhiteKing': (4410, 6, True),
 'WhiteKnight': (6057, 2, True)}
 
BlackPixelValues=[i[0] for i in list(BlackPieces.values())]
WhitePixelValues=[i[0] for i in list(WhitePieces.values())]

stockfish.set_elo_rating(3000)
stockfish.set_depth(15)
 
def evaluate_position(white_turn=True, board_flipped=is_board_flipped):
    start_time = time.time()
    # take a screenshot of the board
    take_screenshot('image1.png')
    image = cv2.imread('image1.png')
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    cv2.imwrite('gray image.png', gray)
    im = Image.open('gray image.png')
 
    # Set up the board from the Chess library
    board = chess.Board()
    # Remove all the pieces because they will be specified in the next step
    board.clear()
    # Set the turn to White to play, unless otherwise specified
    board.turn = white_turn 
 
    nn=0;
    n=0
    for i in range(8):
        for j in range(8):
 
            im1=im.crop((j*(box_width), i*(box_width), (j+1)*(box_width-0), (i+1)*(box_width-0)))
            im1.save('pieces//'+str(nn)+'.png')
            n+=1        
 
            n=myList[i][j]
            # Read each cropped chess square and identify the chess piece and color.
            image = cv2.imread('pieces//'+str(nn)+'.png')
            BlackPiece=np.sum(image==0)
            WhitePiece=np.sum(image==255)
            res_val=(0,0,True)
            if BlackPiece>min(BlackPixelValues)-50:
                # Identify the chess piece based on he number of black pixels closest to the 
                # values from the BlackPieces dictionary.
                col_key, res_val = min(BlackPieces.items(), key=lambda x: abs(BlackPiece - x[1][0]))
            if WhitePiece>min(WhitePixelValues)-50:
                # Identify the chess piece based on he number of white pixels closest to the 
                # values from the BlackPieces dictionary.
                col_key, res_val = min(WhitePieces.items(), key=lambda x: abs(WhitePiece - x[1][0]))
            # set the chess piece on the board based on it position, piece type, and color. 
            board.set_piece_at(n,piece=chess.Piece(piece_type=res_val[1],color=res_val[2]))
            nn+=1
 
    #create the FEN based on the current position 
    turn_fen=' w - - 1 0' if board.turn == True else ' b - - 0 1'
    current_fen=board.board_fen()+turn_fen
    # Assign the postion in Stockfish based on FEN
    stockfish.set_fen_position(current_fen)
    # Get the top moves
    top_moves=stockfish.get_top_moves()
    #Get the best move
    my_move=top_moves[0]['Move']
    # Move the chess piece based on the best move
    board.push(chess.Move.from_uci(my_move))
 
    #Create output
    print('Time:',time.time()-start_time)
    print('Best Move:', my_move)
    print('Evaluation:', stockfish.get_evaluation())
    print('Top moves:')
    for i in top_moves:
        print(i)
 
    if board_flipped:
        board.apply_transform(chess.flip_vertical)
        board.apply_transform(chess.flip_horizontal)
        display(board)
    else:
        display(board)

evaluate_position(white_turn=True)