from __future__ import annotations

from dataclasses import dataclass
import logging
from typing import Any

from homeassistant.config_entries import ConfigEntry
from homeassistant.core import Event, HomeAssistant, State
from homeassistant.exceptions import ConfigEntryNotReady
from homeassistant.helpers import event as event_helper

from .const import (
    CONF_ANGLE_ADDRESS,
    CONF_ANGLE_STATE_ADDRESS,
    CONF_COMMAND_ADDRESS,
    CONF_MOVE_LONG_ADDRESS,
    CONF_MOVE_SHORT_ADDRESS,
    CONF_POSITION_ADDRESS,
    CONF_POSITION_STATE_ADDRESS,
    CONF_STATE_ADDRESS,
    CONF_STOP_ADDRESS,
)

_LOGGER = logging.getLogger(__name__)

KNX_DOMAIN = "knx"


@dataclass(frozen=True)
class BinarySensorPort:
    entity_id: str
    state_address: str | None


@dataclass(frozen=True)
class CoverPort:
    entity_id: str
    move_long_address: str | None
    move_short_address: str | None
    stop_address: str | None
    position_address: str | None
    position_state_address: str | None
    angle_address: str | None
    angle_state_address: str | None


@dataclass(frozen=True)
class SwitchPort:
    entity_id: str
    command_address: str | None
    state_address: str | None


