"""QWeather client: JWT auth, real-time weather, city search, intelligent caching."""
import json
import requests
from datetime import datetime
from backend.time_util import now as tz_now, strftime as tz_strftime, strptime as tz_strptime, localize as tz_localize
from flask import current_app
from backend.models import get_db
from backend.jwt_util import sign_jwt, generate_key_pair

# QWeather API host (shared dev host, or user's dedicated host)
QWEATHER_API = "https://devapi.qweather.com"
QWEATHER_GEO_API = "https://geoapi.qweather.com"

# Cache TTL in seconds (default 30 min)
CACHE_TTL = 1800


# ─── Config ────────────────────────────────

def _uid() -> int:
    """Resolve the current user (request session or scheduler thread)."""
    try:
        from backend.auth import current_user_id
        return current_user_id() or 0
    except Exception:
        return 0


def get_config(user_id: int = None) -> dict:
    if user_id is None:
        user_id = _uid()
    db = get_db(current_app.config["DB_PATH"])
    row = db.execute("SELECT * FROM weather_config WHERE user_id=?", (user_id,)).fetchone()
    db.close()
    return dict(row) if row else {"user_id": user_id}


def update_config(api_key: str = None,
                  city: str = None, lat: float = None, lon: float = None,
                  units: str = None, update_interval: int = None,
                  credential_id: str = None, project_id: str = None,
                  qweather_host: str = None, user_id: int = None):
    if user_id is None:
        user_id = _uid()
    if qweather_host is not None and qweather_host.strip():
        from backend.url_util import is_safe_https_host
        if not is_safe_https_host(qweather_host):
            raise ValueError("API Host 无效或不安全：仅允许公网域名（如 abc123.def.qweatherapi.com）")
    db = get_db(current_app.config["DB_PATH"])
    fields = []
    vals = []
    for key, val in [
        ("api_key", api_key),
        ("city", city), ("lat", lat), ("lon", lon),
        ("units", units), ("update_interval", update_interval),
        ("credential_id", credential_id), ("project_id", project_id),
        ("qweather_host", qweather_host),
    ]:
        if val is not None:
            fields.append(f"{key}=?")
            vals.append(val)
    row = db.execute("SELECT id FROM weather_config WHERE user_id=?", (user_id,)).fetchone()
    if row is None:
        db.execute("INSERT INTO weather_config (user_id) VALUES (?)", (user_id,))
    if fields:
        vals.append(user_id)
        db.execute(f"UPDATE weather_config SET {', '.join(fields)} WHERE user_id=?", vals)
        db.commit()
    db.close()


def generate_weather_keys() -> dict:
    """Generate new Ed25519 key pair for QWeather JWT auth.
    
    Returns:
        dict with public_key (private key stored in DB)
    """
    priv, pub = generate_key_pair()
    user_id = _uid()
    db = get_db(current_app.config["DB_PATH"])
    row = db.execute("SELECT id FROM weather_config WHERE user_id=?", (user_id,)).fetchone()
    if row is None:
        db.execute("INSERT INTO weather_config (user_id) VALUES (?)", (user_id,))
    db.execute(
        "UPDATE weather_config SET jwt_private_key=?, jwt_public_key=? WHERE user_id=?",
        (priv, pub, user_id)
    )
    db.commit()
    db.close()
    return {"public_key": pub}


# ─── JWT Token ─────────────────────────────

def _get_auth_header(cfg: dict) -> dict:
    """Build the Authorization header for QWeather API.

    仅和风天气。优先 JWT（credential_id + project_id + jwt_private_key），
    否则回退到和风旧版 API Key（X-QW-Api-Key）。
    """
    priv_key = cfg.get("jwt_private_key", "")
    kid = cfg.get("credential_id", "")
    sub = cfg.get("project_id", "")

    if priv_key and kid and sub:
        token = sign_jwt(priv_key, kid, sub)
        return {"Authorization": f"Bearer {token}"}

    api_key = cfg.get("api_key", "")
    if api_key:
        return {"X-QW-Api-Key": api_key}

    return {}


# ─── API Host ──────────────────────────────

