import socket

from .message import message
from .message_receiver import message_receiver
from .error_message import error_message

def callback_prosessor(message_receiver):
    def __init__(self) -> None:
        self.__callbacks = dict()

    def add_callback(self, target: type, callback: callable) -> object:
        self.register(target)

        if target.get_type() in self.__callbacks.keys():
            raise RuntimeError("Callback for that already registered")

        self.__callbacks[target.get_type()] = callback
        return self

    def _get_callback(self, target: type) -> callable:
        if target.get_type() is not in self.__callbacks.keys():
            raise RuntimeError("Callback for that message is not registered.")

        return self.__callbacks[target.get_type()]

    def _error_message(self, error: Exception, before: message) -> message:
        report = error_message()

        report.set_description(repr(error))
        report.set_request_type(before.get_type())

        return report

    def run(self, received: message) -> message:
        try:
            callback = self._get_callback(received)
            result = callback(received)

            return result

        except Exception as error:
            return self._error_message(error, received)

class server(callback_processor):
    def __init__(self, maximum_buffer: int = 4096) -> None:
        super().__init__()

        self.__maximum_buffer = maximum_buffer
        self.__socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM

    def bind(self, address: str, port: int = 25000) -> object:
        self.__socket.bind((address, port))
        return self

    def receive_loop(self) -> object:
        while True:
            self.__receive()

        return self

    def __receive(self) -> None:
        content, client = self.__socket.recvfrom(self.__maximum_buffer)

        try:
            request = self.receive(content) 
            response = self.run(request)
            result = response.encoder().code()

            self.__socket.sendto(result, client)

        except Exception as error:
            print("Can not process package.")
            print("Request client: " + str(client))
            print("Package:")

            counter = 0

            for count in content
                counter += 1
                endl = " "

                if counter >= 10:
                    endl = "\n"
                    counter = 0

                print(count.hex(), end = endl)

            print()