"""Service Open-Meteo — enrichi avec sol, ETP, humidité, données passées."""
import logging
from datetime import datetime, date, timezone
from typing import Any

import httpx

from app.config import METEO_LAT, METEO_LON

logger = logging.getLogger(__name__)

WMO_LABELS = {
    0: "Ensoleillé", 1: "Principalement ensoleillé", 2: "Partiellement nuageux",
    3: "Couvert", 45: "Brouillard", 48: "Brouillard givrant",
    51: "Bruine légère", 53: "Bruine modérée", 55: "Bruine dense",
    61: "Pluie légère", 63: "Pluie modérée", 65: "Pluie forte",
    71: "Neige légère", 73: "Neige modérée", 75: "Neige forte",
    80: "Averses légères", 81: "Averses modérées", 82: "Averses violentes",
    85: "Averses de neige", 95: "Orage", 96: "Orage avec grêle", 99: "Orage violent",
}

# Champs daily disponibles (noms v1 actuels de l'API Open-Meteo)
# Nota : soil_temperature_0cm est hourly uniquement ; windspeed_10m_max et
# weathercode ont été renommés en wind_speed_10m_max et weather_code.
_DAILY_FIELDS = [
    "temperature_2m_max",
    "temperature_2m_min",
    "precipitation_sum",
    "wind_speed_10m_max",
    "weather_code",
    "relative_humidity_2m_max",
    "et0_fao_evapotranspiration",
]

_HOURLY_FIELDS = [
    "soil_temperature_0cm",
]


def _to_float(value: Any) -> float | None:
    if value is None:
        return None
    try:
        return float(value)
    except (TypeError, ValueError):
        return None


def _value_at(values: list[Any], index: int, default: Any = None) -> Any:
    if index < 0 or index >= len(values):
        return default
    return values[index]


def _daily_soil_average(raw: dict[str, Any]) -> dict[str, float]:
    """Construit un mapping ISO-date -> moyenne de soil_temperature_0cm."""
    hourly = raw.get("hourly", {})
    times = hourly.get("time", []) or []
    soils = hourly.get("soil_temperature_0cm", []) or []
    by_day: dict[str, list[float]] = {}

    for idx, ts in enumerate(times):
        soil = _to_float(_value_at(soils, idx))
        if soil is None or not isinstance(ts, str) or len(ts) < 10:
            continue
        day = ts[:10]
        by_day.setdefault(day, []).append(soil)

    return {
        day: round(sum(vals) / len(vals), 2)
        for day, vals in by_day.items()
        if vals
    }


def fetch_and_store_forecast(lat: float = METEO_LAT, lon: float = METEO_LON) -> list[dict]:
    """Appelle Open-Meteo et retourne la liste des jours (past_days=7 + forecast=8).

    Retourne la liste des jours pour être stockée en base par le scheduler.
    """
    url = "https://api.open-meteo.com/v1/forecast"
    # Passer chaque champ séparément (liste de tuples) pour éviter l'encodage
    # d'une chaîne CSV qui est rejetée par certaines versions de l'API.
    params: list[tuple[str, Any]] = [
        ("latitude", lat),
        ("longitude", lon),
        ("past_days", 7),
        ("forecast_days", 8),
        ("timezone", "Europe/Paris"),
    ]
    for field in _DAILY_FIELDS:
        params.append(("daily", field))
    for field in _HOURLY_FIELDS:
        params.append(("hourly", field))

    try:
        r = httpx.get(url, params=params, timeout=15)
        r.raise_for_status()
        raw = r.json()
    except Exception as e:
        logger.error(f"Open-Meteo fetch error: {e}")
        return []

    daily = raw.get("daily", {})
    dates = daily.get("time", [])
    soil_by_day = _daily_soil_average(raw)
    now_iso = datetime.now(timezone.utc).isoformat()
    rows = []

    for i, d in enumerate(dates):
        code = int(_value_at(daily.get("weather_code", []), i, 0) or 0)
        row = {
            "date": d,
            "t_min": _to_float(_value_at(daily.get("temperature_2m_min", []), i)),
            "t_max": _to_float(_value_at(daily.get("temperature_2m_max", []), i)),
            "pluie_mm": _to_float(_value_at(daily.get("precipitation_sum", []), i, 0.0)) or 0.0,
            "vent_kmh": _to_float(_value_at(daily.get("wind_speed_10m_max", []), i, 0.0)) or 0.0,
            "wmo": code,
            "label": WMO_LABELS.get(code, f"Code {code}"),
            "humidite_moy": _to_float(_value_at(daily.get("relative_humidity_2m_max", []), i)),
            "sol_0cm": soil_by_day.get(d),
            "etp_mm": _to_float(_value_at(daily.get("et0_fao_evapotranspiration", []), i)),
            "fetched_at": now_iso,
        }
        rows.append(row)

    return rows


def fetch_forecast(lat: float = METEO_LAT, lon: float = METEO_LON, days: int = 14) -> dict[str, Any]:
    """Compatibilité ascendante avec l'ancien endpoint GET /api/meteo."""
    rows = fetch_and_store_forecast(lat, lon)
    # Filtrer seulement les jours futurs (à partir d'aujourd'hui)
    today = date.today().isoformat()
    future = [r for r in rows if r["date"] >= today][:days]
    return {"days": future}