def _api_host(cfg: dict) -> str:
    host = cfg.get("qweather_host", "").strip()
    from backend.url_util import is_safe_https_host
    if host and is_safe_https_host(host):
        return f"https://{host}"
    return QWEATHER_API


def _geo_host(cfg: dict) -> str:
    # If user has a dedicated host, GeoAPI is under the same host
    host = cfg.get("qweather_host", "").strip()
    from backend.url_util import is_safe_https_host
    if host and is_safe_https_host(host):
        return f"https://{host}"
    return QWEATHER_GEO_API


# ─── City Lookup ───────────────────────────

def city_lookup(query: str, number: int = 10) -> list:
    """Search cities via QWeather GeoAPI.
    
    Returns list of {name, id, lat, lon, adm1, adm2, country}
    """
    cfg = get_config()
    headers = _get_auth_header(cfg)
    if not headers:
        return []

    host = _geo_host(cfg)
    url = f"{host}/v2/city/lookup"
    params = {
        "location": query,
        "number": min(number, 20),
        "lang": "zh",
    }

    try:
        resp = requests.get(url, params=params, headers=headers, timeout=8)
        if resp.status_code != 200:
            current_app.logger.error(f"City lookup failed: {resp.status_code} {resp.text}")
            return []
        data = resp.json()
        if data.get("code") != "200":
            return []
        results = []
        for loc in data.get("location", []):
            results.append({
                "name": loc.get("name", ""),
                "id": loc.get("id", ""),
                "lat": loc.get("lat", ""),
                "lon": loc.get("lon", ""),
                "adm1": loc.get("adm1", ""),
                "adm2": loc.get("adm2", ""),
                "country": loc.get("country", ""),
            })
        return results
    except Exception as e:
        current_app.logger.error(f"City lookup error: {e}")
        return []


# ─── Weather Fetch ─────────────────────────

def fetch_weather(force: bool = False, user_id: int = None) -> dict:
    """Fetch real-time weather from QWeather and cache it.
    
    Args:
        force: If True, skip fallback cache on error — return error directly.
    """
    if user_id is None:
        user_id = _uid()
    return _fetch_qweather(get_config(user_id), force=force, user_id=user_id)


def _fetch_qweather(cfg: dict, force: bool = False, user_id: int = None) -> dict:
    """Fetch weather from QWeather v7/weather/now."""
    headers = _get_auth_header(cfg)
    if not headers:
        return {"error": "未配置 JWT 密钥或 API Key", "city": cfg.get("city", "")}

    lat = cfg.get("lat") or 39.9042
    lon = cfg.get("lon") or 116.4074
    host = _api_host(cfg)

    url = f"{host}/v7/weather/now"
    params = {
        "location": f"{lon:.2f},{lat:.2f}",
        "lang": "zh",
    }

    try:
        resp = requests.get(url, params=params, headers=headers, timeout=10)
        if resp.status_code == 401:
            current_app.logger.error("QWeather: JWT auth failed (401)")
            return {"error": "JWT 认证失败，请检查密钥配置", "city": cfg.get("city", "")}
        if resp.status_code == 403:
            current_app.logger.error(f"QWeather: forbidden (403) body={resp.text[:200]}")
            # Detect Invalid Host (shared dev domain deprecated)
            if "invalid host" in resp.text.lower() or "unauthorized api host" in resp.text.lower():
                return {"error": "API Host 无效：共享开发域名已弃用，请在控制端配置专属 API Host（和风控制台 → 产品 → API Host）", "city": cfg.get("city", "")}
            return {"error": "请求被拒绝（403），请检查额度、权限或 API Host 配置", "city": cfg.get("city", "")}
        if resp.status_code == 429:
            msg = "请求太频繁，请稍后再试"
            current_app.logger.warning(f"QWeather: rate limited (429)")
            return {"error": msg, "city": cfg.get("city", "")} if force else _fallback_cache(cfg, user_id)
        resp.raise_for_status()
        data = resp.json()
        if data.get("code") != "200":
            err_msg = data.get("code", "unknown")
            current_app.logger.error(f"QWeather API error code: {err_msg}")
            return {"error": f"API 错误: {err_msg}", "city": cfg.get("city", "")}
    except requests.exceptions.Timeout:
        msg = "API 请求超时"
        current_app.logger.error(f"QWeather: timeout")
        return {"error": msg, "city": cfg.get("city", "")} if force else _fallback_cache(cfg, user_id)
    except requests.exceptions.ConnectionError:
        msg = "无法连接 API"
        current_app.logger.error(f"QWeather: connection failed")
        return {"error": msg, "city": cfg.get("city", "")} if force else _fallback_cache(cfg, user_id)
    except Exception as e:
        msg = str(e)
        current_app.logger.error(f"QWeather error: {e}")
        return {"error": msg, "city": cfg.get("city", "")} if force else _fallback_cache(cfg, user_id)

    now_data = data.get("now", {})

    # Map QWeather icon codes to something displayable
    icon_code = now_data.get("icon", "999")

    result = {
        "city": cfg.get("city", ""),
        "temp": float(now_data.get("temp", 0)),
        "feels_like": float(now_data.get("feelsLike", 0)),
        "humidity": int(now_data.get("humidity", 0)),
        "pressure": int(now_data.get("pressure", 0)),
        "description": now_data.get("text", ""),
        "icon": icon_code,
        "wind_speed": float(now_data.get("windSpeed", 0)),
        "wind_dir": now_data.get("windDir", ""),
        "wind_scale": int(now_data.get("windScale", 0)),
        "visibility": now_data.get("vis", ""),
        "precip": now_data.get("precip", "0"),
        "cloud": now_data.get("cloud", ""),
        "dew": now_data.get("dew", ""),
        "obs_time": now_data.get("obsTime", ""),
        "updated_at": tz_now().isoformat(),
        "provider": "qweather",
    }

    _save_cache(result, user_id)
    current_app.event_bus.publish("weather_updated", result, user_id=user_id)
    return result



