import json
from enum import Enum
from typing import Union, Type, Tuple

from kurocore.database import Database
from kurocore.vk import VkKeyboard, VKApiException, VK
from kurocore.vk.utils import generate_random_id


class MessageArgs(dict):
    def __init__(self, args: dict):
        self.__args: dict = args
        super().__init__(args)

    def __getattr__(self, item):
        try:
            return self.__args[item]
        except KeyError:
            return None


class VkObject:
    __slots__ = (
        'raw',
    )

    def __init__(self, raw):
        self.raw = raw


class PhotoSize:
    __slots__ = (
        'type', 'url', 'width', 'height'
    )

    def __init__(self, raw: dict):
        self.type: str = raw['type']
        self.url: str = raw['url']
        self.width: int = raw['width']
        self.height: int = raw['height']


class StickerSize:
    __slots__ = (
        'url', 'width', 'height'
    )

    def __init__(self, raw: dict):
        self.url: str = raw['url']
        self.width: int = raw['width']
        self.height: int = raw['height']


class Photo(VkObject):
    __slots__ = (
        'id', 'album_id', 'owner_id', 'access_key',
        'user_id', 'text', 'date', 'sizes',
        'type'
    )

    def __init__(self, raw: dict):
        super().__init__(raw)
        self.type = 'photo'
        self.raw: dict = raw['photo']

        self.id: int = self.raw['id']
        self.album_id: int = self.raw['album_id']
        self.owner_id: int = self.raw['owner_id']
        self.access_key: str = self.raw.get('access_key', '')
        self.user_id: int = self.raw.get('user_id', 0)

        self.text: str = self.raw['text']
        self.date: int = self.raw['date']  # unix time
        self.sizes = [PhotoSize(r) for r in self.raw['sizes']]

    def __repr__(self):
        return f'photo{self.owner_id}_{self.id}'


class Sticker(VkObject):
    __slots__ = (
        'type', 'images', 'images_with_background',
        'animation_url', 'is_allowed'
    )

    def __init__(self, raw: dict):
        super().__init__(raw)

        self.type = 'sticker'
        self.raw: dict = raw['sticker']

        self.images = [StickerSize(img) for img in self.raw['images']]
        self.images_with_background = [StickerSize(img) for img in self.raw['images_with_background']]

        self.animation_url = self.raw.get('animation_url', '')
        self.is_allowed = self.raw.get('is_allowed')

    def __repr__(self):
        return f'sticker{self}'


class DocumentType(Enum):
    TEXT = 1
    ARCHIVE = 2
    GIF = 3
    PHOTO = 4
    AUDIO = 5
    VIDEO = 6
    BOOKS = 7
    UNKNOWN = 8


class Document(VkObject):
    __slots__ = (
        'id', 'album_id', 'owner_id',
        'title', 'size', 'ext', 'url',
        'date', 'type'
    )

    def __init__(self, raw: dict):
        super().__init__(raw)
        self.raw: dict = raw['doc']
        self.id: int = self.raw['id']
        self.owner_id: int = self.raw['owner_id']

        self.title: str = self.raw['title']
        self.size: int = self.raw['size']  # размер в байтах
        self.ext: str = self.raw['ext']  # расширение
        self.url: str = self.raw['url']
        self.date: int = self.raw['date']  # unix time
        self.type: DocumentType = self.raw['type']

    def __repr__(self):
        return f'doc{self.owner_id}_{self.id}'


Attachment = Type[Photo], Type[Document], Type[Sticker]


