import os
import asyncio
import aiohttp
from aiohttp import web

import chess
from chesspp import engine

_DIR = os.path.abspath(os.path.dirname(__file__))
_DATA_DIR = os.path.abspath(os.path.join(_DIR, "static_data"))
_INDEX = os.path.join(_DATA_DIR, "index.html")


def load_index() -> str:
    """
        Load and return the chessboard html file from disk
    """
    with open(_INDEX, 'r') as fp:
        return fp.read()


class Simulate:
    """ Run a simulation of two engines"""
    def __init__(self, engine_white=None, engine_black=None):
        if engine_white is None:
            engine_white = engine.ClassicMctsEngine(chess.WHITE)
        if engine_black is None:
            engine_black = engine.ClassicMctsEngine(chess.BLACK)

        self.white = engine_white
        self.black = engine_black

    def run(self):
        board = chess.Board()

        is_white_playing = True
        while not board.is_game_over():
            play_result = self.white.play(board) if is_white_playing else self.black.play(board)
            yield play_result.move
            board.push(play_result.move)
            is_white_playing = not is_white_playing


async def handle_index(request) -> web.Response:
    """ Entry point of webpage, returns the index html"""
    return web.Response(text=load_index(), content_type='text/html')


async def handle_websocket(request):
    """ Handles a websocket connection to the frontend"""
    ws = web.WebSocketResponse()
    await ws.prepare(request)

    async def wait_msg():
        """ Handles messages from client """
        async for msg in ws:
            if msg.type == aiohttp.WSMsgType.TEXT:
                if msg.data == 'close':
                    await ws.close()
            elif msg.type == aiohttp.WSMsgType.ERROR:
                print(f'ws connection closed with exception {ws.exception()}')
    
    async def turns():
        """ Simulates the game and sends the response to the client """
        runner = Simulate().run()
        def sim():
            return next(runner, None)

        turn = await asyncio.to_thread(sim)
        while turn is not None:
            await ws.send_str(turn.uci())
            turn = await asyncio.to_thread(sim)
    
    async with asyncio.TaskGroup() as tg:
        tg.create_task(wait_msg())
        tg.create_task(turns())

    print('websocket connection closed')
    return ws

def run_app():
    app = web.Application()
    app.add_routes([
        web.get('/', handle_index),
        web.get('/ws', handle_websocket),
        web.static('/img/chesspieces/wikipedia/', _DATA_DIR),
    ])
    web.run_app(app)

if __name__ == '__main__':
    run_app()