"""
价格行为学(PA)引擎 — 动K/静K、供需区Q评分、连续K加速、起爆点判定

核心概念：
- 动K(Dynamic Candle)：实体占比>70% + 振幅>1.5×ATR → 强方向性力量
- 静K(Static Candle)：实体占比<40% + 振幅<0.8×ATR → 犹豫/平衡/蓄力
- 供需区：由动K+静K群组成，Q评分≥7才是高质量区
- 起爆点：静K群后出现动K = 从蓄力到爆发的转折
- 连续K：高低点不断抬高/降低 = 趋势加速段
"""

import pandas as pd
import numpy as np
from typing import List, Dict, Optional, Tuple

from config_loader import (
    dynamic_k_thresholds,
    static_k_thresholds,
    zone_params,
    ignition_params,
    continuous_k_params,
    exhaustion_params,
    entry_point_params,
)


# ==================== 动K/静K识别 ====================

def classify_candles(df: pd.DataFrame, atr: float) -> List[Dict]:
    """
    对每根K线做动K/静K分类
    返回: [{"index": i, "type": "dynamic"/"static"/"neutral", "direction": 1/-1/0, ...}]
    """
    dynamic_body_ratio_min, dynamic_atr_ratio_min = dynamic_k_thresholds()
    static_body_ratio_max, static_atr_ratio_max = static_k_thresholds()
    results = []
    for i in range(len(df)):
        o = float(df["open"].iloc[i])
        c = float(df["close"].iloc[i])
        h = float(df["high"].iloc[i])
        l = float(df["low"].iloc[i])
        v = float(df["volume"].iloc[i])

        body = abs(c - o)
        total_range = h - l
        if total_range <= 0 or l <= 0 or atr <= 0:
            results.append({"index": i, "type": "neutral", "direction": 0,
                            "body_ratio": 0, "swing_ratio": 0, "volume": v})
            continue

        body_ratio = body / total_range  # 实体占比
        swing_ratio = total_range / l     # 振幅/低价 ≈ 涨跌幅

        atr_ratio = total_range / atr     # 振幅/ATR

        # 动K：实体占比>70% + 振幅>1.5×ATR
        if body_ratio > dynamic_body_ratio_min and atr_ratio > dynamic_atr_ratio_min:
            direction = 1 if c > o else -1
            results.append({"index": i, "type": "dynamic", "direction": direction,
                            "body_ratio": body_ratio, "swing_ratio": swing_ratio,
                            "atr_ratio": atr_ratio, "volume": v})
        # 静K：实体占比<40% + 振幅<0.8×ATR
        elif body_ratio < static_body_ratio_max and atr_ratio < static_atr_ratio_max:
            results.append({"index": i, "type": "static", "direction": 0,
                            "body_ratio": body_ratio, "swing_ratio": swing_ratio,
                            "atr_ratio": atr_ratio, "volume": v})
        else:
            direction = 1 if c > o else -1 if c < o else 0
            results.append({"index": i, "type": "neutral", "direction": direction,
                            "body_ratio": body_ratio, "swing_ratio": swing_ratio,
                            "atr_ratio": atr_ratio, "volume": v})

    return results


def calc_atr(df: pd.DataFrame, period: int = 14) -> float:
    """计算ATR"""
    if df is None or len(df) < period + 1:
        return 0.0
    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 = tr.rolling(period).mean().iloc[-1]
    return float(atr) if not pd.isna(atr) else 0.0


# ==================== 供需区 + Q评分 ====================

