crystalfontz.dbus.domain

class ConfigM:
    """
    Map `Config` to and from `ConfigT`
    (`Tuple[Optional[str], str, str, str, str, int, float, int]`).
    """

    t: ClassVar[str] = struct(
        FileM,
        PortM,
        ModelM,
        RevisionM,
        RevisionM,
        BaudRateM,
        TimeoutM,
        RetryTimesM,
    )

    @staticmethod
    def pack(config: Config) -> ConfigT:
        """
        Pack `Config` to `ConfigT`.
        """

        return (
            FileM.pack(config.file),
            config.port,
            config.model,
            RevisionM.pack(config.hardware_rev),
            RevisionM.pack(config.firmware_rev),
            config.baud_rate,
            TimeoutM.pack(config.timeout),
            RetryTimesM.pack(config.retry_times),
        )

    @staticmethod
    def unpack(config: ConfigT) -> Config:
        """
        Unpack `ConfigT` to `Config`.
        """

        (
            file,
            port,
            model,
            hardware_rev,
            firmware_rev,
            baud_rate,
            timeout,
            retry_times,
        ) = config

        return cast(Any, Config)(
            file=file,
            port=port,
            model=model,
            hardware_rev=RevisionM.unpack(hardware_rev),
            firmware_rev=RevisionM.unpack(firmware_rev),
            baud_rate=baud_rate,
            timeout=TimeoutM.unpack(timeout),
            retry_times=RetryTimesM.unpack(retry_times),
        )

class CursorStyleM:
    """
    Map `CursorStyle` to and from `CursorStyleT` (`int`).
    """

    t: ClassVar[str] = "q"

    @staticmethod
    def pack(style: CursorStyle) -> CursorStyleT:
        """
        Pack `CursorStyle` to `CursorStyleT`.
        """

        return style.value

    @staticmethod
    def unpack(style: CursorStyleT) -> CursorStyle:
        """
        Unpack `CursorStyleT` to `CursorStyle`.
        """

        return CURSOR_STYLES[style]

class DowDeviceInformationM:
    """
    Map `DowDeviceInformation` to and from `DowDeviceInformationT`
    (`Tuple[int, int]`).
    """

    t: ClassVar[str] = t(IndexM, "t")

    @staticmethod
    def pack(info: DowDeviceInformation) -> DowDeviceInformationT:
        return (info.index, info.rom_id)

    @staticmethod
    def unpack(info: DowDeviceInformationT) -> DowDeviceInformation:
        """
        Unpack `DowDeviceInformation` to `DowDeviceInformationT`.
        """

        index, rom_id = info
        return DowDeviceInformation(index, rom_id)

class DowTransactionResultM:
    """
    Map `DowTransactionResult` to and from `DowTransactionResultT`
    (`Tuple[int, bytes, int]`).
    """

    t: ClassVar[str] = t(IndexM, BytesM, Uint16M)

    @staticmethod
    def pack(res: DowTransactionResult) -> DowTransactionResultT:
        return (res.index, res.data, res.crc)

    @staticmethod
    def unpack(res: DowTransactionResultT) -> DowTransactionResult:
        """
        Unpack `DowTransactionResultT` to `DowTransactionResult`.
        """

        index, data, crc = res
        return DowTransactionResult(index, data, crc)

class GpioReadM:
    """
    Map `GpioRead` to and from `GpioReadT`
    (`Tuple[int, Tuple[bool, bool, bool], int, int]`).
    """

    t: ClassVar[str] = t(IndexM, struct(GpioStateM), ByteM, GpioSettingsM)

    @staticmethod
    def pack(gpio_read: GpioRead) -> GpioReadT:
        return (
            gpio_read.index,
            GpioStateM.pack(gpio_read.state),
            gpio_read.requested_level,
            GpioSettingsM.pack(gpio_read.settings),
        )

    @staticmethod
    def unpack(gpio_read: GpioReadT) -> GpioRead:
        """
        Unpack `GpioReadT` to `GpioRead`.
        """

        index, state, requested_level, settings = gpio_read
        return GpioRead(
            index=index,
            state=GpioStateM.unpack(state),
            requested_level=requested_level,
            settings=GpioSettingsM.unpack(settings),
        )

