AI-Trader/market/monitor.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
转折点监控模块
实时监控价格与转折点的接近程度，并通过WebSocket推送提醒
"""

from typing import Dict, List, Optional, Set
from datetime import datetime
import threading
import asyncio
import json
import os

from .store import MarketStore
from .pivot_detector import PivotDetector
from .pending_orders import PendingOrderManager


# 配置文件路径
CONFIG_FILE = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'data', 'trade_config.json')


# 交易配置
class TradeConfig:
    """交易配置"""
    _instance = None
    _lock = threading.Lock()

    def __init__(self):
        self.enabled = True  # 是否启用自动生成

        # 默认配置
        self.default_volume = 0.01  # 默认手数
        self.default_sl_offset = 0.05  # 默认止损偏移（固定点数）

        # MT5服务器时区偏移（单位：小时）
        # 正数表示MT5时间比本地时间快，负数表示比本地时间慢
        # 例如：MT5服务器时间是GMT+2，本地时间是GMT+8，则偏移为 -6
        self.mt5_timezone_offset = 0

        # 按品种配置: {symbol: {"volume": 0.01, "sl_offset": 0.05, "key_levels": "5000,5100", "key_level_threshold": 0.0008}}
        self.symbol_config = {
            "GOLD#": {"volume": 0.01, "sl_offset": 0.5},
            "OILCASH#": {"volume": 0.01, "sl_offset": 0.05},
        }

        # 启动时自动加载配置文件
        self._load_from_file()

    def _load_from_file(self):
        """从配置文件加载配置"""
        try:
            if os.path.exists(CONFIG_FILE):
                with open(CONFIG_FILE, 'r', encoding='utf-8') as f:
                    data = json.load(f)
                    self.update(data)
                print(f"[TradeConfig] 已从配置文件加载: mt5_timezone_offset={self.mt5_timezone_offset}")
            else:
                print(f"[TradeConfig] 配置文件不存在: {CONFIG_FILE}，使用默认配置")
        except Exception as e:
            print(f"[TradeConfig] 加载配置文件失败: {e}，使用默认配置")

    def save_to_file(self):
        """保存配置到文件"""
        try:
            os.makedirs(os.path.dirname(CONFIG_FILE), exist_ok=True)
            with open(CONFIG_FILE, 'w', encoding='utf-8') as f:
                json.dump(self.to_dict(), f, indent=2, ensure_ascii=False)
            print(f"[TradeConfig] 配置已保存到: {CONFIG_FILE}")
            return True
        except Exception as e:
            print(f"[TradeConfig] 保存配置文件失败: {e}")
            return False

    @classmethod
    def get_instance(cls):
        if cls._instance is None:
            with cls._lock:
                if cls._instance is None:
                    cls._instance = cls()
        return cls._instance

    def get_symbol_config(self, symbol: str) -> Dict:
        """获取品种配置，如果未配置则返回默认值"""
        if symbol in self.symbol_config:
            config = self.symbol_config[symbol]
            return {
                "volume": config.get("volume", self.default_volume),
                "sl_offset": config.get("sl_offset", self.default_sl_offset),
                "key_levels": config.get("key_levels", ""),
                "key_level_threshold": config.get("key_level_threshold", 0.0008)
            }
        return {
            "volume": self.default_volume,
            "sl_offset": self.default_sl_offset,
            "key_levels": "",
            "key_level_threshold": 0.0008
        }

    def get_key_levels(self, symbol: str) -> List[float]:
        """
        获取品种的关键点位列表

        Args:
            symbol: 品种名称

        Returns:
            关键点位列表，如 [5000, 5100, 5200]
        """
        config = self.get_symbol_config(symbol)
        key_levels_str = config.get("key_levels", "")
        if not key_levels_str:
            return []

        levels = []
        for level_str in key_levels_str.split(","):
            level_str = level_str.strip()
            if level_str:
                try:
                    levels.append(float(level_str))
                except ValueError:
                    continue
        return sorted(levels)

    def to_dict(self) -> Dict:
        return {
            "enabled": self.enabled,
            "default_volume": self.default_volume,
            "default_sl_offset": self.default_sl_offset,
            "mt5_timezone_offset": self.mt5_timezone_offset,
            "symbol_config": self.symbol_config
        }

    def update(self, data: Dict):
        if "enabled" in data:
            self.enabled = bool(data["enabled"])
        if "default_volume" in data:
            self.default_volume = float(data["default_volume"])
        if "default_sl_offset" in data:
            self.default_sl_offset = float(data["default_sl_offset"])
        if "mt5_timezone_offset" in data:
            self.mt5_timezone_offset = float(data["mt5_timezone_offset"])
        if "symbol_config" in data:
            self.symbol_config = data["symbol_config"]


class PivotMonitor:
    """转折点监控器"""

    def __init__(self, store: MarketStore, detector: PivotDetector,
                 pending_orders: PendingOrderManager = None, llm_analyzer=None):
        self.store = store
        self.detector = detector
        self.pending_orders = pending_orders
        self.trade_config = TradeConfig.get_instance()
        self.llm_analyzer = llm_analyzer

        # WebSocket连接管理
        self._ws_clients: Set = set()
        self._ws_lock = threading.Lock()

        # 已提醒的转折点（避免重复提醒）
        # 结构: {(symbol, period, timestamp, price): datetime}
        self._alerted_pivots: Dict[tuple, datetime] = {}
        self._alert_lock = threading.Lock()

        # AI入场价提醒冷却（避免重复提醒）
        self._alerted_ai_entries: Dict[str, datetime] = {}

        # 关键点位订单冷却（避免重复生成订单）
        # 结构: {symbol_key: datetime}
        self._alerted_key_levels: Dict[str, datetime] = {}

        # 主事件循环引用（在FastAPI启动时设置）
        self._main_loop = None

        # 提醒冷却时间（秒）
        self.alert_cooldown = 300  # 5分钟内同一转折点不重复提醒

        # 关键点位订单冷却时间（秒）- 与订单超时时间一致
        self.key_level_cooldown = 180  # 3分钟

        print("[PivotMonitor] 转折点监控器已初始化")

    def set_event_loop(self, loop):
        """设置主事件循环引用"""
        self._main_loop = loop
        print(f"[PivotMonitor] 已设置主事件循环")

    def set_statistics_history(self, statistics_history):
        """设置统计数据历史引用（用于获取价差）"""
        self._statistics_history = statistics_history

    def _get_symbol_spread(self, symbol: str) -> Optional[float]:
        """
        获取指定品种的最新价差

        Args:
            symbol: 品种名称

        Returns:
            价差（金额），如果没有返回None
        """
        if not hasattr(self, '_statistics_history') or not self._statistics_history:
            return None

        symbol_normalized = symbol.replace('#', '')

        # 从最新的统计数据中查找该品种的价差
        for stat in reversed(list(self._statistics_history)):
            stat_symbol = stat.get('symbol', '')
            stat_normalized = stat_symbol.replace('#', '')
            if stat_normalized == symbol_normalized:
                spread = stat.get('spread')
                if spread is not None and spread > 0:
                    return spread

        return None

    def _calculate_take_profit(self, action: str, entry_price: float, sl: float, tp: float = None) -> Optional[float]:
        """
        计算并修正止盈价格

        规则：
        1. 止盈方向必须正确（买入止盈>入场价，卖出止盈<入场价）
        2. 风险回报比至少为1（止盈距离 >= 止损距离）
        3. 如果不满足，按照风险回报比=1重新计算

        Args:
            action: 'b' 买入 或 's' 卖出
            entry_price: 入场价格
            sl: 止损价格
            tp: 原始止盈价格（可能为None）

        Returns:
            修正后的止盈价格，如果止损设置有问题返回None
        """
        if action == 'b':
            # 买入：止损应该 < 入场价
            risk = entry_price - sl
            if risk <= 0:
                # 止损设置有问题（止损高于入场价），不生成订单
                print(f"[PivotMonitor] 警告: 买入止损{sl}高于入场价{entry_price}，跳过订单")
                return None

            # 计算最小止盈（风险回报比=1）
            min_tp = entry_price + risk

            # 如果没有止盈，或者止盈不满足条件，使用最小止盈
            if tp is None or tp <= entry_price or (tp - entry_price) < risk:
                print(f"[PivotMonitor] 修正买入止盈: 原{tp} -> 新{min_tp:.2f} (风险={risk:.2f})")
                return round(min_tp, 2)
            return round(tp, 2)

        else:  # action == 's'
            # 卖出：止损应该 > 入场价
            risk = sl - entry_price
            if risk <= 0:
                # 止损设置有问题（止损低于入场价），不生成订单
                print(f"[PivotMonitor] 警告: 卖出止损{sl}低于入场价{entry_price}，跳过订单")
                return None

            # 计算最小止盈（风险回报比=1）
            min_tp = entry_price - risk

            # 如果没有止盈，或者止盈不满足条件，使用最小止盈
            if tp is None or tp >= entry_price or (entry_price - tp) < risk:
                print(f"[PivotMonitor] 修正卖出止盈: 原{tp} -> 新{min_tp:.2f} (风险={risk:.2f})")
                return round(min_tp, 2)
            return round(tp, 2)

    def _get_auto_key_levels(self, symbol: str, current_price: float) -> List[float]:
        """
        根据品种价格位数自动计算关键点位

        规则：
        - 一位数价格：能被1整除
        - 两位数价格：能被5整除
        - 三位数价格：能被10整除
        - 四位数价格：能被100整除
        - 五位数或六位数价格：能被1000整除

        Args:
            symbol: 品种名称
            current_price: 当前价格

        Returns:
            关键点位列表（当前价格上下各3个）
        """
        if current_price <= 0:
            return []

        # 计算整数部分位数
        int_part = int(current_price)
        num_digits = len(str(int_part)) if int_part > 0 else 1

        # 根据位数确定步长
        if num_digits == 1:
            step = 1
        elif num_digits == 2:
            step = 5
        elif num_digits == 3:
            step = 10
        elif num_digits == 4:
            step = 100
        else:  # 5位数或6位数
            step = 1000

        # 计算当前价格所在的基础点位
        base_level = int(current_price / step) * step

        # 生成上下各3个关键点位
        levels = []
        for i in range(-3, 4):
            level = base_level + i * step
            if level > 0:  # 确保价格为正
                levels.append(float(level))

        return sorted(levels)

    def check_key_levels(self, symbol: str, current_price: float) -> Optional[Dict]:
        """
        检查价格是否接近关键点位，并生成交易指令

        策略逻辑：
        - 向下走接近关键点位 → 买入（支撑位）
        - 向上走接近关键点位 → 卖出（压力位）

        如果没有配置关键点位，则自动计算关键点位

        Args:
            symbol: 交易品种
            current_price: 当前价格

        Returns:
            交易指令或None
        """
        if not self.trade_config.enabled:
            return None

        # 获取关键点位配置
        key_levels = self.trade_config.get_key_levels(symbol)

        # 如果没有配置关键点位，自动计算
        if not key_levels:
            key_levels = self._get_auto_key_levels(symbol, current_price)

        if not key_levels:
            return None

        threshold = self.trade_config.get_symbol_config(symbol).get("key_level_threshold", 0.0008)

        # 找到最近的关键点位
        nearest_level = None
        min_distance = float('inf')

        for level in key_levels:
            distance_pct = abs(current_price - level) / current_price
            if distance_pct < min_distance:
                min_distance = distance_pct
                nearest_level = level

        if nearest_level is None:
            return None

        # 判断是否在阈值范围内
        distance_pct = abs(current_price - nearest_level) / current_price
        if distance_pct > threshold:
            return None

        # 检查是否已经为该关键点位生成过订单（在冷却时间内）
        current_time = datetime.now()
        key_level_key = f"{symbol}_{nearest_level}"
        if key_level_key in self._alerted_key_levels:
            last_alert = self._alerted_key_levels[key_level_key]
            elapsed = (current_time - last_alert).total_seconds()
            if elapsed < self.key_level_cooldown:
                # 还在冷却时间内，跳过
                return None

        # 记录提醒时间
        self._alerted_key_levels[key_level_key] = current_time

        # 判断走势方向：通过价格相对于关键点位的位置

        # 获取品种配置
        config = self.trade_config.get_symbol_config(symbol)
        volume = config["volume"]

        # 获取价差
        spread = self._get_symbol_spread(symbol)

        # 根据价格与关键点位的关系判断方向
        if current_price > nearest_level:
            # 价格在关键点位上方，向下接近 → 买入（支撑位）
            action = 'b'
            sl = nearest_level - (nearest_level * 0.006)  # 关键点位下方万分之六
            if spread:
                sl -= spread  # 买入止损需要更低
            # 止盈：1.5倍风险回报比
            risk = current_price - sl
            tp = current_price + risk * 1.5
            if spread:
                tp -= spread  # 买入止盈需要更低
            reason = f"关键点位策略: 价格向下接近 {nearest_level}（支撑位）"
        else:
            # 价格在关键点位下方，向上接近 → 卖出（压力位）
            action = 's'
            sl = nearest_level + (nearest_level * 0.006)  # 关键点位上方万分之六
            if spread:
                sl += spread  # 卖出止损需要更高
            # 止盈：1.5倍风险回报比
            risk = sl - current_price
            tp = current_price - risk * 1.5
            if spread:
                tp += spread  # 卖出止盈需要更高
            reason = f"关键点位策略: 价格向上接近 {nearest_level}（压力位）"

        # 验证并修正止盈
        tp = self._calculate_take_profit(action, current_price, sl, tp)
        if tp is None:
            # 止损设置有问题，不生成订单
            return None

        # 获取各周期的AI建议方向
        ai_directions = self._get_ai_directions_by_period(symbol)
        key_level_direction_text = '买入' if action == 'b' else '卖出'

        # 判断方向一致性并生成建议
        direction_analysis = self._analyze_direction_consistency(action, ai_directions)

        # 创建订单
        order = {
            "symbol": symbol,
            "action": action,
            "price": current_price,
            "mount": volume,
            "sl": round(sl, 2),
            "tp": tp,
            "reason": reason,
            "description": "Key Level Strategy",
            "source": "key_level",
            "key_level": nearest_level,
            "distance_pct": round(distance_pct * 100, 4),
            "generated_at": current_time.isoformat(),
            # 新增AI方向对比字段
            "ai_directions": ai_directions,  # 各周期AI方向
            "key_level_direction_text": key_level_direction_text,
            "direction_consistent": direction_analysis['is_consistent'],
            "consistent_periods": direction_analysis['consistent_periods'],
            "inconsistent_periods": direction_analysis['inconsistent_periods'],
            "recommendation": direction_analysis['recommendation'],
            "recommendation_color": direction_analysis['recommendation_color']
        }

        # 添加到待确认订单
        if self.pending_orders:
            order_id = self.pending_orders.add_order(order)
            order["order_id"] = order_id

            print(f"[PivotMonitor] 关键点位策略生成订单: {order_id} - {action} {symbol} @ {current_price}, 关键位={nearest_level}, SL={sl:.2f}, TP={tp:.2f}")
            print(f"[PivotMonitor] AI各周期方向: {ai_directions}, 关键点位方向: {key_level_direction_text}, 一致周期: {direction_analysis['consistent_periods']}, 建议: {direction_analysis['recommendation']}")

            # 推送关键点位订单通知到前端
            self._broadcast_key_level_order(order)

            return order

        return None

    def _get_ai_directions_by_period(self, symbol: str) -> Dict[str, Dict]:
        """
        获取AI各周期的交易建议方向

        Args:
            symbol: 交易品种

        Returns:
            {period: {'direction': 'buy'/'sell', 'text': '买入'/'卖出', 'entry_price': xxx}}
        """
        if not self.llm_analyzer:
            return {}

        result = {}
        try:
            analysis = self.llm_analyzer.get_analysis(symbol)
            if not analysis:
                return {}

            # 从交易建议中获取各周期方向
            analysis_data = analysis.get('analysis', {})
            trade_suggestions = analysis_data.get('trade_suggestions', [])

            for suggestion in trade_suggestions:
                period = suggestion.get('period', '')
                direction = suggestion.get('direction', '')
                entry_price = suggestion.get('entry_price')

                if period and direction:
                    # 标准化方向
                    direction_lower = direction.lower().strip()
                    if direction_lower in ['buy', '买入', '多头']:
                        direction_normalized = 'buy'
                        direction_text = '买入'
                    elif direction_lower in ['sell', '卖出', '空头']:
                        direction_normalized = 'sell'
                        direction_text = '卖出'
                    else:
                        continue

                    result[period] = {
                        'direction': direction_normalized,
                        'text': direction_text,
                        'entry_price': entry_price
                    }

            return result
        except Exception as e:
            print(f"[PivotMonitor] 获取AI各周期方向失败: {e}")
            return {}

    def _analyze_direction_consistency(self, key_level_action: str, ai_directions: Dict[str, Dict]) -> Dict:
        """
        分析关键点位方向与AI各周期方向的一致性

        Args:
            key_level_action: 'b' 或 's'
            ai_directions: {period: {'direction': 'buy'/'sell', ...}}

        Returns:
            {
                'is_consistent': bool,  # 是否有任一周期一致
                'consistent_periods': [],  # 一致的周期列表
                'inconsistent_periods': [],  # 不一致的周期列表
                'recommendation': str,  # 建议文本
                'recommendation_color': str  # 建议颜色
            }
        """
        if not ai_directions:
            return {
                'is_consistent': False,
                'consistent_periods': [],
                'inconsistent_periods': [],
                'recommendation': 'AI暂无建议，请谨慎操作',
                'recommendation_color': 'warning'
            }

        consistent_periods = []
        inconsistent_periods = []

        for period, dir_info in ai_directions.items():
            ai_dir = dir_info.get('direction', '')

            # b = buy, s = sell
            if (key_level_action == 'b' and ai_dir == 'buy') or \
               (key_level_action == 's' and ai_dir == 'sell'):
                consistent_periods.append(period)
            else:
                inconsistent_periods.append(period)

        # 判断整体一致性
        is_consistent = len(consistent_periods) > 0 and len(inconsistent_periods) == 0

        # 生成建议
        if len(consistent_periods) == len(ai_directions):
            # 全部一致
            recommendation = f"AI各周期方向一致，建议下单"
            recommendation_color = "success"
        elif len(consistent_periods) > 0:
            # 部分一致
            recommendation = f"AI部分周期一致({','.join(consistent_periods)})，建议谨慎"
            recommendation_color = "warning"
        else:
            # 全部不一致
            recommendation = f"AI方向不一致，建议慎重"
            recommendation_color = "error"

        return {
            'is_consistent': is_consistent,
            'consistent_periods': consistent_periods,
            'inconsistent_periods': inconsistent_periods,
            'recommendation': recommendation,
            'recommendation_color': recommendation_color
        }

    def check_ai_entry(self, symbol: str, current_price: float) -> List[Dict]:
        """
        检查价格是否接近AI建议的入场价，并生成交易指令

        Args:
            symbol: 交易品种
            current_price: 当前价格

        Returns:
            AI入场价提醒列表
        """
        if not self.llm_analyzer:
            return []

        if not self.trade_config.enabled:
            return []

        # 检查AI入场价
        ai_matches = self.llm_analyzer.check_entry_price_nearby(symbol, current_price, threshold=0.0001)

        ai_entry_alerts = []
        current_time = datetime.now()

        # 获取价差
        spread = self._get_symbol_spread(symbol)

        for match in ai_matches:
            # 生成待确认订单
            action = 'b' if match['direction'] == 'buy' else 's'

            # 检查是否已经提醒过这个AI入场价（5分钟内不重复）
            ai_key = f"{symbol}_{match['period']}_{match['entry_price']}_{match['direction']}"
            if ai_key in self._alerted_ai_entries:
                last_alert = self._alerted_ai_entries[ai_key]
                elapsed = (current_time - last_alert).total_seconds()
                if elapsed < self.alert_cooldown:
                    continue

            # 记录提醒时间
            self._alerted_ai_entries[ai_key] = current_time

            # 根据方向调整止损止盈（考虑价差）
            sl = match['stop_loss']
            tp = match['take_profit']
            if spread:
                if action == 'b':
                    # 买入：止损需要更低，止盈需要更低
                    sl -= spread
                    tp -= spread
                else:
                    # 卖出：止损需要更高，止盈需要更高
                    sl += spread
                    tp += spread

            # 验证并修正止盈
            tp = self._calculate_take_profit(action, current_price, sl, tp)
            if tp is None:
                # 止损设置有问题，跳过此订单
                continue

            order = {
                "symbol": symbol,
                "action": action,
                "price": current_price,
                "mount": self.trade_config.get_symbol_config(symbol).get("volume", 0.01),
                "sl": round(sl, 2) if sl else None,
                "tp": tp,
                "reason": f"AI建议入场: {match['reason']}",
                "description": "AI Trend Strategy",
                "source": "ai_entry_nearby",
                "ai_period": match['period'],
                "ai_entry_price": match['entry_price'],
                "ai_direction": match['direction'],
                "generated_at": current_time.isoformat()
            }

            # 添加到待确认订单
            if self.pending_orders:
                order_id = self.pending_orders.add_order(order)
                order["order_id"] = order_id

                # 构建提醒
                alert = {
                    "type": "ai_entry_alert",
                    "symbol": symbol,
                    "period": match['period'],
                    "direction": match['direction'],
                    "entry_price": match['entry_price'],
                    "current_price": current_price,
                    "price_diff_pct": match['price_diff_pct'],
                    "stop_loss": sl,
                    "take_profit": tp,
                    "reason": match['reason'],
                    "pending_order": order,
                    "timestamp": current_time.isoformat()
                }
                ai_entry_alerts.append(alert)

                print(f"[PivotMonitor] AI趋势策略生成订单: {order_id} - {action} {symbol} @ {current_price}, AI入场价={match['entry_price']}")

                # 广播AI入场价提醒
                self._broadcast_alert(alert)

        return ai_entry_alerts

    def check_and_alert(self, symbol: str, current_price: float) -> List[Dict]:
        """
        检查价格是否接近转折点，并发送提醒
        同时检测关键点位策略

        Args:
            symbol: 交易品种
            current_price: 当前价格

        Returns:
            接近的转折点列表
        """
        # 检查关键点位策略
        self.check_key_levels(symbol, current_price)

        # 检查AI趋势策略
        self.check_ai_entry(symbol, current_price)

        # 检查是否接近转折点
        near_pivots = self.detector.check_near_pivot(symbol, current_price)

        if not near_pivots:
            return []

        # 过滤已提醒过的转折点
        new_alerts = []
        current_time = datetime.now()

        with self._alert_lock:
            for pivot in near_pivots:
                key = (
                    pivot['symbol'],
                    pivot['period'],
                    pivot['timestamp'],
                    pivot['price']
                )

                # 检查是否已提醒过
                if key in self._alerted_pivots:
                    last_alert = self._alerted_pivots[key]
                    elapsed = (current_time - last_alert).total_seconds()

                    # 如果在冷却时间内，跳过
                    if elapsed < self.alert_cooldown:
                        continue

                # 记录提醒时间
                self._alerted_pivots[key] = current_time

                # 构建提醒消息
                is_breakthrough = pivot.get('is_breakthrough', False)
                alert_type = pivot.get('alert_type', '')
                period = pivot['period']

                # 根据类型生成不同的消息
                if is_breakthrough:
                    if 'high' in alert_type:
                        message = f"{pivot['symbol']} {period} 已突破高点 {pivot['price']}, 当前价格 {pivot['current_price']}"
                    else:
                        message = f"{pivot['symbol']} {period} 已突破低点 {pivot['price']}, 当前价格 {pivot['current_price']}"
                else:
                    if 'high' in alert_type:
                        message = f"{pivot['symbol']} {period} 接近高点 {pivot['price']}, 当前价格 {pivot['current_price']}, 距离 {pivot['distance_pct']}%"
                    else:
                        message = f"{pivot['symbol']} {period} 接近低点 {pivot['price']}, 当前价格 {pivot['current_price']}, 距离 {pivot['distance_pct']}%"

                alert = {
                    "type": "pivot_alert",
                    "symbol": pivot['symbol'],
                    "period": period,
                    "direction": pivot['direction'],
                    "pivot_price": pivot['price'],
                    "current_price": pivot['current_price'],
                    "distance_pct": pivot['distance_pct'],
                    "threshold_pct": pivot['threshold_pct'],
                    "timestamp": current_time.isoformat(),
                    "alert_type": alert_type,
                    "is_breakthrough": is_breakthrough,
                    "message": message
                }

                # M1和M5周期接近转折点时，自动生成交易指令
                pending_order = None
                if period in ['M1', 'M5'] and not is_breakthrough:
                    pending_order = self._auto_generate_order(pivot, current_time)

                # 如果生成了订单，加入通知中
                if pending_order:
                    alert["pending_order"] = pending_order

                new_alerts.append(alert)

                # 异步推送WebSocket消息
                self._broadcast_alert(alert)

        # 清理过期的提醒记录
        self._cleanup_alerted()

        return new_alerts

    def _auto_generate_order(self, pivot: Dict, current_time: datetime) -> Optional[Dict]:
        """
        M1周期接近转折点时，自动生成交易指令

        Args:
            pivot: 转折点信息
            current_time: 当前时间

        Returns:
            生成的订单信息，包含order_id
        """
        if not self.pending_orders:
            return None

        if not self.trade_config.enabled:
            return None

        symbol = pivot['symbol']
        current_price = pivot['current_price']
        pivot_price = pivot['price']
        direction = pivot['direction']
        alert_type = pivot['alert_type']

        # 只处理"接近"类型（near_high, near_low）
        if not alert_type.startswith('near_'):
            return None

        # 获取品种配置
        config = self.trade_config.get_symbol_config(symbol)
        volume = config["volume"]
        sl_offset = config["sl_offset"]  # 固定点数偏移

        # 获取价差
        spread = self._get_symbol_spread(symbol)

        order = None

        if alert_type == 'near_low':
            # 接近低点 → 买入
            # 止损 = 低点 - 配置的偏移
            sl = pivot_price - sl_offset
            if spread:
                sl -= spread  # 买入止损需要更低
            # 止盈 = 最近的高点
            tp = self._find_nearest_pivot_price(symbol, 'high', current_price)

            # 验证并修正止盈
            tp = self._calculate_take_profit('b', current_price, sl, tp)
            if tp is not None:
                order = {
                    "symbol": symbol,
                    "action": "b",  # 买入
                    "price": current_price,
                    "mount": volume,
                    "sl": round(sl, 2),
                    "tp": tp,
                    "reason": f"M1接近低点{pivot_price:.2f}，建议买入，止损{sl:.2f}，止盈{tp:.2f}",
                    "description": "Pivot Strategy",
                    "source": "auto_pivot_m1",
                    "pivot_price": pivot_price,
                    "generated_at": current_time.isoformat()
                }

        elif alert_type == 'near_high':
            # 接近高点 → 卖出
            # 止损 = 高点 + 配置的偏移
            sl = pivot_price + sl_offset
            if spread:
                sl += spread  # 卖出止损需要更高
            # 止盈 = 最近的低点
            tp = self._find_nearest_pivot_price(symbol, 'low', current_price)

            # 验证并修正止盈
            tp = self._calculate_take_profit('s', current_price, sl, tp)
            if tp is not None:
                order = {
                    "symbol": symbol,
                    "action": "s",  # 卖出
                    "price": current_price,
                    "mount": volume,
                    "sl": round(sl, 2),
                    "tp": tp,
                    "reason": f"M1接近高点{pivot_price:.2f}，建议卖出，止损{sl:.2f}，止盈{tp:.2f}",
                    "description": "Pivot Strategy",
                    "source": "auto_pivot_m1",
                    "pivot_price": pivot_price,
                    "generated_at": current_time.isoformat()
                }

        if order:
            order_id = self.pending_orders.add_order(order)
            print(f"[PivotMonitor] 自动生成交易指令: {order_id} - {order['action']} {symbol} @ {current_price}")
            # 返回订单信息（包含order_id）
            order["order_id"] = order_id
            return order

        return None

    def _find_nearest_pivot_price(self, symbol: str, direction: str,
                                   current_price: float) -> Optional[float]:
        """
        找到离当前价格最近的转折点价格

        Args:
            symbol: 交易品种
            direction: 'high' 或 'low'
            current_price: 当前价格

        Returns:
            最近的转折点价格，如果没有返回None
        """
        nearest_price = None
        min_distance = float('inf')

        with self.detector._lock:
            for period in self.detector._pivots[symbol]:
                pivots = self.detector._pivots[symbol][period]

                for pivot in pivots:
                    if pivot.direction != direction:
                        continue

                    # 对于高点，只考虑价格高于当前价的
                    # 对于低点，只考虑价格低于当前价的
                    if direction == 'high' and pivot.price <= current_price:
                        continue
                    if direction == 'low' and pivot.price >= current_price:
                        continue

                    distance = abs(pivot.price - current_price)
                    if distance < min_distance:
                        min_distance = distance
                        nearest_price = pivot.price

        return nearest_price

    def _broadcast_new_order(self, order_id: str, order: Dict) -> None:
        """广播新订单通知"""
        message = json.dumps({
            "type": "new_order",
            "order_id": order_id,
            "order": order
        })

        with self._ws_lock:
            clients = list(self._ws_clients)

        for client in clients:
            try:
                asyncio.create_task(self._send_to_client(client, message))
            except Exception as e:
                print(f"[PivotMonitor] 发送新订单通知失败: {e}")

    def _cleanup_alerted(self):
        """清理过期的提醒记录"""
        current_time = datetime.now()

        with self._alert_lock:
            keys_to_remove = []
            for key, alert_time in self._alerted_pivots.items():
                elapsed = (current_time - alert_time).total_seconds()
                if elapsed > self.alert_cooldown * 2:
                    keys_to_remove.append(key)

            for key in keys_to_remove:
                del self._alerted_pivots[key]

    def _broadcast_alert(self, alert: Dict):
        """广播提醒到所有WebSocket客户端"""
        message = json.dumps(alert)

        with self._ws_lock:
            clients = list(self._ws_clients)

        if not clients:
            return

        # 使用保存的主事件循环
        if self._main_loop and self._main_loop.is_running():
            for client in clients:
                try:
                    asyncio.run_coroutine_threadsafe(
                        self._send_to_client(client, message),
                        self._main_loop
                    )
                except Exception as e:
                    print(f"[PivotMonitor] 发送WebSocket消息失败: {e}")
        else:
            # 如果事件循环未就绪，尝试直接创建任务
            try:
                for client in clients:
                    asyncio.create_task(self._send_to_client(client, message))
            except Exception as e:
                print(f"[PivotMonitor] 广播消息失败: {e}")

    def _broadcast_key_level_order(self, order: Dict):
        """广播关键点位订单通知到前端"""
        action_text = '买入' if order['action'] == 'b' else '卖出'
        alert = {
            "type": "key_level_alert",
            "symbol": order['symbol'],
            "action": order['action'],
            "action_text": action_text,
            "price": order['price'],
            "sl": order['sl'],
            "tp": order['tp'],
            "key_level": order['key_level'],
            "distance_pct": order['distance_pct'],
            "reason": order['reason'],
            "pending_order": order,
            "message": f"{order['symbol']} 关键点位策略: {action_text} @ {order['price']}, 关键位={order['key_level']}"
        }
        self._broadcast_alert(alert)

    async def _send_to_client(self, client, message: str):
        """发送消息到客户端"""
        try:
            await client.send_text(message)
        except Exception as e:
            print(f"[PivotMonitor] 发送消息到客户端失败: {e}")
            # 移除失效的客户端
            with self._ws_lock:
                self._ws_clients.discard(client)

    def add_ws_client(self, client):
        """添加WebSocket客户端"""
        with self._ws_lock:
            self._ws_clients.add(client)
            print(f"[PivotMonitor] WebSocket客户端已连接, 当前连接数: {len(self._ws_clients)}")

    def remove_ws_client(self, client):
        """移除WebSocket客户端"""
        with self._ws_lock:
            self._ws_clients.discard(client)
            print(f"[PivotMonitor] WebSocket客户端已断开, 当前连接数: {len(self._ws_clients)}")

    def get_ws_client_count(self) -> int:
        """获取WebSocket客户端数量"""
        with self._ws_lock:
            return len(self._ws_clients)

    def clear_symbol(self, symbol: str):
        """清除某个Symbol的提醒记录"""
        with self._alert_lock:
            keys_to_remove = [k for k in self._alerted_pivots if k[0] == symbol]
            for key in keys_to_remove:
                del self._alerted_pivots[key]

    def get_status(self) -> Dict:
        """获取监控状态"""
        with self._alert_lock:
            alerted_count = len(self._alerted_pivots)

        return {
            "ws_clients": self.get_ws_client_count(),
            "alerted_pivots": alerted_count,
            "alert_cooldown": self.alert_cooldown
        }