class Message(VkObject):
    __slots__ = (
        'vk', 'api', 'raw', 'id', 'conversation_message_id', 'cmid',
        'date', 'peer_id', 'from_id', 'user_id', 'chat_id', 'is_chat',
        'original_text', 'text', 'attachments', 'payload',
        'event_id', 'forwarded_messages', 'reply_message',
        'meta'
    )

    def __init__(self, api, raw):
        super().__init__(raw)

        self.api = api

        if type(raw) is Message:
            self.raw = raw.raw
        else:
            self.raw = raw.get('message', raw)

        self.id: int = self.raw.get('id', 0)
        self.conversation_message_id: int = self.raw.get('conversation_message_id', 0)
        self.cmid: int = self.conversation_message_id
        self.date: int = self.raw.get('date', 0)

        self.peer_id: int = self.raw.get('peer_id', 0)
        self.from_id: int = self.raw.get('from_id', 0)
        self.user_id: int = self.raw.get('user_id', self.from_id)

        self.chat_id: int = self.peer_id - 2000000000
        self.is_chat: bool = self.chat_id > 0

        self.original_text: str = self.raw.get('text', '')
        self.text: str = self.original_text.lower()

        self.attachments: list[Attachment] = load_attachments(self.raw.get('attachments', []))

        raw_payload = self.raw.get('payload', '{}')
        if type(raw_payload) is dict:
            self.payload: dict = raw_payload
        else:
            self.payload: dict = json.loads(raw_payload)

        self.event_id: str = self.raw.get('event_id', '')

        self.forwarded_messages: list = self.raw.get('fwd_messages', [])
        self.reply_message = Message(self.api, self.raw['reply_message']) if 'reply_message' in self.raw else None

        self.meta: dict = {}

    async def send(self, peer_id, text: str = '', attachments: (Tuple[Attachment], Attachment, str) = '',
                   keyboard: Union[VkKeyboard, dict] = None, **kwargs):
        data = kwargs.copy()
        data.update({
            'peer_id': peer_id,
            'random_id': generate_random_id()
        })

        if text:
            data.update({'message': text})

        if keyboard:
            if type(keyboard) is VkKeyboard:
                data.update({'keyboard': keyboard.get_keyboard()})
            else:
                data.update({'keyboard': keyboard})

        if attachments:
            if type(attachments) is str:
                data.update({'attachment': attachments})
            elif type(attachments) in (Photo, Document):
                data.update({'attachment': str(attachments)})
            else:
                data.update({'attachment': dump_attachments(attachments)})

        return MessageID(await self.api.messages.send(**data))

    async def answer_event(self, event_data):
        data = {
            'peer_id': self.peer_id,
            'event_id': self.event_id,
            'user_id': self.user_id,
            'event_data': json.dumps(event_data),
        }

        try:
            return await self.api.messages.sendMessageEventAnswer(**data)
        except VKApiException:
            ...

    async def answer_event_hide_keyboard(self, event_data):
        await self.answer_event(event_data)

        await self.api.messages.edit(
            peer_id=self.peer_id,
            conversation_message_id=self.conversation_message_id,
            keyboard=VkKeyboard.get_empty_keyboard()
        )

    async def answer(self, text: str = '', attachments: (list[Attachment], Attachment, str) = '', **kwargs):
        return await self.send(self.peer_id, text, attachments, **kwargs)

    async def edit(self, text='', attachments: list[Attachment] = '', keyboard: Union[VkKeyboard, dict] = None,
                   **kwargs):
        data: dict = kwargs.copy()
        data.update({
            'peer_id': self.peer_id
        })

        if text:
            data.update({'message': text})

        if keyboard:
            if type(keyboard) is VkKeyboard:
                data.update({'keyboard': keyboard.get_keyboard()})
            else:
                data.update({'keyboard': keyboard})

        if attachments:
            if type(attachments) is str:
                data.update({'attachment': attachments})
            elif type(attachments) in (Photo, Document):
                data.update({'attachment': str(attachments)})
            elif type(attachments) is list:
                if type(attachments[0]) is dict:
                    data.update({'attachment': dump_attachments(load_attachments(attachments))})
                else:
                    data.update({'attachment': dump_attachments(attachments)})

        if 'cmid' not in kwargs and 'conversation_message_id' not in kwargs:
            data.update({
                'conversation_message_id': self.conversation_message_id
            })
        if 'cmid' in kwargs:
            data.update({
                'conversation_message_id': kwargs['cmid']
            })
            kwargs.pop('cmid')

        try:
            message_id = await self.api.messages.edit(**data)
        except VKApiException:
            message_id = await self.api.messages.send(**data, random_id=generate_random_id())

        return MessageID(message_id)

    async def get_by_cmid(self, cmid: int):
        data = {
            'peer_id': self.peer_id,
            'conversation_message_ids': [cmid]
        }
        res = await self.api.messages.getByConversationMessageId(**data)
        return Message(self.api, res['items'][0])

    def __repr__(self):
        return str(self.raw)


class MessageContext:
    __slots__ = ('api', 'msg', 'db', 'args', 'meta')

    def __init__(self, api, msg, db):
        self.api: VK = api
        self.msg: Message = msg
        self.db: Database = db
        self.args = None
        self.meta = {}

    def __repr__(self):
        return f'<MessageContext{self.msg}({self.args})>'


def load_attachments(raw: list[dict]) -> list[Attachment]:
    attachments = []
    for attachment in raw:
        match attachment['type']:
            case 'photo':
                attachments.append(Photo(attachment))
            case 'doc':
                attachments.append(Document(attachment))
            case 'sticker':
                attachments.append(Sticker(attachment))
            case _:
                attachments.append(VkObject(attachment))
    return attachments


def dump_attachments(raw_attachments: list[Attachment]) -> str:
    return ','.join(map(repr, raw_attachments))


class EventActions:
    SHOW_SNACKBAR = 'show_snackbar'
    OPEN_LINK = 'open_link'
    OPEN_APP = 'open_app'


class MessageID:
    def __init__(self, body):
        if type(body) is dict:
            self.message_id = body.get('message_id', 0)
            self.cmid = body.get('cmid', 0)
        else:
            self.message_id = body
            self.cmid = body