import json
from datetime import datetime, timezone, timedelta
from services.auth import login_required
from services.core import get_network
from services.redis import redis
from resolvers.load import load_messages
from ariadne import QueryType

query = QueryType()


@query.field("searchRecipients")
@login_required
async def search_recipients(_, info, text: str, limit: int = 50, offset: int = 0):
    result = []
    # TODO: maybe redis scan?
    author_id = info.context["author_id"]
    talk_before = await redis.execute("GET", f"/chats_by_author/{author_id}")
    if talk_before:
        talk_before = list(json.loads(talk_before))[offset : (offset + limit)]
        for chat_id in talk_before:
            members = await redis.execute("GET", f"/chats/{chat_id}/members")
            if members:
                members = list(json.loads(members))
                for member in members:
                    if member.startswith(text):
                        if member not in result:
                            result.append(member)

    more_amount = limit - len(result)
    if more_amount > 0:
        result += await get_network(author_id, more_amount)
    return {"members": list(result), "error": None}


@query.field("searchMessages")
@login_required
async def search_in_chats(_, info, by, limit, offset):
    author_id = info.context["author_id"]
    lookup_chats = set(await redis.execute("SMEMBERS", f"chats_by_author/{author_id}"))
    messages_set = set([])

    by_member = by.get("author")
    body_like = by.get("body")
    days_ago = by.get("days")

    # pre-filter lookup chats
    if by_member:
        # all author's chats where reqeusting author is participating
        lookup_chats = filter(
            lambda ca: by_member in ca["members"],
            list(lookup_chats),
        )

    # load the messages from lookup chats
    for c in lookup_chats:
        chat_id = c.decode("utf-8")
        mmm = await load_messages(chat_id, limit, offset)
        if by_member:
            mmm = filter(lambda mx: mx["author"] == by_member, mmm)
        if body_like:
            mmm = filter(lambda mx: body_like in mx["body"], mmm)
        if days_ago:
            mmm = filter(
                lambda msg: datetime.now(tz=timezone.utc) - int(msg["createdAt"])
                < timedelta(days=days_ago),
                mmm,
            )

        messages_set.union(set(mmm))
    messages_sorted = list(messages_set).sort()
    return {"messages": messages_sorted, "error": None}


search_resolvers = {
    "Query": {
        "searchMessages": search_in_chats,
        "searchRecipients": search_recipients,
    }
}