class KeyActivityReportM:
    """
    Map `KeyActivityReport` to and from `KeyActivityReportT`
    """

    t: ClassVar[str] = KeyActivityM.t

    @staticmethod
    def pack(report: KeyActivityReport) -> KeyActivityReportT:
        return KeyActivityM.pack(report.activity)

    @staticmethod
    def unpack(report: KeyActivityReportT) -> KeyActivityReport:
        return KeyActivityReport(KeyActivityM.unpack(report))

class KeypadBrightnessM(OptFloatM):
    """
    Map `Optional[float]` to and from `KeypadBrightnessT` (`float`).

    `KeypadBrightnessM` is an alias for `OptFloatM`.
    """

    t: ClassVar[str] = OptFloatM.t

class KeypadPolledM:
    """
    Map `KeypadPolled` to and from `KeypadPolledT`
    (`Tuple[KeyStateT, KeyStateT, KeyStateT, KeyStateT, KeyStateT, KeyStateT]`,
    where `KeyStateT = Tuple[bool, bool, bool]`).
    """

    t: ClassVar[str] = KeyStatesM.t

    @staticmethod
    def pack(polled: KeypadPolled) -> KeyStatesT:
        return KeyStatesM.pack(polled.states)

    @staticmethod
    def unpack(polled: KeypadPolledT) -> KeypadPolled:
        """
        Unpack `KeypadPolledT` to `KeypadPolled`.
        """

        return KeypadPolled(KeyStatesM.unpack(polled))

class LcdMemoryM:
    """
    Map `LcdMemory` to and from `LcdMemoryT` (`Tuple[int, bytes]`).
    """

    t: ClassVar[str] = t(AddressM, BytesM)

    @staticmethod
    def pack(memory: LcdMemory) -> LcdMemoryT:
        return (memory.address, memory.data)

    @staticmethod
    def unpack(obj: LcdMemoryT) -> LcdMemory:
        """
        Unpack `LcdMemoryT` to `LcdMemory`.
        """

        address, buff = obj
        return LcdMemory(address, buff)

class LcdRegisterM:
    """
    Map `LcdRegister` to and from `LcdRegisterT` (`bool`).
    """

    t: ClassVar[str] = "b"

    @staticmethod
    def pack(register: LcdRegister) -> LcdRegisterT:
        return bool(register.value)

    @staticmethod
    def unpack(register: LcdRegisterT) -> LcdRegister:
        return LCD_REGISTERS[register]

class OptBytesM:
    """
    Map `Optional[bytes]` to and from `OptBytesT` (`bytes`).

    None values are represented by an empty bytestring.
    """

    t: ClassVar[str] = BytesM.t
    none: ClassVar[OptBytesT] = b""

    @classmethod
    def pack(cls: Type[Self], buff: Optional[bytes]) -> OptBytesT:
        """
        Pack `Optional[bytes]` to `OptBytesT`.
        """

        if buff is None:
            return cls.none
        return buff

    @staticmethod
    def unpack(buff: OptBytesT) -> Optional[bytes]:
        """
        Unpack `OptBytesT` to `Optional[bytes]`.
        """

        if not buff:
            return None
        return buff

class OptFloatM:
    """
    Map `Optional[float]` to and from `OptFloatT` (`float`), where float values
    are expected to be positive.

    None values are represented by negative values, namely `-1.0`.
    """

    t: ClassVar[str] = "d"
    none: ClassVar[OptFloatT] = -1.0

    @classmethod
    def pack(cls: Type[Self], t: Optional[float]) -> OptFloatT:
        """
        Pack `Optional[float]` to `OptFloatT`.
        """

        return t if t is not None else cls.none

    @staticmethod
    def unpack(t: OptFloatT) -> Optional[float]:
        """
        Unpack `OptFloatT` to `Optional[float]`.
        """

        return t if t >= 0 else None

