from fastapi import APIRouter, WebSocket, Depends, status
from starlette.websockets import WebSocketDisconnect

from app.exceptions import UDontHavePermissionException, MessageNotFoundException
from app.users.chat.dao import ChatDAO
from app.users.chat.shemas import SMessage
from app.users.chat.websocket import manager
from app.users.dao import UserDAO
from app.users.dependencies import get_current_user
from app.users.models import Users

router = APIRouter(
    prefix="/chat",
    tags=["Чат"]
)


@router.post("", status_code=status.HTTP_201_CREATED)
async def add_message_to_chat(
        chat_id: int,
        message: str,
        image_url: str = None,
        user: Users = Depends(get_current_user)
):
    send_message_to_chat = await ChatDAO.send_message(
        user_id=user.id,
        chat_id=chat_id,
        message=message,
        image_url=image_url
    )


@router.delete("/delete_message", status_code=status.HTTP_204_NO_CONTENT)
async def delete_message_from_chat(
        message_id: int,
        user: Users = Depends(get_current_user)
):
    get_message_sender = await ChatDAO.get_message_by_id(message_id=message_id)
    if get_message_sender is None:
        raise MessageNotFoundException
    if get_message_sender["user_id"] != user.id:
        get_user_role = await UserDAO.get_user_role(user_id=user.id)
        if not get_user_role == 1:
            raise UDontHavePermissionException
    deleted_message = await ChatDAO.delete_message(message_id=message_id)
    return deleted_message


@router.get("/get_last_message", response_model=SMessage)
async def get_last_message(chat_id: int, user: Users = Depends(get_current_user)):
    message = dict(await ChatDAO.get_last_message(chat_id=chat_id))
    user_avatar = await UserDAO.get_user_avatar(user_id=user.id)
    message["user_avatar"] = user_avatar
    print(message)
    if message is not None:
        return message
    raise MessageNotFoundException


@router.post("/create_chat")
async def create_chat(
        user_to_exclude: int,
        user: Users = Depends(get_current_user)
):
    created_chat = await ChatDAO.create(user_id=user_to_exclude)
    return created_chat


@router.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket, user: Users = Depends(get_current_user)):
    await manager.connect(websocket)
    try:
        while True:
            data = await websocket.receive_text()

            await manager.broadcast(f"User {user.id}: {data}")
    except WebSocketDisconnect:
        manager.disconnect(websocket)
        await manager.broadcast(f"User {user.id}: себался")