def find_supply_demand_zones(df: pd.DataFrame, candles_class: List[Dict],
                              atr: float, lookback: int = 50) -> List[Dict]:
    """
    识别结构化供需区（动K+静K群+动K确认）并计算Q评分

    供给区模式：阴动K(方向-1) → 静K群(2-5根) → 阳动K确认(方向+1)离开
    需求区模式：阳动K(方向+1) → 静K群(2-5根) → 阴动K确认(方向-1)离开

    返回: [{"type": "supply"/"demand", "top": float, "btm": float,
             "q_score": float, "freshness": int, ...}]
    """
    cfg_lookback, min_static_count, _ = zone_params()
    lookback = cfg_lookback if cfg_lookback else lookback

    zones = []
    if not candles_class or atr <= 0:
        return zones

    # 只看最近lookback根K线
    start_idx = max(0, len(candles_class) - lookback)

    for i in range(start_idx, len(candles_class)):
        c = candles_class[i]
        if c["type"] != "dynamic":
            continue

        # 检查后面是否有静K群+确认动K
        base_dir = c["direction"]  # 起始动K方向

        # 寻找静K群（紧随起始动K之后的2-5根静K）
        static_start = i + 1
        static_count = 0
        static_end = static_start
        for j in range(static_start, min(static_start + 5, len(candles_class))):
            if candles_class[j]["type"] == "static":
                static_count += 1
                static_end = j + 1
            else:
                break

        if static_count < min_static_count:  # 需要至少N根静K
            continue

        # 寻找确认动K（静K群之后的动K）
        confirm_idx = None
        for j in range(static_end, min(static_end + 3, len(candles_class))):
            if candles_class[j]["type"] == "dynamic":
                confirm_idx = j
                break

        if confirm_idx is None:
            continue

        confirm_dir = candles_class[confirm_idx]["direction"]

        # 判断区类型
        # 供给区：起始是阴动K，确认是阳动K离开向上
        # 需求区：起始是阳动K，确认是阴动K离开向下
        if base_dir == -1 and confirm_dir == 1:
            zone_type = "supply"
        elif base_dir == 1 and confirm_dir == -1:
            zone_type = "demand"
        else:
            continue  # 方向不匹配

        # 计算区的范围
        # 供给区：从静K群最低点到起始动K高点
        # 需求区：从起始动K低点到静K群最高点
        region_indices = [i] + list(range(static_start, static_end))
        region_highs = [float(df["high"].iloc[ri]) for ri in region_indices]
        region_lows = [float(df["low"].iloc[ri]) for ri in region_indices]

        if zone_type == "supply":
            zone_top = max(region_highs)
            zone_btm = min(region_lows)
        else:
            zone_top = max(region_highs)  # 需求区top = 阳动K高点+静K高点
            zone_btm = min(region_lows)    # 需求区btm = 最低点

        zone_height = zone_top - zone_btm
        if zone_height <= 0:
            continue

        # 离去强度：确认动K的离开幅度 / 区高度
        confirm_price = float(df["close"].iloc[confirm_idx])
        if zone_type == "supply":
            leave_dist = confirm_price - zone_top  # 离开供给区向上
        else:
            leave_dist = zone_btm - confirm_price  # 离开需求区向下

        leave_ratio = abs(leave_dist) / zone_height if zone_height > 0 else 0

        # Q评分（0-10分）
        q_score = _calc_q_score(
            zone_type=zone_type,
            base_speed=static_count,       # 静K数量（基底速度）
            freshness=_calc_freshness(df, zone_top, zone_btm, i, zone_type),
            age=len(candles_class) - i,    # K线年龄
            leave_ratio=leave_ratio,
            reaction_strength=_calc_reaction_strength(df, zone_type, zone_top, zone_btm, i),
        )

        zones.append({
            "type": zone_type,
            "top": round(zone_top, 6),
            "btm": round(zone_btm, 6),
            "q_score": q_score,
            "leave_ratio": round(leave_ratio, 2),
            "base_index": i,
            "confirm_index": confirm_idx,
            "static_count": static_count,
            "age": len(candles_class) - i,
        })

    # 去重：同价位区域保留Q评分最高的
    deduped = {}
    for z in zones:
        key = (z["type"], round(z["btm"], 4), round(z["top"], 4))
        if key not in deduped or z["q_score"] > deduped[key]["q_score"]:
            deduped[key] = z

    return sorted(deduped.values(), key=lambda z: z["q_score"], reverse=True)


