"""Python wrapper for getting air quality data from GIOS."""

import asyncio
import logging
from collections.abc import Generator
from http import HTTPStatus
from typing import Any, Final, Self, cast

from aiohttp import ClientSession
from dacite import from_dict
from yarl import URL

from .const import (
    ATTR_AQI,
    ATTR_ID,
    ATTR_INDEX,
    ATTR_INDEX_LEVEL,
    ATTR_NAME,
    ATTR_VALUE,
    POLLUTANT_MAP,
    STATE_MAP,
    URL_INDEXES,
    URL_SENSOR,
    URL_STATION,
    URL_STATIONS,
)
from .exceptions import ApiError, InvalidSensorsDataError, NoStationError
from .model import GiosSensors, GiosStation

_LOGGER: Final = logging.getLogger(__name__)


class Gios:
    """Main class to perform GIOS API requests."""

    def __init__(self, station_id: int | None, session: ClientSession) -> None:
        """Initialize."""
        self.station_id = station_id
        self.latitude: float | None = None
        self.longitude: float | None = None
        self.station_name: str | None = None
        self._station_data: list[dict[str, Any]] = []
        self._measurement_stations: dict[int, GiosStation] = {}

        self.session = session

    @classmethod
    async def create(
        cls: type[Self],
        session: ClientSession,
        station_id: int | None = None,
    ) -> Self:
        """Create a new instance."""
        instance = cls(station_id, session)

        await instance.initialize()

        return instance

    async def initialize(self) -> None:
        """Initialize."""
        msg = "Initializing GIOS"
        if self.station_id:
            msg += f" for station ID: {self.station_id}"
        _LOGGER.debug(msg)

        stations = await self._get_stations()
        self._measurement_stations = {
            station.id: station for station in self._parse_stations(stations)
        }

        if self.station_id is None:
            return

        if (station := self.measurement_stations.get(self.station_id)) is None:
            msg = f"{self.station_id} is not a valid measuring station ID"
            raise NoStationError(msg)

        self.latitude = station.latitude
        self.longitude = station.longitude
        self.station_name = station.name

    @property
    def measurement_stations(self) -> dict[int, GiosStation]:
        """Return measurement stations dict."""
        return self._measurement_stations

    async def async_update(self) -> GiosSensors:
        """Update GIOS data."""
        if self.station_id is None:
            msg = "Measuring station ID is not set"
            raise NoStationError(msg)

        data: dict[str, dict[str, Any]] = {}
        invalid_sensors: list[str] = []

        if not self._station_data:
            self._station_data = await self._get_station()

        if not self._station_data:
            msg = "Invalid measuring station data from GIOS API"
            raise InvalidSensorsDataError(msg)

        data = {
            sensor["Wskaźnik - wzór"].lower(): {
                ATTR_ID: sensor["Identyfikator stanowiska"],
                ATTR_NAME: POLLUTANT_MAP[sensor["Wskaźnik"]],
            }
            for sensor in self._station_data
            if sensor["Wskaźnik"] in POLLUTANT_MAP
        }

        sensors = await self._get_all_sensors(data)

        # The GIOS server sends null values for sensors several minutes before
        # adding new data from measuring station. If the newest value is null
        # we take the earlier value.
        for sensor, sensor_data in data.items():
            try:
                sensor_entry = sensors[sensor]["Lista danych pomiarowych"]
                if (
                    sensor_value := sensor_entry[0]["Wartość"]
                    or sensor_entry[1]["Wartość"]
                ):
                    sensor_data[ATTR_VALUE] = sensor_value
                else:
                    invalid_sensors.append(sensor)
            except (IndexError, KeyError, TypeError):
                invalid_sensors.append(sensor)

        for sensor in invalid_sensors:
            data.pop(sensor)

        if not data:
            msg = "Invalid sensor data from GIOS API"
            raise InvalidSensorsDataError(msg)

        indexes = await self._get_indexes()

        for sensor, sensor_data in data.items():
            if index_value := indexes.get("AqIndex", {}).get(
                ATTR_INDEX_LEVEL.format(sensor.upper())
            ):
                sensor_data[ATTR_INDEX] = STATE_MAP[index_value]

        if (aq_index := indexes.get("AqIndex", {})).get(
            "Status indeksu ogólnego dla stacji pomiarowej"
        ) and (index_value := aq_index.get("Nazwa kategorii indeksu")):
            data[ATTR_AQI.lower()] = {
                ATTR_NAME: ATTR_AQI,
                ATTR_VALUE: STATE_MAP[index_value],
            }

        if data.get("pm2.5"):
            data["pm25"] = data.pop("pm2.5")

        result: GiosSensors = from_dict(data_class=GiosSensors, data=data)
        return result

    async def _get_stations(self) -> Any:
        """Retrieve list of measurement stations."""
        result = await self._async_get(URL_STATIONS.with_query(page=0, size=1000))
        return result.get("Lista stacji pomiarowych", [])

    def _parse_stations(self, stations: list[dict[str, Any]]) -> Generator[GiosStation]:
        """Parse stations data."""
        for station in stations:
            yield GiosStation(
                cast(int, station["Identyfikator stacji"]),
                station["Nazwa stacji"],
                float(station["WGS84 φ N"]),
                float(station["WGS84 λ E"]),
            )

    async def _get_station(self) -> Any:
        """Retrieve measuring station data."""
        url = URL_STATION / str(self.station_id)
        result = await self._async_get(url)
        return result.get("Lista stanowisk pomiarowych dla podanej stacji", [])

    async def _get_all_sensors(self, sensors: dict[str, Any]) -> dict[str, Any]:
        """Retrieve all sensors data."""
        tasks = [self._get_sensor(sensors[sensor][ATTR_ID]) for sensor in sensors]
        results = await asyncio.gather(*tasks)
        return dict(zip(sensors, results, strict=True))

    async def _get_sensor(self, sensor: int) -> Any:
        """Retrieve sensor data."""
        url = URL_SENSOR / str(sensor)
        return await self._async_get(url, do_not_raise=True)

    async def _get_indexes(self) -> Any:
        """Retrieve indexes data."""
        url = URL_INDEXES / str(self.station_id)
        return await self._async_get(url)

    async def _async_get(self, url: URL, do_not_raise: bool = False) -> Any:
        """Retrieve data from GIOS API."""
        async with self.session.get(url) as resp:
            _LOGGER.debug("Data retrieved from %s, status: %s", url, resp.status)
            if resp.status != HTTPStatus.OK.value:
                msg = f"Invalid response from GIOS API: {resp.status}"

                if do_not_raise:
                    _LOGGER.info(msg)
                    return {}

                _LOGGER.warning(msg)
                raise ApiError(str(resp.status))

            return await resp.json()