from abc import abstractmethod
from typing import Union

from .iremote import IRemote


class Adapter(IRemote):
    """Adapter to the common interface."""

    @abstractmethod
    def ins(self):
        pass

    @abstractmethod
    def outs(self):
        pass

    @abstractmethod
    def input(self):
        pass

    @abstractmethod
    def output(self):
        pass

    @property
    def identifier(self):
        pass

    def getter(self, index: int = None, direction: str = None) -> Union[int, dict]:
        if index is None:
            return self._remote.get_num_devices(direction)

        vals = self._remote.get_device_description(index, direction)
        types = {1: "mme", 3: "wdm", 4: "ks", 5: "asio"}
        return {"name": vals[0], "type": types[vals[1]], "id": vals[2]}


class Device(Adapter):
    """Defines concrete implementation for device"""

    @classmethod
    def make(cls, remote):
        """
        Factory function for device.

        Returns a Device class of a kind.
        """

        def num_ins(cls) -> int:
            return cls.getter(direction="in")

        def num_outs(cls) -> int:
            return cls.getter(direction="out")

        DEVICE_cls = type(
            f"Device{remote.kind}",
            (cls,),
            {
                "ins": property(num_ins),
                "outs": property(num_outs),
            },
        )
        return DEVICE_cls(remote)

    def __str__(self):
        return f"{type(self).__name__}"

    def input(self, index: int) -> dict:
        return self.getter(index=index, direction="in")

    def output(self, index: int) -> dict:
        return self.getter(index=index, direction="out")