def _calc_q_score(zone_type, base_speed, freshness, age, leave_ratio, reaction_strength):
    """
    Q质量评分（0-10分）
    维度：基底速度(0-2) + 新鲜度(0-2) + 年龄(0-1) + 离去强度(0-3) + 回踩反应(0-2)
    """
    _, _, q_score_breakpoints = zone_params()
    base_speed_bp = q_score_breakpoints.get("base_speed", [2, 3, 5])
    freshness_bp = q_score_breakpoints.get("freshness", [0, 2])
    age_bp = q_score_breakpoints.get("age", [20, 40])
    leave_ratio_bp = q_score_breakpoints.get("leave_ratio", [1.0, 1.5, 2.5, 3.0])

    score = 0.0

    # 1. 基底速度（静K越少越好，说明蓄力时间短、爆发快）
    if base_speed <= base_speed_bp[0]:
        score += 2
    elif base_speed <= base_speed_bp[1]:
        score += 1.5
    elif base_speed <= base_speed_bp[2]:
        score += 1
    else:
        score += 0

    # 2. 新鲜度（未被触碰的次数越少越好）
    if freshness <= freshness_bp[0]:
        score += 2
    elif freshness <= freshness_bp[1]:
        score += 1
    else:
        score += 0

    # 3. 年龄（越近越好）
    if age <= age_bp[0]:
        score += 1
    elif age <= age_bp[1]:
        score += 0.5
    else:
        score += 0

    # 4. 离去强度（离开幅度/区域高度 ≥2.5倍=最强）
    if leave_ratio >= leave_ratio_bp[3]:
        score += 3
    elif leave_ratio >= leave_ratio_bp[2]:
        score += 2.5
    elif leave_ratio >= leave_ratio_bp[1]:
        score += 2
    elif leave_ratio >= leave_ratio_bp[0]:
        score += 1
    else:
        score += 0

    # 5. 回踩反应（回踩后快速离开=强反应）
    score += min(reaction_strength, 2)

    return round(score, 1)


def _calc_freshness(df, zone_top, zone_btm, base_index, zone_type):
    """计算区域被触碰次数（新鲜度）"""
    touches = 0
    price = float(df["close"].iloc[-1])

    for j in range(base_index + 1, len(df)):
        h = float(df["high"].iloc[j])
        l = float(df["low"].iloc[j])

        if zone_type == "supply" and l <= zone_top:
            touches += 1
        elif zone_type == "demand" and h >= zone_btm:
            touches += 1

    return touches


def _calc_reaction_strength(df, zone_type, zone_top, zone_btm, base_index):
    """计算回踩后反应强度"""
    if base_index + 6 >= len(df):
        return 0

    # 看回踩后2根K线是否快速离开区域
    reaction = 0
    for j in range(base_index + 2, min(base_index + 8, len(df))):
        c = float(df["close"].iloc[j])

        if zone_type == "supply":
            # 回踩供给区后是否快速远离（向下远离=强反应）
            dist = (zone_btm - c) / (zone_top - zone_btm) if (zone_top - zone_btm) > 0 else 0
            reaction = max(reaction, max(0, dist))
        else:
            # 回踩需求区后是否快速远离（向上远离=强反应）
            dist = (c - zone_top) / (zone_top - zone_btm) if (zone_top - zone_btm) > 0 else 0
            reaction = max(reaction, max(0, dist))

    # 映射到0-2分
    if reaction >= 2.0:
        return 2
    elif reaction >= 1.0:
        return 1
    elif reaction >= 0.5:
        return 0.5
    return 0


# ==================== 连续K识别（趋势加速） ====================

def find_continuous_k(df: pd.DataFrame) -> List[Dict]:
    """
    识别连续K线组合（高低点不断抬高的阳线群/不断降低的阴线群）
    对应TV的is_continue_hl逻辑

    返回: [{"type": "bullish_continue"/"bearish_continue", "length": int,
             "start_index": int, "strength": float}]
    """
    min_count = continuous_k_params().get("min_count", 3)
    results = []
    if len(df) < min_count:
        return results

    closes = df["close"].values
    opens = df["open"].values
    highs = df["high"].values
    lows = df["low"].values

    # 从最新K线往回找连续模式
    i = len(df) - 1

    # 多头连续（阳线+高点抬高+低点抬高）
    bull_count = 0
    bull_start = i
    for j in range(i, -1, -1):
        if closes[j] > opens[j]:  # 阳线
            if j < i:
                if lows[j] < lows[j+1] and highs[j] < highs[j+1]:
                    # 低点抬高 + 高点抬高 = 多头连续
                    bull_count += 1
                    bull_start = j
                else:
                    break
            else:
                bull_count = 1
                bull_start = j
        else:
            break

    if bull_count >= min_count:
        strength = sum(highs[k] - lows[k] for k in range(bull_start, i+1)) / df["close"].iloc[-1]
        results.append({
            "type": "bullish_continue",
            "length": bull_count,
            "start_index": bull_start,
            "strength": round(float(strength), 4),
        })

    # 空头连续（阴线+高点降低+低点降低）
    bear_count = 0
    bear_start = i
    for j in range(i, -1, -1):
        if closes[j] < opens[j]:  # 阴线
            if j < i:
                if lows[j] > lows[j+1] and highs[j] > highs[j+1]:
                    bear_count += 1
                    bear_start = j
                else:
                    break
            else:
                bear_count = 1
                bear_start = j
        else:
            break

    if bear_count >= min_count:
        strength = sum(highs[k] - lows[k] for k in range(bear_start, i+1)) / float(df["close"].iloc[-1])
        results.append({
            "type": "bearish_continue",
            "length": bear_count,
            "start_index": bear_start,
            "strength": round(float(strength), 4),
        })

    return results


