efb-qq-plugin-go-cqhttp/efb_qq_plugin_go_cqhttp/GoCQHttp.py

import asyncio
import copy
import logging
import tempfile
import threading
import time
import uuid
from datetime import datetime, timedelta
from typing import Any, BinaryIO, Dict, List, Optional, Tuple, Union

import aiocqhttp
from aiocqhttp import CQHttp, Event
from aiocqhttp.exceptions import NetworkError
from efb_qq_slave import BaseClient, QQMessengerChannel
from ehforwarderbot import Chat, Message, MsgType, Status, coordinator
from ehforwarderbot.chat import (
    ChatMember,
    GroupChat,
    PrivateChat,
    SelfChatMember,
    SystemChatMember,
)
from ehforwarderbot.exceptions import (
    EFBChatNotFound,
    EFBMessageError,
    EFBOperationNotSupported,
)
from ehforwarderbot.message import MessageCommand, MessageCommands
from ehforwarderbot.status import MessageRemoval
from ehforwarderbot.types import ChatID, MessageID
from ehforwarderbot.utils import extra
from hypercorn.asyncio import serve
from hypercorn.config import Config as HyperConfig
from PIL import Image
from quart.logging import create_serving_logger

from .ChatMgr import ChatManager
from .Exceptions import (
    CoolQAPIFailureException,
    CoolQDisconnectedException,
    CoolQOfflineException,
)
from .MsgDecorator import QQMsgProcessor
from .Utils import (
    async_send_messages_to_master,
    coolq_text_encode,
    download_file,
    download_group_avatar,
    download_user_avatar,
    process_quote_text,
    qq_emoji_list,
    strf_time,
)


