from typing import Annotated

from fastapi import APIRouter, Depends, UploadFile
from sqlalchemy.ext.asyncio import AsyncSession

from backend.dependecies import CurrentUserDependency
from backend.session import get_session
from models import User
from schemas.chat import *
from services.auth import get_current_user
from services.chat import ChatService

chat_router = APIRouter(
    prefix='/chat',
    tags=['chat'],
)


@chat_router.post(
    '/message',
    operation_id='send_text_message',
    response_model=SendTextMessageResponse,
)
async def send_text_message(
        session: Annotated[AsyncSession, Depends(get_session)],
        user: Annotated[User, Depends(get_current_user)],
        request: SendTextMessageRequest,
):
    return await ChatService(session).send_message(request, user)


@chat_router.post(
    '/message/repeat',
    operation_id='repeat_sending_text_message',
    response_model=RepeatSendingTextMessageResponse,
)
async def repeat_sending_text_message(
        session: Annotated[AsyncSession, Depends(get_session)],
        request: RepeatSendingTextMessageRequest,
):
    return await ChatService(session).repeat_sending_message(request)


@chat_router.post(
    '/message/files',
    operation_id='send_messages_with_files',
    response_model=LoadMessagesResponse,
)
async def send_messages_with_files(
        session: Annotated[AsyncSession, Depends(get_session)],
        user: Annotated[User, Depends(get_current_user)],
        files: list[UploadFile],
        chat_id: int,
        caption: str,
):
    return await ChatService(session).send_messages_with_files(files, chat_id, caption, user)


@chat_router.delete(
    '/message/{message_id}',
    operation_id='delete_message',
    response_model=DeleteMessageResponse,
)
async def delete_message(
        session: Annotated[AsyncSession, Depends(get_session)],
        message_id: int,
):
    return await ChatService(session).delete_message(message_id)


@chat_router.patch(
    '/message',
    operation_id='edit_message',
    response_model=EditMessageResponse,
)
async def edit_message(
        session: Annotated[AsyncSession, Depends(get_session)],
        request: EditMessageRequest,
):
    return await ChatService(session).edit_message(request)


@chat_router.post(
    '/',
    operation_id='get_chat',
    response_model=GetChatResponse,
)
async def get_chat(
        session: Annotated[AsyncSession, Depends(get_session)],
        request: GetChatRequest,
):
    return await ChatService(session).get_chat(request)


@chat_router.get(
    '/for-client/{client_id}',
    operation_id='get_client_chats_list',
    response_model=GetChatsListResponse,
)
async def get_client_chats_list(
        session: Annotated[AsyncSession, Depends(get_session)],
        client_id: int,
):
    return await ChatService(session).get_client_chats_list(client_id)


@chat_router.post(
    '/create',
    operation_id='create_chat',
    response_model=CreateChatResponse,
)
async def create_chat(
        session: Annotated[AsyncSession, Depends(get_session)],
        request: CreateChatRequest,
        user: CurrentUserDependency,
):
    return await ChatService(session).create_chat(request, user)


@chat_router.post(
    '/messages',
    operation_id='get_messages',
    response_model=GetMessagesResponse,
)
async def get_messages(
        session: Annotated[AsyncSession, Depends(get_session)],
        request: GetMessagesRequest,
):
    return await ChatService(session).get_messages(request)


@chat_router.get(
    '/tg-file/{file_id}',
)
async def get_tg_file(
        session: Annotated[AsyncSession, Depends(get_session)],
        file_id: int,
):
    return await ChatService(session).get_tg_file(file_id)