# ─── Cache ─────────────────────────────────

def _save_cache(data: dict, user_id: int = None):
    """Write weather data to the cache table, replacing any existing row."""
    if user_id is None:
        user_id = _uid()
    now_str = tz_strftime()
    db = get_db(current_app.config["DB_PATH"])
    db.execute("DELETE FROM weather_cache WHERE user_id=?", (user_id,))
    db.execute(
        "INSERT INTO weather_cache (user_id, data, updated_at) VALUES (?, ?, ?)",
        (user_id, json.dumps(data), now_str)
    )
    db.commit()
    db.close()


def _fallback_cache(cfg: dict, user_id: int = None) -> dict:
    """Return cached data if available, else error."""
    if user_id is None:
        user_id = _uid()
    db = get_db(current_app.config["DB_PATH"])
    cache = db.execute(
        "SELECT data FROM weather_cache WHERE user_id=?", (user_id,)
    ).fetchone()
    db.close()
    if cache:
        cached = json.loads(cache["data"])
        cached["cached"] = True
        return cached
    return {"error": "无法获取天气数据", "city": cfg.get("city", "")}


def get_cached_weather(user_id: int = None) -> dict:
    """Return cached weather or empty error."""
    if user_id is None:
        user_id = _uid()
    db = get_db(current_app.config["DB_PATH"])
    row = db.execute("SELECT * FROM weather_cache WHERE user_id=?", (user_id,)).fetchone()
    db.close()
    if row:
        return json.loads(row["data"])
    return {"error": "暂无天气数据"}


# ─── Next Update Schedule ─────────────────

