import json
from threading import Timer

import bdfparser
from sense_hat import SenseHat


class Display:
    def __init__(self, mqttc, uid, name):
        self.mqttc = mqttc
        self.sense = SenseHat()
        self.uid = uid
        self.name = name

        self.init_lights()
        self.mqttc.will_set(self.availability_topic, "offline", retain=True)

    @property
    def device(self):
        return {
            "identifiers": [self.uid],
            "name": self.name,
        }

    @property
    def availability_topic(self):
        return f"{self.uid}/display/availability"

    def init_lights(self):
        options = {
            "device": self.device,
            "availability_topic": self.availability_topic,
        }

        self.main_light = Light("LED", self.uid, "led", self.sense, **options)

    def publish_discovery(self):
        self.main_light.publish_discovery(self.mqttc)

    def publish_online(self):
        self.subscribe()
        self.mqttc.publish(self.availability_topic, "online", retain=True)

    def subscribe(self):
        self.main_light.subscribe(self.mqttc)

    def on_message(self, *args, **kwargs):
        self.main_light.on_message(*args, **kwargs)


class Light:
    def __init__(self, name, parent_uid, slug, sense, **kwargs):
        self.name = name
        self.parent_uid = parent_uid
        self.slug = slug
        self.sense = sense
        self.options = kwargs

        self._switch = False
        self._color = [255, 255, 255]
        self._pre = ""
        self._value = ""

        self.font = bdfparser.Font("src/tom-thumb.bdf")
        self.timer = Timer(0, self.__init__)

    def publish_discovery(self, mqttc):
        mqttc.publish(
            self.discovery_topic,
            json.dumps(
                {
                    "command_topic": self.command_topic("command"),
                    "effect_command_topic": self.command_topic("effect"),
                    "effect_list": ["Low Light", "Normal"],
                    "effect_state_topie": self.state_topic,
                    "effect_value_template": "{{ value_json.effect }}",
                    "icon": "mdi:dots-grid",
                    "name": self.name,
                    "on_command_type": "brightness",
                    "rgb_command_topic": self.command_topic("rgb"),
                    "rgb_state_topic": self.state_topic,
                    "rgb_value_template": "{{ value_json.rgb }}",
                    "retain": True,
                    "unique_id": self.uid,
                    "state_topic": self.state_topic,
                    "state_value_template": "{{ value_json.state }}",
                }
                | self.options
            ),
            retain=True,
        )
        self.publish_state(mqttc)

    def subscribe(self, mqttc):
        mqttc.subscribe(self.command_topic("command"))
        mqttc.subscribe(self.command_topic("effect"))
        mqttc.subscribe(self.command_topic("rgb"))

        mqttc.subscribe(self.command_topic("value"))

    def on_message(self, client, userdata, message):
        data = message.payload.decode()
        print(data)

        match message.topic.rsplit("/", maxsplit=1):
            case [self.base_topic, "command"]:
                self.switch = data == "ON"
            case [self.base_topic, "rgb"]:
                self.color = list(map(int, data.split(",")))
            case [self.base_topic, "effect"]:
                self.sense.low_light = data == "Low Light"
            case [self.base_topic, "value"]:
                self.value = data
            case _:
                return
        self.publish_state(client)

    def publish_state(self, mqttc):
        mqttc.publish(
            self.state_topic,
            json.dumps(
                {
                    "effect": "Low Light" if self.sense.low_light else "Normal",
                    "rgb": self.rgb,
                    "state": self.state,
                }
            ),
            retain=True,
        )

    @property
    def uid(self):
        return f"{self.parent_uid}_{self.slug}"

    @property
    def discovery_topic(self):
        return f"homeassistant/light/{self.uid}/config"

    @property
    def base_topic(self):
        return f"{self.parent_uid}/display/{self.slug}"

    def command_topic(self, cmd):
        return f"{self.base_topic}/{cmd}"

    @property
    def state_topic(self):
        return f"{self.parent_uid}/display/{self.slug}/state"

    @property
    def switch(self):
        return self._switch

    @switch.setter
    def switch(self, value):
        self._switch = value
        if value:
            self.update_value()
        else:
            self.sense.clear()

    @property
    def state(self):
        return "ON" if self.switch else "OFF"

    @property
    def color(self):
        return self._color

    @color.setter
    def color(self, value):
        self._color = value
        if not self.switch:
            self.switch = True
        self.display_value()

    @property
    def rgb(self):
        return ",".join(map(str, self.color))

    @property
    def value(self):
        return f"{self._pre} {self._value}"

    @value.setter
    def value(self, value):
        match value.split():
            case [val]:
                self._pre = ""
                self._value = val
            case [pre, val, *_]:
                self._pre = pre
                self._value = val
        self.display_value()

    def update_value(self):
        if not self.switch:
            return

        if not self._pre:
            self.display_value()
            return

        self.timer.cancel()

        pixels = self.to_pixels(self._pre)
        self.sense.set_pixels(pixels)

        self.timer = Timer(1, self.display_value, kwargs=dict(timer=True))
        self.timer.start()

    def display_value(self, timer=False):
        if (not timer and self.timer.is_alive()) or not self.switch:
            return

        pixels = self.to_pixels(self._value)
        self.sense.set_pixels(pixels)

    def to_pixels(self, text):
        if text:
            return [
                self.color if x else [0, 0, 0]
                for x in self.font.draw(text).crop(8, 8, yoff=-2).todata(3)
            ]

        return [self.color] * 64