import asyncio
import json
import logging
from threading import Thread

import websockets
from websockets import WebSocketServerProtocol
from websockets.exceptions import ConnectionClosedOK

from hopper.models.ws_dto import GameDumpDto
from settings import settings


class WSServer(Thread):
    async def handler(self, websocket: WebSocketServerProtocol) -> None:
        """New handler instance spawns for each connected client"""
        self.connected_clients.add(websocket)
        logging.info(f"Add client: {websocket.id}")

        try:
            # send initial game dump to connected client
            await self.send_game_dump_to_client(websocket)
            # loop and do nothing while client is connected
            connected = True
            while connected:
                try:
                    # we're expecting nothing from client, but read if client sends a message
                    await websocket.recv()
                except ConnectionClosedOK:
                    connected = False
        finally:
            self.connected_clients.remove(websocket)
            logging.info(f"Remove client: {websocket.id}")

    def _create_game_dump_message(self) -> str:
        # avoid circular imports
        from hopper.api.dependencies import get_game_engine

        engine = get_game_engine()

        game_dump = GameDumpDto(
            board=engine.board,
            destination=engine.board.destination,
            players=engine.players,
            layers=engine.get_board_layout().layers,
        )
        return json.dumps(game_dump.dict())

    async def send_game_dump_to_client(
        self, websocket: WebSocketServerProtocol
    ) -> None:
        """Send game dump to the client"""
        message = self._create_game_dump_message()
        logging.debug(f"Sending game dump to client: {websocket.id}")
        await websocket.send(message)

    async def send_game_dump(self) -> None:
        """Broadcast game state to all connected clients"""
        if not self.connected_clients:
            return

        message = self._create_game_dump_message()
        logging.debug(
            f"Sending game dump to clients: {self.connected_clients}: {message}"
        )
        for client in self.connected_clients:
            await client.send(message)

    async def run_async(self) -> None:
        logging.info(
            f"Starting FairHopper Websockets Server on {settings.ws_server.HOST}:{settings.ws_server.PORT}"
        )

        async with websockets.serve(
            ws_handler=self.handler,
            host=settings.ws_server.HOST,
            port=settings.ws_server.PORT,
        ):
            await asyncio.Future()  # run forever

    def run(self) -> None:
        self.connected_clients = set[WebSocketServerProtocol]()
        asyncio.run(self.run_async())