from __future__ import annotations

import logging
from dataclasses import dataclass
from datetime import datetime
import re
from urllib.parse import quote

import requests

from app.ha.exceptions import (
    HaAuthError,
    HaHttpError,
    HaTimeoutError,
    HaUnexpectedPayloadError,
)

logger = logging.getLogger(__name__)

_ENTITY_ID_PATTERN = re.compile(r"^[a-z0-9_]+\.[a-z0-9_]+$")
_MAX_HISTORY_SECONDS = 31 * 24 * 60 * 60


@dataclass(frozen=True)
class HaClientSettings:
    url: str
    token: str
    timeout_seconds: int = 10


class HaClient:
    def __init__(self, settings: HaClientSettings) -> None:
        self._settings = settings
        self._session = requests.Session()
        self._session.headers.update({
            "Authorization": f"Bearer {settings.token}",
            "Content-Type": "application/json",
        })

    def close(self) -> None:
        self._session.close()

    def list_entities(self) -> list[dict[str, object]]:
        payload = self._get_json("/api/states")
        if not isinstance(payload, list):
            raise HaUnexpectedPayloadError(
                "Antwort von Home Assistant hat unerwartetes Format."
            )
        return payload

    def get_history(
        self,
        entity_ids: list[str],
        start_time: datetime,
        end_time: datetime,
    ) -> list[object]:
        if not entity_ids:
            raise ValueError("Mindestens eine entity_id ist erforderlich.")
        if len(entity_ids) > 100:
            raise ValueError("Es können höchstens 100 Entities abgefragt werden.")
        if any(not _ENTITY_ID_PATTERN.fullmatch(entity_id) for entity_id in entity_ids):
            raise ValueError("entity_id enthält ein ungültiges Format.")
        if start_time.tzinfo is None or end_time.tzinfo is None:
            raise ValueError("start_time und end_time müssen eine Zeitzone enthalten.")
        if end_time <= start_time:
            raise ValueError("end_time muss nach start_time liegen.")
        if (end_time - start_time).total_seconds() > _MAX_HISTORY_SECONDS:
            raise ValueError("History-Abfragen sind auf 31 Tage begrenzt.")

        start = quote(start_time.isoformat(), safe=":+")
        payload = self._get_json(
            f"/api/history/period/{start}",
            params={
                "filter_entity_id": ",".join(entity_ids),
                "end_time": end_time.isoformat(),
                "minimal_response": "1",
                "no_attributes": "1",
            },
        )
        if not isinstance(payload, list):
            raise HaUnexpectedPayloadError(
                "History-Antwort von Home Assistant hat unerwartetes Format."
            )
        return payload

    def _get_json(
        self,
        path: str,
        *,
        params: dict[str, str] | None = None,
    ) -> object:
        try:
            response = self._session.get(
                f"{self._settings.url.rstrip('/')}{path}",
                params=params,
                timeout=self._settings.timeout_seconds,
            )
        except requests.Timeout as exc:
            raise HaTimeoutError("Zeitüberschreitung beim Zugriff auf Home Assistant.") from exc
        except requests.RequestException as exc:
            raise HaHttpError(
                getattr(getattr(exc, "response", None), "status_code", 502),
                "Netzwerkfehler beim Zugriff auf Home Assistant.",
            ) from exc

        if response.status_code in (401, 403):
            raise HaAuthError(
                response.status_code,
                "Authentifizierung bei Home Assistant fehlgeschlagen.",
            )

        try:
            response.raise_for_status()
        except requests.HTTPError as exc:
            raise HaHttpError(
                response.status_code,
                "Home Assistant meldet einen Fehler.",
            ) from exc

        try:
            payload = response.json()
        except ValueError as exc:
            raise HaUnexpectedPayloadError(
                "Antwort von Home Assistant ist kein gültiges JSON."
            ) from exc

        return payload