"""Szenenauswahl eines ninstrip."""

from __future__ import annotations

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

from .coordinator import NinstripConfigEntry, NinstripCoordinator
from .entity import NinstripEntity, NinstripSacnEntity

# Wird angezeigt, wenn keine Szene aufgeschaltet ist oder jemand die Segmente
# seit dem Aufschalten veraendert hat.
NONE_OPTION = "—"

# Was das Geraet 2,5 s nach dem letzten sACN-Paket tut. Werte wie ha-ninlight.
ON_TIMEOUT_OPTIONS = ["release", "hold"]

# Was nach einer Stromunterbrechung passiert (nl_settings.c: last, on, off).
POWER_ON_OPTIONS = ["last", "on", "off"]


async def async_setup_entry(
    hass: HomeAssistant,
    entry: NinstripConfigEntry,
    async_add_entities: AddConfigEntryEntitiesCallback,
) -> None:
    coordinator = entry.runtime_data
    async_add_entities(
        [
            NinstripPresetSelect(coordinator),
            NinstripPowerOnSelect(coordinator),
            NinstripSacnOnTimeoutSelect(coordinator),
        ]
    )


class NinstripPowerOnSelect(NinstripEntity, SelectEntity):
    """Was der Strip tut, wenn der Strom wiederkommt."""

    _attr_entity_category = EntityCategory.CONFIG
    _attr_translation_key = "power_on_behaviour"
    _attr_options = POWER_ON_OPTIONS

    def __init__(self, coordinator: NinstripCoordinator) -> None:
        super().__init__(coordinator, "power_on_behaviour")

    @property
    def current_option(self) -> str | None:
        wert = self.coordinator.data.state.get("power_on_behaviour")
        return wert if wert in POWER_ON_OPTIONS else None

    async def async_select_option(self, option: str) -> None:
        await self.coordinator.async_set_state(power_on_behaviour=option)


class NinstripPresetSelect(NinstripEntity, SelectEntity):
    """Waehlt eine der belegten Szenen aus."""

    _attr_translation_key = "preset"
    _attr_icon = "mdi:playlist-play"

    def __init__(self, coordinator: NinstripCoordinator) -> None:
        super().__init__(coordinator, "preset")

    def _used(self) -> list[dict]:
        presets = self.coordinator.data.presets.get("presets") or []
        return [p for p in presets if p.get("used")]

    @property
    def options(self) -> list[str]:
        return [NONE_OPTION] + [str(p.get("name") or f"Szene {p['id'] + 1}") for p in self._used()]

    @property
    def current_option(self) -> str:
        """Nach einer Aenderung an den Segmenten passt keine Szene mehr - dann '—'."""
        state = self.coordinator.data.state
        if state.get("preset_modified"):
            return NONE_OPTION
        aktiv = state.get("preset")
        if aktiv is None:
            return NONE_OPTION
        for p in self._used():
            if p.get("id") == aktiv:
                return str(p.get("name") or f"Szene {aktiv + 1}")
        return NONE_OPTION

    async def async_select_option(self, option: str) -> None:
        if option == NONE_OPTION:
            # Es gibt kein "Szene abwaehlen" - das Gegenstueck ist Ausschalten.
            await self.coordinator.async_set_state(on=False)
            return
        for p in self._used():
            name = str(p.get("name") or f"Szene {p['id'] + 1}")
            if name == option:
                index = int(p["id"])
                # index als Vorgabewert binden: sonst zeigt das Lambda auf die
                # Schleifenvariable statt auf den Wert von jetzt.
                await self.coordinator.async_call(lambda c, index=index: c.apply_preset(index))
                await self.coordinator.async_after_change()
                return


class NinstripSacnOnTimeoutSelect(NinstripSacnEntity, SelectEntity):
    """Was nach dem Ende eines sACN-Stroms passiert.

    release: zurueck zum vorherigen Bild. hold: das letzte Bild bleibt stehen,
    bis ein Bedienbefehl kommt - jede Aenderung ueber Home Assistant holt die
    Kontrolle zurueck.
    """

    _attr_entity_category = EntityCategory.CONFIG
    _attr_translation_key = "sacn_on_timeout"
    _attr_options = ON_TIMEOUT_OPTIONS

    def __init__(self, coordinator: NinstripCoordinator) -> None:
        super().__init__(coordinator, "sacn_on_timeout")

    @property
    def current_option(self) -> str | None:
        value = self.sacn.get("on_timeout")
        return value if value in ON_TIMEOUT_OPTIONS else None

    async def async_select_option(self, option: str) -> None:
        await self.coordinator.async_set_sacn(on_timeout=option)