from .pubsub_router_interface import IPubsubRouter
from .pb import rpc_pb2
from .message import MessageSub, MessageTalk
from .message import create_message_talk

class FloodSub(IPubsubRouter):

    def __init__(self, protocols):
        self.protocols = protocols
        self.pubsub = None

    def get_protocols(self):
        """
        :return: the list of protocols supported by the router
        """
        return self.protocols

    def attach(self, pubsub):
        """
        Attach is invoked by the PubSub constructor to attach the router to a
        freshly initialized PubSub instance.
        :param pubsub: pubsub instance to attach to
        """
        self.pubsub = pubsub

    def add_peer(self, peer_id, protocol_id):
        """
        Notifies the router that a new peer has been connected
        :param peer_id: id of peer to add
        """

    def remove_peer(self, peer_id):
        """
        Notifies the router that a peer has been disconnected
        :param peer_id: id of peer to remove
        """

    def handle_rpc(self, rpc):
        """
        Invoked to process control messages in the RPC envelope.
        It is invoked after subscriptions and payload messages have been processed
        :param rpc: rpc message
        """

    async def publish(self, sender_peer_id, message):
        """
        Invoked to forward a new message that has been validated.
        This is where the "flooding" part of floodsub happens

        With flooding, routing is almost trivial: for each incoming message,
        forward to all known peers in the topic. There is a bit of logic,
        as the router maintains a timed cache of previous messages,
        so that seen messages are not further forwarded.
        It also never forwards a message back to the source
        or the peer that forwarded the message.
        :param sender_peer_id: peer_id of message sender
        :param message: message to forward
        """

        # Encode message
        # encoded_msg = message.encode()

        if isinstance(message, str):
            msg_talk = create_message_talk(message)
            message = rpc_pb2.Message(
            from_id=str(msg_talk.origin_id).encode('utf-8'),
            seqno=str(msg_talk.message_id).encode('utf-8'),
            topicIDs=msg_talk.topics,
            data=msg_talk.data.encode()

            )
        packet = rpc_pb2.RPC()
        print("YEET")
        print(type(message))
        packet.publish.extend([message])



        # Get message sender, origin, and topics
        # msg_talk = create_message_talk(message)
        msg_sender = str(sender_peer_id)
        # msg_origin = msg_talk.origin_id
        # topics = msg_talk.topics

        # Deliver to self if self was origin
        # Note: handle_talk checks if self is subscribed to topics in message
        if msg_sender == message.from_id and msg_sender == str(self.pubsub.host.get_id()):
            old_format = MessageTalk(sender_peer_id,
                                     message.from_id,
                                     message.topicIDs,
                                     message.data,
                                     message.seqno)
            await self.pubsub.handle_talk(old_format)

        # Deliver to self and peers
        for topic in message.topicIDs:
            if topic in self.pubsub.peer_topics:
                for peer_id_in_topic in self.pubsub.peer_topics[topic]:
                    # Forward to all known peers in the topic that are not the
                    # message sender and are not the message origin
                    if peer_id_in_topic not in (msg_sender, message.from_id):
                        stream = self.pubsub.peers[peer_id_in_topic]
                        await stream.write(packet.SerializeToString())
                    else:
                        # Implies publish did not write
                        print("publish did not write")

    def join(self, topic):
        """
        Join notifies the router that we want to receive and
        forward messages in a topic. It is invoked after the
        subscription announcement
        :param topic: topic to join
        """

    def leave(self, topic):
        """
        Leave notifies the router that we are no longer interested in a topic.
        It is invoked after the unsubscription announcement.
        :param topic: topic to leave
        """