# ==================== 起爆点判定 ====================

def detect_ignition_point(candles_class: List[Dict], df: pd.DataFrame,
                           atr: float, min_static_count: int = 2) -> List[Dict]:
    """
    检测起爆点：静K群后出现动K = 从蓄力到爆发的转折

    条件：
    1. 连续min_static_count根静K（蓄力段）
    2. 紧随其后出现动K（方向性爆发）
    3. 动K实体 > 静K群平均实体 × 3（爆发力量显著）

    返回: [{"index": int, "direction": 1/-1, "strength": float,
             "static_before": int, "signal_type": str}]
    """
    lookback, cfg_min_static_count, static_search_range, _ = ignition_params()
    min_static_count = cfg_min_static_count if cfg_min_static_count else min_static_count

    ignitions = []
    if not candles_class or atr <= 0:
        return ignitions

    start_idx = max(0, len(candles_class) - lookback)  # 只看最近N根

    for i in range(start_idx, len(candles_class)):
        c = candles_class[i]
        if c["type"] != "dynamic":
            continue

        # 检查前面是否有静K群
        static_count = 0
        for j in range(i - 1, max(i - (static_search_range + 1), start_idx - 1), -1):
            if candles_class[j]["type"] == "static":
                static_count += 1
            else:
                break

        if static_count < min_static_count:
            continue

        # 检查爆发强度：动K实体 vs 静K群平均实体
        dynamic_body = abs(float(df["close"].iloc[i]) - float(df["open"].iloc[i]))

        # 静K群平均实体
        static_bodies = []
        for j in range(i - static_count, i):
            if candles_class[j]["type"] == "static":
                sb = abs(float(df["close"].iloc[j]) - float(df["open"].iloc[j]))
                static_bodies.append(sb)
        avg_static_body = sum(static_bodies) / len(static_bodies) if static_bodies else 0

        # 爆发强度 = 动K实体 / 静K平均实体
        if avg_static_body <= 0:
            strength_ratio = dynamic_body / atr if atr > 0 else 0
        else:
            strength_ratio = dynamic_body / avg_static_body

        # 动K方向
        direction = c["direction"]

        # 信号类型命名
        if direction == 1:
            signal_type = "起爆点↑(静K→阳动K)"
        elif direction == -1:
            signal_type = "起爆点↓(静K→阴动K)"
        else:
            continue

        age_bars = len(candles_class) - 1 - i
        ignitions.append({
            "index": i,
            "direction": direction,
            "strength_ratio": round(strength_ratio, 2),
            "static_before": static_count,
            "dynamic_atr_ratio": round(c["atr_ratio"], 2),
            "signal_type": signal_type,
            "age_bars": age_bars,
        })

    return ignitions


# ==================== 15min入场点分析 ====================