def get_next_update_times(user_id: int = None) -> dict:
    """Compute next scheduled update times based on cron rules.
    
    - Weather (current): every :00 and :30
    - Hourly forecast: every :01 past the hour
    """
    from datetime import timedelta
    if user_id is None:
        user_id = _uid()
    now = tz_now()

    # Next weather update: next :00 or :30
    if now.minute < 30:
        next_w = now.replace(minute=30, second=0, microsecond=0)
    else:
        next_w = (now + timedelta(hours=1)).replace(minute=0, second=0, microsecond=0)

    # Next hourly update: next :01
    if now.minute < 1:
        next_h = now.replace(minute=1, second=0, microsecond=0)
    else:
        next_h = (now + timedelta(hours=1)).replace(minute=1, second=0, microsecond=0)

    # Read last update times from cached JSON (local time) not SQLite datetime('now') which is UTC
    db = get_db(current_app.config["DB_PATH"])

    w_updated = None
    w_row = db.execute("SELECT data FROM weather_cache WHERE user_id=?", (user_id,)).fetchone()
    if w_row and w_row["data"]:
        w_data = json.loads(w_row["data"])
        w_updated = w_data.get("updated_at", None)

    h_updated = None
    h_row = db.execute("SELECT data FROM weather_hourly_cache WHERE user_id=?", (user_id,)).fetchone()
    if h_row and h_row["data"]:
        # Hourly data is a list; we store fetched_at separately, but for display
        # use the local-computed schedule as last-update signal
        h_row2 = db.execute("SELECT fetched_at FROM weather_hourly_cache WHERE user_id=?", (user_id,)).fetchone()
        if h_row2 and h_row2[0]:
            # Keep the UTC string but note it's UTC — we'll just pass it
            h_updated = h_row2[0]

    db.close()

    return {
        "weather_updated_at": w_updated,
        "weather_next_update": next_w.strftime("%Y-%m-%d %H:%M:%S"),
        "hourly_updated_at": h_updated,
        "hourly_next_update": next_h.strftime("%Y-%m-%d %H:%M:%S"),
    }


# ─── Hourly Forecast ──────────────────────

def fetch_hourly(user_id: int = None) -> list:
    """Fetch 24-hour forecast from QWeather, filter past hours, cache.

    Returns filtered list of {time, temp, icon, text, pop, windSpeed, windDir}.
    Handles cross-hour/cross-day: filters out fxTime < now, so stale cache
    never shows expired hours. If filtered result is short, caller should
    re-fetch (handled by scheduler every 60 min).
    """
    if user_id is None:
        user_id = _uid()
    cfg = get_config(user_id)

    headers = _get_auth_header(cfg)
    if not headers:
        return []

    lat = cfg.get("lat") or 39.9042
    lon = cfg.get("lon") or 116.4074
    host = _api_host(cfg)
    url = f"{host}/v7/weather/24h"
    params = {"location": f"{lon:.2f},{lat:.2f}", "lang": "zh"}

    try:
        resp = requests.get(url, params=params, headers=headers, timeout=10)
        if resp.status_code != 200:
            current_app.logger.error(f"Hourly fetch failed: {resp.status_code}")
            return _get_cached_hourly(user_id) or []
        data = resp.json()
        if data.get("code") != "200":
            return _get_cached_hourly(user_id) or []
        raw_list = data.get("hourly", [])
    except Exception as e:
        current_app.logger.error(f"Hourly fetch error: {e}")
        return _get_cached_hourly(user_id) or []

    now = tz_now()
    today_date = now.strftime("%Y-%m-%d")
    filtered = []
    for h in raw_list:
        fx_str = h.get("fxTime", "")
        fx_time = _parse_qw_time(fx_str)
        if not fx_time:
            continue
        # Unify to a local timezone-aware datetime via the time middleware.
        # fxTime from QWeather may carry an offset (+08:00) or be naive;
        # never strip tzinfo — that breaks comparison with tz_now().
        fx_local = tz_localize(fx_time)
        if fx_local >= now:
            # Determine if this hour is today or tomorrow
            fx_date = fx_local.strftime("%Y-%m-%d")
            day_label = "明日" if fx_date > today_date else "今日"
            filtered.append({
                "time": fx_local.strftime("%H:%M"),
                "day": day_label,
                "temp": h.get("temp", ""),
                "icon": h.get("icon", "999"),
                "text": h.get("text", ""),
                "pop": h.get("pop", "0"),
                "wind_speed": h.get("windSpeed", "0"),
                "wind_dir": h.get("windDir", ""),
            })

    _save_hourly_cache(filtered, user_id)
    current_app.logger.info(f"Hourly: fetched {len(raw_list)} → {len(filtered)} future hours")
    return filtered


def _parse_qw_time(s: str):
    """Parse QWeather ISO time string to datetime, or None."""
    if not s:
        return None
    try:
        # Format: "2026-07-14T15:00+08:00" or "2026-07-14T15:00+08:00"
        return datetime.fromisoformat(s)
    except Exception:
        pass
    try:
        # Fallback: "2026-07-14T15:00"
        return datetime.strptime(s[:16], "%Y-%m-%dT%H:%M")
    except Exception:
        return None


