import logging
from socketio import AsyncServer

from app.websocket.connection_manager import ConnectionManager
from app.utils.auth import verify_token

logger = logging.getLogger(f'{__name__}.handlers')


def register_handlers(sio: AsyncServer, manager: ConnectionManager) -> None:
    """Register all WebSocket event handlers"""

    @sio.event
    async def connect(sid, environ, auth):
        """Handle new connection"""
        try:
            # Verify JWT token
            token = auth.get("token")
            if not token:
                logger.warning(f"Connection {sid} rejected: no token")
                return False

            user_data = verify_token(token)
            user_id = user_data.get("user_id")

            if not user_id:
                logger.warning(f"Connection {sid} rejected: invalid token")
                return False

            await manager.connect(sid, user_id)
            await sio.emit("connected", {"user_id": user_id}, room=sid)

            logger.info(f"Connection {sid} accepted for user {user_id}")
            return True

        except Exception as e:
            logger.error(f"Connection error: {e}")
            return False

    @sio.event
    async def disconnect(sid):
        """Handle disconnection"""
        await manager.disconnect(sid)

    @sio.event
    async def join_game(sid, data):
        """Handle join game request"""
        try:
            game_id = data.get("game_id")
            role = data.get("role", "player")

            if not game_id:
                await manager.emit_to_user(
                    sid,
                    "error",
                    {"message": "Missing game_id"}
                )
                return

            # TODO: Verify user has access to game

            await manager.join_game(sid, game_id, role)
            await manager.emit_to_user(
                sid,
                "game_joined",
                {"game_id": game_id, "role": role}
            )

        except Exception as e:
            logger.error(f"Join game error: {e}")
            await manager.emit_to_user(
                sid,
                "error",
                {"message": str(e)}
            )

    @sio.event
    async def leave_game(sid, data):
        """Handle leave game request"""
        try:
            game_id = data.get("game_id")
            if game_id:
                await manager.leave_game(sid, game_id)

        except Exception as e:
            logger.error(f"Leave game error: {e}")

    @sio.event
    async def heartbeat(sid):
        """Handle heartbeat ping"""
        await sio.emit("heartbeat_ack", {}, room=sid)