import json

from services.core import get_author
from services.redis import redis
from services.auth import login_required
from services.schema import query
from .chats import create_chat
from .unread import get_unread_counter


# NOTE: not an API handler
async def load_messages(chat_id: str, limit: int = 5, offset: int = 0, ids=[]):
    """load :limit messages for :chat_id with :offset"""
    messages = []
    try:
        message_ids = [] + ids
        if limit:
            mids = await redis.lrange(
                f"chats/{chat_id}/message_ids", offset, offset + limit
            )
            mids = [mid.decode("utf-8") for mid in mids]
            message_ids += mids
        if message_ids:
            message_keys = [f"chats/{chat_id}/messages/{mid}" for mid in message_ids]
            messages = await redis.mget(*message_keys)
            messages = [json.loads(msg.decode("utf-8")) for msg in messages]
            replies = []
            for m in messages:
                rt = m.get("replyTo")
                if rt:
                    rt = int(rt)
                    if rt not in message_ids:
                        replies.append(rt)
            if replies:
                messages += await load_messages(redis, chat_id, limit=0, ids=replies)
    except Exception as e:
        print(e)
    return messages


@query.field("loadChats")
@login_required
async def load_chats(_, info, limit: int = 50, offset: int = 0):
    """load :limit chats of current user with :offset"""
    author_id = info.context["author_id"]
    cids = list(
        (await redis.execute("SMEMBERS", f"chats_by_author/{author_id}")) or []
    )[offset : offset + limit]
    members_online = (await redis.execute("SMEMBERS", "authors-online")) or []
    chats = []
    if len(cids) == 0:
        r = await create_chat(None, info, members=[1])  # member with id = 1 is discours
        cids.append(r["chat"]["id"])
    for cid in cids:
        cid = cid.decode("utf-8")
        c = await redis.execute("GET", "chats/" + cid)
        if c:
            c = dict(json.loads(c))
            c["messages"] = await load_messages(cid, 5, 0)
            c["unread"] = await get_unread_counter(cid, author_id)
            member_ids = c["members"].copy()
            c["members"] = []
            for member_id in member_ids:
                a = await get_author(member_id)
                if a:
                    c["members"].append(
                        {
                            "id": a.id,
                            "slug": a.slug,
                            "userpic": a.userpic,
                            "name": a.name,
                            "lastSeen": a.lastSeen,
                            "online": a.id in members_online,
                        }
                    )
            chats.append(c)
    return {"chats": chats, "error": None}


@query.field("loadMessagesBy")
@login_required
async def load_messages_by(_, info, by, limit: int = 10, offset: int = 0):
    """load :limit messages of :chat_id with :offset"""
    author_id = info.context["author_id"]
    user_chats = await redis.execute("SMEMBERS", "chats_by_author/" + str(author_id))
    user_chats = [c.decode("utf-8") for c in user_chats]
    if user_chats:
        messages = []
        by_chat = by.get("chat")
        if by_chat in user_chats:
            chat = await redis.execute("GET", f"chats/{by_chat}")
            if not chat:
                return {"messages": [], "error": "chat not exist"}
            # everyone's messages in filtered chat
            messages = await load_messages(by_chat, limit, offset)
        return {
            "messages": sorted(list(messages), key=lambda m: m["createdAt"]),
            "error": None,
        }
    else:
        return {"error": "Cannot access messages of this chat"}


@query.field("loadRecipients")
async def load_recipients(_, _info, limit=50, offset=0):
    """load possible chat participants"""
    onliners = (await redis.execute("SMEMBERS", "authors-online")) or []
    members = []
    with local_session() as session:
        all_authors = session.query(Author).limit(limit).offset(offset)
        for a in all_authors:
            members.append(
                {
                    "id": a.id,
                    "slug": a.slug,
                    "userpic": a.userpic,
                    "name": a.name,
                    "lastSeen": a.lastSeen,
                    "online": a.id in onliners,
                }
            )
    return {"members": members, "error": None}


load_resolvers = {
    "Query": {
        "loadRecipients": load_recipients,
        "loadMessagesBy": load_messages_by,
        "loadChats": load_chats,
    }
}