#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020-02-09 15:52
# @Author  : Lemon
# @File    : callback.py
# @Software: PyCharm
import logging
from threading import Thread

from fbchat import ThreadType, Message, \
    ShareAttachment, FileAttachment, AudioAttachment, VideoAttachment, ImageAttachment, Sticker, LocationAttachment

from lib import common
from lib.facebook import FacebookClient
from lib.sqlhelper import UserList, Status
from munch import Munch

log = logging.getLogger(__name__)


class CallBack():

    def _notify_(self, type_, client, body: dict):
        print('【%s】' % type_, body)

    def _task_(self, type_, client, taskid: int, code: int, msg: dict = None):
        print('【%s】' % type_, code, msg)

    def onLoggingIn(self, email, password, cookie, user_agent=None):
        user_obj = UserList.get(email=email)
        if not user_obj:
            user_obj = UserList.insert(email=email, password=password, status=Status.LOGGINE, cookie=cookie,
                                       user_agent=user_agent)
        else:
            user_obj.set(status=Status.LOGGINE)

        return user_obj

    def onLoggedIn(self, client: FacebookClient):
        client.user_obj.set(
            fbid=client.uid,
            status=Status.ONLINE,
            cookie=client.get_cookie(),
            user_agent=client.get_user_agent()
        )

        self._notify_(
            type_="account",
            client=client,
            body={'event': 'onUpdateMyInfo', 'info': client.info()}
        )
        t = Thread(target=client.listen, name=client.email, args=(True,))
        t.setDaemon(True)
        t.start()

    def onLoggingError(self, email, reason, taskid=0):

        u = UserList.get(email=email)
        if u: u.set(status=Status.FAILED)

        client = Munch(email=email)
        self._notify_(
            type_="account",
            client=client,
            body={'event': 'onLoginFailed', 'reason': reason}
        )

    def onLogout(self, client):
        client.user_obj.set(status=Status.OFFLINE)

        self._notify_(
            type_="account",
            client=client,
            body={'event': 'onLogout', 'cookie': client.get_cookie()}
        )

    def onListening(self, client):
        self._notify_(
            type_="account",
            client=client,
            body={'cookie': client.get_cookie(), 'event': 'onLoginSuccess'}
        )

    def onListenError(self, client: FacebookClient, exception=None):
        self._notify_(
            type_="error",
            client=client,
            body={'msg': "Got exception while listening {}".format(exception)}
        )
        return True

    def onMessage(
            self,
            client: FacebookClient,
            mid=None,
            author_id=None,
            message=None,
            message_object: Message = None,
            thread_id=None,
            thread_type=ThreadType.USER,
            ts=None,
            metadata=None,
            msg=None,
    ):
        client.markAsDelivered(thread_id, message_object.uid)
        client.markAsRead(thread_id)

        body = {
            "to": client.uid,
            "msgId": mid,
            "from": thread_id,
            "timeInMillis": ts
        }

        if thread_type == ThreadType.GROUP:
            body['roomSender'] = author_id

        if message_object.text:
            body['content'] = message_object.text
            self._notify_(type_="textMsg", client=client, body=body)
        else:
            self._fixattachments(message_object, msg)

            if message_object.attachments:
                msg = message_object.attachments[0]
                if isinstance(msg, ShareAttachment):
                    body.update(common.todict(msg))
                    self._notify_(type_="linkMsg", client=client, body=body)
                elif isinstance(msg, FileAttachment):
                    body.update(common.todict(msg))
                    self._notify_(type_="fileMsg", client=client, body=body)
                elif isinstance(msg, AudioAttachment):
                    body.update(common.todict(msg))
                    self._notify_(type_="voiceMsg", client=client, body=body)
                elif isinstance(msg, VideoAttachment):
                    body.update(common.todict(msg))
                    self._notify_(type_="videoMsg", client=client, body=body)
                elif isinstance(msg, ImageAttachment):
                    body.update(common.todict(msg))
                    self._notify_(type_="imageMsg", client=client, body=body)
                else:
                    body.update(common.todict(msg))
                    self._notify_(type_="unknownMsg", client=client, body=body)
            elif message_object.sticker:
                body.update(common.todict(message_object.sticker))
                self._notify_(type_="stickerMsg", client=client, body=body)
            else:
                print(message_object)

    def _fixattachments(self, message_object, msg):
        if msg.get("attachments") and not message_object.attachments:
            try:
                data = msg.get("attachments")[0]['mercury']['extensible_attachment']['story_attachment']
                if data.get("target", {}).get('__typename') == 'User':
                    message_object.attachments.append(ShareAttachment._from_graphql(data))
            except:
                pass

    def onColorChange(
            self,
            client: FacebookClient,
            mid=None,
            author_id=None,
            new_color=None,
            thread_id=None,
            thread_type=ThreadType.USER,
            ts=None,
            metadata=None,
            msg=None,
    ):
        body = {
            'actorFbId': msg['messageMetadata']['actorFbId'],
            'adminText': msg['messageMetadata']['adminText'],
            'type': msg['type'],
            'class': msg['class'],
            'thread_id': thread_id,
            'thread_type': thread_type.name,
        }
        body.update(msg['untypedData'])
        self._notify_(type_="colorChange", client=client, body=body)

    def onEmojiChange(
            self,
            client: FacebookClient,
            mid=None,
            author_id=None,
            new_emoji=None,
            thread_id=None,
            thread_type=ThreadType.USER,
            ts=None,
            metadata=None,
            msg=None,
    ):
        body = {
            'new_emoji': new_emoji,
            'actorFbId': msg['messageMetadata']['actorFbId'],
            'adminText': msg['messageMetadata']['adminText'],
            'type': msg['type'],
            'class': msg['class'],
            'thread_id': thread_id,
            'thread_type': thread_type.name,
        }
        body.update(msg['untypedData'])
        self._notify_(type_="emojiChange", client=client, body=body)

    def onTitleChange(
            self,
            client: FacebookClient,
            mid=None,
            author_id=None,
            new_title=None,
            thread_id=None,
            thread_type=ThreadType.USER,
            ts=None,
            metadata=None,
            msg=None,
    ):
        body = {
            'new_title': new_title,
            'actorFbId': msg['messageMetadata']['actorFbId'],
            'adminText': msg['messageMetadata']['adminText'],
            'type': msg['type'],
            'class': msg['class'],
            'thread_id': thread_id,
            'thread_type': thread_type.name,
        }
        body.update(msg['untypedData'])
        self._notify_(type_="nicknameChange", client=client, body=body)

    def onImageChange(
            self,
            client: FacebookClient,
            mid=None,
            author_id=None,
            new_image=None,
            thread_id=None,
            thread_type=ThreadType.GROUP,
            ts=None,
            msg=None,
    ):
        log.info("{} changed thread image in {}".format(author_id, thread_id))

    def onNicknameChange(
            self,
            client: FacebookClient,
            mid=None,
            author_id=None,
            changed_for=None,
            new_nickname=None,
            thread_id=None,
            thread_type=ThreadType.USER,
            ts=None,
            metadata=None,
            msg=None,
    ):
        body = {
            'new_nickname': new_nickname,
            'actorFbId': msg['messageMetadata']['actorFbId'],
            'adminText': msg['messageMetadata']['adminText'],
            'type': msg['type'],
            'class': msg['class'],
            'thread_id': thread_id,
            'thread_type': thread_type.name,
        }
        body.update(msg['untypedData'])
        self._notify_(type_="nicknameChange", client=client, body=body)

    def onAdminAdded(
            self,
            client: FacebookClient,
            mid=None,
            added_id=None,
            author_id=None,
            thread_id=None,
            thread_type=ThreadType.GROUP,
            ts=None,
            msg=None,
    ):
        log.info("{} added admin: {} in {}".format(author_id, added_id, thread_id))

    def onAdminRemoved(
            self,
            client: FacebookClient,
            mid=None,
            removed_id=None,
            author_id=None,
            thread_id=None,
            thread_type=ThreadType.GROUP,
            ts=None,
            msg=None,
    ):
        log.info("{} removed admin: {} in {}".format(author_id, removed_id, thread_id))

    def onApprovalModeChange(
            self,
            client: FacebookClient,
            mid=None,
            approval_mode=None,
            author_id=None,
            thread_id=None,
            thread_type=ThreadType.GROUP,
            ts=None,
            msg=None,
    ):
        """Called when the client is listening, and somebody changes approval mode in a group.

        Args:
            mid: The action ID
            approval_mode: True if approval mode is activated
            author_id: The ID of the person who changed approval mode
            thread_id: Thread ID that the action was sent to. See :ref:`intro_threads`
            ts: A timestamp of the action
            msg: A full set of the data received
        """
        if approval_mode:
            log.info("{} activated approval mode in {}".format(author_id, thread_id))
        else:
            log.info("{} disabled approval mode in {}".format(author_id, thread_id))

    def onMessageSeen(
            self,
            client: FacebookClient,
            seen_by=None,
            thread_id=None,
            thread_type=ThreadType.USER,
            seen_ts=None,
            ts=None,
            metadata=None,
            msg=None,
    ):
        """Called when the client is listening, and somebody marks a message as seen.

        Args:
            seen_by: The ID of the person who marked the message as seen
            thread_id: Thread ID that the action was sent to. See :ref:`intro_threads`
            thread_type (ThreadType): Type of thread that the action was sent to. See :ref:`intro_threads`
            seen_ts: A timestamp of when the person saw the message
            ts: A timestamp of the action
            metadata: Extra metadata about the action
            msg: A full set of the data received
        """
        log.info(
            "Messages seen by {} in {} ({}) at {}s".format(
                seen_by, thread_id, thread_type.name, seen_ts / 1000
            )
        )

    def onMessageDelivered(
            self,
            client: FacebookClient,
            msg_ids=None,
            delivered_for=None,
            thread_id=None,
            thread_type=ThreadType.USER,
            ts=None,
            metadata=None,
            msg=None,
    ):
        """Called when the client is listening, and somebody marks messages as delivered.

        Args:
            msg_ids: The messages that are marked as delivered
            delivered_for: The person that marked the messages as delivered
            thread_id: Thread ID that the action was sent to. See :ref:`intro_threads`
            thread_type (ThreadType): Type of thread that the action was sent to. See :ref:`intro_threads`
            ts: A timestamp of the action
            metadata: Extra metadata about the action
            msg: A full set of the data received
        """
        log.info(
            "Messages {} delivered to {} in {} ({}) at {}s".format(
                msg_ids, delivered_for, thread_id, thread_type.name, ts / 1000
            )
        )

    def onMarkedSeen(
            self, client: FacebookClient, threads=None, seen_ts=None, ts=None, metadata=None, msg=None
    ):
        """Called when the client is listening, and the client has successfully marked threads as seen.

        Args:
            threads: The threads that were marked
            author_id: The ID of the person who changed the emoji
            seen_ts: A timestamp of when the threads were seen
            ts: A timestamp of the action
            metadata: Extra metadata about the action
            msg: A full set of the data received
        """
        log.info(
            "Marked messages as seen in threads {} at {}s".format(
                [(x[0], x[1].name) for x in threads], seen_ts / 1000
            )
        )

    def onMessageUnsent(
            self,
            client: FacebookClient,
            mid=None,
            author_id=None,
            thread_id=None,
            thread_type=None,
            ts=None,
            msg=None,
    ):
        """Called when the client is listening, and someone unsends (deletes for everyone) a message.

        Args:
            mid: ID of the unsent message
            author_id: The ID of the person who unsent the message
            thread_id: Thread ID that the action was sent to. See :ref:`intro_threads`
            thread_type (ThreadType): Type of thread that the action was sent to. See :ref:`intro_threads`
            ts: A timestamp of the action
            msg: A full set of the data received
        """
        log.info(
            "{} unsent the message {} in {} ({}) at {}s".format(
                author_id, repr(mid), thread_id, thread_type.name, ts / 1000
            )
        )

    def onPeopleAdded(
            self,
            client: FacebookClient,
            mid=None,
            added_ids=None,
            author_id=None,
            thread_id=None,
            ts=None,
            msg=None,
    ):
        """Called when the client is listening, and somebody adds people to a group thread.

        Args:
            mid: The action ID
            added_ids: The IDs of the people who got added
            author_id: The ID of the person who added the people
            thread_id: Thread ID that the action was sent to. See :ref:`intro_threads`
            ts: A timestamp of the action
            msg: A full set of the data received
        """
        log.info(
            "{} added: {} in {}".format(author_id, ", ".join(added_ids), thread_id)
        )

    def onPersonRemoved(
            self,
            client: FacebookClient,
            mid=None,
            removed_id=None,
            author_id=None,
            thread_id=None,
            ts=None,
            msg=None,
    ):
        """Called when the client is listening, and somebody removes a person from a group thread.

        Args:
            mid: The action ID
            removed_id: The ID of the person who got removed
            author_id: The ID of the person who removed the person
            thread_id: Thread ID that the action was sent to. See :ref:`intro_threads`
            ts: A timestamp of the action
            msg: A full set of the data received
        """
        log.info("{} removed: {} in {}".format(author_id, removed_id, thread_id))

    def onFriendRequest(self, client: FacebookClient, from_id=None, msg=None):
        """Called when the client is listening, and somebody sends a friend request.

        Args:
            from_id: The ID of the person that sent the request
            msg: A full set of the data received
        """
        from_id = str(from_id)
        log.info("Friend request from {}".format(from_id))
        try:
            info = client._fetchInfo(from_id)[from_id]
            info.pop("type")
        except:
            info = {"id": from_id}
        self._notify_('friendRequest', client, body=info)

    def _onSeen(self, client: FacebookClient, locations=None, ts=None, msg=None):
        """
        Todo:
            Document this, and make it public

        Args:
            locations: ---
            ts: A timestamp of the action
            msg: A full set of the data received
        """

    def onInbox(self, client: FacebookClient, unseen=None, unread=None, recent_unread=None, msg=None):
        """
        Todo:
            Documenting this

        Args:
            unseen: --
            unread: --
            recent_unread: --
            msg: A full set of the data received
        """
        log.info("Inbox event: {}, {}, {}".format(unseen, unread, recent_unread))

    def onTyping(
            self, client: FacebookClient, author_id=None, status=None, thread_id=None, thread_type=None,
            msg=None
    ):
        """Called when the client is listening, and somebody starts or stops typing into a chat.

        Args:
            author_id: The ID of the person who sent the action
            status (TypingStatus): The typing status
            thread_id: Thread ID that the action was sent to. See :ref:`intro_threads`
            thread_type (ThreadType): Type of thread that the action was sent to. See :ref:`intro_threads`
            msg: A full set of the data received
        """
        print("onTyping")

    def onGamePlayed(
            self,
            client: FacebookClient,
            mid=None,
            author_id=None,
            game_id=None,
            game_name=None,
            score=None,
            leaderboard=None,
            thread_id=None,
            thread_type=None,
            ts=None,
            metadata=None,
            msg=None,
    ):
        """Called when the client is listening, and somebody plays a game.

        Args:
            mid: The action ID
            author_id: The ID of the person who played the game
            game_id: The ID of the game
            game_name: Name of the game
            score: Score obtained in the game
            leaderboard: Actual leader board of the game in the thread
            thread_id: Thread ID that the action was sent to. See :ref:`intro_threads`
            thread_type (ThreadType): Type of thread that the action was sent to. See :ref:`intro_threads`
            ts: A timestamp of the action
            metadata: Extra metadata about the action
            msg: A full set of the data received
        """
        log.info(
            '{} played "{}" in {} ({})'.format(
                author_id, game_name, thread_id, thread_type.name
            )
        )

    def onReactionAdded(
            self,
            client: FacebookClient,
            mid=None,
            reaction=None,
            author_id=None,
            thread_id=None,
            thread_type=None,
            ts=None,
            msg=None,
    ):
        """Called when the client is listening, and somebody reacts to a message.

        Args:
            mid: Message ID, that user reacted to
            reaction (MessageReaction): Reaction
            add_reaction: Whether user added or removed reaction
            author_id: The ID of the person who reacted to the message
            thread_id: Thread ID that the action was sent to. See :ref:`intro_threads`
            thread_type (ThreadType): Type of thread that the action was sent to. See :ref:`intro_threads`
            ts: A timestamp of the action
            msg: A full set of the data received
        """
        body = {
            'thread_id': thread_id,
            'thread_type': thread_type.name,
            'author_id': author_id,
            'mid': mid,
            'action': 'add',
            'reaction': reaction.value
        }
        self._notify_('reactionMsg', client, body=body)

    def onReactionRemoved(
            self,
            client: FacebookClient,
            mid=None,
            author_id=None,
            thread_id=None,
            thread_type=None,
            ts=None,
            msg=None,
    ):
        """Called when the client is listening, and somebody removes reaction from a message.

        Args:
            mid: Message ID, that user reacted to
            author_id: The ID of the person who removed reaction
            thread_id: Thread ID that the action was sent to. See :ref:`intro_threads`
            thread_type (ThreadType): Type of thread that the action was sent to. See :ref:`intro_threads`
            ts: A timestamp of the action
            msg: A full set of the data received
        """
        body = {
            'thread_id': thread_id,
            'thread_type': thread_type.name,
            'author_id': author_id,
            'mid': mid,
            'action': 'remove',
        }
        self._notify_('reactionMsg', client, body=body)

    def onBlock(
            self, client: FacebookClient, author_id=None, thread_id=None, thread_type=None, ts=None, msg=None
    ):
        """Called when the client is listening, and somebody blocks client.

        Args:
            author_id: The ID of the person who blocked
            thread_id: Thread ID that the action was sent to. See :ref:`intro_threads`
            thread_type (ThreadType): Type of thread that the action was sent to. See :ref:`intro_threads`
            ts: A timestamp of the action
            msg: A full set of the data received
        """
        log.info(
            "{} blocked {} ({}) thread".format(author_id, thread_id, thread_type.name)
        )

    def onUnblock(
            self, client: FacebookClient, author_id=None, thread_id=None, thread_type=None, ts=None, msg=None
    ):
        """Called when the client is listening, and somebody blocks client.

        Args:
            author_id: The ID of the person who unblocked
            thread_id: Thread ID that the action was sent to. See :ref:`intro_threads`
            thread_type (ThreadType): Type of thread that the action was sent to. See :ref:`intro_threads`
            ts: A timestamp of the action
            msg: A full set of the data received
        """
        log.info(
            "{} unblocked {} ({}) thread".format(author_id, thread_id, thread_type.name)
        )

    def onLiveLocation(
            self,
            client: FacebookClient,
            mid=None,
            location=None,
            author_id=None,
            thread_id=None,
            thread_type=None,
            ts=None,
            msg=None,
    ):
        """Called when the client is listening and somebody sends live location info.

        Args:
            mid: The action ID
            location (LiveLocationAttachment): Sent location info
            author_id: The ID of the person who sent location info
            thread_id: Thread ID that the action was sent to. See :ref:`intro_threads`
            thread_type (ThreadType): Type of thread that the action was sent to. See :ref:`intro_threads`
            ts: A timestamp of the action
            msg: A full set of the data received
        """
        log.info(
            "{} sent live location info in {} ({}) with latitude {} and longitude {}".format(
                author_id, thread_id, thread_type, location.latitude, location.longitude
            )
        )

    def onCallStarted(
            self,
            client: FacebookClient,
            mid=None,
            caller_id=None,
            is_video_call=None,
            thread_id=None,
            thread_type=None,
            ts=None,
            metadata=None,
            msg=None,
    ):
        """Called when the client is listening, and somebody starts a call in a group.

        Todo:
            Make this work with private calls.

        Args:
            mid: The action ID
            caller_id: The ID of the person who started the call
            is_video_call: True if it's video call
            thread_id: Thread ID that the action was sent to. See :ref:`intro_threads`
            thread_type (ThreadType): Type of thread that the action was sent to. See :ref:`intro_threads`
            ts: A timestamp of the action
            metadata: Extra metadata about the action
            msg: A full set of the data received
        """
        log.info(
            "{} started call in {} ({})".format(caller_id, thread_id, thread_type.name)
        )

    def onCallEnded(
            self,
            client: FacebookClient,
            mid=None,
            caller_id=None,
            is_video_call=None,
            call_duration=None,
            thread_id=None,
            thread_type=None,
            ts=None,
            metadata=None,
            msg=None,
    ):
        """Called when the client is listening, and somebody ends a call in a group.

        Todo:
            Make this work with private calls.

        Args:
            mid: The action ID
            caller_id: The ID of the person who ended the call
            is_video_call: True if it was video call
            call_duration: Call duration in seconds
            thread_id: Thread ID that the action was sent to. See :ref:`intro_threads`
            thread_type (ThreadType): Type of thread that the action was sent to. See :ref:`intro_threads`
            ts: A timestamp of the action
            metadata: Extra metadata about the action
            msg: A full set of the data received
        """
        log.info(
            "{} ended call in {} ({})".format(caller_id, thread_id, thread_type.name)
        )

    def onUserJoinedCall(
            self,
            client: FacebookClient,
            mid=None,
            joined_id=None,
            is_video_call=None,
            thread_id=None,
            thread_type=None,
            ts=None,
            metadata=None,
            msg=None,
    ):
        """Called when the client is listening, and somebody joins a group call.

        Args:
            mid: The action ID
            joined_id: The ID of the person who joined the call
            is_video_call: True if it's video call
            thread_id: Thread ID that the action was sent to. See :ref:`intro_threads`
            thread_type (ThreadType): Type of thread that the action was sent to. See :ref:`intro_threads`
            ts: A timestamp of the action
            metadata: Extra metadata about the action
            msg: A full set of the data received
        """
        log.info(
            "{} joined call in {} ({})".format(joined_id, thread_id, thread_type.name)
        )

    def onPollCreated(
            self,
            client: FacebookClient,
            mid=None,
            poll=None,
            author_id=None,
            thread_id=None,
            thread_type=None,
            ts=None,
            metadata=None,
            msg=None,
    ):
        """Called when the client is listening, and somebody creates a group poll.

        Args:
            mid: The action ID
            poll (Poll): Created poll
            author_id: The ID of the person who created the poll
            thread_id: Thread ID that the action was sent to. See :ref:`intro_threads`
            thread_type (ThreadType): Type of thread that the action was sent to. See :ref:`intro_threads`
            ts: A timestamp of the action
            metadata: Extra metadata about the action
            msg: A full set of the data received
        """
        log.info(
            "{} created poll {} in {} ({})".format(
                author_id, poll, thread_id, thread_type.name
            )
        )

    def onPollVoted(
            self,
            client: FacebookClient,
            mid=None,
            poll=None,
            added_options=None,
            removed_options=None,
            author_id=None,
            thread_id=None,
            thread_type=None,
            ts=None,
            metadata=None,
            msg=None,
    ):
        """Called when the client is listening, and somebody votes in a group poll.

        Args:
            mid: The action ID
            poll (Poll): Poll, that user voted in
            author_id: The ID of the person who voted in the poll
            thread_id: Thread ID that the action was sent to. See :ref:`intro_threads`
            thread_type (ThreadType): Type of thread that the action was sent to. See :ref:`intro_threads`
            ts: A timestamp of the action
            metadata: Extra metadata about the action
            msg: A full set of the data received
        """
        log.info(
            "{} voted in poll {} in {} ({})".format(
                author_id, poll, thread_id, thread_type.name
            )
        )

    def onPlanCreated(
            self,
            client: FacebookClient,
            mid=None,
            plan=None,
            author_id=None,
            thread_id=None,
            thread_type=None,
            ts=None,
            metadata=None,
            msg=None,
    ):
        """Called when the client is listening, and somebody creates a plan.

        Args:
            mid: The action ID
            plan (Plan): Created plan
            author_id: The ID of the person who created the plan
            thread_id: Thread ID that the action was sent to. See :ref:`intro_threads`
            thread_type (ThreadType): Type of thread that the action was sent to. See :ref:`intro_threads`
            ts: A timestamp of the action
            metadata: Extra metadata about the action
            msg: A full set of the data received
        """
        log.info(
            "{} created plan {} in {} ({})".format(
                author_id, plan, thread_id, thread_type.name
            )
        )

    def onPlanEnded(
            self,
            client: FacebookClient,
            mid=None,
            plan=None,
            thread_id=None,
            thread_type=None,
            ts=None,
            metadata=None,
            msg=None,
    ):
        """Called when the client is listening, and a plan ends.

        Args:
            mid: The action ID
            plan (Plan): Ended plan
            thread_id: Thread ID that the action was sent to. See :ref:`intro_threads`
            thread_type (ThreadType): Type of thread that the action was sent to. See :ref:`intro_threads`
            ts: A timestamp of the action
            metadata: Extra metadata about the action
            msg: A full set of the data received
        """
        log.info(
            "Plan {} has ended in {} ({})".format(plan, thread_id, thread_type.name)
        )

    def onPlanEdited(
            self,
            client: FacebookClient,
            mid=None,
            plan=None,
            author_id=None,
            thread_id=None,
            thread_type=None,
            ts=None,
            metadata=None,
            msg=None,
    ):
        """Called when the client is listening, and somebody edits a plan.

        Args:
            mid: The action ID
            plan (Plan): Edited plan
            author_id: The ID of the person who edited the plan
            thread_id: Thread ID that the action was sent to. See :ref:`intro_threads`
            thread_type (ThreadType): Type of thread that the action was sent to. See :ref:`intro_threads`
            ts: A timestamp of the action
            metadata: Extra metadata about the action
            msg: A full set of the data received
        """
        log.info(
            "{} edited plan {} in {} ({})".format(
                author_id, plan, thread_id, thread_type.name
            )
        )

    def onPlanDeleted(
            self,
            client: FacebookClient,
            mid=None,
            plan=None,
            author_id=None,
            thread_id=None,
            thread_type=None,
            ts=None,
            metadata=None,
            msg=None,
    ):
        """Called when the client is listening, and somebody deletes a plan.

        Args:
            mid: The action ID
            plan (Plan): Deleted plan
            author_id: The ID of the person who deleted the plan
            thread_id: Thread ID that the action was sent to. See :ref:`intro_threads`
            thread_type (ThreadType): Type of thread that the action was sent to. See :ref:`intro_threads`
            ts: A timestamp of the action
            metadata: Extra metadata about the action
            msg: A full set of the data received
        """
        log.info(
            "{} deleted plan {} in {} ({})".format(
                author_id, plan, thread_id, thread_type.name
            )
        )

    def onPlanParticipation(
            self,
            client: FacebookClient,
            mid=None,
            plan=None,
            take_part=None,
            author_id=None,
            thread_id=None,
            thread_type=None,
            ts=None,
            metadata=None,
            msg=None,
    ):
        """Called when the client is listening, and somebody takes part in a plan or not.

        Args:
            mid: The action ID
            plan (Plan): Plan
            take_part (bool): Whether the person takes part in the plan or not
            author_id: The ID of the person who will participate in the plan or not
            thread_id: Thread ID that the action was sent to. See :ref:`intro_threads`
            thread_type (ThreadType): Type of thread that the action was sent to. See :ref:`intro_threads`
            ts: A timestamp of the action
            metadata: Extra metadata about the action
            msg: A full set of the data received
        """
        if take_part:
            log.info(
                "{} will take part in {} in {} ({})".format(
                    author_id, plan, thread_id, thread_type.name
                )
            )
        else:
            log.info(
                "{} won't take part in {} in {} ({})".format(
                    author_id, plan, thread_id, thread_type.name
                )
            )

    def onQprimer(self, client: FacebookClient, ts=None, msg=None):
        """Called when the client just started listening.

        Args:
            ts: A timestamp of the action
            msg: A full set of the data received
        """
        pass

    def onChatTimestamp(self, client: FacebookClient, buddylist=None, msg=None):
        """Called when the client receives chat online presence update.

        Args:
            buddylist: A list of dictionaries with friend id and last seen timestamp
            msg: A full set of the data received
        """
        log.debug("Chat Timestamps received: {}".format(buddylist))

    def onBuddylistOverlay(self, client: FacebookClient, statuses=None, msg=None):
        """Called when the client is listening and client receives information about friend active status.

        Args:
            statuses (dict): Dictionary with user IDs as keys and :class:`ActiveStatus` as values
            msg: A full set of the data received
        """

    def onUnknownMesssageType(self, client: FacebookClient, msg=None):
        """Called when the client is listening, and some unknown data was received.

        Args:
            msg: A full set of the data received
        """
        log.debug("Unknown message received: {}".format(msg))

    def onMessageError(self, client: FacebookClient, exception=None, msg=None):
        """Called when an error was encountered while parsing received data.

        Args:
            exception: The exception that was encountered
            msg: A full set of the data received
        """
        log.exception("Exception in parsing of {}".format(msg))