# SPDX-License-Identifier: AGPL-3.0-or-later
"""Implementations used for weather conditions and forecast."""
# pylint: disable=too-few-public-methods
from __future__ import annotations

__all__ = [
    "symbol_url",
    "Temperature",
    "Pressure",
    "WindSpeed",
    "RelativeHumidity",
    "Compass",
    "WeatherConditionType",
]

import typing

import base64
import babel
import babel.numbers

from searx import network
from searx.cache import ExpireCache, ExpireCacheCfg
from searx.extended_types import sxng_request
from searx.wikidata_units import convert_to_si, convert_from_si

WEATHER_SYMBOL_CACHE: ExpireCache = None  # type: ignore
"""A simple cache for weather condition icons."""

YR_WEATHER_SYMBOL_URL = "https://raw.githubusercontent.com/nrkno/yr-weather-symbols/refs/heads/master/symbols/outline"


def _get_locale_tag() -> str:
    # pylint: disable=import-outside-toplevel,disable=cyclic-import
    from searx import query
    from searx.preferences import ClientPref

    query = query.RawTextQuery(sxng_request.form.get("q", ""), [])
    if query.languages and query.languages[0] not in ["all", "auto"]:
        return query.languages[0]

    search_lang = sxng_request.form.get("language")
    if search_lang and search_lang not in ["all", "auto"]:
        return search_lang

    client_pref = ClientPref.from_http_request(sxng_request)
    search_lang = client_pref.locale_tag
    if search_lang and search_lang not in ["all", "auto"]:
        return search_lang
    return "en"


def symbol_url(condition: WeatherConditionType) -> str | None:
    """Returns ``data:`` URL for the weather condition symbol or ``None`` if
    the condition is not of type :py:obj:`WeatherConditionType`.

    If symbol (SVG) is not already in the :py:obj:`WEATHER_SYMBOL_CACHE` its
    fetched from https://github.com/nrkno/yr-weather-symbols

    .. todo::

        Symbols for darkmode/lightmode .. and day/night symnbols (for latter we
        need a geopint / critical)
    """
    global WEATHER_SYMBOL_CACHE  # pylint: disable=global-statement

    fname = YR_WEATHER_SYMBOL_MAP.get(condition)
    if fname is None:
        return None

    if WEATHER_SYMBOL_CACHE is None:
        WEATHER_SYMBOL_CACHE = ExpireCache.build_cache(
            ExpireCacheCfg(
                name="WEATHER_SYMBOL_CACHE",
                MAX_VALUE_LEN=1024 * 200,  # max. 200kB per icon (icons have most often 10-20kB)
            )
        )

    origin_url = f"{YR_WEATHER_SYMBOL_URL}/{fname}.svg"
    data_url = WEATHER_SYMBOL_CACHE.get(origin_url)
    if data_url is not None:
        return data_url

    response = network.get(origin_url, timeout=3)
    if response and response.status_code == 200:
        mimetype = response.headers['Content-Type']
        data_url = f"data:{mimetype};base64,{str(base64.b64encode(response.content), 'utf-8')}"
        WEATHER_SYMBOL_CACHE.set(key=origin_url, value=data_url, expire=None)
    return data_url


