"""
Trend Engine — Shared weather analysis module
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Extracted from bot_listener.py to provide a single source of truth
for both Telegram bot and web dashboard.
"""

import math
from typing import List, Optional, Tuple, Dict, Any

from src.analysis.deb_algorithm import (
    calculate_dynamic_weights,
    get_deb_accuracy,
    update_daily_record,
)
from src.analysis.settlement_rounding import wu_round
from src.data_collection.city_risk_profiles import get_city_risk_profile


def _sf(v):
    """Safe float conversion — prevents JSON str types from breaking math."""
    if v is None:
        return None
    try:
        return float(v)
    except Exception:
        return None


def analyze_weather_trend(
    weather_data: dict,
    temp_symbol: str,
    city_name: Optional[str] = None,
) -> Tuple[str, str, Dict[str, Any]]:
    """
    Analyze weather trend from multi-source data.

    Returns:
        (display_str, ai_context, structured_data)

        display_str: HTML-formatted insights for Telegram display
        ai_context:  plain-text context for AI analysis
        structured_data: dict with computed values for direct use:
            - mu: probability center
            - probabilities: [{value, range, probability}, ...]
            - trend_info: {direction, recent, is_cooling, is_dead_market}
            - peak_status: "before" / "in_window" / "past"
            - peak_hours: list of peak hour strings
            - deb_prediction: DEB blended value
            - current_forecasts: {model: temp, ...}
            - forecast_miss_deg: float
            - max_so_far: float
            - cur_temp: float
            - wu_settle: int
    """
    insights: List[str] = []
    ai_features: List[str] = []
    mu = None
    sorted_probs = []
    _deb_to_save = None

    metar = weather_data.get("metar", {})
    open_meteo = weather_data.get("open-meteo", {})
    mgm = weather_data.get("mgm") or {}
    nws = weather_data.get("nws", {})

    empty_result = ("", "", {})
    if not metar and not mgm:
        return empty_result

    max_so_far = _sf(metar.get("current", {}).get("max_temp_so_far")) if metar else _sf(mgm.get("current", {}).get("mgm_max_temp"))
    cur_temp = _sf(metar.get("current", {}).get("temp")) if metar else _sf(mgm.get("current", {}).get("temp"))

    daily = open_meteo.get("daily", {})
    hourly = open_meteo.get("hourly", {})
    times = hourly.get("time", [])
    temps = hourly.get("temperature_2m", [])

    # === Forecasts ===
    current_forecasts: Dict[str, Optional[float]] = {}
    if daily.get("temperature_2m_max"):
        current_forecasts["Open-Meteo"] = _sf(daily.get("temperature_2m_max")[0])
    if nws.get("today_high") is not None:
        current_forecasts["NWS"] = _sf(nws.get("today_high"))
    
    mgm = weather_data.get("mgm", {})
    if mgm and mgm.get("today_high") is not None:
        current_forecasts["MGM"] = _sf(mgm.get("today_high"))

    mm_forecasts = weather_data.get("multi_model", {}).get("forecasts", {})
    for m_name, m_val in mm_forecasts.items():
        if m_val is not None:
            current_forecasts[m_name] = _sf(m_val)

    forecast_highs = [h for h in current_forecasts.values() if h is not None]
    forecast_high = max(forecast_highs) if forecast_highs else None
    forecast_median = (
        sorted(forecast_highs)[len(forecast_highs) // 2] if forecast_highs else None
    )

    wind_speed = metar.get("current", {}).get("wind_speed_kt", 0)

    # === Local time ===
    local_time_full = open_meteo.get("current", {}).get("local_time", "")
    try:
        local_date_str = local_time_full.split(" ")[0]
        time_parts = local_time_full.split(" ")[1].split(":")
        local_hour = int(time_parts[0])
        local_minute = int(time_parts[1]) if len(time_parts) > 1 else 0
    except Exception:
        from datetime import datetime
        local_date_str = datetime.now().strftime("%Y-%m-%d")
        local_hour = datetime.now().hour
        local_minute = datetime.now().minute
    local_hour_frac = local_hour + local_minute / 60

    # === DEB ===
    deb_prediction = None
    deb_weights = ""
    if city_name and current_forecasts:
        blended_high, weight_info = calculate_dynamic_weights(
            city_name, current_forecasts
        )
        if blended_high is not None:
            deb_prediction = blended_high
            deb_weights = weight_info
            insights.insert(
                0,
                f"🧬 <b>DEB 融合预测</b>：<b>{blended_high}{temp_symbol}</b> ({weight_info})",
            )
            ai_features.append(
                f"🧬 DEB系统已通过历史偏差矫正算出期待点是: {blended_high}{temp_symbol}。"
            )
        _deb_to_save = blended_high

    # === METAR trend ===
    recent_temps = metar.get("recent_temps", [])
    trend_desc = ""
    trend_direction = "unknown"
    if len(recent_temps) >= 2:
        temps_only = [t for _, t in recent_temps]
        latest_val = temps_only[0]
        prev_val = temps_only[1]
        diff = latest_val - prev_val
        if len(temps_only) >= 3:
            all_same = all(t == latest_val for t in temps_only[:3])
            all_rising = all(
                temps_only[i] >= temps_only[i + 1]
                for i in range(min(3, len(temps_only)) - 1)
            )
            all_falling = all(
                temps_only[i] <= temps_only[i + 1]
                for i in range(min(3, len(temps_only)) - 1)
            )
            trend_display = " → ".join(
                [f"{t}{temp_symbol}@{tm}" for tm, t in recent_temps[:3]]
            )
            if all_same:
                trend_desc = f"📉 温度已停滞（{trend_display}），大概率到顶。"
                trend_direction = "stagnant"
            elif all_rising and diff > 0:
                trend_desc = f"📈 仍在升温（{trend_display}）。"
                trend_direction = "rising"
            elif all_falling and diff < 0:
                trend_desc = f"📉 已开始降温（{trend_display}）。"
                trend_direction = "falling"
            else:
                trend_desc = f"📊 温度波动中（{trend_display}）。"
                trend_direction = "mixed"
        elif diff == 0:
            trend_desc = f"📉 温度持平（最近两条都是 {latest_val}{temp_symbol}）。"
            trend_direction = "stagnant"
        elif diff > 0:
            trend_desc = f"📈 仍在升温（{prev_val} → {latest_val}{temp_symbol}）。"
            trend_direction = "rising"
        else:
            trend_desc = f"📉 已开始降温（{prev_val} → {latest_val}{temp_symbol}）。"
            trend_direction = "falling"

    is_cooling = "降温" in trend_desc

    om_today = daily.get("temperature_2m_max", [None])[0]

    # === Peak hours ===
    peak_hours = []
    if times and temps and om_today is not None:
        for t_str, temp in zip(times, temps):
            if t_str.startswith(local_date_str) and abs(temp - om_today) <= 0.2:
                hour = int(t_str.split("T")[1][:2])
                if 8 <= hour <= 19:
                    peak_hours.append(t_str.split("T")[1][:5])
    if peak_hours:
        first_peak_h = int(peak_hours[0].split(":")[0])
        last_peak_h = int(peak_hours[-1].split(":")[0])
    else:
        first_peak_h, last_peak_h = 13, 15

    # Peak status
    if local_hour_frac > last_peak_h:
        peak_status = "past"
    elif first_peak_h <= local_hour_frac <= last_peak_h:
        peak_status = "in_window"
    else:
        peak_status = "before"

    # === Ensemble ===
    ensemble = weather_data.get("ensemble", {})
    ens_p10 = _sf(ensemble.get("p10"))
    ens_p90 = _sf(ensemble.get("p90"))
    ens_median = _sf(ensemble.get("median"))
    ens_data = {"p10": ens_p10, "p90": ens_p90, "median": ens_median}

    sigma = None
    fallback_sigma = False

    if ens_p10 is not None and ens_p90 is not None and ens_median is not None:
        msg1 = (
            f"📊 <b>集合预报</b>：中位数 {ens_median}{temp_symbol}，"
            f"90% 区间 [{ens_p10}{temp_symbol} - {ens_p90}{temp_symbol}]。"
        )
        if not is_cooling:
            insights.append(msg1)
        ai_features.append(msg1)

        if om_today is not None:
            if om_today > ens_p90 and (
                max_so_far is None or max_so_far < om_today - 0.5
            ):
                ai_features.append(
                    f"⚡ 预报偏高：确定性预报 {om_today}{temp_symbol} 超集合90%上限，"
                    f"更可能接近 {ens_median}{temp_symbol}。"
                )
            elif om_today < ens_p10 and (
                max_so_far is None or max_so_far < ens_median
            ):
                ai_features.append(
                    f"⚡ 预报偏低：确定性预报 {om_today}{temp_symbol} 低于集合90%下限，"
                    f"更可能接近 {ens_median}{temp_symbol}。"
                )

        # === Sigma calculation ===
        sigma = (ens_p90 - ens_p10) / 2.56
        if sigma < 0.1:
            sigma = 0.1

        # MAE floor
        if city_name:
            acc = get_deb_accuracy(city_name)
            if acc:
                _, hist_mae, _, _ = acc
                if hist_mae > sigma:
                    sigma = hist_mae

        # Shock Score
        shock_score = 0.0
        recent_obs = metar.get("recent_obs", [])
        if len(recent_obs) >= 2:
            oldest = recent_obs[-1]
            newest = recent_obs[0]
            wdir_old = _sf(oldest.get("wdir"))
            wdir_new = _sf(newest.get("wdir"))
            wspd_new = _sf(newest.get("wspd")) or 0
            if wdir_old is not None and wdir_new is not None:
                angle_diff = abs(wdir_new - wdir_old)
                if angle_diff > 180:
                    angle_diff = 360 - angle_diff
                wind_weight = min(wspd_new / 15.0, 1.0)
                shock_score += min(angle_diff / 90.0, 1.0) * wind_weight * 0.4
            cloud_old = oldest.get("cloud_rank", 0)
            cloud_new = newest.get("cloud_rank", 0)
            shock_score += min(abs(cloud_new - cloud_old) / 3.0, 1.0) * 0.35
            altim_old = _sf(oldest.get("altim"))
            altim_new = _sf(newest.get("altim"))
            if altim_old is not None and altim_new is not None:
                shock_score += min(abs(altim_new - altim_old) / 4.0, 1.0) * 0.25

        if shock_score > 0.05:
            sigma *= 1 + 0.5 * shock_score

        # Time decay
        if local_hour_frac > last_peak_h:
            sigma *= 0.3
        elif first_peak_h <= local_hour_frac <= last_peak_h:
            sigma *= 0.7
    else:
        # Fallback for sigma when ensemble is missing
        fallback_sigma = True
        if forecast_highs and len(forecast_highs) > 1:
            sigma = max(0.6, (max(forecast_highs) - min(forecast_highs)) / 2.0)
        else:
            sigma = 1.0
            
        if city_name:
            acc = get_deb_accuracy(city_name)
            if acc and acc[1] > sigma:
                sigma = acc[1]

        if local_hour_frac > last_peak_h:
            sigma *= 0.3
        elif first_peak_h <= local_hour_frac <= last_peak_h:
            sigma *= 0.7

    # === Dead Market ===
    is_dead_market = False
    if max_so_far is not None and cur_temp is not None:
        if local_hour >= 21 and max_so_far - cur_temp >= 3.0:
            is_dead_market = True
        elif local_hour > last_peak_h and max_so_far - cur_temp >= 1.5:
            is_dead_market = True

    # === Probability Engine ===
    probabilities: List[Dict[str, Any]] = []
    forecast_miss_deg = 0.0

    if (ens_p10 is not None and ens_p90 is not None) or fallback_sigma:
        if not is_dead_market:
            # Forecast miss magnitude
            if max_so_far is not None and forecast_median is not None:
                forecast_miss_deg = round(forecast_median - max_so_far, 1)
    
            fallback_center = forecast_median if forecast_median is not None else (forecast_high if forecast_high is not None else cur_temp)
            center = ens_median if ens_median is not None else fallback_center
    
            # Reality-anchored μ
            if (
                max_so_far is not None
                and forecast_median is not None
                and peak_status in ("past", "in_window")
                and max_so_far < forecast_median - 2.0
            ):
                if is_cooling or peak_status == "past":
                    mu = max_so_far
                else:
                    mu = max_so_far + 0.5
            else:
                mu = (
                    forecast_median * 0.7 + center * 0.3
                    if forecast_median is not None and center is not None
                    else center
                )
                if max_so_far is not None and mu is not None and max_so_far > mu:
                    mu = max_so_far + (0.3 if not is_cooling else 0.0)

        # Forecast miss severity for AI
        if forecast_miss_deg > 2.0 and peak_status in ("past", "in_window"):
            severity = "重" if forecast_miss_deg > 5.0 else ("中" if forecast_miss_deg > 3.0 else "轻")
            min_fc = min((v for v in forecast_highs if v is not None), default=None)
            _trend_dir = "降温" if is_cooling else ("停滞" if "停滞" in trend_desc else "升温")
            ai_features.append(
                f"🚨 预报崩盘 [{severity}级失准]: 最低预报 {min_fc}{temp_symbol} vs "
                f"实测最高 {max_so_far}{temp_symbol}，偏差 {forecast_miss_deg}°。当前趋势: {_trend_dir}。"
            )

        # Probability Engine
        probs_result = calculate_prob_distribution(
            mu, sigma, max_so_far, temp_symbol
        )
        mu = probs_result.get("mu", mu)
        probabilities = probs_result.get("probabilities", [])
        sorted_probs = probs_result.get("sorted_probs", [])
        
        if sorted_probs:
            prob_parts = [
                f"{int(t)}{temp_symbol} [{t - 0.5}~{t + 0.5}) {p * 100:.0f}%"
                for t, p in sorted_probs[:4]
            ]
            if prob_parts:
                prob_str = " | ".join(prob_parts)
                insights.append(f"🎲 <b>结算概率</b> (μ={mu:.1f})：{prob_str}")
                ai_features.append(f"🎲 数学概率分布：{prob_str}")

    elif is_dead_market:
        settled_wu = wu_round(max_so_far) if max_so_far is not None else 0
        dead_msg = f"🎲 <b>结算预测</b>：已锁定 {settled_wu}{temp_symbol} (死盘确认)"
        insights.append(dead_msg)
        ai_features.append("🎲 状态: 确认死盘，结算已无悬念。")
        if max_so_far is not None:
            mu = max_so_far
            probabilities = [
                {"value": settled_wu, "range": f"[{settled_wu-0.5}~{settled_wu+0.5})", "probability": 1.0}
            ]

    # === Actual exceeds forecast ===
    if max_so_far is not None and forecast_high is not None:
        if max_so_far > forecast_high + 0.5:
            exceed_by = max_so_far - forecast_high
            bt_msg = (
                f"🚨 <b>实测已超预报</b>：{max_so_far}{temp_symbol} 超过上限 "
                f"{forecast_high}{temp_symbol}（+{exceed_by:.1f}°）。"
            )
            insights.append(bt_msg)
            ai_features.append(
                f"🚨 异常: 实测已冲破所有预报上限 ({max_so_far}{temp_symbol} vs {forecast_high}{temp_symbol})。"
            )
    if trend_desc:
        ai_features.append(trend_desc)

    # === Settlement boundary ===
    if max_so_far is not None:
        settled = wu_round(max_so_far)
        fractional = max_so_far - int(max_so_far)
        dist_to_boundary = abs(fractional - 0.5)
        if dist_to_boundary <= 0.3:
            if fractional < 0.5:
                msg = (
                    f"⚖️ <b>结算边界</b>：当前最高 {max_so_far}{temp_symbol} → WU 结算 "
                    f"<b>{settled}{temp_symbol}</b>，但只差 <b>{0.5 - fractional:.1f}°</b> "
                    f"就会进位到 {settled + 1}{temp_symbol}！"
                )
            else:
                msg = (
                    f"⚖️ <b>结算边界</b>：当前最高 {max_so_far}{temp_symbol} → WU 结算 "
                    f"<b>{settled}{temp_symbol}</b>，刚刚越过进位线，再降 "
                    f"<b>{fractional - 0.5:.1f}°</b> 就会回落到 {settled - 1}{temp_symbol}。"
                )
            insights.append(msg)
            ai_features.append(msg)

    # === Peak window AI hints ===
    if peak_hours:
        window = (
            f"{peak_hours[0]} - {peak_hours[-1]}"
            if len(peak_hours) > 1
            else peak_hours[0]
        )
        if local_hour <= last_peak_h:
            if last_peak_h < 6:
                ai_features.append("⚠️ <b>提示</b>：预测最热在凌晨，后续气温可能一路走低。")
            elif local_hour < first_peak_h and (
                max_so_far is None or max_so_far < forecast_high
            ):
                target_temp = om_today if om_today is not None else forecast_high
                ai_features.append(
                    f"🎯 <b>关注重点</b>：看看那个时段能否涨到 {target_temp}{temp_symbol}。"
                )

        remain_hrs = first_peak_h - local_hour_frac
        if local_hour_frac > last_peak_h:
            ai_features.append(f"⏱️ 状态: 预报峰值时段已过 ({window})。")
        elif first_peak_h <= local_hour_frac <= last_peak_h:
            remain_in_window = last_peak_h - local_hour_frac
            if remain_in_window < 1:
                ai_features.append(
                    f"⏱️ 状态: 正处于预报最热窗口 ({window})内，距窗口结束约 {int(remain_in_window * 60)} 分钟。"
                )
            else:
                ai_features.append(
                    f"⏱️ 状态: 正处于预报最热窗口 ({window})内，距窗口结束约 {remain_in_window:.1f}h。"
                )
        elif remain_hrs < 1:
            ai_features.append(
                f"⏱️ 状态: 距最热时段开始还有约 {int(remain_hrs * 60)} 分钟 ({window})，尚未进入峰值窗口。"
            )
        else:
            ai_features.append(f"⏱️ 状态: 距最热时段开始还有约 {remain_hrs:.1f}h ({window})。")

    # === AI fact features ===
    if cur_temp is not None:
        ai_features.append(f"🌡️ 当前实测温度: {cur_temp}{temp_symbol}。")
    if max_so_far is not None:
        ai_features.append(
            f"🏔️ 今日实测最高温: {max_so_far}{temp_symbol} (WU结算={wu_round(max_so_far)}{temp_symbol})。"
        )
    if city_name:
        _profile = get_city_risk_profile(city_name)
        if _profile and _profile.get("metar_rounding"):
            ai_features.append(f"⚠️ METAR特性: {_profile['metar_rounding']}")
    if wind_speed:
        wind_dir = metar.get("current", {}).get("wind_dir", "未知")
        ai_features.append(f"🌬️ 当下风况: 约 {wind_speed}kt (方向 {wind_dir}°)。")
    humidity = metar.get("current", {}).get("humidity")
    if humidity and humidity > 80:
        ai_features.append(f"💦 湿度极高 ({humidity}%)。")

    clouds = metar.get("current", {}).get("clouds", [])
    if clouds:
        cover = clouds[-1].get("cover", "")
        c_desc = {"OVC": "全阴", "BKN": "多云", "SCT": "散云", "FEW": "少云"}.get(cover, cover)
        ai_features.append(f"☁️ 天空状况: {c_desc}。")

    wx_desc = metar.get("current", {}).get("wx_desc")
    if wx_desc:
        ai_features.append(f"🌧️ 天气现象: {wx_desc}。")

    max_temp_time_str = metar.get("current", {}).get("max_temp_time", "")
    if max_so_far is not None and max_temp_time_str:
        try:
            max_h = int(max_temp_time_str.split(":")[0])
            max_temp_rad = 0.0
            hourly_rad = hourly.get("shortwave_radiation", [])
            for t_str, rad in zip(times, hourly_rad):
                if t_str.startswith(local_date_str) and int(t_str.split("T")[1][:2]) == max_h:
                    max_temp_rad = rad if rad is not None else 0.0
                    break
            if max_temp_rad < 50:
                ai_features.append(
                    f"🌙 动力事实: 最高温出现在低辐射时段 ({max_temp_time_str}, 辐射{max_temp_rad:.0f}W/m²)。"
                )
        except Exception:
            pass

    # === Save daily record (with μ + prob snapshot) ===
    try:
        _prob_list = None
        if sorted_probs:
            _prob_list = [
                {"value": int(t), "probability": round(p, 3)}
                for t, p in sorted_probs[:4]
            ]
        elif is_dead_market and max_so_far is not None:
            _prob_list = [{"value": wu_round(max_so_far), "probability": 1.0}]

        update_daily_record(
            city_name,
            local_date_str,
            current_forecasts,
            max_so_far,
            deb_prediction=_deb_to_save,
            mu=mu,
            probabilities=_prob_list,
        )
    except Exception:
        pass

    # === Build recent list for trend_info ===
    recent_list = []
    for tm, t in recent_temps[:4]:
        recent_list.append({"time": tm, "temp": t})

    # === Structured result ===
    structured = {
        "mu": mu,
        "probabilities": probabilities,
        "trend_info": {
            "direction": trend_direction if 'trend_direction' in dir() else "unknown",
            "recent": recent_list,
            "is_cooling": is_cooling,
            "is_dead_market": is_dead_market,
        },
        "peak_status": peak_status,
        "peak_hours": peak_hours,
        "deb_prediction": deb_prediction,
        "deb_weights": deb_weights,
        "current_forecasts": current_forecasts,
        "ens_data": ens_data,
        "forecast_miss_deg": forecast_miss_deg,
        "max_so_far": max_so_far,
        "cur_temp": cur_temp,
        "wu_settle": wu_round(max_so_far) if max_so_far is not None else None,
    }
    display_str = "\n".join(insights) if insights else ""
    return display_str, "\n".join(ai_features), structured


def calculate_prob_distribution(
    mu: float, sigma: float, max_so_far: Optional[float], temp_symbol: str
) -> Dict[str, Any]:
    """
    Generalized Gaussian probability distribution calculation.
    """
    if mu is None or sigma is None:
        return {}

    def _norm_cdf(x, m, s):
        # 0.5 * (1 + erf( (x-m)/(s*sqrt(2)) ))
        return 0.5 * (1 + math.erf((x - m) / (sigma * math.sqrt(2))))

    min_possible_wu = wu_round(max_so_far) if max_so_far is not None else -999
    probs = {}
    
    # Range: mu +/- 3 sigma or at least +/- 2 degrees
    search_range = max(2, int(sigma * 2.5))
    target_mu = wu_round(mu)
    
    for n in range(target_mu - search_range, target_mu + search_range + 1):
        if n < min_possible_wu:
            continue
        p = _norm_cdf(n + 0.5, mu, sigma) - _norm_cdf(n - 0.5, mu, sigma)
        if p > 0.01:
            probs[n] = p

    total_p = sum(probs.values())
    sorted_probs = []
    probabilities = []
    
    if total_p > 0:
        norm_probs = {k: v / total_p for k, v in probs.items()}
        sorted_probs = sorted(norm_probs.items(), key=lambda x: x[1], reverse=True)
        for t, p in sorted_probs[:4]:
            probabilities.append({
                "value": int(t),
                "range": f"[{t-0.5}~{t+0.5})",
                "probability": round(p, 3)
            })

    return {
        "mu": mu,
        "sigma": sigma,
        "probabilities": probabilities,
        "sorted_probs": sorted_probs
    }