def get_cached_hourly(user_id: int = None) -> list:
    """Return cached hourly forecast with cross-time filtering.

    Filters out past hours using proper time comparison (handles
    cross-midnight correctly). If fewer than 12 remain, logs a warning
    so the scheduler knows to refresh early.
    """
    if user_id is None:
        user_id = _uid()
    data = _get_cached_hourly(user_id)
    if not data:
        return []

    # Detect old cache format (missing "day" field) — force re-fetch
    if not data[0].get("day"):
        current_app.logger.info("Hourly: old cache format detected, force re-fetch")
        return []

    now = tz_now()
    now_minutes = now.hour * 60 + now.minute

    valid = []
    for h in data:
        parts = h.get("time", "00:00").split(":")
        h_minutes = int(parts[0]) * 60 + int(parts[1])
        day = h.get("day", "今日")
        # Keep if: it's "今日" and time hasn't passed, OR it's "明日" (always future)
        if (day == "今日" and h_minutes >= now_minutes) or day == "明日":
            valid.append(h)

    if len(valid) < 12:
        current_app.logger.info(
            f"Hourly cache: only {len(valid)} future hours left, will refresh soon"
        )
    return valid


def _save_hourly_cache(data: list, user_id: int = None):
    """Persist hourly data, replacing old cache."""
    if user_id is None:
        user_id = _uid()
    now_str = tz_strftime()
    db = get_db(current_app.config["DB_PATH"])
    db.execute(
        "DELETE FROM weather_hourly_cache WHERE user_id=?", (user_id,)
    )
    db.execute(
        "INSERT INTO weather_hourly_cache (user_id, data, fetched_at) VALUES (?, ?, ?)",
        (user_id, json.dumps(data), now_str)
    )
    db.commit()
    db.close()


def _get_cached_hourly(user_id: int = None) -> list | None:
    """Read cached hourly data from DB."""
    if user_id is None:
        user_id = _uid()
    db = get_db(current_app.config["DB_PATH"])
    row = db.execute(
        "SELECT data FROM weather_hourly_cache WHERE user_id=?", (user_id,)
    ).fetchone()
    db.close()
    if row and row["data"]:
        return json.loads(row["data"])
    return None


# ─── Minutely Forecast (manual, rate-limited) ─

_MINUTELY_COOLDOWN = 180  # 3 minutes in seconds

def fetch_minutely(user_id: int = None) -> dict:
    """Fetch minute-level precipitation forecast from QWeather v7/minutely/5m.
    
    Rate-limited: once per 3 minutes. Returns cooldown info on rejection.
    """
    if user_id is None:
        user_id = _uid()
    # Check cooldown
    db = get_db(current_app.config["DB_PATH"])
    row = db.execute(
        "SELECT fetched_at FROM weather_minutely_cache WHERE user_id=?", (user_id,)
    ).fetchone()
    if row and row["fetched_at"]:
        try:
            last = tz_strptime(row["fetched_at"], "%Y-%m-%d %H:%M:%S") if 'T' not in row["fetched_at"] else tz_strptime(row["fetched_at"][:19].replace('T', ' '), "%Y-%m-%d %H:%M:%S")
            elapsed = (tz_now() - last).total_seconds()
            if elapsed < _MINUTELY_COOLDOWN:
                remaining = int(_MINUTELY_COOLDOWN - elapsed)
                db.close()
                return {"error": f"冷却中，剩余 {remaining} 秒", "cooldown": remaining}
        except Exception:
            pass
    db.close()

    cfg = get_config(user_id)
    headers = _get_auth_header(cfg)
    if not headers:
        return {"error": "未配置认证"}

    lat = cfg.get("lat") or 39.9042
    lon = cfg.get("lon") or 116.4074
    host = _api_host(cfg)
    url = f"{host}/v7/minutely/5m"
    params = {"location": f"{lon:.2f},{lat:.2f}", "lang": "zh"}

    try:
        resp = requests.get(url, params=params, headers=headers, timeout=10)
        if resp.status_code != 200:
            return {"error": f"API 返回 {resp.status_code}"}
        data = resp.json()
        if data.get("code") != "200":
            return {"error": f"API 错误: {data.get('code')}"}
    except Exception as e:
        return {"error": str(e)}

    now_str = tz_strftime()
    result = {
        "summary": data.get("summary", ""),
        "minutely": data.get("minutely", []),
        "fetched_at": now_str,
    }
    db = get_db(current_app.config["DB_PATH"])
    db.execute("DELETE FROM weather_minutely_cache WHERE user_id=?", (user_id,))
    db.execute(
        "INSERT INTO weather_minutely_cache (user_id, data, fetched_at) VALUES (?, ?, ?)",
        (user_id, json.dumps(result), now_str)
    )
    db.commit()
    db.close()
    return result