class Temperature:
    """Class for converting temperature units and for string representation of
    measured values."""

    si_name = "Q11579"

    Units = typing.Literal["°C", "°F", "K"]
    """Supported temperature units."""

    units = list(typing.get_args(Units))

    def __init__(self, value: float, unit: Units):
        if unit not in self.units:
            raise ValueError(f"invalid unit: {unit}")
        self.si: float = convert_to_si(  # pylint: disable=invalid-name
            si_name=self.si_name,
            symbol=unit,
            value=value,
        )

    def __str__(self):
        return self.l10n()

    def value(self, unit: Units) -> float:
        return convert_from_si(si_name=self.si_name, symbol=unit, value=self.si)

    def l10n(
        self,
        unit: Units | None = None,
        locale: babel.Locale | None = None,
        template: str = "{value} {unit}",
        num_pattern: str = "#,##0",
    ) -> str:
        """Localized representation of a measured value.

        If the ``unit`` is not set, an attempt is made to determine a ``unit``
        matching the territory of the ``locale``.  If the locale is not set, an
        attempt is made to determine it from the HTTP request.

        The value is converted into the respective unit before formatting.

        The argument ``num_pattern`` is used to determine the string formatting
        of the numerical value:

        - https://babel.pocoo.org/en/latest/numbers.html#pattern-syntax
        - https://unicode.org/reports/tr35/tr35-numbers.html#Number_Format_Patterns

        The argument ``template`` specifies how the **string formatted** value
        and unit are to be arranged.

        - `Format Specification Mini-Language
          <https://docs.python.org/3/library/string.html#format-specification-mini-language>`.
        """
        if locale is None:
            locale = babel.Locale.parse(_get_locale_tag(), sep='-')

        if unit is None:  # unit by territory
            unit = "°C"
            if locale.territory in ["US"]:
                unit = "°F"
        val_str = babel.numbers.format_decimal(self.value(unit), locale=locale, format=num_pattern)
        return template.format(value=val_str, unit=unit)


class Pressure:
    """Class for converting pressure units and for string representation of
    measured values."""

    si_name = "Q44395"

    Units = typing.Literal["Pa", "hPa", "cm Hg", "bar"]
    """Supported units."""

    units = list(typing.get_args(Units))

    def __init__(self, value: float, unit: Units):
        if unit not in self.units:
            raise ValueError(f"invalid unit: {unit}")
        # pylint: disable=invalid-name
        self.si: float = convert_to_si(si_name=self.si_name, symbol=unit, value=value)

    def __str__(self):
        return self.l10n()

    def value(self, unit: Units) -> float:
        return convert_from_si(si_name=self.si_name, symbol=unit, value=self.si)

    def l10n(
        self,
        unit: Units | None = None,
        locale: babel.Locale | None = None,
        template: str = "{value} {unit}",
        num_pattern: str = "#,##0",
    ) -> str:
        if locale is None:
            locale = babel.Locale.parse(_get_locale_tag(), sep='-')

        if unit is None:  # unit by territory?
            unit = "hPa"

        val_str = babel.numbers.format_decimal(self.value(unit), locale=locale, format=num_pattern)
        return template.format(value=val_str, unit=unit)


class WindSpeed:
    """Class for converting speed or velocity units and for string
    representation of measured values.

    .. hint::

       Working with unit ``Bft`` (:py:obj:`searx.wikidata_units.Beaufort`) will
       throw a :py:obj:`ValueError` for egative values or values greater 16 Bft
       (55.6 m/s)
    """

    si_name = "Q182429"

    Units = typing.Literal["m/s", "km/h", "kn", "mph", "mi/h", "Bft"]
    """Supported units."""

    units = list(typing.get_args(Units))

    def __init__(self, value: float, unit: Units):
        if unit not in self.units:
            raise ValueError(f"invalid unit: {unit}")
        # pylint: disable=invalid-name
        self.si: float = convert_to_si(si_name=self.si_name, symbol=unit, value=value)

    def __str__(self):
        return self.l10n()

    def value(self, unit: Units) -> float:
        return convert_from_si(si_name=self.si_name, symbol=unit, value=self.si)

    def l10n(
        self,
        unit: Units | None = None,
        locale: babel.Locale | None = None,
        template: str = "{value} {unit}",
        num_pattern: str = "#,##0",
    ) -> str:
        if locale is None:
            locale = babel.Locale.parse(_get_locale_tag(), sep='-')

        if unit is None:  # unit by territory?
            unit = "m/s"

        val_str = babel.numbers.format_decimal(self.value(unit), locale=locale, format=num_pattern)
        return template.format(value=val_str, unit=unit)


