import gradio as gr
from PIL import Image, ImageDraw, ImageFont
import random, time

DIRECTIONS = [(-1,-1),(-1,0),(-1,1),(0,-1),(0,1),(1,-1),(1,0),(1,1)]

history_log = []

# Load custom fonts or fall back
try:
    FONT_L = ImageFont.truetype("DejaVuSans-Bold.ttf", 36)
    FONT_S = ImageFont.truetype("DejaVuSans-Bold.ttf", 20)
except:
    FONT_L = ImageFont.load_default()
    FONT_S = ImageFont.load_default()

def initialize_board():
    b = [[0]*8 for _ in range(8)]
    b[3][3], b[4][4] = 1, 1
    b[3][4], b[4][3] = -1, -1
    return b

def get_flips(board, r, c, p):
    if board[r][c] != 0: return []
    flips=[]
    for dr,dc in DIRECTIONS:
        rr,cc=r+dr,c+dc; buf=[]
        while 0<=rr<8 and 0<=cc<8 and board[rr][cc]==-p:
            buf.append((rr,cc)); rr+=dr; cc+=dc
        if buf and 0<=rr<8 and 0<=cc<8 and board[rr][cc]==p:
            flips+=buf
    return flips

def apply_move(board, r, c, p):
    f=get_flips(board,r,c,p)
    if not f: return False
    board[r][c]=p
    for rr,cc in f: board[rr][cc]=p
    return True

def choose_move(board, player):
    valid=[(r,c) for r in range(8) for c in range(8) if get_flips(board,r,c,player)]
    return random.choice(valid) if valid else None

def count_score(board):
    b=sum(cell==-1 for row in board for cell in row)
    w=sum(cell==1 for row in board for cell in row)
    return b,w

def is_game_over(board):
    return not any(get_flips(board,r,c,p) for p in (-1,1) for r in range(8) for c in range(8))

def board_to_image(board, state):
    board_state, player, last_user, last_ai, history = state
    size, cell = 400, 400//8
    img=Image.new('RGB',(size,size+cell*5),'darkgreen')
    draw=ImageDraw.Draw(img)

    b,w=count_score(board_state)
    draw.rectangle([0,0,size,cell],fill='navy')
    draw.text((10,2),f"BLACK: {b}",font=FONT_L,fill='white')
    draw.text((size-200,2),f"WHITE: {w}",font=FONT_L,fill='white')

    if is_game_over(board_state):
        winner = "DRAW" if b==w else ("BLACK WINS" if b>w else "WHITE WINS")
        draw.rectangle([0,cell,size,cell*2],fill='darkred')
        draw.text((size//2-120,cell+2),winner,font=FONT_L,fill='yellow')
        draw.text((size//2-120,cell+30),"Click 'New Game' to restart",font=FONT_S,fill='white')

    for r in range(8):
        for c in range(8):
            x0,y0=c*cell,cell*2+r*cell; x1,y1=x0+cell,y0+cell
            draw.rectangle([x0,y0,x1,y1],outline='black')
            if board_state[r][c]==0 and get_flips(board_state,r,c,player):
                draw.ellipse([x0+cell*0.4,y0+cell*0.4,x0+cell*0.6,y0+cell*0.6],fill='yellow')
            if board_state[r][c]==1: draw.ellipse([x0+4,y0+4,x1-4,y1-4],fill='white')
            if board_state[r][c]==-1: draw.ellipse([x0+4,y0+4,x1-4,y1-4],fill='black')

    for mark,clr in ((last_user,'red'),(last_ai,'blue')):
        if mark:
            mr,mc=mark; x0,y0=mc*cell,cell*2+mr*cell; x1,y1=x0+cell,y0+cell
            draw.rectangle([x0,y0,x1,y1],outline=clr,width=4)

    y=cell*2+8*cell+10
    if history:
        draw.text((10,y),"History:",font=FONT_S,fill='white'); y+=cell//2
        for res in history[-5:]:
            draw.text((10,y),res,font=FONT_S,fill='white'); y+=cell//2

    return img

def click_handler(evt, state):
    if state is None:
        state = (initialize_board(), -1, None, None, [])
    board, player, lu, la, history = state
    if callable(evt.index):
        x, y = evt.index()
    else:
        x, y = evt.index
    cell = 400 // 8
    c, r = int(x // cell), int((y - cell * 2) // cell)

    if 0 <= r < 8 and 0 <= c < 8 and not is_game_over(board):
        if apply_move(board, r, c, player):
            lu, player = (r, c), -player

    yield board_to_image(board, (board, player, lu, la, history)), (board, player, lu, la, history)

    if is_game_over(board):
        winner = "DRAW" if count_score(board)[0] == count_score(board)[1] else ("BLACK" if count_score(board)[0] > count_score(board)[1] else "WHITE")
        history.append(f"Game {len(history)+1}: {winner}")
        history_log.append(f"Game {len(history_log)+1}: {winner}")
        yield board_to_image(board, (board, player, lu, la, history)), (board, player, lu, la, history)
        return

    thinking_img = board_to_image(board, (board, player, lu, la, history))
    draw = ImageDraw.Draw(thinking_img)
    draw.text((150, 400 - 25), "AI Thinking...", font=FONT_S, fill='cyan')
    yield thinking_img, (board, player, lu, la, history)
    time.sleep(1.5)

    ai_mv = choose_move(board, player)
    if ai_mv:
        apply_move(board, ai_mv[0], ai_mv[1], player)
        la, player = ai_mv, -player
    yield board_to_image(board, (board, player, lu, la, history)), (board, player, lu, la, history)

def reset_handler():
    new_board = initialize_board()
    return new_board, -1, None, None, history_log.copy()

with gr.Blocks() as demo:
    state=gr.State((initialize_board(),-1,None,None,[]))
    img=gr.Image(value=board_to_image(initialize_board(),(initialize_board(),-1,None,None,[])),interactive=True)
    new_btn=gr.Button("New Game")
    img.select(click_handler,inputs=[state],outputs=[img,state])
    new_btn.click(fn=lambda: (initialize_board(), -1, None, None, history_log.copy()), outputs=[state, img])
    demo.launch()