class GoCQHttp(BaseClient):
    client_name: str = "GoCQHttp Client"
    client_id: str = "GoCQHttp"
    client_config: Dict[str, Any]

    coolq_bot: CQHttp = None
    logger: logging.Logger = logging.getLogger(__name__)
    channel: QQMessengerChannel

    friend_list: List[Dict] = []
    friend_dict: Dict[int, dict] = {}
    stranger_dict: Dict[int, dict] = {}
    group_list: List[Dict] = []
    group_dict: Dict[int, dict] = {}
    group_member_dict: Dict[int, Dict[str, Any]] = {}
    group_member_info_dict: Dict[Tuple[int, int], dict] = {}
    discuss_list: List[Dict] = []
    extra_group_list: List[Dict] = []
    repeat_counter = 0
    update_repeat_counter = 0

    def __init__(self, client_id: str, config: Dict[str, Any], channel):
        super().__init__(client_id, config)
        self.client_config = config[self.client_id]
        self.coolq_bot = CQHttp(
            api_root=self.client_config["api_root"],
            access_token=self.client_config["access_token"],
        )
        self.channel = channel
        self.chat_manager = ChatManager(channel)

        self.is_connected = False
        self.is_logged_in = False
        self.msg_decorator = QQMsgProcessor(instance=self)

        self.loop = asyncio.get_event_loop()
        self.shutdown_event = asyncio.Event()

        asyncio.set_event_loop(self.loop)

        async def forward_msgs_wrapper(msg_elements: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
            fmt_msgs: List[Dict] = []
            for msg in msg_elements:
                from_user = await self.get_user_info(msg["sender"]["user_id"])
                header_text = {"data": {"text": f'{from_user["remark"]}（{from_user["nickname"]}）：\n'}, "type": "text"}
                footer_text = {"data": {"text": "\n- - - - - - - - - - - - - - -\n"}, "type": "text"}
                msg["content"].insert(0, header_text)
                msg["content"].append(footer_text)
                for i, inner_msg in enumerate(msg["content"]):
                    if "content" in inner_msg:
                        if i == 1:
                            fmt_msgs.pop()
                            msg["content"].pop()
                        fmt_msgs += await forward_msgs_wrapper([inner_msg])
                    else:
                        fmt_msgs.append(inner_msg)
            return fmt_msgs

        async def message_element_wrapper(
            context: Dict[str, Any], msg_element: Dict[str, Any], chat: Chat
        ) -> Tuple[str, List[Message], List[Tuple[Tuple[int, int], Union[Chat, ChatMember]]]]:
            msg_type = msg_element["type"]
            msg_data = msg_element["data"]
            main_text: str = ""
            messages: List[Message] = []
            at_list: List[Tuple[Tuple[int, int], Union[Chat, ChatMember]]] = []
            if msg_type == "text":
                main_text = msg_data["text"]
            elif msg_type == "face":
                qq_face = int(msg_data["id"])
                if qq_face in qq_emoji_list:
                    main_text = qq_emoji_list[qq_face]
                else:
                    main_text = "\u2753"  # ❓
            elif msg_type == "sface":
                main_text = "\u2753"  # ❓
            elif msg_type == "at":
                # todo Recheck if bug exists
                g_id = context["group_id"]
                my_uid = await self.get_qq_uid()
                self.logger.debug("My QQ uid: %s\n" "QQ mentioned: %s\n", my_uid, msg_data["qq"])
                if str(msg_data["qq"]) == "all":
                    group_card = "all"
                else:
                    member_info = (await self.get_user_info(msg_data["qq"], group_id=g_id))["in_group_info"]
                    group_card = member_info["card"] if member_info["card"] != "" else member_info["nickname"]
                self.logger.debug("Group card: {}".format(group_card))
                substitution_begin = len(main_text)
                substitution_end = len(main_text) + len(group_card) + 1
                main_text = "@{} ".format(group_card)
                if str(my_uid) == str(msg_data["qq"]) or str(msg_data["qq"]) == "all":
                    at_dict = ((substitution_begin, substitution_end), chat.self)
                    at_list.append(at_dict)
            elif msg_type == "reply":
                ref_user = await self.get_user_info(msg_data["qq"])
                main_text = (
                    f'「{ref_user["remark"]}（{ref_user["nickname"]}）：{msg_data["text"]}」\n'
                    "- - - - - - - - - - - - - - -\n"
                )
            elif msg_type == "forward":
                forward_msgs = (await self.coolq_api_query("get_forward_msg", message_id=msg_data["id"]))["messages"]
                logging.debug(f"Forwarded message: {forward_msgs}")
                fmt_forward_msgs = await forward_msgs_wrapper(forward_msgs)
                logging.debug(f"Formated forwarded message: {forward_msgs}")
                header_msg = {"data": {"text": "合并转发消息开始\n- - - - - - - - - - - - - - -\n"}, "type": "text"}
                footer_msg = {"data": {"text": "合并转发消息结束"}, "type": "text"}
                fmt_forward_msgs.insert(0, header_msg)
                fmt_forward_msgs.append(footer_msg)
                main_text, messages, _ = await message_elements_wrapper(context, fmt_forward_msgs, chat)
                return main_text, messages, []
            else:
                messages.extend(self.call_msg_decorator(msg_type, msg_data, chat))
            return main_text, messages, at_list

        async def message_elements_wrapper(
            context: Dict[str, Any], msg_elements: List[Dict[str, Any]], chat: Chat
        ) -> Tuple[str, List[Message], Dict[Tuple[int, int], Union[Chat, ChatMember]]]:
            messages: List[Message] = []
            main_text: str = ""
            at_dict: Dict[Tuple[int, int], Union[Chat, ChatMember]] = {}
            for msg_element in msg_elements:
                sub_main_text, sub_messages, sub_at_list = await message_element_wrapper(context, msg_element, chat)
                main_text_len = len(main_text)
                for at_tuple in sub_at_list:
                    pos = (
                        at_tuple[0][0] + main_text_len,
                        at_tuple[0][1] + main_text_len,
                    )
                    at_dict[pos] = at_tuple[1]
                main_text += sub_main_text
                messages.extend(sub_messages)
            return main_text, messages, at_dict

        @self.coolq_bot.on_message
        async def handle_msg(context: Event):
            async def _handle_msg():
                self.logger.debug(repr(context))
                msg_elements = context["message"]
                qq_uid = context["user_id"]
                chat: Chat
                author: ChatMember

                # ignore qq guild message
                if context["message_type"] == "guild":
                    return
                user = await self.get_user_info(qq_uid)
                if context["message_type"] == "private":
                    context["alias"] = user["remark"]
                    chat: PrivateChat = await self.chat_manager.build_efb_chat_as_private(context)
                else:
                    chat = await self.chat_manager.build_efb_chat_as_group(context)

                if "anonymous" not in context or context["anonymous"] is None:
                    if context["message_type"] == "group":
                        if context["sub_type"] == "notice":
                            context["event_description"] = "System Notification"
                            context["uid_prefix"] = "group_notification"
                            author = chat.add_system_member(
                                name=context["event_description"],
                                uid=ChatID("__{context[uid_prefix]}__".format(context=context)),
                            )
                        else:
                            user = await self.get_user_info(qq_uid, group_id=context["group_id"])
                            context["nickname"] = user["remark"]
                            if user["is_in_group"]:
                                context["alias"] = user["in_group_info"]["card"]
                            else:
                                context["alias"] = user["remark"]
                            author = await self.chat_manager.build_or_get_efb_member(chat, context)
                    elif context["message_type"] == "private":
                        author = chat.other
                    else:
                        author = await self.chat_manager.build_or_get_efb_member(chat, context)
                else:  # anonymous user in group
                    author = self.chat_manager.build_efb_chat_as_anonymous_user(chat, context)

                main_text, messages, at_dict = await message_elements_wrapper(context, msg_elements, chat)

                if main_text != "":
                    messages.append(self.msg_decorator.qq_text_simple_wrapper(main_text, at_dict))
                coolq_msg_id = context["message_id"]
                for i in range(len(messages)):
                    if not isinstance(messages[i], Message):
                        continue
                    efb_msg: Message = messages[i]
                    efb_msg.uid = (
                        f"{chat.uid.split('_')[-1]}_{coolq_msg_id}_{i}"
                        if i > 0
                        else f"{chat.uid.split('_')[-1]}_{coolq_msg_id}"
                    )
                    efb_msg.chat = chat
                    efb_msg.author = author
                    # if qq_uid != '80000000':

                    # Append discuss group into group list
                    if context["message_type"] == "discuss" and efb_msg.chat not in self.discuss_list:
                        self.discuss_list.append(efb_msg.chat)

                    efb_msg.deliver_to = coordinator.master
                    async_send_messages_to_master(efb_msg)

            asyncio.create_task(_handle_msg())

        @self.coolq_bot.on_notice("group_increase")
        async def handle_group_increase_msg(context: Event):
            context["event_description"] = "\u2139 Group Member Increase Event"
            if (context["sub_type"]) == "invite":
                text = "{nickname}({context[user_id]}) joined the group({group_name}) via invitation"
            else:
                text = "{nickname}({context[user_id]}) joined the group({group_name})"

            original_group = await self.get_group_info(context["group_id"], False)
            group_name = context["group_id"]
            if original_group is not None and "group_name" in original_group:
                group_name = original_group["group_name"]
            text = text.format(
                nickname=(await self.get_stranger_info(context["user_id"]))["nickname"],
                context=context,
                group_name=group_name,
            )

            context["message"] = text
            await self.send_efb_group_notice(context)

        @self.coolq_bot.on_notice("group_decrease")
        async def handle_group_decrease_msg(context: Event):
            context["event_description"] = "\u2139 Group Member Decrease Event"
            original_group = await self.get_group_info(context["group_id"], False)
            group_name = context["group_id"]
            if original_group is not None and "group_name" in original_group:
                group_name = original_group["group_name"]
            text = ""
            if context["sub_type"] == "kick_me":
                text = ("You've been kicked from the group({})").format(group_name)
            else:
                if context["sub_type"] == "leave":
                    text = "{nickname}({context[user_id]}) quited the group({group_name})"
                else:
                    text = "{nickname}({context[user_id]}) was kicked from the group({group_name})"
                text = text.format(
                    nickname=(await self.get_stranger_info(context["user_id"]))["nickname"],
                    context=context,
                    group_name=group_name,
                )
            context["message"] = text
            await self.send_efb_group_notice(context)

        @self.coolq_bot.on_notice("group_admin")
        async def handle_group_admin_msg(context: Event):
            context["event_description"] = "\u2139 Group Admin Change Event"
            if (context["sub_type"]) == "set":
                text = "{nickname}({context[user_id]}) has been appointed as the group({group_name}) administrator"
            else:
                text = "{nickname}({context[user_id]}) has been de-appointed as the group({group_name}) administrator"

            original_group = await self.get_group_info(context["group_id"], False)
            group_name = context["group_id"]
            if original_group is not None and "group_name" in original_group:
                group_name = original_group["group_name"]
            text = text.format(
                nickname=(await self.get_stranger_info(context["user_id"]))["nickname"],
                context=context,
                group_name=group_name,
            )

            context["message"] = text
            await self.send_efb_group_notice(context)

        @self.coolq_bot.on_notice("group_ban")
        async def handle_group_ban_msg(context: Event):
            context["event_description"] = "\u2139 Group Member Restrict Event"
            if (context["sub_type"]) == "ban":
                text = (
                    "{nickname}({context[user_id]}) "
                    "is restricted for speaking for {time} at the group({group_name}) by "
                    "{nickname_}({context[operator_id]})"
                )
                time_text = strf_time(context["duration"])
            else:
                text = (
                    "{nickname}({context[user_id]}) "
                    "is lifted from restrictions at the group({group_name}) by "
                    "{nickname_}({context[operator_id]}){time}"
                )
                time_text = ""

            original_group = await self.get_group_info(context["group_id"], False)
            group_name = context["group_id"]
            if original_group is not None and "group_name" in original_group:
                group_name = original_group["group_name"]
            text = text.format(
                nickname=(await self.get_stranger_info(context["user_id"]))["nickname"],
                context=context,
                time=time_text,
                group_name=group_name,
                nickname_=(await self.get_stranger_info(context["operator_id"]))["nickname"],
            )

            context["message"] = text
            await self.send_efb_group_notice(context)

        @self.coolq_bot.on_notice("offline_file")
        async def handle_offline_file_upload_msg(context: Event):
            async def _handle_offline_file_upload_msg():
                context["event_description"] = "\u2139 Offline File Upload Event"
                context["uid_prefix"] = "offline_file"
                file_info_msg = ("Filename: {file[name]}\n" "File size: {file[size]}").format(file=context["file"])
                user = await self.get_user_info(context["user_id"])
                text = "{remark}({nickname}) uploaded a file to you\n"
                text = text.format(remark=user["remark"], nickname=user["nickname"]) + file_info_msg
                context["message"] = text
                self.send_msg_to_master(context)
                param_dict = {
                    "context": context,
                    "download_url": context["file"]["url"],
                }
                await self.async_download_file(**param_dict)

            asyncio.create_task(_handle_offline_file_upload_msg())

        @self.coolq_bot.on_notice("group_upload")
        async def handle_group_file_upload_msg(context: Event):
            async def _handle_group_file_upload_msg():
                context["event_description"] = "\u2139 Group File Upload Event"
                context["uid_prefix"] = "group_upload"
                original_group = await self.get_group_info(context["group_id"], False)
                group_name = context["group_id"]
                if original_group is not None and "group_name" in original_group:
                    group_name = original_group["group_name"]

                file_info_msg = ("File ID: {file[id]}\n" "Filename: {file[name]}\n" "File size: {file[size]}").format(
                    file=context["file"]
                )
                member_info = (await self.get_user_info(context["user_id"], group_id=context["group_id"]))[
                    "in_group_info"
                ]
                group_card = member_info["card"] if member_info["card"] != "" else member_info["nickname"]
                text = "{member_card}({context[user_id]}) uploaded a file to group({group_name})\n"
                text = text.format(member_card=group_card, context=context, group_name=group_name) + file_info_msg
                context["message"] = text
                await self.send_efb_group_notice(context)

                param_dict = {
                    "context": context,
                    "group_id": context["group_id"],
                    "file_id": context["file"]["id"],
                    "busid": context["file"]["busid"],
                }
                self.async_download_group_file(**param_dict)

            asyncio.create_task(_handle_group_file_upload_msg())

        @self.coolq_bot.on_notice("friend_add")
        async def handle_friend_add_msg(context: Event):
            context["event_description"] = "\u2139 New Friend Event"
            context["uid_prefix"] = "friend_add"
            text = "{nickname}({context[user_id]}) has become your friend!"
            text = text.format(
                nickname=(await self.get_stranger_info(context["user_id"]))["nickname"],
                context=context,
            )
            context["message"] = text
            self.send_msg_to_master(context)

        @self.coolq_bot.on_notice("group_recall")
        async def handle_group_recall_msg(context: Event):
            coolq_msg_id = context["message_id"]
            chat = GroupChat(channel=self.channel, uid=f"group_{context['group_id']}")

            efb_msg = Message(chat=chat, uid=MessageID(f"{chat.uid.split('_')[-1]}_{coolq_msg_id}"))
            coordinator.send_status(
                MessageRemoval(source_channel=self.channel, destination_channel=coordinator.master, message=efb_msg)
            )

        @self.coolq_bot.on_notice("friend_recall")
        async def handle_friend_recall_msg(context: Event):
            coolq_msg_id = context["message_id"]

            try:
                chat: PrivateChat = await self.chat_manager.build_efb_chat_as_private(context)
            except Exception:
                return
            efb_msg = Message(chat=chat, uid=MessageID(f"{chat.uid.split('_')[-1]}_{coolq_msg_id}"))
            coordinator.send_status(
                MessageRemoval(source_channel=self.channel, destination_channel=coordinator.master, message=efb_msg)
            )

        @self.coolq_bot.on_request("friend")  # Add friend request
        async def handle_add_friend_request(context: Event):
            self.logger.debug(repr(context))
            context["event_description"] = "\u2139 New Friend Request"
            context["uid_prefix"] = "friend_request"
            text = (
                "{nickname}({context[user_id]}) wants to be your friend!\n"
                "Here is the verification comment:\n"
                "{context[comment]}"
            )
            text = text.format(
                nickname=(await self.get_stranger_info(context["user_id"]))["nickname"],
                context=context,
            )
            context["message"] = text
            commands = [
                MessageCommand(
                    name=("Accept"),
                    callable_name="process_friend_request",
                    kwargs={"result": "accept", "flag": context["flag"]},
                ),
                MessageCommand(
                    name=("Decline"),
                    callable_name="process_friend_request",
                    kwargs={"result": "decline", "flag": context["flag"]},
                ),
            ]
            context["commands"] = commands
            self.send_msg_to_master(context)

        @self.coolq_bot.on_request("group")
        async def handle_group_request(context: Event):
            self.logger.debug(repr(context))
            context["uid_prefix"] = "group_request"
            context["group_name"] = ("[Request]") + (await self.get_group_info(context["group_id"]))["group_name"]
            context["group_id_orig"] = context["group_id"]
            context["group_id"] = str(context["group_id"]) + "_notification"
            context["message_type"] = "group"
            context["event_description"] = "\u2139 New Group Join Request"
            original_group = await self.get_group_info(context["group_id_orig"], False)
            group_name = context["group_id"]
            if original_group is not None and "group_name" in original_group:
                group_name = original_group["group_name"]
            msg = Message()
            msg.uid = "group" + "_" + str(context["group_id"])
            msg.author = (self.chat_manager.build_efb_chat_as_system_user(context)).other
            msg.chat = await self.chat_manager.build_efb_chat_as_group(context)
            msg.deliver_to = coordinator.master
            msg.type = MsgType.Text
            name = ""
            if not await self.get_friend_remark(context["user_id"]):
                name = "{}({})[{}] ".format(
                    (await self.get_stranger_info(context["user_id"]))["nickname"],
                    await self.get_friend_remark(context["user_id"]),
                    context["user_id"],
                )
            else:
                name = "{}[{}] ".format(
                    (await self.get_stranger_info(context["user_id"]))["nickname"],
                    context["user_id"],
                )
            msg.text = "{} wants to join the group {}({}). \nHere is the comment: {}".format(
                name, group_name, context["group_id_orig"], context["comment"]
            )
            msg.commands = MessageCommands(
                [
                    MessageCommand(
                        name=("Accept"),
                        callable_name="process_group_request",
                        kwargs={
                            "result": "accept",
                            "flag": context["flag"],
                            "sub_type": context["sub_type"],
                        },
                    ),
                    MessageCommand(
                        name=("Decline"),
                        callable_name="process_group_request",
                        kwargs={
                            "result": "decline",
                            "flag": context["flag"],
                            "sub_type": context["sub_type"],
                        },
                    ),
                ]
            )
            coordinator.send_message(msg)

        asyncio.run(self.check_status_periodically(run_once=True))

    def run_instance(self, host: str, port: int, debug: bool = False):
        def _run():
            config = HyperConfig()
            config.access_log_format = "%(h)s %(r)s %(s)s %(b)s %(D)s"
            access_logger = create_serving_logger()
            access_logger.setLevel(logging.WARNING)
            config.accesslog = access_logger
            config.bind = [f"{host}:{port}"]
            if debug is not None:
                self.debug = debug
                config.use_reloader = debug
            config.errorlog = config.accesslog

            self.loop.create_task(serve(self.coolq_bot.server_app, config, shutdown_trigger=self.shutdown_event.wait))
            self.loop.create_task(self.check_status_periodically())
            self.loop.create_task(self.update_contacts_periodically())
            self.loop.run_forever()

        self.t = threading.Thread(target=_run)
        self.t.daemon = True
        self.t.start()

    def relogin(self):
        raise NotImplementedError

    def logout(self):
        raise NotImplementedError

    @extra(
        name=("Check CoolQ Status"),
        desc=("Force efb-qq-slave to refresh status from CoolQ Client.\n" "Usage: {function_name}"),
    )
    def login(self, param: str = ""):
        asyncio.run(self.check_status_periodically(run_once=True))
        return "Done"

    async def get_stranger_info(self, user_id: int, no_cache: bool = False) -> Dict[str, Any]:
        user_id = int(user_id)
        return await self.get_user_info(user_id, no_cache=no_cache)

    async def get_login_info(self) -> Dict[Any, Any]:
        res = await self.coolq_bot.get_status()
        if "good" in res or "online" in res:
            data = await self.coolq_bot.get_login_info()
            return {
                "status": 0,
                "data": {"uid": data["user_id"], "nickname": data["nickname"]},
            }
        else:
            return {"status": 1}

    async def get_groups(self) -> List:
        # todo Add support for discuss group iteration
        await self.update_group_list()  # Force update group list
        res = self.group_list
        # res = self.coolq_bot.get_group_list()
        groups = []
        for i in range(len(res)):
            context = {"message_type": "group", "group_id": res[i]["group_id"]}
            efb_chat = await self.chat_manager.build_efb_chat_as_group(context)
            groups.append(efb_chat)
        for i in range(len(self.extra_group_list)):
            does_exist = False
            for _j in range(len(res)):
                if str(self.extra_group_list[i]["group_id"]) == str(res[i]["group_id"]):
                    does_exist = True
                    break
            if does_exist:
                continue
            context = {
                "message_type": "group",
                "group_id": self.extra_group_list[i]["group_id"],
            }
            efb_chat = await self.chat_manager.build_efb_chat_as_group(context)
            groups.append(efb_chat)
        return groups + self.discuss_list

    async def get_friends(self) -> List:
        try:
            await self.update_friend_list()  # Force update friend list
        except CoolQAPIFailureException:
            self.deliver_alert_to_master(("Failed to retrieve the friend list.\n" "Only groups are shown."))
            return []
        users = []
        for current_user in self.friend_list:
            context = {
                "user_id": str(current_user["user_id"]),
                "nickname": current_user["nickname"],
                "alias": current_user["remark"],
            }
            efb_chat = await self.chat_manager.build_efb_chat_as_private(context)
            users.append(efb_chat)
        return users

    def receive_message(self):
        # Replaced by handle_msg()
        pass

    def send_message(self, msg: "Message") -> "Message":
        # todo Add support for edited message
        """
        self.logger.info("[%s] Sending message to WeChat:\n"
                         "uid: %s\n"
                         "Type: %s\n"
                         "Text: %s\n"
                         "Target Chat: %s\n"
                         "Target uid: %s\n",
                         msg.uid,
                         msg.chat.chat_uid, msg.type, msg.text, repr(msg.target.chat), msg.target.uid)
        """
        m = QQMsgProcessor(instance=self)
        chat_type = msg.chat.uid.split("_")

        self.logger.debug("[%s] Is edited: %s", msg.uid, msg.edit)
        if msg.edit:
            try:
                uid_type = msg.uid.split("_")
                asyncio.run(self.recall_message(uid_type[1]))
            except CoolQAPIFailureException:
                raise EFBOperationNotSupported(
                    ("Failed to recall the message!\n" "This message may have already expired.")
                )

        if msg.type in [MsgType.Text, MsgType.Link]:
            if msg.text == "kick`":
                group_id = chat_type[1]
                user_id = msg.target.author.uid
                asyncio.run(self.coolq_api_query("set_group_kick", group_id=group_id, user_id=user_id))
            else:
                if isinstance(msg.target, Message):
                    max_length = 50
                    tgt_text = coolq_text_encode(process_quote_text(msg.target.text, max_length))
                    tgt_alias = ""
                    if chat_type[0] != "private" and not isinstance(msg.target.author, SelfChatMember):
                        tgt_alias += m.coolq_code_at_wrapper(msg.target.author.uid)
                    else:
                        tgt_alias = ""
                    msg.text = "%s%s\n\n%s" % (
                        tgt_alias,
                        tgt_text,
                        coolq_text_encode(msg.text),
                    )
                msg.uid = asyncio.run(self.coolq_send_message(chat_type[0], chat_type[1], msg.text))
                self.logger.debug("[%s] Sent as a text message. %s", msg.uid, msg.text)
        elif msg.type in (MsgType.Image, MsgType.Sticker, MsgType.Animation):
            self.logger.info("[%s] Image/Sticker/Animation %s", msg.uid, msg.type)
            text = ""
            if msg.type != MsgType.Sticker:
                text += m.coolq_code_image_wrapper(msg.file, msg.path)
            else:
                with tempfile.NamedTemporaryFile(suffix=".gif") as f:
                    img = Image.open(msg.file)
                    try:
                        alpha = img.split()[3]
                        mask = Image.eval(alpha, lambda a: 255 if a <= 128 else 0)
                    except IndexError:
                        mask = Image.eval(img.split()[0], lambda a: 0)
                    img = img.convert("RGB").convert("P", palette=Image.ADAPTIVE, colors=255)
                    img.paste(255, mask)
                    img.save(f, transparency=255)
                    msg.file.close()
                    f.seek(0)
                    text += m.coolq_code_image_wrapper(f, f.name)
            if msg.text:
                msg.uid = asyncio.run(
                    self.coolq_send_message(chat_type[0], chat_type[1], text + coolq_text_encode(msg.text))
                )
            else:
                msg.uid = asyncio.run(self.coolq_send_message(chat_type[0], chat_type[1], text))
        # todo More MsgType Support
        elif msg.type is MsgType.Voice:
            text = m.coolq_voice_image_wrapper(msg.file, msg.path)
            msg.uid = asyncio.run(self.coolq_send_message(chat_type[0], chat_type[1], text))
            if msg.text:
                asyncio.run(self.coolq_send_message(chat_type[0], chat_type[1], msg.text))
        return msg

    def call_msg_decorator(self, msg_type: str, *args) -> List[Message]:
        try:
            func = getattr(self.msg_decorator, "qq_{}_wrapper".format(msg_type))
        except AttributeError:
            msg = f"Unsupported message type: {msg_type}"
            self.logger.error(msg)
            return self.msg_decorator.qq_unsupported_wrapper(msg)
        else:
            return func(*args)

    async def get_qq_uid(self):
        res = await self.get_login_info()
        if res["status"] == 0:
            return res["data"]["uid"]
        else:
            return None

    async def get_group_member_list(self, group_id, no_cache=False) -> List[Dict[str, Any]]:
        if (
            no_cache
            or (group_id not in self.group_member_dict)
            or (datetime.now() - self.group_member_dict[group_id]["time"] > timedelta(hours=1))
        ):  # Force Update
            try:
                member_list = await self.coolq_api_query("get_group_member_list", group_id=group_id, no_cache=no_cache)
            except CoolQAPIFailureException as e:
                self.deliver_alert_to_master(("Failed the get group member detail.") + "{}".format(e))
                return []
            self.group_member_dict[group_id] = {
                "members": member_list,
                "time": datetime.now(),
            }
        return self.group_member_dict[group_id]["members"]

    async def get_user_info(self, user_id: int, group_id: Optional[str] = None, no_cache=False):
        user_id = int(user_id)
        if no_cache or (not self.friend_list) or (user_id not in self.friend_dict):
            await self.update_friend_list()
        friend = self.friend_dict.get(user_id)
        if friend:
            user = copy.deepcopy(friend)
            user["is_friend"] = True
        else:
            if no_cache:
                stranger = await self.coolq_api_query("get_stranger_info", user_id=user_id)
                self.stranger_dict[user_id] = stranger
            stranger = self.stranger_dict.get(user_id)
            if stranger is None:
                stranger = await self.coolq_api_query("get_stranger_info", user_id=user_id)
                self.stranger_dict[user_id] = stranger
            user = copy.deepcopy(stranger)
            user["is_friend"] = False
        if group_id is not None:
            user["is_in_group"] = False
            member = next(
                filter(lambda member: member["user_id"] == user_id, await self.get_group_member_list(group_id)), None
            )
            if member is None:
                member = next(
                    filter(
                        lambda member: member["user_id"] == user_id,
                        await self.get_group_member_list(group_id, no_cache=True),
                    ),
                    None,
                )
            if member is not None:
                user["is_in_group"] = True
                user["in_group_info"] = member
        remark = user.get("remark")
        if not remark:
            user["remark"] = user["nickname"]
        return user

    async def get_group_info(self, group_id, no_cache=False):
        if no_cache or not self.group_list:
            await self.update_group_list()
        group = self.group_dict.get(group_id)
        if group:
            return group
        if no_cache:
            for extra_group in self.extra_group_list:
                if extra_group["group_id"] == group_id:
                    return extra_group
        try:
            external_group = await self.get_external_group_info(group_id)
        except CoolQAPIFailureException:
            self.logger.error(f"Get external group({group_id}) info failed.")
            return None
        else:
            self.extra_group_list.append(external_group)
            return external_group

    async def coolq_send_message(self, msg_type, uid, message):
        keyword = msg_type if msg_type != "private" else "user"
        res = await self.coolq_api_query("send_msg", message_type=msg_type, **{keyword + "_id": uid}, message=message)
        return str(uid) + "_" + str(res["message_id"])

    async def _coolq_api_wrapper(self, func_name, **kwargs):
        try:
            res = await self.coolq_bot.call_action(func_name, **kwargs)
        except NetworkError as e:
            raise CoolQDisconnectedException(("Unable to connect to CoolQ Client!" "Error Message:\n{}").format(str(e)))
        except aiocqhttp.Error as ex:
            api_ex = CoolQAPIFailureException(
                ("CoolQ HTTP API encountered an error!\n" "Status Code:{} " "Return Code:{}").format(
                    ex.status_code, ex.retcode
                )
            )
            api_ex.status_code = ex.status_code
            api_ex.retcode = ex.retcode
            raise api_ex
        else:
            return res

    async def check_running_status(self):
        res = await self._coolq_api_wrapper("get_status")
        if res["good"] or res["online"]:
            return True
        else:
            raise CoolQOfflineException(("CoolQ Client isn't working correctly!"))

    async def coolq_api_query(self, func_name, **kwargs) -> Any:
        """# Do not call get_status too frequently
        if self.check_running_status():
            return self._coolq_api_wrapper(func_name, **kwargs)
        """
        if self.is_logged_in and self.is_connected:
            return await self._coolq_api_wrapper(func_name, **kwargs)
        elif self.repeat_counter < 3:
            self.deliver_alert_to_master(("Your status is offline.\n" "You may try login with /0_login"))
            self.repeat_counter += 1

    async def check_status_periodically(self, run_once: bool = False):
        interval = 300
        while True:
            self.logger.debug("Start checking status...")
            flag = True
            try:
                flag = await self.check_running_status()
            except CoolQDisconnectedException as e:
                if self.repeat_counter < 3:
                    self.deliver_alert_to_master(
                        (
                            "We're unable to communicate with CoolQ Client.\n"
                            "Please check the connection and credentials provided.\n"
                            "{}"
                        ).format(str(e))
                    )
                    self.repeat_counter += 1
                self.is_connected = False
                self.is_logged_in = False
                interval = 3600
            except (CoolQOfflineException, CoolQAPIFailureException):
                if self.repeat_counter < 3:
                    self.deliver_alert_to_master(
                        (
                            "CoolQ is running in abnormal status.\n"
                            "You may need to relogin your account "
                            "or have a check in CoolQ Client.\n"
                        )
                    )
                    self.repeat_counter += 1
                self.is_connected = True
                self.is_logged_in = False
                interval = 3600
            else:
                if not flag:
                    if self.repeat_counter < 3:
                        self.deliver_alert_to_master(
                            (
                                "We don't know why, but status check failed.\n"
                                "Please enable debug mode and consult the log "
                                "for more details."
                            )
                        )
                        self.repeat_counter += 1
                    self.is_connected = True
                    self.is_logged_in = False
                    interval = 3600
                else:
                    self.logger.debug("Status: OK")
                    self.is_connected = True
                    self.is_logged_in = True
                    self.repeat_counter = 0
            if run_once:
                return
            await asyncio.sleep(interval)

    def deliver_alert_to_master(self, message: str):
        context = {
            "message": message,
            "uid_prefix": "alert",
            "event_description": ("CoolQ Alert"),
        }
        self.send_msg_to_master(context)

    async def update_friend_list(self):
        self.friend_list = await self.coolq_api_query("get_friend_list")
        if self.friend_list:
            self.logger.debug("Update friend list completed. Entries: %s", len(self.friend_list))
            for friend in self.friend_list:
                if friend["remark"] == "":
                    friend["remark"] = friend["nickname"]
                self.friend_dict[friend["user_id"]] = friend
        else:
            self.logger.warning("Failed to update friend list")

    async def update_group_list(self):
        self.group_list = await self.coolq_api_query("get_group_list")
        if self.group_list:
            self.logger.debug("Update group list completed. Entries: %s", len(self.group_list))
            for group in self.group_list:
                self.group_dict[group["group_id"]] = group
        else:
            self.logger.warning("Failed to update group list")

    async def update_contacts_periodically(self, run_once: bool = False):
        interval = 1800
        while True:
            self.logger.debug("Start updating friend & group list")
            if self.is_connected and self.is_logged_in:
                try:
                    await self.update_friend_list()
                    await self.update_group_list()
                except CoolQAPIFailureException as ex:
                    if (ex.status_code) == 200 and (ex.retcode) == 104 and self.update_repeat_counter < 3:
                        self.send_cookie_expired_alarm()
                    if self.update_repeat_counter < 3:
                        self.deliver_alert_to_master(("Errors occurred when updating contacts: ") + (ex.message))
                        self.update_repeat_counter += 1
                else:
                    self.update_repeat_counter = 0
            self.logger.debug("Update completed")
            if run_once:
                return
            await asyncio.sleep(interval)

    async def get_friend_remark(self, uid):
        if (not self.friend_list) or (uid not in self.friend_dict):
            await self.update_friend_list()
        if uid not in self.friend_dict:
            return None  # I don't think you have such a friend
        return self.friend_dict[uid]["remark"]

    async def send_efb_group_notice(self, context):
        context["message_type"] = "group"
        self.logger.debug(repr(context))
        chat = await self.chat_manager.build_efb_chat_as_group(context)
        try:
            author = chat.get_member(SystemChatMember.SYSTEM_ID)
        except KeyError:
            author = chat.add_system_member()
        event_description = context.get("event_description", "")
        msg = Message(
            uid="__group_notice__.%s" % int(time.time()),
            type=MsgType.Text,
            chat=chat,
            author=author,
            text=(event_description + "\n\n" + context["message"]) if event_description else context["message"],
            deliver_to=coordinator.master,
        )
        coordinator.send_message(msg)

    def send_msg_to_master(self, context):
        self.logger.debug(repr(context))
        if not getattr(coordinator, "master", None):  # Master Channel not initialized
            raise Exception(context["message"])
        chat = self.chat_manager.build_efb_chat_as_system_user(context)
        try:
            author = chat.get_member(SystemChatMember.SYSTEM_ID)
        except KeyError:
            author = chat.add_system_member()
        msg = Message(
            uid="__{context[uid_prefix]}__.{uni_id}".format(context=context, uni_id=str(int(time.time()))),
            type=MsgType.Text,
            chat=chat,
            author=author,
            deliver_to=coordinator.master,
        )

        if "message" in context:
            msg.text = context["message"]
        if "commands" in context:
            msg.commands = MessageCommands(context["commands"])
        coordinator.send_message(msg)

    # As the old saying goes
    # A programmer spent 20% of time on coding
    # while the rest 80% on considering a variable/function/class name
    async def get_external_group_info(self, group_id):  # Special thanks to @lwl12 for thinking of this name
        res = await self.coolq_api_query("get_group_info", group_id=group_id)
        return res

    def send_status(self, status: "Status"):
        if isinstance(status, MessageRemoval):
            if not isinstance(status.message.author, SelfChatMember):
                raise EFBMessageError(("You can only recall your own messages."))
            try:
                uid_type = status.message.uid.split("_")
                asyncio.run(self.recall_message(uid_type[1]))
            except CoolQAPIFailureException:
                raise EFBMessageError(("Failed to recall the message. This message may have already expired."))
        else:
            raise EFBOperationNotSupported()
        # todo

    async def recall_message(self, message_id):
        await self.coolq_api_query("delete_msg", message_id=message_id)

    def send_cookie_expired_alarm(self):
        self.deliver_alert_to_master(
            (
                "Your cookie of CoolQ Client seems to be expired. "
                "Although it will not affect the normal functioning of sending/receiving "
                "messages, however, you may encounter issues like failing to retrieve "
                "friend list. Please consult "
                "https://github.com/milkice233/efb-qq-slave/wiki/Workaround-for-expired"
                "-cookies-of-CoolQ for solutions."
            )
        )

    async def process_friend_request(self, result, flag):
        res = "true" if result == "accept" else "false"
        try:
            await self.coolq_api_query("set_friend_add_request", approve=res, flag=flag)
        except CoolQAPIFailureException as e:
            return ("Failed to process request! Error Message:\n") + getattr(e, "message", repr(e))
        return "Done"

    async def process_group_request(self, result, flag, sub_type):
        res = "true" if result == "accept" else "false"
        try:
            await self.coolq_api_query("set_group_add_request", approve=res, flag=flag, sub_type=sub_type)
        except CoolQAPIFailureException as e:
            return ("Failed to process request! Error Message:\n") + getattr(e, "message", repr(e))
        return "Done"

    async def async_download_file(self, context, download_url):
        res = download_file(download_url)
        if isinstance(res, str):
            context["message"] = ("[Download] ") + res
            await self.send_efb_group_notice(context)
        elif res is None:
            pass
        else:
            data = {"file": res, "filename": context["file"]["name"]}
            context["message_type"] = "group"
            efb_msg = self.msg_decorator.qq_file_after_wrapper(data)
            efb_msg.uid = str(context["user_id"]) + "_" + str(uuid.uuid4()) + "_" + str(1)
            efb_msg.text = "Sent a file\n{}".format(context["file"]["name"])
            if context["uid_prefix"] == "offline_file":
                efb_msg.chat = asyncio.run(self.chat_manager.build_efb_chat_as_private(context))
            elif context["uid_prefix"] == "group_upload":
                efb_msg.chat = asyncio.run(self.chat_manager.build_efb_chat_as_group(context))
            efb_msg.author = asyncio.run(self.chat_manager.build_or_get_efb_member(efb_msg.chat, context))
            efb_msg.deliver_to = coordinator.master
            async_send_messages_to_master(efb_msg)

    async def async_download_group_file(self, context, group_id, file_id, busid):
        file = await self.coolq_api_query("get_group_file_url", group_id=group_id, file_id=file_id, busid=busid)
        download_url = file["url"]
        await self.async_download_file(context, download_url)

    def get_chat_picture(self, chat: "Chat") -> BinaryIO:
        chat_type = chat.uid.split("_")
        if chat_type[0] == "private":
            return download_user_avatar(chat_type[1])
        elif chat_type[0] == "group":
            return download_group_avatar(chat_type[1])
        else:
            return download_group_avatar("")

    def get_chats(self):
        async def _get_chats():
            return await asyncio.gather(self.get_friends(), self.get_groups())

        friend_chats, group_chats = asyncio.run(_get_chats())
        return friend_chats + group_chats

    def get_chat(self, chat_uid: ChatID) -> "Chat":
        # todo what is member_uid used for?
        chat_type = chat_uid.split("_")
        if chat_type[0] == "private":
            qq_uid = int(chat_type[1])
            remark = asyncio.run(self.get_friend_remark(qq_uid))
            context: Dict[str, Any] = {"user_id": qq_uid}
            if remark is not None:
                context["alias"] = remark
            return asyncio.run(self.chat_manager.build_efb_chat_as_private(context))
        elif chat_type[0] == "group":
            group_id = int(chat_type[1])
            context = {"message_type": "group", "group_id": group_id}
            return asyncio.run(self.chat_manager.build_efb_chat_as_group(context, update_member=True))
        elif chat_type[0] == "discuss":
            discuss_id = int(chat_type[1])
            context = {"message_type": "discuss", "discuss_id": discuss_id}
            return asyncio.run(self.chat_manager.build_efb_chat_as_group(context))
        raise EFBChatNotFound()

    async def check_self_update(self, run_once: bool = False):
        interval = 60 * 60 * 24
        while True:
            latest_version = self.channel.check_updates()
            if latest_version is not None:
                self.deliver_alert_to_master(
                    "New version({version}) of EFB-QQ-Slave has released! "
                    "Please manually update EQS by stopping ehForwarderbot first and then execute "
                    "<code>pip3 install --upgrade efb-qq-slave</code>".format(version=latest_version)
                )
            else:
                pass
            if run_once:
                return
            await asyncio.sleep(interval)

    def poll(self):
        asyncio.run(self.check_self_update(run_once=True))
        self.run_instance(
            host=self.client_config["host"],
            port=self.client_config["port"],
            debug=False,
        )

    def stop_polling(self):
        self.logger.debug("Gracefully stopping QQ Slave")
        self.shutdown_event.set()
        self.loop.stop()
        self.t.join()