class RelativeHumidity:
    """Amount of relative humidity in the air. The unit is ``%``"""

    Units = typing.Literal["%"]
    """Supported unit."""

    units = list(typing.get_args(Units))

    def __init__(self, humidity: float):
        self.humidity = humidity

    def __str__(self):
        return self.l10n()

    def value(self) -> float:
        return self.humidity

    def l10n(
        self,
        locale: babel.Locale | None = None,
        template: str = "{value}{unit}",
        num_pattern: str = "#,##0",
    ) -> str:
        if locale is None:
            locale = babel.Locale.parse(_get_locale_tag(), sep='-')

        unit = "%"
        val_str = babel.numbers.format_decimal(self.value(), locale=locale, format=num_pattern)
        return template.format(value=val_str, unit=unit)


class Compass:
    """Class for converting compass points and azimuth values (360°)"""

    Units = typing.Literal["°", "Point"]

    Point = typing.Literal[
        "N", "NNE", "NE", "ENE", "E", "ESE", "SE", "SSE", "S", "SSW", "SW", "WSW", "W", "WNW", "NW", "NNW"
    ]
    """Compass point type definition"""

    TURN = 360.0
    """Full turn (360°)"""

    POINTS = list(typing.get_args(Point))
    """Compass points."""

    RANGE = TURN / len(POINTS)
    """Angle sector of a compass point"""

    def __init__(self, azimuth: float | int | Point):
        if isinstance(azimuth, str):
            if azimuth not in self.POINTS:
                raise ValueError(f"Invalid compass point: {azimuth}")
            azimuth = self.POINTS.index(azimuth) * self.RANGE
        self.azimuth = azimuth % self.TURN

    def __str__(self):
        return self.l10n()

    def value(self, unit: Units):
        if unit == "Point":
            return self.point(self.azimuth)
        if unit == "°":
            return self.azimuth
        raise ValueError(f"unknown unit: {unit}")

    @classmethod
    def point(cls, azimuth: float | int) -> Point:
        """Returns the compass point to an azimuth value."""
        azimuth = azimuth % cls.TURN
        # The angle sector of a compass point starts 1/2 sector range before
        # and after compass point (example: "N" goes from -11.25° to +11.25°)
        azimuth = azimuth - cls.RANGE / 2
        idx = int(azimuth // cls.RANGE)
        return cls.POINTS[idx]

    def l10n(
        self,
        unit: Units = "Point",
        locale: babel.Locale | None = None,
        template: str = "{value}{unit}",
        num_pattern: str = "#,##0",
    ) -> str:
        if locale is None:
            locale = babel.Locale.parse(_get_locale_tag(), sep='-')

        if unit == "Point":
            val_str = self.value(unit)
            return template.format(value=val_str, unit="")

        val_str = babel.numbers.format_decimal(self.value(unit), locale=locale, format=num_pattern)
        return template.format(value=val_str, unit=unit)


WeatherConditionType = typing.Literal[
    # The capitalized string goes into to i18n/l10n (en: "Clear sky" -> de: "wolkenloser Himmel")
    "clear sky",
    "cloudy",
    "fair",
    "fog",
    "heavy rain and thunder",
    "heavy rain showers and thunder",
    "heavy rain showers",
    "heavy rain",
    "heavy sleet and thunder",
    "heavy sleet showers and thunder",
    "heavy sleet showers",
    "heavy sleet",
    "heavy snow and thunder",
    "heavy snow showers and thunder",
    "heavy snow showers",
    "heavy snow",
    "light rain and thunder",
    "light rain showers and thunder",
    "light rain showers",
    "light rain",
    "light sleet and thunder",
    "light sleet showers and thunder",
    "light sleet showers",
    "light sleet",
    "light snow and thunder",
    "light snow showers and thunder",
    "light snow showers",
    "light snow",
    "partly cloudy",
    "rain and thunder",
    "rain showers and thunder",
    "rain showers",
    "rain",
    "sleet and thunder",
    "sleet showers and thunder",
    "sleet showers",
    "sleet",
    "snow and thunder",
    "snow showers and thunder",
    "snow showers",
    "snow",
]
"""Standardized designations for weather conditions.  The designators were
taken from a collaboration between NRK and Norwegian Meteorological Institute
(yr.no_).  `Weather symbols`_ can be assigned to the identifiers
(weathericons_) and they are included in the translation (i18n/l10n
:origin:`searx/searxng.msg`).

.. _yr.no: https://www.yr.no/en
.. _Weather symbols: https://github.com/nrkno/yr-weather-symbols
.. _weathericons: https://github.com/metno/weathericons
"""

YR_WEATHER_SYMBOL_MAP = {
    "clear sky": "01d",  # 01d clearsky_day
    "fair": "02d",  # 02d fair_day
    "partly cloudy": "03d",  # 03d partlycloudy_day
    "cloudy": "04",  # 04 cloudy
    "light rain showers": "40d",  # 40d lightrainshowers_day
    "rain showers": "05d",  # 05d rainshowers_day
    "heavy rain showers": "41d",  # 41d heavyrainshowers_day
    "light rain showers and thunder": "24d",  # 24d lightrainshowersandthunder_day
    "rain showers and thunder": "06d",  # 06d rainshowersandthunder_day
    "heavy rain showers and thunder": "25d",  # 25d heavyrainshowersandthunder_day
    "light sleet showers": "42d",  # 42d lightsleetshowers_day
    "sleet showers": "07d",  # 07d sleetshowers_day
    "heavy sleet showers": "43d",  # 43d heavysleetshowers_day
    "light sleet showers and thunder": "26d",  # 26d lightssleetshowersandthunder_day
    "sleet showers and thunder": "20d",  # 20d sleetshowersandthunder_day
    "heavy sleet showers and thunder": "27d",  # 27d heavysleetshowersandthunder_day
    "light snow showers": "44d",  # 44d lightsnowshowers_day
    "snow showers": "08d",  # 08d snowshowers_day
    "heavy snow showers": "45d",  # 45d heavysnowshowers_day
    "light snow showers and thunder": "28d",  # 28d lightssnowshowersandthunder_day
    "snow showers and thunder": "21d",  # 21d snowshowersandthunder_day
    "heavy snow showers and thunder": "29d",  # 29d heavysnowshowersandthunder_day
    "light rain": "46",  # 46 lightrain
    "rain": "09",  # 09 rain
    "heavy rain": "10",  # 10 heavyrain
    "light rain and thunder": "30",  # 30 lightrainandthunder
    "rain and thunder": "22",  # 22 rainandthunder
    "heavy rain and thunder": "11",  # 11 heavyrainandthunder
    "light sleet": "47",  # 47 lightsleet
    "sleet": "12",  # 12 sleet
    "heavy sleet": "48",  # 48 heavysleet
    "light sleet and thunder": "31",  # 31 lightsleetandthunder
    "sleet and thunder": "23",  # 23 sleetandthunder
    "heavy sleet and thunder": "32",  # 32 heavysleetandthunder
    "light snow": "49",  # 49 lightsnow
    "snow": "13",  # 13 snow
    "heavy snow": "50",  # 50 heavysnow
    "light snow and thunder": "33",  # 33 lightsnowandthunder
    "snow and thunder": "14",  # 14 snowandthunder
    "heavy snow and thunder": "34",  # 34 heavysnowandthunder
    "fog": "15",  # 15 fog
}
"""Map a :py:obj:`WeatherConditionType` to a `YR weather symbol`_

.. code::

   base_url = "https://raw.githubusercontent.com/nrkno/yr-weather-symbols/refs/heads/master/symbols"
   icon_url = f"{base_url}/outline/{YR_WEATHER_SYMBOL_MAP['sleet showers']}.svg"

.. _YR weather symbol: https://github.com/nrkno/yr-weather-symbols/blob/master/locales/en.json

"""

if __name__ == "__main__":

    # test: fetch all symbols of the type catalog ..
    for c in typing.get_args(WeatherConditionType):
        symbol_url(condition=c)

    title = "cached weather condition symbols"
    print(title)
    print("=" * len(title))
    print(WEATHER_SYMBOL_CACHE.state().report())
    print()
    title = f"properties of {WEATHER_SYMBOL_CACHE.cfg.name}"
    print(title)
    print("=" * len(title))
    print(str(WEATHER_SYMBOL_CACHE.properties))  # type: ignore