from typing import List, Tuple, Optional, Any
from aiohttp import ClientSession, BasicAuth, TCPConnector
import logging
import asyncio
from pydantic import BaseModel, Field


logger = logging.getLogger(__name__)


DEVICE_TYPE_LOCK = "HmIP-DLD"
CHANNEL_TYPES_RELEVANT = ["DOOR_LOCK_STATE_TRANSMITTER", "MAINTENANCE"]
PARAM_ADDRESSES_RELEVANT = [
    "ACTIVITY_STATE",
    "LOCK_STATE",
    "LOCK_TARGET_LEVEL",
    "ERROR_JAMMED",
    "LOW_BAT",
    "UNREACH",
]


class CCURef(BaseModel):
    href: str
    rel: str
    title: str


class CCUDeviceList(BaseModel):
    description: str
    identifier: str
    title: str
    links: List[CCURef] = Field(alias="~links")


class CCUDeviceInfo(BaseModel):
    address: str
    identifier: str
    title: str
    type: str
    links: List[CCURef] = Field(alias="~links")


class CCUChannelInfo(BaseModel):
    address: Optional[str] = None
    index: Optional[int] = None
    title: str
    description: str = Field(default="")
    type: Optional[str] = Field(default=None)
    links: List[CCURef] = Field(alias="~links")


class CCUParamInfo(BaseModel):
    id: str
    mqttStatusTopic: str
    links: List[CCURef] = Field(alias="~links")


class CCUValue(BaseModel):
    s: int
    ts: int
    v: Any


LockData = List[Tuple[CCUDeviceInfo, List[Tuple[CCUChannelInfo, List[CCUParamInfo]]]]]


class CCUJackClient:
    base_uri: str
    locks: LockData

    def __init__(self, base_uri: str, auth: BasicAuth):
        self.http = ClientSession(
            base_url=base_uri,
            auth=auth,
            raise_for_status=True,
            connector=TCPConnector(ssl=False),
        )
        self.locks = None

    async def find_locks(self):
        logger.debug("Inspecting lock devices present in CCUJack")
        async with self.http.get("/device") as resp:
            devices = CCUDeviceList.model_validate(await resp.json())

            device_infos = await asyncio.gather(
                *[
                    self._inspect_ccu_device(i)
                    for i in devices.links
                    if i.rel == "device"
                ]
            )

            self.locks = [i for i in device_infos if i[0].type == DEVICE_TYPE_LOCK]

    async def query_param_value(self, address: str):
        logger.debug("Querying parameter value from '%s'", address)
        async with self.http.get(f"/device/{address}/~pv") as resp:
            return CCUValue.model_validate(await resp.json())

    async def set_param_value(self, address: str, value: Any):
        logger.debug("Writing parameter value '%s' to '%s'", value, address)
        await self.http.put(f"/device/{address}/~pv", json={"v": value})

    async def _inspect_ccu_device(
        self, device_ref: CCURef
    ) -> Tuple[CCUDeviceInfo, List[Tuple[CCUChannelInfo, List[CCUParamInfo]]]]:
        logger.debug("Inspecting device '%s' (%s)", device_ref.href, device_ref.title)
        async with self.http.get(f"/device/{device_ref.href}") as resp:
            device_info = CCUDeviceInfo.model_validate(await resp.json())

            if device_info.type != DEVICE_TYPE_LOCK:
                return device_info, []

            channel_infos = await asyncio.gather(
                *[
                    self._inspect_ccu_channel(device_ref, i)
                    for i in device_info.links
                    if i.rel == "channel"
                ]
            )

            return device_info, [
                i for i in channel_infos if i[0].type in CHANNEL_TYPES_RELEVANT
            ]

    async def _inspect_ccu_channel(
        self, device_ref: CCURef, channel_ref: CCURef
    ) -> Tuple[CCUChannelInfo, List[CCUParamInfo]]:
        logger.debug(
            "Inspecting device channel '%s/%s'", device_ref.href, channel_ref.href
        )
        async with self.http.get(
            f"/device/{device_ref.href}/{channel_ref.href}"
        ) as resp:
            channel_info = CCUChannelInfo.model_validate(await resp.json())

            param_infos = await asyncio.gather(
                *[
                    self._inspect_ccu_param(device_ref, channel_ref, i)
                    for i in channel_info.links
                    if i.rel == "parameter" and i.href in PARAM_ADDRESSES_RELEVANT
                ]
            )

            return channel_info, param_infos

    async def _inspect_ccu_param(
        self, device_ref: CCURef, channel_ref: CCURef, param_ref: CCURef
    ) -> CCUParamInfo:
        logger.debug(
            "Inspecting device parameter '%s/%s/%s'",
            device_ref.href,
            channel_ref.href,
            param_ref.href,
        )
        async with self.http.get(
            f"/device/{device_ref.href}/{channel_ref.href}/{param_ref.href}"
        ) as resp:
            return CCUParamInfo.model_validate(await resp.json())