from abc import ABC, abstractmethod
from pyudev import Context, Monitor, MonitorObserver, Device


class Handler(ABC):
    """Abstract Handler calss for device monitoring

    NOTE: No checking are done for overlaping filters and callback will be
    even by multiple handlers.

    Args:
        ABC: Abstract Base Class, provides abstract method functionality and
             readability.
    """

    def __init__(self, filter) -> None:
        """Initiate a monitor observer and applies `filter` if any provided

        Args:
            filter (_type_): _description_
        """
        monitor = Monitor.from_netlink(Context())
        if filter:
            monitor.filter_by(filter)
        self.observer = MonitorObserver(monitor, callback=self.handler)
        self.observer.start()

    @abstractmethod
    def callback(self, device: Device):
        """Callback

        This method must be implemented by child calsses. This method is
        responsible for further managments of the devices related to its filter.

        Args:
            device (pyudev.Device): device passed by observer through handler
        """
        raise NotImplemented("Callback MUST be implemented")

    def handler(self, device):
        """wrapper around callback implemented

        Args:
            device (pyudev.Device): modified device passed by self.observer
        """
        self.callback(device)


class MouseHandler(Handler):
    def __init__(self) -> None:
        """Initiate UsbHanlder

        Initialization contains two major steps. First it would do a
        configuration for currently available devices and then it would wait for
        USB udev events to reconfigure the settings. configurations would be
        done by (This part is not decided yet. it could be done by BASH SCRIPTS
        or we can invoke xinput binaries via python itself. a bash script
        solution would be benefitial since it can used as utility).
        """
        # TODO: use somthing that only captures
        super().__init__("usb")

    def callback(self, device):
        print(device.action)