from typing import List, Optional

from ..models.chat import (
    ArchiveChat,
    CheckIsWhatsappNumber,
    MediaMessage,
    MessageKey,
    Presence,
    ProfilePicture,
    ReadMessage,
    UnreadChat,
    UpdateMessage,
)


class ChatService:
    def __init__(self, client):
        self.client = client

    def check_is_whatsapp_numbers(
        self, instance_id: str, data: CheckIsWhatsappNumber, instance_token: str
    ):
        return self.client.post(
            f"chat/whatsappNumbers/{instance_id}",
            data=data.__dict__,
            instance_token=instance_token,
        )

    def mark_message_as_read(
        self, instance_id: str, messages: List[ReadMessage], instance_token: str
    ):
        return self.client.post(
            f"chat/markMessageAsRead/{instance_id}",
            data={"readMessages": [m.__dict__ for m in messages]},
            instance_token=instance_token,
        )

    def archive_chat(self, instance_id: str, data: ArchiveChat, instance_token: str):
        return self.client.post(
            f"chat/archiveChat/{instance_id}",
            data=data.__dict__,
            instance_token=instance_token,
        )

    def mark_chat_unread(self, instance_id: str, data: UnreadChat, instance_token: str):
        return self.client.post(
            f"chat/markChatUnread/{instance_id}",
            data=data.__dict__,
            instance_token=instance_token,
        )

    def delete_message_for_everyone(self, instance_id: str, data: MessageKey, instance_token: str):
        return self.client.delete(
            f"chat/deleteMessageForEveryone/{instance_id}",
            data=data.__dict__,
            instance_token=instance_token,
        )

    def fetch_profile_picture_url(
        self, instance_id: str, data: ProfilePicture, instance_token: str
    ):
        return self.client.post(
            f"chat/fetchProfilePictureUrl/{instance_id}",
            data=data.__dict__,
            instance_token=instance_token,
        )

    def get_base64_from_media_message(
        self, instance_id: str, data: MediaMessage, instance_token: str
    ):
        return self.client.post(
            f"chat/getBase64FromMediaMessage/{instance_id}",
            data=data.__dict__,
            instance_token=instance_token,
        )

    def update_message(self, instance_id: str, data: UpdateMessage, instance_token: str):
        return self.client.post(
            f"chat/updateMessage/{instance_id}",
            data=data.__dict__,
            instance_token=instance_token,
        )

    def send_presence(self, instance_id: str, data: Presence, instance_token: str):
        return self.client.post(
            f"chat/sendPresence/{instance_id}",
            data=data.__dict__,
            instance_token=instance_token,
        )

    def get_messages(
        self,
        instance_id: str,
        remote_jid: str,
        instance_token: str,
        message_id: Optional[str] = None,
        whatsapp_message_id: Optional[str] = None,
        from_me: Optional[bool] = None,
        message_type: Optional[str] = None,
        source: Optional[str] = None,
        timestamp_start: Optional[str] = None,
        timestamp_end: Optional[str] = None,
        page: int = 1,
        offset: int = 50,
    ):
        """
        Obtém mensagens de um chat com filtros opcionais

        Args:
            timestamp_start: Data inicial no formato ISO (ex: "2025-01-16T00:00:00Z")
            timestamp_end: Data final no formato ISO (ex: "2025-01-16T23:59:59Z")
        """
        where = {"key": {"remoteJid": remote_jid}}

        if message_id:
            where["id"] = message_id
        if whatsapp_message_id:
            where["key"]["id"] = whatsapp_message_id
        if from_me is not None:
            where["key"]["fromMe"] = from_me
        if message_type:
            where["messageType"] = message_type
        if source:
            where["source"] = source
        if timestamp_start or timestamp_end:
            where["messageTimestamp"] = {}
            if timestamp_start:
                where["messageTimestamp"]["gte"] = timestamp_start
            if timestamp_end:
                where["messageTimestamp"]["lte"] = timestamp_end

        payload = {
            "where": where,
            "page": page,
            "offset": offset,
        }

        return self.client.post(
            f"chat/findMessages/{instance_id}",
            data=payload,
            instance_token=instance_token,
        )