def get_cached_minutely(user_id: int = None) -> dict | None:
    """Return cached minutely forecast if available."""
    if user_id is None:
        user_id = _uid()
    db = get_db(current_app.config["DB_PATH"])
    row = db.execute("SELECT data FROM weather_minutely_cache WHERE user_id=?", (user_id,)).fetchone()
    db.close()
    if row and row["data"]:
        return json.loads(row["data"])
    return None


# ─── Weather Warnings (manual, rate-limited) ─

def fetch_warnings(user_id: int = None) -> dict:
    """Fetch weather warnings from QWeather v7/warning/now.
    
    Rate-limited: once per 3 minutes. Returns cooldown info on rejection.
    """
    if user_id is None:
        user_id = _uid()
    # Check cooldown
    db = get_db(current_app.config["DB_PATH"])
    row = db.execute(
        "SELECT fetched_at FROM weather_warning_cache WHERE user_id=?", (user_id,)
    ).fetchone()
    if row and row["fetched_at"]:
        try:
            last = tz_strptime(row["fetched_at"], "%Y-%m-%d %H:%M:%S") if 'T' not in row["fetched_at"] else tz_strptime(row["fetched_at"][:19].replace('T', ' '), "%Y-%m-%d %H:%M:%S")
            elapsed = (tz_now() - last).total_seconds()
            if elapsed < _MINUTELY_COOLDOWN:
                remaining = int(_MINUTELY_COOLDOWN - elapsed)
                db.close()
                return {"error": f"冷却中，剩余 {remaining} 秒", "cooldown": remaining}
        except Exception:
            pass
    db.close()

    cfg = get_config(user_id)
    headers = _get_auth_header(cfg)
    if not headers:
        return {"error": "未配置认证"}

    lat = round(cfg.get("lat") or 39.9042, 2)
    lon = round(cfg.get("lon") or 116.4074, 2)
    host = _api_host(cfg)
    url = f"{host}/weatheralert/v1/current/{lat}/{lon}"
    params = {"lang": "zh"}

    try:
        resp = requests.get(url, params=params, headers=headers, timeout=10)
        if resp.status_code == 403:
            return {"error": "天气预警为付费功能，当前订阅不可用", "unavailable": True}
        if resp.status_code != 200:
            return {"error": f"API 返回 {resp.status_code}"}
        data = resp.json()
        alert_list = data.get("alerts", [])
    except Exception as e:
        return {"error": str(e)}

    now_str = tz_strftime()
    result = {
        "warnings": alert_list,
        "fetched_at": now_str,
        "zero_result": data.get("metadata", {}).get("zeroResult", False),
    }
    db = get_db(current_app.config["DB_PATH"])
    db.execute("DELETE FROM weather_warning_cache WHERE user_id=?", (user_id,))
    db.execute(
        "INSERT INTO weather_warning_cache (user_id, data, fetched_at) VALUES (?, ?, ?)",
        (user_id, json.dumps(result), now_str)
    )
    db.commit()
    db.close()
    return result


def get_cached_warnings(user_id: int = None) -> dict | None:
    """Return cached warnings if available."""
    if user_id is None:
        user_id = _uid()
    db = get_db(current_app.config["DB_PATH"])
    row = db.execute("SELECT data FROM weather_warning_cache WHERE user_id=?", (user_id,)).fetchone()
    db.close()
    if row and row["data"]:
        return json.loads(row["data"])
    return None