from fastapi import APIRouter, Depends, status


from app.exceptions import UserDontHavePermissionException, MessageNotFoundException
from app.users.chat.dao import ChatDAO
from app.users.chat.shemas import SMessage

from app.users.dao import UserDAO
from app.users.dependencies import get_current_user, validate_user_access_to_chat
from app.users.models import Users

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


@router.get("")
async def root(user: Users = Depends(get_current_user)):
    print(user)
    return user.id


@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 UserDontHavePermissionException
    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.get("/last_messages")
async def get_last_messages():
    pass