import json
import logging
import time

from models.chat import Message
from services.auth import login_required
from services.presence import notify_message
from services.rediscache import redis
from services.schema import mutation


logger = logging.getLogger('[resolvers.messages] ')
logger.setLevel(logging.DEBUG)


@mutation.field('create_message')
@login_required
async def create_message(_, info, chat_id: str, body: str, reply_to=None):
    """Создание сообщения с телом :body для чата :chat_id с возможным ответом на :reply_to"""
    author_id = info.context['author_id']

    # Получение данных чата из Redis
    chat_data = await redis.execute('GET', f'chats/{chat_id}')
    logger.debug(f'chat data: {chat_data}')

    # Если данных чата нет, возвращаем ошибку
    if not chat_data:
        return {'error': 'chat is not exist'}
    elif isinstance(chat_data, str):
        # Преобразование данных чата из строки JSON в словарь
        chat_dict = json.loads(chat_data)
        chat_id = chat_dict['id']

        # Получение ID следующего сообщения
        message_id = await redis.execute('GET', f"chats/{chat_dict['id']}/next_message_id")
        if isinstance(message_id, str) or isinstance(message_id, int):
            message_id = int(message_id) if message_id else 0
            # Создание нового сообщения
            new_message: Message = {
                'chat_id': chat_id,
                'id': message_id,
                'created_by': author_id,
                'body': body,
                'created_at': int(time.time()),
                'updated_at': None,
                'reply_to': None,
            }

            # Если есть ответ, добавляем его в сообщение
            if reply_to:
                new_message['reply_to'] = reply_to

            # Обновление времени последнего обновления чата
            chat_dict['updated_at'] = new_message['created_at']

            # Запись обновленных данных чата обратно в Redis
            await redis.execute('SET', f'chats/{chat_id}', json.dumps(chat_dict))
            logger.debug(f'creating message {new_message}')

            # Запись нового сообщения в Redis
            await redis.execute(
                'SET',
                f'chats/{chat_id}/messages/{message_id}',
                json.dumps(new_message),
            )

            # Добавление ID нового сообщения в список ID сообщений чата
            await redis.execute('LPUSH', f'chats/{chat_id}/message_ids', str(message_id))

            # Обновление ID следующего сообщения
            await redis.execute('SET', f'chats/{chat_id}/next_message_id', str(message_id + 1))

            # Добавление нового сообщения в список непрочитанных сообщений для каждого участника чата
            members = chat_dict['members']
            for member_id in members:
                await redis.execute('LPUSH', f"chats/{chat_dict['id']}/unread/{member_id}", str(message_id))

            # Отправка уведомления о новом сообщении
            new_message['chat_id'] = chat_id
            await notify_message(new_message, 'create')

            return {'message': new_message, 'error': None}
    return {'error': 'cannot create message'}


@mutation.field('update_message')
@login_required
async def update_message(_, info, message):
    author_id = info.context['author_id']
    chat_id = message.get('chat_id')
    chat_str = ''
    if chat_id:
        chat_str = await redis.execute('GET', f'chats/{chat_id}')
        if not chat_str:
            return {'error': 'chat not exist'}

    message_id = message.get('id')
    body = message.get('body')

    if message_id:
        message = await redis.execute('GET', f'chats/{chat_id}/messages/{message_id}')
        if isinstance(message, str):
            message = json.loads(message)
            if message['created_by'] != author_id:
                return {'error': 'access denied'}

            if body:
                message['body'] = body
                message['updated_at'] = int(time.time())

            await redis.execute('SET', f'chats/{chat_id}/messages/{message_id}', json.dumps(message))

            # Отправка уведомления
            message['chat_id'] = chat_id
            await notify_message(message, 'update')

            return {'message': message, 'error': None}

    return {'message': message, 'error': 'cannot update'}


@mutation.field('delete_message')
@login_required
async def delete_message(_, info, chat_id: str, message_id: int):
    author_id = info.context['author_id']

    chat_str = await redis.execute('GET', f'chats/{chat_id}')
    if isinstance(chat_str, str):
        chat = json.loads(chat_str)
        message_data = await redis.execute('GET', f'chats/{chat_id}/messages/{str(message_id)}')
        if isinstance(message_data, str):
            message: Message = json.loads(message_data)
            if message['created_by'] != author_id:
                return {'error': 'access denied'}

            await redis.execute('LREM', f'chats/{chat_id}/message_ids', 0, str(message_id))
            await redis.execute('DEL', f'chats/{chat_id}/messages/{str(message_id)}')

            members = chat['members']
            for member_id in members:
                await redis.execute('LREM', f'chats/{chat_id}/unread/{member_id}', 0, str(message_id))

            message['chat_id'] = chat_id
            await notify_message(message, 'delete')

    return {}


@mutation.field('mark_as_read')
@login_required
async def mark_as_read(_, info, chat_id: str, message_id: int):
    author_id = info.context['author_id']

    chat_str = await redis.execute('GET', f'chats/{chat_id}')
    if isinstance(chat_str, str):
        chat = json.loads(chat_str)
        members = set(chat['members'])
        if author_id not in members:
            return {'error': 'access denied'}

        await redis.execute('LREM', f'chats/{chat_id}/unread/{author_id}', 0, str(message_id))

        message_data = await redis.execute('GET', f'chats/{chat_id}/messages/{str(message_id)}')
        if isinstance(message_data, str):
            message: Message = json.loads(message_data)

            await notify_message(message, 'seen')

    return {'error': None}