#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
from devices.base import base, base_output
import logging


class hue_light(base_output):
    """ Communication (MQTT)

        hue_light {
                |      "state": ["ON" / "OFF" / "TOGGLE"]
                |      "linkquality": [0...255] lqi
                |      "brightness": [0...254]
                |      "color_mode": ["color_temp"]
                |      "color_temp": ["coolest", "cool", "neutral", "warm", "warmest", 250...454]
                | }
                +- get {
                |           "state": ""
                |      }
                +- set {
                            "state": ["ON" / "OFF"]
                            "brightness": [0...256]
                            "color_temp": [250...454]
                            "transition": [0...] seconds
                            "brightness_move": [-X...0...X] X/s
                            "brightness_step": [-X...0...X]
                            "color_temp_move": [-X...0...X] X/s
                            "color_temp_step": [-X...0...X]
                        }
    """
    KEY_LINKQUALITY = "linkquality"
    KEY_OUTPUT_0 = "state"
    KEY_BRIGHTNESS = "brightness"
    KEY_COLOR_TEMP = "color_temp"
    #
    TX_TYPE = base.TX_DICT
    TX_FILTER_DATA_KEYS = [KEY_OUTPUT_0, KEY_BRIGHTNESS, KEY_COLOR_TEMP]
    STATE_KEYS = TX_FILTER_DATA_KEYS
    #
    RX_KEYS = [KEY_LINKQUALITY, KEY_OUTPUT_0, KEY_BRIGHTNESS, KEY_COLOR_TEMP]
    RX_IGNORE_KEYS = ['update', 'color_mode']
    RX_FILTER_DATA_KEYS = [KEY_OUTPUT_0, KEY_BRIGHTNESS, KEY_COLOR_TEMP]

    def __state_logging__(self, inst, key, data):
        if key in [self.KEY_OUTPUT_0, self.KEY_BRIGHTNESS, self.KEY_COLOR_TEMP]:
            self.logger.info("State change of '%s' to '%s'", key, repr(data))

    def __device_to_instance_filter__(self, key, data):
        if key == self.KEY_BRIGHTNESS:
            return int(round((data - 1) * 100 / 253, 0))
        elif key == self.KEY_COLOR_TEMP:
            return int(round((data - 250) * 10 / 204, 0))
        return super().__device_to_instance_filter__(key, data)

    def __instance_to_device_filter__(self, key, data):
        if key == self.KEY_BRIGHTNESS:
            return int(round(data * 253 / 100 + 1, 0))
        elif key == self.KEY_COLOR_TEMP:
            return int(round(data * 204 / 10 + 250, 0))
        return super().__instance_to_device_filter__(key, data)

    #
    # RX
    #
    @property
    def output_0(self):
        """rv: [True, False]"""
        return self.get(self.KEY_OUTPUT_0, False)

    @property
    def linkquality(self):
        """rv: numeric value"""
        return self.get(self.KEY_LINKQUALITY, 0)

    @property
    def brightness(self):
        """rv: numeric value [0%, ..., 100%]"""
        return self.get(self.KEY_BRIGHTNESS, 0)

    @property
    def color_temp(self):
        """rv: numeric value [0, ..., 10]"""
        return self.get(self.KEY_COLOR_TEMP, 0)

    #
    # TX
    #
    def request_data(self, device=None, key=None, data=None):
        self.mqtt_client.send(self.topic + "/set", '{"hue_power_on_behavior": "recover"}')

    def set_output_0(self, state):
        """state: [True, False]"""
        self.send_command(self.KEY_OUTPUT_0, state)

    def set_output_0_mcb(self, device, key, data):
        self.set_output_0(data)

    def toggle_output_0_mcb(self, device, key, data):
        self.set_output_0(not self.output_0)

    def set_brightness(self, brightness):
        """brightness: [0, ..., 100]"""
        self.send_command(self.KEY_BRIGHTNESS, brightness)

    def set_brightness_mcb(self, device, key, data):
        self.set_brightness(data)

    def set_color_temp(self, color_temp):
        """color_temp: [0, ..., 10]"""
        self.send_command(self.KEY_COLOR_TEMP, color_temp)

    def set_color_temp_mcb(self, device, key, data):
        self.set_color_temp(data)

    def __all_off__(self):
        if self.output_0:
            self.set_output_0(False)