import pickle
from uuid import UUID

from aiohttp import ClientConnectorError

from backend.config import KAFKA_PRODUCER_TOPIC, CHAT_CONNECTOR_API_KEY
from external.kafka import producer
from external.kafka.enums import KafkaMessageType
from external.kafka.schemas.producer import *
from services.base import BaseService


class ProducerService(BaseService):
    @staticmethod
    async def _send_message(request: BaseConnectorRequest):
        try:
            await producer.send(KAFKA_PRODUCER_TOPIC, value=pickle.dumps(request.model_dump()))
        except ClientConnectorError:
            return False, 'Ошибка подключения к коннектору'
        except Exception as e:
            return False, str(e)
        return True, 'Сообщение отправлено'

    @staticmethod
    async def send_message_to_connector(
            message_text: str,
            group_id: UUID,
            topic_id: int,
            message_id: int,
    ) -> tuple[bool, str]:
        request = SendMessageToConnectorRequest(
            message_type=KafkaMessageType.SEND,
            app_auth_key=CHAT_CONNECTOR_API_KEY,
            message=MessageSchema(
                message_id=message_id,
                text=message_text,
                group_id=str(group_id),
                topic_id=topic_id,
            ),
        )
        return await ProducerService._send_message(request)

    @staticmethod
    async def send_message_deleting_to_connector(
            message_id: int,
            tg_message_id: int,
            group_id: UUID,
    ) -> tuple[bool, str]:
        request = SendMessageDeletingToConnectorRequest(
            message_type=KafkaMessageType.DELETE,
            app_auth_key=CHAT_CONNECTOR_API_KEY,
            message=BaseMessageSchema(
                message_id=message_id,
                tg_message_id=tg_message_id,
                group_id=str(group_id),
            ),
        )
        return await ProducerService._send_message(request)

    @staticmethod
    async def send_message_editing_to_connector(
            message_id: int,
            tg_message_id: int,
            group_id: UUID,
            text: str,
    ) -> tuple[bool, str]:
        request = SendMessageEditingToConnectorRequest(
            message_type=KafkaMessageType.EDIT,
            app_auth_key=CHAT_CONNECTOR_API_KEY,
            message=EditMessageSchema(
                message_id=message_id,
                tg_message_id=tg_message_id,
                group_id=str(group_id),
                text=text,
            )
        )
        return await ProducerService._send_message(request)