"""信号时效指数衰减 + 假突破/假破位概率模型（多空双向）。

## 信号时效衰减
替换硬截断的 stale 判断，改为指数衰减：
- 1H 信号：前 2 小时权重 1.0，之后每小时 ×0.6
- 4H 信号：前 8 小时权重 1.0，之后每 4 小时 ×0.5
- 15m 信号：前 30 分钟权重 1.0，之后每 15 分钟 ×0.5
- D1 信号：前 24 小时权重 1.0，之后每天 ×0.7

## 假突破/假破位概率模型
事前估计突破质量（多空通用）：
- 成交量倍数（突破时量 vs 均量）
- 突破幅度 vs ATR
- 时段流动性（亚洲时段流动性薄）
- 前方供需区距离
- 连续突破尝试次数（多次失败后的突破更可靠）
"""

from __future__ import annotations

import math
from datetime import datetime, timezone
from typing import Optional

import numpy as np
import pandas as pd

from app.config.config_loader import _get_section as _get_cfg_section


# ===========================================================================
# Part 1: 信号时效指数衰减
# ===========================================================================

def _decay_config() -> dict:
    try:
        cfg = _get_cfg_section("signal_decay") or {}
    except Exception:
        cfg = {}
    return {
        # (grace_period_hours, decay_rate_per_period, period_hours)
        "1h": {
            "grace_hours": float(cfg.get("1h_grace_hours", 2)),
            "decay_rate": float(cfg.get("1h_decay_rate", 0.6)),
            "period_hours": float(cfg.get("1h_period_hours", 1)),
        },
        "4h": {
            "grace_hours": float(cfg.get("4h_grace_hours", 8)),
            "decay_rate": float(cfg.get("4h_decay_rate", 0.5)),
            "period_hours": float(cfg.get("4h_period_hours", 4)),
        },
        "15m": {
            "grace_hours": float(cfg.get("15m_grace_hours", 0.5)),
            "decay_rate": float(cfg.get("15m_decay_rate", 0.5)),
            "period_hours": float(cfg.get("15m_period_hours", 0.25)),
        },
        "1d": {
            "grace_hours": float(cfg.get("1d_grace_hours", 24)),
            "decay_rate": float(cfg.get("1d_decay_rate", 0.7)),
            "period_hours": float(cfg.get("1d_period_hours", 24)),
        },
        # Minimum weight below which signal is considered expired
        "min_weight": float(cfg.get("min_weight", 0.05)),
    }


def compute_signal_decay(age_hours: float, timeframe: str = "1h") -> float:
    """Compute exponential decay weight for a signal based on its age.

    Args:
        age_hours: how many hours ago the signal fired
        timeframe: the signal's timeframe ("15m", "1h", "4h", "1d")

    Returns:
        weight between 0.0 and 1.0
    """
    cfg = _decay_config()
    tf_cfg = cfg.get(timeframe, cfg["1h"])
    min_weight = cfg["min_weight"]

    grace = tf_cfg["grace_hours"]
    decay_rate = tf_cfg["decay_rate"]
    period = tf_cfg["period_hours"]

    if age_hours <= grace:
        return 1.0

    # Number of decay periods elapsed after grace
    elapsed = age_hours - grace
    periods = elapsed / period if period > 0 else elapsed

    # Exponential decay: weight = decay_rate ^ periods
    weight = math.pow(decay_rate, periods)

    return max(min_weight, min(1.0, weight))


def apply_decay_to_score(base_score: float, age_hours: float, timeframe: str = "1h") -> float:
    """Apply time decay to a factor score.

    Args:
        base_score: the original score (positive or negative)
        age_hours: signal age in hours
        timeframe: signal timeframe

    Returns:
        decayed score (same sign, reduced magnitude)
    """
    weight = compute_signal_decay(age_hours, timeframe)
    return round(base_score * weight, 3)


def is_signal_expired(age_hours: float, timeframe: str = "1h") -> bool:
    """Check if a signal has decayed below minimum threshold."""
    cfg = _decay_config()
    weight = compute_signal_decay(age_hours, timeframe)
    return weight <= cfg["min_weight"]