class OptGpioSettingsM:
    """
    Map `Optional[GpioSettings]` to and from `OptGpioSettingsT` (`int`).

    Optional GPIO settings are represented by a UINT16, where values higher
    than 0xFF are treated as None. When GPIO settings are defined, the integer
    value will be the same as with required GPIO settings.
    """

    t: ClassVar[str] = Uint16M.t
    none: ClassVar[int] = 0xFF00

    @classmethod
    def pack(cls: Type[Self], settings: Optional[GpioSettings]) -> OptGpioSettingsT:
        return GpioSettingsM.pack(settings) if settings is not None else cls.none

    @staticmethod
    def unpack(settings: OptGpioSettingsT) -> Optional[GpioSettings]:
        return GpioSettingsM.unpack(settings) if settings <= 0xFF else None

class OptStrM:
    """
    Map `Optional[str]` to and from `StrT` (`str`).

    None values are represented by an empty string.
    """

    t: ClassVar[str] = "s"
    none: ClassVar[str] = ""

    @classmethod
    def pack(cls: Type[Self], string: Optional[str]) -> OptStrT:
        """
        Pack `Optional[str]` to `OptStrT`.
        """

        return string or cls.none

    @classmethod
    def unpack(cls: Type[Self], string: OptStrT) -> Optional[str]:
        """
        Unpack `OptStrT` to `Optional[str]`.
        """

        return string if string != cls.none else None

class PongM:
    """
    Map `Pong` to and from `PongT` (`bytes`).
    """

    t: ClassVar[str] = BytesM.t

    @staticmethod
    def pack(pong: Pong) -> PongT:
        """
        Pack `Pong` to `PongT`.
        """

        return pong.response

    @staticmethod
    def unpack(pong: PongT) -> Pong:
        """
        Unpack `PongT` to `Pong`.
        """

        return Pong(pong)

class RetryTimesM(OptIntM):
    """
    Map `Optional[int]` to and from `RetryTimesT` (`int`).

    `RetryTimesM` is an alias for `OptIntM`.
    """

    t: ClassVar[str] = OptIntM.t
    none: ClassVar[int] = OptIntM.none

class TemperatureDisplayItemM:
    """
    Map `TemperatureDisplayItem` to and from `TemperatureDisplayItemT`
    (`Tuple[int, int, int, int, bool]`).
    """

    t: ClassVar[str] = t(IndexM, TemperatureDigitsM, PositionM, PositionM, "b")

    @staticmethod
    def pack(item: TemperatureDisplayItem) -> TemperatureDisplayItemT:
        """
        Pack `TemperatureDisplayItem` to `TemperatureDisplayItemT`.
        """

        return (
            item.index,
            item.n_digits,
            item.column,
            item.row,
            TemperatureUnitM.pack(item.units),
        )

    @staticmethod
    def unpack(
        item: TemperatureDisplayItemT,
    ) -> TemperatureDisplayItem:
        """
        Unpack `TemperatureDisplayItemT` to `TemperatureDisplayItem`.
        """

        index, n_digits, column, row, units = item
        return TemperatureDisplayItem(
            index,
            TemperatureDigitsM.unpack(n_digits),
            column,
            row,
            TemperatureUnitM.unpack(units),
        )

class TemperatureReportM:
    """
    Map `TemperatureReport` to and from `KeyActivityReportT`
    """

    t: ClassVar[str] = t(IndexM, "dd")

    @staticmethod
    def pack(report: TemperatureReport) -> TemperatureReportT:
        return (report.index, report.celsius, report.fahrenheit)

    @staticmethod
    def unpack(report: TemperatureReportT) -> TemperatureReport:
        index, celsius, fahrenheit = report
        return TemperatureReport(index, celsius, fahrenheit)

class TimeoutM(OptFloatM):
    """
    Map `Optional[float]` to and from `TimeoutT` (`float`).

    `TimeoutM` is an alias for `OptFloatM`.
    """

    t: ClassVar[str] = OptFloatM.t
    none: ClassVar[float] = OptFloatM.none

class VersionsM:
    """
    Map `Versions` to and from `VersionsT` (`Tuple[str, str, str]`).
    """

    t: ClassVar[str] = t(ModelM, RevisionM, RevisionM)

    @staticmethod
    def pack(versions: Versions) -> VersionsT:
        return (versions.model, versions.hardware_rev, versions.firmware_rev)

    @staticmethod
    def unpack(versions: VersionsT) -> Versions:
        """
        Unpack `VersionsT` to `Versions`.
        """

        return Versions(*versions)