"""Select for Midea."""

from dataclasses import dataclass
from typing import cast, override

from midealocal.const import DeviceType

from homeassistant.components.select import SelectEntity, SelectEntityDescription
from homeassistant.const import EntityCategory
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback

from .entity import MideaConfigEntry, MideaEntity, midea_api_call

PARALLEL_UPDATES = 0


@dataclass(kw_only=True, frozen=True)
class MideaSelectEntityDescription(SelectEntityDescription):
    """Description for a Midea select entity."""

    models: list[DeviceType]
    options_attribute: str
    """Device property name returning the list of valid option strings."""
    requires_power: bool = False
    """Entity is only operable while the device's ``power`` attribute is on."""


SELECTS: list[MideaSelectEntityDescription] = [
    MideaSelectEntityDescription(
        key="direction",
        translation_key="direction",
        models=[DeviceType.X40],
        options_attribute="directions",
    ),
    MideaSelectEntityDescription(
        key="fan_speed",
        translation_key="fan_speed",
        models=[DeviceType.A1, DeviceType.FC, DeviceType.FD],
        options_attribute="fan_speeds",
    ),
    MideaSelectEntityDescription(
        key="water_level_set",
        translation_key="water_level_set",
        models=[DeviceType.A1],
        options_attribute="water_level_sets",
    ),
    MideaSelectEntityDescription(
        key="wind_lr_angle",
        translation_key="wind_lr_angle",
        models=[DeviceType.AC],
        options_attribute="wind_lr_angles",
        requires_power=True,
    ),
    MideaSelectEntityDescription(
        key="wind_ud_angle",
        translation_key="wind_ud_angle",
        models=[DeviceType.AC],
        options_attribute="wind_ud_angles",
        requires_power=True,
    ),
    MideaSelectEntityDescription(
        key="rate_select",
        translation_key="rate_select",
        models=[DeviceType.AC],
        options_attribute="rate_selects",
        requires_power=True,
    ),
    MideaSelectEntityDescription(
        key="silent_level",
        translation_key="silent_level",
        models=[DeviceType.C3],
        options_attribute="silent_modes",
    ),
    MideaSelectEntityDescription(
        key="oscillation_mode",
        translation_key="oscillation_mode",
        models=[DeviceType.FA],
        options_attribute="oscillation_modes",
    ),
    MideaSelectEntityDescription(
        key="oscillation_angle",
        translation_key="oscillation_angle",
        models=[DeviceType.FA],
        options_attribute="oscillation_angles",
    ),
    MideaSelectEntityDescription(
        key="tilting_angle",
        translation_key="tilting_angle",
        models=[DeviceType.FA],
        options_attribute="tilting_angles",
    ),
    MideaSelectEntityDescription(
        key="detect_mode",
        translation_key="detect_mode",
        models=[DeviceType.FC],
        options_attribute="detect_modes",
    ),
    MideaSelectEntityDescription(
        key="mode",
        translation_key="mode",
        models=[DeviceType.FC],
        options_attribute="modes",
    ),
    MideaSelectEntityDescription(
        key="screen_display",
        translation_key="screen_display",
        models=[DeviceType.FC, DeviceType.FD],
        options_attribute="screen_displays",
        entity_category=EntityCategory.CONFIG,
    ),
]


async def async_setup_entry(
    hass: HomeAssistant,
    config_entry: MideaConfigEntry,
    async_add_entities: AddConfigEntryEntitiesCallback,
) -> None:
    """Set up selects for device."""
    device = config_entry.runtime_data

    async_add_entities(
        MideaSelect(device, description)
        for description in SELECTS
        if device.device_type in description.models
        and description.key in device.attributes
    )


class MideaSelect(MideaEntity, SelectEntity):
    """Represent a Midea select."""

    entity_description: MideaSelectEntityDescription

    @property
    @override
    def available(self) -> bool:
        """Return entity availability."""
        if not super().available:
            return False
        if self.entity_description.requires_power:
            return bool(self._device.get_attribute("power"))
        return True

    @property
    @override
    def options(self) -> list[str]:
        """Return the list of valid options."""
        return cast(
            list[str], getattr(self._device, self.entity_description.options_attribute)
        )

    @property
    @override
    def current_option(self) -> str | None:
        """Return the currently selected option."""
        value = self._device.get_attribute(self.entity_description.key)
        if not isinstance(value, str):
            return None
        return value

    @override
    def select_option(self, option: str) -> None:
        """Select an option."""
        with midea_api_call():
            self._device.set_attribute(attr=self.entity_description.key, value=option)