def signal_freshness_label(age_hours: float, timeframe: str = "1h") -> str:
    """Human-readable freshness label."""
    weight = compute_signal_decay(age_hours, timeframe)
    if weight >= 0.9:
        return "新鲜"
    elif weight >= 0.5:
        return "有效"
    elif weight >= 0.2:
        return "衰减中"
    elif weight > 0.05:
        return "即将过期"
    else:
        return "已过期"


# ===========================================================================
# Part 2: 假突破/假破位概率模型（多空双向）
# ===========================================================================

def _breakout_quality_config() -> dict:
    try:
        cfg = _get_cfg_section("breakout_quality") or {}
    except Exception:
        cfg = {}
    return {
        # Volume requirements
        "vol_ratio_strong": float(cfg.get("vol_ratio_strong", 3.0)),
        "vol_ratio_weak": float(cfg.get("vol_ratio_weak", 1.5)),
        # ATR requirements
        "atr_breakout_strong": float(cfg.get("atr_breakout_strong", 1.5)),
        "atr_breakout_weak": float(cfg.get("atr_breakout_weak", 0.5)),
        # Time-of-day (UTC hours for Asian session = low liquidity)
        "low_liquidity_start_utc": int(cfg.get("low_liquidity_start_utc", 0)),
        "low_liquidity_end_utc": int(cfg.get("low_liquidity_end_utc", 8)),
        # Prior attempts
        "prior_fail_lookback": int(cfg.get("prior_fail_lookback", 20)),
        "prior_fail_bonus_per_attempt": float(cfg.get("prior_fail_bonus_per_attempt", 8)),
        # Nearby zone penalty
        "zone_distance_close_pct": float(cfg.get("zone_distance_close_pct", 2.0)),
        "zone_distance_far_pct": float(cfg.get("zone_distance_far_pct", 5.0)),
        # Thresholds
        "high_quality_min": float(cfg.get("high_quality_min", 70)),
        "low_quality_max": float(cfg.get("low_quality_max", 40)),
        # Weights
        "weight_high_quality": float(cfg.get("weight_high_quality", 3.0)),
        "weight_low_quality_penalty": float(cfg.get("weight_low_quality_penalty", -4.0)),
    }