def analyze_entry_point(h1_df: pd.DataFrame, m15_df: pd.DataFrame,
                         atr_1h: float, zones_4h: List[Dict],
                         direction: int = 1) -> Dict:
    """
    15min级别入场点分析

    方向=1(做多)：寻找回踩到需求区+出现静K确认 = 最佳买点
    方向=-1(做空)：寻找反弹到供给区+出现静K确认 = 最佳卖点

    返回: {
        "action": "即刻买入"/"等回踩"/"放弃",
        "entry_type": str,
        "wait_price": float,  # 等回踩的目标价位
        "confidence": float,  # 0-1
        "reason": str,
        "breakout_k_info": dict,  # 突破K线信息
        "pullback_info": dict,    # 回踩信息
        "false_breakout": bool,   # 是否假突破
    }
    """
    if m15_df is None or len(m15_df) < 20 or atr_1h <= 0:
        return {"action": "放弃", "entry_type": "数据不足",
                "wait_price": 0, "confidence": 0, "reason": "15min数据不足",
                "false_breakout": False}

    entry_cfg = entry_point_params()
    recent_15min = entry_cfg.get("recent_15min", 6)
    dy_bear_max = entry_cfg.get("dy_bear_max", 3)

    price_1h = float(h1_df["close"].iloc[-1]) if h1_df is not None else 0
    atr_15 = calc_atr(m15_df, 14)
    m15_class = classify_candles(m15_df, atr_15)

    # 找最近2-3根15min的突破K线
    recent_15 = m15_class[-recent_15min:]  # 最近N根15min
    breakout_k = None
    pullback_k = None
    false_breakout = False

    # 1. 找突破K线：必须是最近/上一根15min内发生，避免把1小时前突破当作“正在突破”
    max_breakout_age = entry_cfg.get("max_breakout_age_bars", 1)
    for c in reversed(recent_15):
        age_bars = len(m15_class) - 1 - c.get("index", -1)
        if age_bars > max_breakout_age:
            continue
        if c["type"] == "dynamic" and c["direction"] == direction:
            breakout_k = c
            breakout_k["age_bars"] = age_bars
            break

    # 2. 突破后是否有回踩（静K或neutral+小实体）
    if breakout_k:
        bk_idx = breakout_k["index"]
        # 看突破K线之后的K线
        for c in m15_class[bk_idx+1:]:
            if c["type"] == "static" or (c["type"] == "neutral" and c["body_ratio"] < 0.35):
                pullback_k = c
                break

    # 3. 假突破检测：突破后立刻回落跌破突破K线低点(做多)/突破K线高点(做空)
    if breakout_k:
        bk_low = float(m15_df["low"].iloc[breakout_k["index"]])
        bk_high = float(m15_df["high"].iloc[breakout_k["index"]])
        current_price = float(m15_df["close"].iloc[-1])

        if direction == 1 and current_price < bk_low:
            false_breakout = True
        elif direction == -1 and current_price > bk_high:
            false_breakout = True

    # 4. 判断入场类型
    if false_breakout:
        return {
            "action": "放弃",
            "entry_type": "假突破",
            "wait_price": 0,
            "confidence": 0,
            "reason": "突破后回落，假突破信号",
            "breakout_k_info": {"index": breakout_k["index"] if breakout_k else -1,
                                "atr_ratio": breakout_k["atr_ratio"] if breakout_k else 0},
            "pullback_info": {},
            "false_breakout": True,
        }

    # 5. 找目标回踩价位（4H需求区或1H均线支撑）
    wait_price = 0
    if direction == 1:
        # 做多：找最近的4H需求区top作为回踩目标
        demand_zones = [z for z in zones_4h if z["type"] == "demand" and z["q_score"] >= 7]
        if demand_zones:
            # 价格还在需求区上方 → 回踩到需求区top是最佳买点
            nearest_demand = min(demand_zones, key=lambda z: abs(z["top"] - price_1h))
            if nearest_demand["top"] < price_1h:
                wait_price = round(nearest_demand["top"], 6)
        else:
            # 无高质量需求区，用1H MA20作为回踩目标
            if h1_df is not None and len(h1_df) >= 20:
                ma20_1h = float(h1_df["close"].rolling(20).mean().iloc[-1])
                if ma20_1h < price_1h:
                    wait_price = round(ma20_1h, 6)

    elif direction == -1:
        # 做空：找最近的4H供给区btm作为反弹目标
        supply_zones = [z for z in zones_4h if z["type"] == "supply" and z["q_score"] >= 7]
        if supply_zones:
            nearest_supply = min(supply_zones, key=lambda z: abs(z["btm"] - price_1h))
            if nearest_supply["btm"] > price_1h:
                wait_price = round(nearest_supply["btm"], 6)

    # 6. 综合判断（v11纯前瞻版 — 用PA行为替代RSI/布林）
    current_price_15 = float(m15_df["close"].iloc[-1])

    # 即刻买入条件：15min动K连续 + 无连续阴动K超买反转
    if breakout_k and not pullback_k:
        # 突破正在发生，没有回踩 — PA判断：15min近6根中阴动K<3即非超买反转
        candles_15 = classify_candles(m15_df, calc_atr(m15_df, 14))
        recent_15 = candles_15[-recent_15min:] if len(candles_15) >= recent_15min else candles_15
        dy_bear_15 = sum(1 for c in recent_15 if c["type"] == "dynamic" and c["direction"] == -1)
        no_overbought_reversal = dy_bear_15 < dy_bear_max

        if no_overbought_reversal:
            return {
                "action": "即刻买入",
                "entry_type": "突破进行中(15min动K连续)",
                "wait_price": round(current_price_15, 6),
                "confidence": 0.8,
                "reason": f"15min突破K线正在发生，近{recent_15min}根阴动K={dy_bear_15}<{dy_bear_max}(无超买反转)",
                "breakout_k_info": {"index": breakout_k["index"],
                                    "atr_ratio": round(breakout_k["atr_ratio"], 2),
                                    "direction": breakout_k["direction"],
                                    "age_bars": breakout_k.get("age_bars", 0)},
                "pullback_info": {},
                "false_breakout": False,
            }

    # 等回踩条件：突破后出现静K回踩
    if breakout_k and pullback_k:
        pb_idx = pullback_k["index"]
        pb_low = float(m15_df["low"].iloc[pb_idx])
        pb_high = float(m15_df["high"].iloc[pb_idx])
        return {
            "action": "等回踩",
            "entry_type": "突破后回踩确认",
            "wait_price": wait_price if wait_price > 0 else round(pb_low, 6),
            "confidence": 0.6,
            "reason": f"突破后15min出现静K回踩，等价格回到${wait_price or pb_low:.4f}附近入场",
            "breakout_k_info": {"index": breakout_k["index"],
                                "atr_ratio": round(breakout_k["atr_ratio"], 2)},
            "pullback_info": {"index": pb_idx,
                              "low": round(pb_low, 6),
                              "high": round(pb_high, 6)},
            "false_breakout": False,
        }

    # 放弃条件：15min出现连续阴动K（PA超买反转信号）
    candles_15_all = classify_candles(m15_df, calc_atr(m15_df, 14))
    recent_15_all = candles_15_all[-recent_15min:] if len(candles_15_all) >= recent_15min else candles_15_all
    dy_bear_15_all = sum(1 for c in recent_15_all if c["type"] == "dynamic" and c["direction"] == -1)
    if dy_bear_15_all >= dy_bear_max:
        return {
            "action": "放弃",
            "entry_type": "超买反转(PA)",
            "wait_price": 0,
            "confidence": 0,
            "reason": f"15min近{recent_15min}根阴动K={dy_bear_15_all}≥{dy_bear_max}(超买反转信号)",
            "false_breakout": False,
        }

    # 默认：HTF已确认多头，15min无明显突破K但也不存在反转信号
    # → 不再强制等回踩（37%失败率已被数据证实），改为参考当前价即刻入场
    # 由上层质量闸门对极端追高做最后拦截
    return {
        "action": "即刻买入",
        "entry_type": "HTF趋势延续(15min无反转)",
        "wait_price": round(current_price_15, 6),
        "confidence": 0.5,
        "reason": f"1H/4H已确认多头，15min无动K突破但阴动K={dy_bear_15_all}<{dy_bear_max}(无反转)，即刻入场",
        "breakout_k_info": {},
        "pullback_info": {},
        "false_breakout": False,
    }


