"""Support for Tuya Climate."""

from __future__ import annotations

import json
import logging
from typing import Any

from tuya_iot import TuyaDevice, TuyaDeviceManager

from homeassistant.components.climate import DOMAIN as DEVICE_DOMAIN, ClimateEntity
from homeassistant.components.climate.const import (
    HVAC_MODE_AUTO,
    HVAC_MODE_COOL,
    HVAC_MODE_DRY,
    HVAC_MODE_FAN_ONLY,
    HVAC_MODE_HEAT,
    HVAC_MODE_OFF,
    SUPPORT_FAN_MODE,
    SUPPORT_SWING_MODE,
    SUPPORT_TARGET_HUMIDITY,
    SUPPORT_TARGET_TEMPERATURE,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import TEMP_CELSIUS, TEMP_FAHRENHEIT
from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers.dispatcher import async_dispatcher_connect
from homeassistant.helpers.entity import Entity
from homeassistant.helpers.entity_platform import AddEntitiesCallback

from .base import TuyaHaEntity
from .const import (
    DOMAIN,
    TUYA_DEVICE_MANAGER,
    TUYA_DISCOVERY_NEW,
    TUYA_HA_DEVICES,
    TUYA_HA_TUYA_MAP,
)

_LOGGER = logging.getLogger(__name__)


# Air Conditioner
# https://developer.tuya.com/en/docs/iot/f?id=K9gf46qujdmwb
DPCODE_SWITCH = "switch"
DPCODE_TEMP_SET = "temp_set"
DPCODE_TEMP_SET_F = "temp_set_f"
DPCODE_MODE = "mode"
DPCODE_HUMIDITY_SET = "humidity_set"
DPCODE_FAN_SPEED_ENUM = "fan_speed_enum"

# Temperature unit
DPCODE_TEMP_UNIT_CONVERT = "temp_unit_convert"
DPCODE_C_F = "c_f"

# swing flap switch
DPCODE_SWITCH_HORIZONTAL = "switch_horizontal"
DPCODE_SWITCH_VERTICAL = "switch_vertical"

# status
DPCODE_TEMP_CURRENT = "temp_current"
DPCODE_TEMP_CURRENT_F = "temp_current_f"
DPCODE_HUMIDITY_CURRENT = "humidity_current"

SWING_OFF = "swing_off"
SWING_VERTICAL = "swing_vertical"
SWING_HORIZONTAL = "swing_horizontal"
SWING_BOTH = "swing_both"

DEFAULT_MIN_TEMP = 7
DEFAULT_MAX_TEMP = 35

TUYA_HVAC_TO_HA = {
    "hot": HVAC_MODE_HEAT,
    "cold": HVAC_MODE_COOL,
    "wet": HVAC_MODE_DRY,
    "wind": HVAC_MODE_FAN_ONLY,
    "auto": HVAC_MODE_AUTO,
}

TUYA_SUPPORT_TYPE = {
    "kt",  # Air conditioner
    "qn",  # Heater
    "wk",  # Thermostat
}


async def async_setup_entry(
    hass: HomeAssistant, entry: ConfigEntry, async_add_entities: AddEntitiesCallback
) -> None:
    """Set up tuya climate dynamically through tuya discovery."""
    _LOGGER.debug("climate init")

    hass.data[DOMAIN][entry.entry_id][TUYA_HA_TUYA_MAP][
        DEVICE_DOMAIN
    ] = TUYA_SUPPORT_TYPE

    @callback
    def async_discover_device(dev_ids: list[str]) -> None:
        """Discover and add a discovered tuya climate."""
        _LOGGER.debug("climate add-> %s", dev_ids)
        if not dev_ids:
            return
        entities = _setup_entities(hass, entry, dev_ids)
        async_add_entities(entities)

    entry.async_on_unload(
        async_dispatcher_connect(
            hass, TUYA_DISCOVERY_NEW.format(DEVICE_DOMAIN), async_discover_device
        )
    )

    device_manager = hass.data[DOMAIN][entry.entry_id][TUYA_DEVICE_MANAGER]
    device_ids = []
    for (device_id, device) in device_manager.device_map.items():
        if device.category in TUYA_SUPPORT_TYPE:
            device_ids.append(device_id)
    async_discover_device(device_ids)


def _setup_entities(
    hass: HomeAssistant, entry: ConfigEntry, device_ids: list[str]
) -> list[Entity]:
    """Set up Tuya Climate."""
    device_manager = hass.data[DOMAIN][entry.entry_id][TUYA_DEVICE_MANAGER]
    entities: list[Entity] = []
    for device_id in device_ids:
        device = device_manager.device_map[device_id]
        if device is None:
            continue
        entities.append(TuyaHaClimate(device, device_manager))
        hass.data[DOMAIN][entry.entry_id][TUYA_HA_DEVICES].add(device_id)
    return entities


class TuyaHaClimate(TuyaHaEntity, ClimateEntity):
    """Tuya Switch Device."""

    def __init__(self, device: TuyaDevice, device_manager: TuyaDeviceManager) -> None:
        """Init Tuya Ha Climate."""
        super().__init__(device, device_manager)
        if DPCODE_C_F in self.tuya_device.status:
            self.dp_temp_unit = DPCODE_C_F
        else:
            self.dp_temp_unit = DPCODE_TEMP_UNIT_CONVERT

    def get_temp_set_scale(self) -> int | None:
        """Get temperature set scale."""
        dp_temp_set = DPCODE_TEMP_SET if self.is_celsius() else DPCODE_TEMP_SET_F
        temp_set_value_range_item = self.tuya_device.status_range.get(dp_temp_set)
        if not temp_set_value_range_item:
            return None

        temp_set_value_range = json.loads(temp_set_value_range_item.values)
        return temp_set_value_range.get("scale")

    def get_temp_current_scale(self) -> int | None:
        """Get temperature current scale."""
        dp_temp_current = (
            DPCODE_TEMP_CURRENT if self.is_celsius() else DPCODE_TEMP_CURRENT_F
        )
        temp_current_value_range_item = self.tuya_device.status_range.get(
            dp_temp_current
        )
        if not temp_current_value_range_item:
            return None

        temp_current_value_range = json.loads(temp_current_value_range_item.values)
        return temp_current_value_range.get("scale")

    # Functions

    def set_hvac_mode(self, hvac_mode: str) -> None:
        """Set new target hvac mode."""
        commands = []
        if hvac_mode == HVAC_MODE_OFF:
            commands.append({"code": DPCODE_SWITCH, "value": False})
        else:
            commands.append({"code": DPCODE_SWITCH, "value": True})

        for tuya_mode, ha_mode in TUYA_HVAC_TO_HA.items():
            if ha_mode == hvac_mode:
                commands.append({"code": DPCODE_MODE, "value": tuya_mode})
                break

        self._send_command(commands)

    def set_fan_mode(self, fan_mode: str) -> None:
        """Set new target fan mode."""
        self._send_command([{"code": DPCODE_FAN_SPEED_ENUM, "value": fan_mode}])

    def set_humidity(self, humidity: float) -> None:
        """Set new target humidity."""
        self._send_command([{"code": DPCODE_HUMIDITY_SET, "value": int(humidity)}])

    def set_swing_mode(self, swing_mode: str) -> None:
        """Set new target swing operation."""
        if swing_mode == SWING_BOTH:
            commands = [
                {"code": DPCODE_SWITCH_VERTICAL, "value": True},
                {"code": DPCODE_SWITCH_HORIZONTAL, "value": True},
            ]
        elif swing_mode == SWING_HORIZONTAL:
            commands = [
                {"code": DPCODE_SWITCH_VERTICAL, "value": False},
                {"code": DPCODE_SWITCH_HORIZONTAL, "value": True},
            ]
        elif swing_mode == SWING_VERTICAL:
            commands = [
                {"code": DPCODE_SWITCH_VERTICAL, "value": True},
                {"code": DPCODE_SWITCH_HORIZONTAL, "value": False},
            ]
        else:
            commands = [
                {"code": DPCODE_SWITCH_VERTICAL, "value": False},
                {"code": DPCODE_SWITCH_HORIZONTAL, "value": False},
            ]

        self._send_command(commands)

    def set_temperature(self, **kwargs: Any) -> None:
        """Set new target temperature."""
        _LOGGER.debug("climate temp-> %s", kwargs)
        code = DPCODE_TEMP_SET if self.is_celsius() else DPCODE_TEMP_SET_F
        temp_set_scale = self.get_temp_set_scale()
        if not temp_set_scale:
            return

        self._send_command(
            [
                {
                    "code": code,
                    "value": int(kwargs["temperature"] * (10 ** temp_set_scale)),
                }
            ]
        )

    def is_celsius(self) -> bool:
        """Return True if device reports in Celsius."""
        if (
            self.dp_temp_unit in self.tuya_device.status
            and self.tuya_device.status.get(self.dp_temp_unit).lower() == "c"
        ):
            return True
        if (
            DPCODE_TEMP_SET in self.tuya_device.status
            or DPCODE_TEMP_CURRENT in self.tuya_device.status
        ):
            return True
        return False

    @property
    def temperature_unit(self) -> str:
        """Return true if fan is on."""
        if self.is_celsius():
            return TEMP_CELSIUS
        return TEMP_FAHRENHEIT

    @property
    def current_temperature(self) -> float | None:
        """Return the current temperature."""
        if (
            DPCODE_TEMP_CURRENT not in self.tuya_device.status
            and DPCODE_TEMP_CURRENT_F not in self.tuya_device.status
        ):
            return None

        temp_current_scale = self.get_temp_current_scale()
        if not temp_current_scale:
            return None

        if self.is_celsius():
            temperature = self.tuya_device.status.get(DPCODE_TEMP_CURRENT)
            if not temperature:
                return None
            return temperature * 1.0 / (10 ** temp_current_scale)

        temperature = self.tuya_device.status.get(DPCODE_TEMP_CURRENT_F)
        if not temperature:
            return None
        return temperature * 1.0 / (10 ** temp_current_scale)

    @property
    def current_humidity(self) -> int:
        """Return the current humidity."""
        return int(self.tuya_device.status.get(DPCODE_HUMIDITY_CURRENT, 0))

    @property
    def target_temperature(self) -> float | None:
        """Return the temperature currently set to be reached."""
        temp_set_scale = self.get_temp_set_scale()
        if temp_set_scale is None:
            return None

        dpcode_temp_set = self.tuya_device.status.get(DPCODE_TEMP_SET)
        if dpcode_temp_set is None:
            return None

        return dpcode_temp_set * 1.0 / (10 ** temp_set_scale)

    @property
    def max_temp(self) -> float:
        """Return the maximum temperature."""
        scale = self.get_temp_set_scale()
        if scale is None:
            return DEFAULT_MAX_TEMP

        if self.is_celsius():
            if DPCODE_TEMP_SET not in self.tuya_device.function:
                return DEFAULT_MAX_TEMP

            function_item = self.tuya_device.function.get(DPCODE_TEMP_SET)
            if function_item is None:
                return DEFAULT_MAX_TEMP

            temp_value = json.loads(function_item.values)

            temp_max = temp_value.get("max")
            if temp_max is None:
                return DEFAULT_MAX_TEMP
            return temp_max * 1.0 / (10 ** scale)
        if DPCODE_TEMP_SET_F not in self.tuya_device.function:
            return DEFAULT_MAX_TEMP

        function_item_f = self.tuya_device.function.get(DPCODE_TEMP_SET_F)
        if function_item_f is None:
            return DEFAULT_MAX_TEMP

        temp_value_f = json.loads(function_item_f.values)

        temp_max_f = temp_value_f.get("max")
        if temp_max_f is None:
            return DEFAULT_MAX_TEMP
        return temp_max_f * 1.0 / (10 ** scale)

    @property
    def min_temp(self) -> float:
        """Return the minimum temperature."""
        temp_set_scal = self.get_temp_set_scale()
        if temp_set_scal is None:
            return DEFAULT_MIN_TEMP

        if self.is_celsius():
            if DPCODE_TEMP_SET not in self.tuya_device.function:
                return DEFAULT_MIN_TEMP

            function_temp_item = self.tuya_device.function.get(DPCODE_TEMP_SET)
            if function_temp_item is None:
                return DEFAULT_MIN_TEMP
            temp_value = json.loads(function_temp_item.values)
            temp_min = temp_value.get("min")
            if temp_min is None:
                return DEFAULT_MIN_TEMP
            return temp_min * 1.0 / (10 ** temp_set_scal)

        if DPCODE_TEMP_SET_F not in self.tuya_device.function:
            return DEFAULT_MIN_TEMP

        temp_value_temp_f = self.tuya_device.function.get(DPCODE_TEMP_SET_F)
        if temp_value_temp_f is None:
            return DEFAULT_MIN_TEMP
        temp_value_f = json.loads(temp_value_temp_f.values)

        temp_min_f = temp_value_f.get("min")
        if temp_min_f is None:
            return DEFAULT_MIN_TEMP

        return temp_min_f * 1.0 / (10 ** temp_set_scal)

    @property
    def target_temperature_step(self) -> float | None:
        """Return target temperature setp."""
        if (
            DPCODE_TEMP_SET not in self.tuya_device.status_range
            and DPCODE_TEMP_SET_F not in self.tuya_device.status_range
        ):
            return 1.0
        temp_set_value_range = json.loads(
            self.tuya_device.status_range.get(
                DPCODE_TEMP_SET if self.is_celsius() else DPCODE_TEMP_SET_F
            ).values
        )
        step = temp_set_value_range.get("step")
        if step is None:
            return None

        temp_set_scale = self.get_temp_set_scale()
        if temp_set_scale is None:
            return None

        return step * 1.0 / (10 ** temp_set_scale)

    @property
    def target_humidity(self) -> int:
        """Return target humidity."""
        return int(self.tuya_device.status.get(DPCODE_HUMIDITY_SET, 0))

    @property
    def hvac_mode(self) -> str:
        """Return hvac mode."""
        if not self.tuya_device.status.get(DPCODE_SWITCH, False):
            return HVAC_MODE_OFF
        if DPCODE_MODE not in self.tuya_device.status:
            return HVAC_MODE_OFF
        if self.tuya_device.status.get(DPCODE_MODE) is not None:
            return TUYA_HVAC_TO_HA[self.tuya_device.status[DPCODE_MODE]]
        return HVAC_MODE_OFF

    @property
    def hvac_modes(self) -> list[str]:
        """Return hvac modes for select."""
        if DPCODE_MODE not in self.tuya_device.function:
            return []
        modes = json.loads(self.tuya_device.function.get(DPCODE_MODE, {}).values).get(
            "range"
        )

        hvac_modes = [HVAC_MODE_OFF]
        for tuya_mode, ha_mode in TUYA_HVAC_TO_HA.items():
            if tuya_mode in modes:
                hvac_modes.append(ha_mode)

        return hvac_modes

    @property
    def fan_mode(self) -> str | None:
        """Return fan mode."""
        return self.tuya_device.status.get(DPCODE_FAN_SPEED_ENUM)

    @property
    def fan_modes(self) -> list[str]:
        """Return fan modes for select."""
        fan_speed_device_function = self.tuya_device.function.get(DPCODE_FAN_SPEED_ENUM)
        if not fan_speed_device_function:
            return []
        return json.loads(fan_speed_device_function.values).get("range", [])

    @property
    def swing_mode(self) -> str:
        """Return swing mode."""
        mode = 0
        if (
            DPCODE_SWITCH_HORIZONTAL in self.tuya_device.status
            and self.tuya_device.status.get(DPCODE_SWITCH_HORIZONTAL)
        ):
            mode += 1
        if (
            DPCODE_SWITCH_VERTICAL in self.tuya_device.status
            and self.tuya_device.status.get(DPCODE_SWITCH_VERTICAL)
        ):
            mode += 2

        if mode == 3:
            return SWING_BOTH
        if mode == 2:
            return SWING_VERTICAL
        if mode == 1:
            return SWING_HORIZONTAL
        return SWING_OFF

    @property
    def swing_modes(self) -> list[str]:
        """Return swing mode for select."""
        return [SWING_OFF, SWING_HORIZONTAL, SWING_VERTICAL, SWING_BOTH]

    @property
    def supported_features(self) -> int:
        """Flag supported features."""
        supports = 0
        if (
            DPCODE_TEMP_SET in self.tuya_device.status
            or DPCODE_TEMP_SET_F in self.tuya_device.status
        ):
            supports |= SUPPORT_TARGET_TEMPERATURE
        if DPCODE_FAN_SPEED_ENUM in self.tuya_device.status:
            supports |= SUPPORT_FAN_MODE
        if DPCODE_HUMIDITY_SET in self.tuya_device.status:
            supports |= SUPPORT_TARGET_HUMIDITY
        if (
            DPCODE_SWITCH_HORIZONTAL in self.tuya_device.status
            or DPCODE_SWITCH_VERTICAL in self.tuya_device.status
        ):
            supports |= SUPPORT_SWING_MODE
        return supports