import abc
import logging

logger = logging.getLogger(__name__)


class IDCA(abc.ABC):
    """Abstract Base Class for DCA groups"""

    def __init__(self, remote, index: int):
        self._remote = remote
        self.index = index + 1
        self.logger = logger.getChild(self.__class__.__name__)

    def getter(self, param: str) -> tuple:
        return self._remote.query(f"{self.address}/{param}")

    def setter(self, param: str, val: int):
        self._remote.send(f"{self.address}/{param}", val)

    @abc.abstractmethod
    def address(self):
        pass


class DCA(IDCA):
    """Concrete class for DCA groups"""

    @property
    def address(self) -> str:
        return f"/dca/{self.index}"

    @property
    def on(self) -> bool:
        return self.getter("on")[0] == 1

    @on.setter
    def on(self, val: bool):
        self.setter("on", 1 if val else 0)

    @property
    def mute(self) -> bool:
        return not self.on

    @mute.setter
    def mute(self, val: bool):
        self.on = not val

    @property
    def name(self) -> str:
        return self.getter("config/name")[0]

    @name.setter
    def name(self, val: str):
        self.setter("config/name", val)

    @property
    def color(self) -> int:
        return self.getter("config/color")[0]

    @color.setter
    def color(self, val: int):
        self.setter("config/color", val)