# ==================== 趋势衰减检测 ====================

def detect_trend_exhaustion(h1_df: pd.DataFrame, atr_1h: float) -> Dict:
    """
    检测1H级别趋势衰减信号（v11纯前瞻版 — 已删除MACD/RSI）

    衰减信号（纯PA行为）：
    - 连续2+根静K（方向性力量减弱）
    - 1H放量阴线×2（多头出货）
    - 1H连续K空头加速（趋势加速下行）
    - 1H连续≥3根阴动K（趋势反转）
    - 放量滞涨（量放大但价格不涨）

    返回: {"exhausted": bool, "signals": [...], "severity": "low"/"medium"/"high"}
    """
    if h1_df is None or len(h1_df) < 30 or atr_1h <= 0:
        return {"exhausted": False, "signals": [], "severity": "low"}

    ex_cfg = exhaustion_params()
    recent_static_count = ex_cfg.get("recent_static_count", 3)
    recent_static_threshold = ex_cfg.get("recent_static_threshold", 2)
    high_vol_bear_threshold = ex_cfg.get("high_vol_bear_threshold", 2)
    dy_bear_threshold = ex_cfg.get("dy_bear_threshold", 3)
    vol_ratio_stagnation = ex_cfg.get("vol_ratio_stagnation", 2.0)
    price_change_stagnation_pct = ex_cfg.get("price_change_stagnation", 0.005) * 100
    min_count = continuous_k_params().get("min_count", 3)

    signals = []
    severity = "low"
    candles = classify_candles(h1_df, atr_1h)

    # 1. 最近2根是否是静K（方向性力量减弱）
    recent_types = [c["type"] for c in candles[-recent_static_count:]]
    static_count_recent = sum(1 for t in recent_types if t == "static")
    if static_count_recent >= recent_static_threshold:
        signals.append(f"1H连续{static_count_recent}静K(方向性减弱)")
        severity = "medium"

    # 2. 1H放量阴线×2（多头出货） — 替代MACD柱收缩
    vol_avg = float(h1_df["volume"].rolling(20).mean().iloc[-1])
    recent_3 = h1_df.tail(3)
    high_vol_bear = 0
    for _, row in recent_3.iterrows():
        vol_r = row["volume"] / vol_avg if vol_avg > 0 else 0
        if vol_r >= vol_ratio_stagnation and row["close"] < row["open"]:
            high_vol_bear += 1
    if high_vol_bear >= high_vol_bear_threshold:
        signals.append(f"1H放量阴线×{high_vol_bear}(多头出货)")
        severity = "medium" if severity == "low" else severity

    # 3. 1H连续K空头加速 — 替代RSI回落
    cont_k = find_continuous_k(h1_df)
    for ck in cont_k:
        if ck["type"] == "bearish_continue" and ck["length"] >= min_count:
            signals.append(f"1H连续{ck['length']}K空头加速")
            severity = "medium" if severity == "low" else severity

    # 4. 1H连续≥3根阴动K（趋势反转） — 替代MACD死叉
    recent_candles = candles[-6:] if len(candles) >= 6 else candles
    dy_bear_count = sum(1 for c in recent_candles if c["type"] == "dynamic" and c["direction"] == -1)
    if dy_bear_count >= dy_bear_threshold:
        signals.append(f"1H连续{dy_bear_count}根阴动K(趋势反转)")
        severity = "high"

    # 5. 放量滞涨（PA行为）
    vol_latest = float(h1_df["volume"].iloc[-1])
    vol_ratio = vol_latest / vol_avg if vol_avg > 0 else 1
    price_change_latest = (float(h1_df["close"].iloc[-1]) / float(h1_df["close"].iloc[-2]) - 1) * 100
    if vol_ratio >= vol_ratio_stagnation and abs(price_change_latest) < price_change_stagnation_pct:
        signals.append(f"1H放量滞涨(量{vol_ratio:.1f}倍但涨{price_change_latest:.2f}%)")
        severity = "high"

    exhausted = severity != "low"

    return {
        "exhausted": exhausted,
        "signals": signals,
        "severity": severity,
    }