class BridgeManager:
    def __init__(self, hass: HomeAssistant, entry: ConfigEntry) -> None:
        self.hass = hass
        self.entry = entry
        self._unsub_listeners: list[callable] = []
        self._knx_event_unsub: callable | None = None
        self._address_handlers: dict[str, callable[[Event], Any]] = {}
        self._registered_addresses: list[tuple[str, str | None]] = []

    async def async_setup(self) -> None:
        if not self.hass.services.has_service(KNX_DOMAIN, "send"):
            raise ConfigEntryNotReady("KNX integration services not available")

        binary_ports, switch_ports, cover_ports = self._load_ports()
        self._register_outgoing(binary_ports, switch_ports, cover_ports)
        await self._register_incoming(switch_ports, cover_ports)

    async def async_unload(self) -> None:
        for unsub in self._unsub_listeners:
            unsub()
        self._unsub_listeners.clear()

        if self._knx_event_unsub is not None:
            self._knx_event_unsub()
            self._knx_event_unsub = None

        await self._unregister_knx_events()

    def _load_ports(
        self,
    ) -> tuple[list[BinarySensorPort], list[SwitchPort], list[CoverPort]]:
        binary_ports: list[BinarySensorPort] = []
        switch_ports: list[SwitchPort] = []
        cover_ports: list[CoverPort] = []

        subentries = getattr(self.entry, "subentries", [])
        for subentry in subentries:
            data = subentry.data
            if subentry.type == "binary_sensor":
                binary_ports.append(
                    BinarySensorPort(
                        entity_id=data["entity_id"],
                        state_address=_clean_address(data.get(CONF_STATE_ADDRESS)),
                    )
                )
            elif subentry.type == "switch":
                switch_ports.append(
                    SwitchPort(
                        entity_id=data["entity_id"],
                        command_address=_clean_address(
                            data.get(CONF_COMMAND_ADDRESS)
                        ),
                        state_address=_clean_address(data.get(CONF_STATE_ADDRESS)),
                    )
                )
            elif subentry.type == "cover":
                cover_ports.append(
                    CoverPort(
                        entity_id=data["entity_id"],
                        move_long_address=_clean_address(data.get(CONF_MOVE_LONG_ADDRESS)),
                        move_short_address=_clean_address(data.get(CONF_MOVE_SHORT_ADDRESS)),
                        stop_address=_clean_address(data.get(CONF_STOP_ADDRESS)),
                        position_address=_clean_address(data.get(CONF_POSITION_ADDRESS)),
                        position_state_address=_clean_address(
                            data.get(CONF_POSITION_STATE_ADDRESS)
                        ),
                        angle_address=_clean_address(data.get(CONF_ANGLE_ADDRESS)),
                        angle_state_address=_clean_address(
                            data.get(CONF_ANGLE_STATE_ADDRESS)
                        ),
                    )
                )

        return binary_ports, switch_ports, cover_ports

    def _register_outgoing(
        self,
        binary_ports: list[BinarySensorPort],
        switch_ports: list[SwitchPort],
        cover_ports: list[CoverPort],
    ) -> None:
        for port in binary_ports:
            if not port.state_address:
                continue
            self._unsub_listeners.append(
                event_helper.async_track_state_change_event(
                    self.hass, [port.entity_id], self._binary_sensor_changed(port)
                )
            )

        for port in switch_ports:
            if not port.state_address:
                continue
            self._unsub_listeners.append(
                event_helper.async_track_state_change_event(
                    self.hass, [port.entity_id], self._switch_changed(port)
                )
            )

        for port in cover_ports:
            if not (port.position_state_address or port.angle_state_address):
                continue
            self._unsub_listeners.append(
                event_helper.async_track_state_change_event(
                    self.hass, [port.entity_id], self._cover_changed(port)
                )
            )

    async def _register_incoming(
        self, switch_ports: list[SwitchPort], cover_ports: list[CoverPort]
    ) -> None:
        for port in switch_ports:
            self._register_knx_switch_address(port.command_address, port)

        for port in cover_ports:
            self._register_knx_address(port.move_long_address, None, port, "move_long")
            self._register_knx_address(port.move_short_address, None, port, "move_short")
            self._register_knx_address(port.stop_address, None, port, "stop")
            self._register_knx_address(
                port.position_address, "percent", port, "position"
            )
            self._register_knx_address(
                port.angle_address, "percent", port, "angle"
            )

        if self._address_handlers:
            self._knx_event_unsub = event_helper.async_track_event(
                self.hass, "knx_event", self._handle_knx_event
            )

        await self._register_knx_events()

    def _register_knx_address(
        self,
        address: str | None,
        value_type: str | None,
        port: CoverPort,
        action: str,
    ) -> None:
        if not address:
            return

        self._address_handlers[address] = lambda event: self._handle_cover_action(
            port, action, event
        )
        self._registered_addresses.append((address, value_type))

    def _register_knx_switch_address(
        self,
        address: str | None,
        port: SwitchPort,
    ) -> None:
        if not address:
            return
        self._address_handlers[address] = lambda event: self._handle_switch_action(
            port, event
        )
        self._registered_addresses.append((address, None))

    async def _register_knx_events(self) -> None:
        for address, value_type in self._registered_addresses:
            data: dict[str, Any] = {"address": address}
            if value_type:
                data["type"] = value_type
            await self.hass.services.async_call(
                KNX_DOMAIN, "event_register", data, blocking=False
            )

    async def _unregister_knx_events(self) -> None:
        for address, value_type in self._registered_addresses:
            data: dict[str, Any] = {"address": address, "remove": True}
            if value_type:
                data["type"] = value_type
            await self.hass.services.async_call(
                KNX_DOMAIN, "event_register", data, blocking=False
            )
        self._registered_addresses.clear()

    def _binary_sensor_changed(self, port: BinarySensorPort) -> callable[[Event], Any]:
        async def _handler(event: Event) -> None:
            new_state: State | None = event.data.get("new_state")
            if new_state is None:
                return
            if new_state.state not in ("on", "off"):
                return
            payload = 1 if new_state.state == "on" else 0
            await self._knx_send_raw(port.state_address, payload)

        return _handler

    def _switch_changed(self, port: SwitchPort) -> callable[[Event], Any]:
        async def _handler(event: Event) -> None:
            new_state: State | None = event.data.get("new_state")
            if new_state is None:
                return
            if new_state.state not in ("on", "off"):
                return
            payload = 1 if new_state.state == "on" else 0
            await self._knx_send_raw(port.state_address, payload)

        return _handler

    def _cover_changed(self, port: CoverPort) -> callable[[Event], Any]:
        async def _handler(event: Event) -> None:
            new_state: State | None = event.data.get("new_state")
            if new_state is None:
                return

            if port.position_state_address is not None:
                position = new_state.attributes.get("current_position")
                if position is not None:
                    await self._knx_send_percent(port.position_state_address, position)

            if port.angle_state_address is not None:
                angle = new_state.attributes.get("current_tilt_position")
                if angle is not None:
                    await self._knx_send_percent(port.angle_state_address, angle)

        return _handler

    async def _handle_knx_event(self, event: Event) -> None:
        if event.data.get("direction") != "Incoming":
            return

        destination = event.data.get("destination")
        if not destination:
            return

        handler = self._address_handlers.get(destination)
        if handler is None:
            return

        await handler(event)

    async def _handle_cover_action(
        self, port: CoverPort, action: str, event: Event
    ) -> None:
        value = _extract_event_value(event)
        if value is None:
            return

        if action == "move_long":
            if value == 0:
                await self._call_cover_service(port.entity_id, "open_cover")
            elif value == 1:
                await self._call_cover_service(port.entity_id, "close_cover")
        elif action == "move_short":
            if value in (0, 1):
                await self._call_cover_service(port.entity_id, "stop_cover")
        elif action == "stop":
            if value in (0, 1):
                await self._call_cover_service(port.entity_id, "stop_cover")
        elif action == "position":
            await self._call_cover_service(
                port.entity_id, "set_cover_position", {"position": value}
            )
        elif action == "angle":
            await self._call_cover_service(
                port.entity_id, "set_cover_tilt_position", {"tilt_position": value}
            )

    async def _handle_switch_action(self, port: SwitchPort, event: Event) -> None:
        value = _extract_event_value(event)
        if value is None:
            return
        if value == 0:
            await self._call_switch_service(port.entity_id, "turn_off")
        elif value == 1:
            await self._call_switch_service(port.entity_id, "turn_on")

    async def _call_cover_service(
        self, entity_id: str, service: str, service_data: dict[str, Any] | None = None
    ) -> None:
        data = {"entity_id": entity_id}
        if service_data:
            data.update(service_data)
        await self.hass.services.async_call(
            "cover", service, data, blocking=False
        )

    async def _call_switch_service(
        self, entity_id: str, service: str, service_data: dict[str, Any] | None = None
    ) -> None:
        data = {"entity_id": entity_id}
        if service_data:
            data.update(service_data)
        await self.hass.services.async_call(
            "switch", service, data, blocking=False
        )

    async def _knx_send_raw(self, address: str | None, payload: int) -> None:
        if not address:
            return
        await self.hass.services.async_call(
            KNX_DOMAIN,
            "send",
            {"address": address, "payload": payload, "payload_length": 0},
            blocking=False,
        )

    async def _knx_send_percent(self, address: str | None, value: int) -> None:
        if not address:
            return
        await self.hass.services.async_call(
            KNX_DOMAIN,
            "send",
            {"address": address, "payload": value, "type": "percent"},
            blocking=False,
        )


def _extract_event_value(event: Event) -> int | None:
    if "value" in event.data:
        try:
            return int(event.data["value"])
        except (TypeError, ValueError):
            return None
    data = event.data.get("data")
    if data is None:
        return None
    if isinstance(data, list) and data:
        data = data[0]
    try:
        return int(data) & 1
    except (TypeError, ValueError):
        return None


def _clean_address(address: Any) -> str | None:
    if not address:
        return None
    if isinstance(address, str):
        stripped = address.strip()
        return stripped or None
    return None