def estimate_breakout_quality(
    df: pd.DataFrame,
    breakout_bar_index: int = -1,
    breakout_level: float = 0,
    direction: str = "long",
    atr: float = 0,
    nearby_zones: Optional[list[dict]] = None,
) -> dict:
    """Estimate the quality/probability of a breakout being genuine vs fake.

    Works for both breakouts (long) and breakdowns (short).

    Args:
        df: kline DataFrame containing the breakout bar
        breakout_bar_index: index of the breakout bar (-1 = latest)
        breakout_level: the price level being broken (resistance for long, support for short)
        direction: "long" (breakout above) or "short" (breakdown below)
        atr: pre-computed ATR (if 0, will compute from df)
        nearby_zones: supply/demand zones near the breakout [{type, top, btm, q_score}]

    Returns:
        {
            "quality_score": float (0-100, higher = more likely genuine),
            "quality_tier": "high" / "medium" / "low",
            "factors": {
                "volume_score": float,
                "magnitude_score": float,
                "timing_score": float,
                "prior_attempts_score": float,
                "zone_clearance_score": float,
            },
            "fake_probability": float (0-1),
            "signal": str,
            "recommendation": str,  # "可即刻买入" / "等确认" / "观察"
        }
    """
    cfg = _breakout_quality_config()
    result = {
        "quality_score": 50.0,
        "quality_tier": "medium",
        "factors": {},
        "fake_probability": 0.5,
        "signal": "",
        "recommendation": "等确认",
    }

    if df is None or len(df) < 20:
        return result

    # Get breakout bar
    if breakout_bar_index == -1:
        breakout_bar_index = len(df) - 1
    if breakout_bar_index < 0 or breakout_bar_index >= len(df):
        return result

    bar = df.iloc[breakout_bar_index]
    bar_close = float(bar["close"])
    bar_open = float(bar["open"])
    bar_high = float(bar["high"])
    bar_low = float(bar["low"])
    bar_vol = float(bar["volume"])

    # Compute ATR if not provided
    if atr <= 0:
        if len(df) >= 15:
            tr = pd.concat([
                df["high"] - df["low"],
                abs(df["high"] - df["close"].shift(1)),
                abs(df["low"] - df["close"].shift(1)),
            ], axis=1).max(axis=1)
            atr = float(tr.rolling(14).mean().iloc[-1])
        if atr <= 0:
            atr = float(df["high"].iloc[-1] - df["low"].iloc[-1])

    # Average volume (20-bar)
    vol_window = min(20, len(df) - 1)
    avg_vol = float(df["volume"].iloc[max(0, breakout_bar_index - vol_window):breakout_bar_index].mean())
    if avg_vol <= 0:
        avg_vol = float(df["volume"].mean())

    # --- Factor 1: Volume (0-25 points) ---
    vol_ratio = bar_vol / avg_vol if avg_vol > 0 else 1
    if vol_ratio >= cfg["vol_ratio_strong"]:
        volume_score = 25.0
    elif vol_ratio >= cfg["vol_ratio_weak"]:
        volume_score = 10.0 + (vol_ratio - cfg["vol_ratio_weak"]) / (cfg["vol_ratio_strong"] - cfg["vol_ratio_weak"]) * 15
    else:
        volume_score = max(0, vol_ratio / cfg["vol_ratio_weak"] * 10)

    # --- Factor 2: Breakout magnitude vs ATR (0-25 points) ---
    if direction == "long":
        magnitude = bar_close - breakout_level if breakout_level > 0 else bar_close - bar_open
    else:
        magnitude = breakout_level - bar_close if breakout_level > 0 else bar_open - bar_close

    atr_ratio = magnitude / atr if atr > 0 else 0
    if atr_ratio >= cfg["atr_breakout_strong"]:
        magnitude_score = 25.0
    elif atr_ratio >= cfg["atr_breakout_weak"]:
        magnitude_score = 8.0 + (atr_ratio - cfg["atr_breakout_weak"]) / (cfg["atr_breakout_strong"] - cfg["atr_breakout_weak"]) * 17
    else:
        magnitude_score = max(0, atr_ratio / cfg["atr_breakout_weak"] * 8)

    # --- Factor 3: Timing / session (0-15 points) ---
    # Try to determine time of breakout
    timing_score = 10.0  # default neutral
    try:
        if "timestamp" in df.columns:
            ts = df["timestamp"].iloc[breakout_bar_index]
            if hasattr(ts, "hour"):
                hour_utc = ts.hour
            else:
                hour_utc = pd.Timestamp(ts).hour
            low_liq_start = cfg["low_liquidity_start_utc"]
            low_liq_end = cfg["low_liquidity_end_utc"]
            if low_liq_start <= hour_utc < low_liq_end:
                timing_score = 3.0  # Asian session = higher fake probability
            elif 13 <= hour_utc <= 20:
                timing_score = 15.0  # US session = most reliable
            else:
                timing_score = 10.0  # European session = decent
    except Exception:
        timing_score = 10.0

    # --- Factor 4: Prior failed attempts (0-20 points) ---
    # More prior failures at this level = more reliable when it finally breaks
    prior_attempts = 0
    lookback = min(cfg["prior_fail_lookback"], breakout_bar_index)
    if breakout_level > 0 and lookback > 0:
        for i in range(breakout_bar_index - lookback, breakout_bar_index):
            if i < 0:
                continue
            if direction == "long":
                # Count bars that touched but failed to close above level
                if float(df["high"].iloc[i]) >= breakout_level and float(df["close"].iloc[i]) < breakout_level:
                    prior_attempts += 1
            else:
                # Count bars that touched but failed to close below level
                if float(df["low"].iloc[i]) <= breakout_level and float(df["close"].iloc[i]) > breakout_level:
                    prior_attempts += 1

    prior_score = min(20.0, prior_attempts * cfg["prior_fail_bonus_per_attempt"])

    # --- Factor 5: Zone clearance (0-15 points) ---
    # If there's a strong opposing zone very close, breakout is more likely to fail
    zone_score = 12.0  # default: no zone info = neutral-positive
    if nearby_zones:
        closest_opposing_dist = float("inf")
        for zone in nearby_zones:
            if direction == "long" and zone.get("type") == "supply":
                # Supply zone above = resistance
                zone_dist = (float(zone.get("btm", 0)) - bar_close) / bar_close * 100 if bar_close > 0 else 999
                if 0 < zone_dist < closest_opposing_dist:
                    closest_opposing_dist = zone_dist
            elif direction == "short" and zone.get("type") == "demand":
                # Demand zone below = support
                zone_dist = (bar_close - float(zone.get("top", 0))) / bar_close * 100 if bar_close > 0 else 999
                if 0 < zone_dist < closest_opposing_dist:
                    closest_opposing_dist = zone_dist

        if closest_opposing_dist < cfg["zone_distance_close_pct"]:
            zone_score = 2.0  # Very close opposing zone = high fake risk
        elif closest_opposing_dist < cfg["zone_distance_far_pct"]:
            zone_score = 8.0
        else:
            zone_score = 15.0  # Clear path

    # --- Combine ---
    quality_score = volume_score + magnitude_score + timing_score + prior_score + zone_score
    quality_score = max(0, min(100, quality_score))

    # Determine tier
    if quality_score >= cfg["high_quality_min"]:
        quality_tier = "high"
        recommendation = "可即刻买入" if direction == "long" else "可即刻做空"
        fake_prob = max(0.05, (100 - quality_score) / 100 * 0.4)
    elif quality_score <= cfg["low_quality_max"]:
        quality_tier = "low"
        recommendation = "观察"
        fake_prob = min(0.9, (100 - quality_score) / 100)
    else:
        quality_tier = "medium"
        recommendation = "等确认"
        fake_prob = (100 - quality_score) / 100 * 0.7

    # Build signal text
    dir_label = "突破" if direction == "long" else "破位"
    signal_parts = []
    if volume_score >= 20:
        signal_parts.append(f"放量{vol_ratio:.1f}x")
    elif volume_score < 8:
        signal_parts.append(f"量不足{vol_ratio:.1f}x")
    if magnitude_score >= 20:
        signal_parts.append(f"幅度{atr_ratio:.1f}ATR")
    elif magnitude_score < 8:
        signal_parts.append(f"幅度弱{atr_ratio:.1f}ATR")
    if prior_attempts >= 2:
        signal_parts.append(f"第{prior_attempts+1}次尝试")
    if timing_score <= 5:
        signal_parts.append("亚洲时段")

    signal = f"{dir_label}质量{'高' if quality_tier == 'high' else '低' if quality_tier == 'low' else '中'}({', '.join(signal_parts)})" if signal_parts else ""

    result.update({
        "quality_score": round(quality_score, 1),
        "quality_tier": quality_tier,
        "factors": {
            "volume_score": round(volume_score, 1),
            "volume_ratio": round(vol_ratio, 2),
            "magnitude_score": round(magnitude_score, 1),
            "atr_ratio": round(atr_ratio, 2),
            "timing_score": round(timing_score, 1),
            "prior_attempts_score": round(prior_score, 1),
            "prior_attempts": prior_attempts,
            "zone_clearance_score": round(zone_score, 1),
        },
        "fake_probability": round(fake_prob, 3),
        "signal": signal,
        "recommendation": recommendation,
    })

    return result


# ---------------------------------------------------------------------------
# Factor scoring interface
# ---------------------------------------------------------------------------

def breakout_quality_factor_score(quality_data: dict) -> tuple[float, str]:
    """Convert breakout quality into a factor score.

    Returns:
        (score_delta, signal_label)
    """
    cfg = _breakout_quality_config()
    tier = quality_data.get("quality_tier", "medium")
    signal = quality_data.get("signal", "")

    if tier == "high":
        return cfg["weight_high_quality"], signal
    elif tier == "low":
        return cfg["weight_low_quality_penalty"], signal
    else:
        return 0.0, ""