# ==================== 综合PA分析 ====================

def full_pa_analysis(df: pd.DataFrame, timeframe: str = "4h") -> Dict:
    """
    对单币单时间框架做完整PA分析

    返回: {
        "candles_class": [...],
        "zones": [...],
        "continuous_k": [...],
        "ignition_points": [...],
        "atr": float,
        "trend_exhaustion": {...},
    }
    """
    atr = calc_atr(df, 14)
    if atr <= 0 or len(df) < 30:
        return {"candles_class": [], "zones": [], "continuous_k": [],
                "ignition_points": [], "atr": 0, "trend_exhaustion": {"exhausted": False, "signals": [], "severity": "low"}}

    candles_class = classify_candles(df, atr)
    zones = find_supply_demand_zones(df, candles_class, atr)
    continuous_k = find_continuous_k(df)
    ignition_points = detect_ignition_point(candles_class, df, atr)

    # 只在1H级别检测趋势衰减
    exhaustion = {}
    if timeframe == "1h":
        exhaustion = detect_trend_exhaustion(df, atr)
    else:
        exhaustion = {"exhausted": False, "signals": [], "severity": "low"}

    return {
        "candles_class": candles_class,
        "zones": zones,
        "continuous_k": continuous_k,
        "ignition_points": ignition_points,
        "atr": round(atr, 6),
        "trend_exhaustion": exhaustion,
    }