mt5_python_ea_suite/core/risk/hedge.py

"""
对冲管理器 — 信号对冲 + 回撤锁仓

两种对冲模式：
  1. 信号对冲：持仓方向与当前加权信号相反 → 开反向单保护
  2. 回撤锁仓：持仓亏损超过阈值 → 锁仓防进一步亏损

解锁条件：
  - 信号回到中性/同向 → 平对冲单
  - 对冲单自身止盈 → 平对冲单
  - 原始仓位平仓 → 同时平对冲单
"""

from logger import logger


class HedgeManager:
    """对冲管理器 — 与 PositionManager 协作，不直接操作仓位"""

    def __init__(self, position_manager, config: dict = None):
        self._pm = position_manager  # PositionManager 引用
        cfg = config or {}

        # ── 信号对冲 ──
        self.signal_hedge_enabled = cfg.get("signal_hedge_enabled", True)
        # 加权信号绝对值超过此阈值才触发对冲（避免噪音）
        self.signal_hedge_threshold = cfg.get("signal_hedge_threshold", 2.0)
        # 对冲比例：0.5=开一半手数，1.0=等量对冲
        self.signal_hedge_ratio = cfg.get("signal_hedge_ratio", 0.5)
        # 信号回到中性以下（绝对值<此值）时解锁
        self.signal_unhedge_threshold = cfg.get("signal_unhedge_threshold", 1.0)

        # ── 回撤锁仓 ──
        self.drawdown_hedge_enabled = cfg.get("drawdown_hedge_enabled", True)
        # 浮亏超过此比例触发锁仓
        self.drawdown_hedge_pct = cfg.get("drawdown_hedge_pct", -0.003)  # -0.3%
        # 锁仓比例
        self.drawdown_hedge_ratio = cfg.get("drawdown_hedge_ratio", 1.0)  # 100%

        # ── 对冲单元管理 ──
        # 每个对冲单元: {original_ticket, hedge_ticket, hedge_type, hedge_volume}
        self._hedge_units = []

        # ── 对冲单止盈 ──
        self.hedge_take_profit_pct = cfg.get("hedge_take_profit_pct", 0.005)  # 0.5%

        # ── 每日最大对冲次数 ──
        self.max_hedges_per_day = cfg.get("max_hedges_per_day", 5)
        self._daily_hedge_count = 0

    # ═══════════════════════════════════════════════════════════
    # 决策接口
    # ═══════════════════════════════════════════════════════════

    def evaluate(self, current_signal: float, current_price: dict) -> list:
        """
        每轮主循环调用：评估所有持仓是否需要对冲/解锁。
        返回需要执行的操作列表: [("hedge", position, reason), ("unhedge", unit, reason), ...]
        """
        actions = []

        # ① 先检查是否需要解锁已有对冲
        for unit in list(self._hedge_units):
            original = self._find_position(unit["original_ticket"])
            if original is None:
                # 原始仓位已平 → 解锁对冲
                actions.append(("unhedge", unit, "原始仓位已平仓"))
                continue

            if self._should_unhedge(unit, original, current_signal, current_price):
                actions.append(("unhedge", unit, unit.get("unhedge_reason", "解锁条件满足")))

        # ② 再检查是否需要开新对冲
        for pos in self._pm.positions:
            ticket = pos["ticket"]

            # 已有对冲的跳过
            if any(u["original_ticket"] == ticket for u in self._hedge_units):
                continue

            hedge_reason = None

            # 回撤锁仓优先（更严重的情况）
            if self.drawdown_hedge_enabled:
                hedge_reason = self._check_drawdown_hedge(pos, current_price)

            # 信号对冲作为补充
            if not hedge_reason and self.signal_hedge_enabled:
                hedge_reason = self._check_signal_hedge(pos, current_signal)

            if hedge_reason and self._can_hedge():
                actions.append(("hedge", pos, hedge_reason))

        return actions

    # ═══════════════════════════════════════════════════════════
    # 对冲执行
    # ═══════════════════════════════════════════════════════════

    def execute_hedge(self, position, reason: str, current_price: dict) -> bool:
        """对指定持仓开反向对冲单"""
        opposite = "sell" if position["position_type"] == "long" else "buy"

        # 确定对冲手数
        hedge_type = "signal" if "信号" in reason else "drawdown"
        ratio = self.signal_hedge_ratio if hedge_type == "signal" else self.drawdown_hedge_ratio
        hedge_volume = position["quantity"] * ratio

        # ★ 手数校验：不能低于最小手数
        symbol_info = self._pm.data_provider.get_symbol_info(self._pm.symbol)
        if symbol_info:
            vol_min = symbol_info.get("volume_min", 0.01) if isinstance(symbol_info, dict) else getattr(symbol_info, "volume_min", 0.01)
            vol_step = symbol_info.get("volume_step", 0.01) if isinstance(symbol_info, dict) else getattr(symbol_info, "volume_step", 0.01)
            hedge_volume = max(vol_min, round(hedge_volume / vol_step) * vol_step)
        else:
            hedge_volume = max(0.01, hedge_volume)

        logger.info(f"🔒 准备对冲: {opposite} {hedge_volume:.2f}手 | 原因: {reason}")

        # 调取开仓
        result = self._pm.data_provider.send_order(
            self._pm.symbol, opposite, hedge_volume
        )
        if result is None:
            logger.error(f"对冲开仓失败: {opposite} @ {hedge_volume}手")
            return False

        try:
            order_id = result["order"] if isinstance(result, dict) else result.order
        except Exception as e:
            logger.error(f"解析对冲单号失败: {e}")
            return False

        if order_id > 0:
            unit = {
                "original_ticket": position["ticket"],
                "hedge_ticket": order_id,
                "hedge_type": hedge_type,
                "hedge_volume": hedge_volume,
                "hedge_direction": opposite,
                "entry_price": current_price.get("last", 0),
                "entry_time": current_price.get("time", None),
            }
            self._hedge_units.append(unit)
            self._daily_hedge_count += 1
            logger.info(
                f"🔒 对冲开仓: Ticket {position['ticket']} → 反向 {opposite} "
                f"@{hedge_volume}手 (Ticket {order_id}) | 原因: {reason}"
            )
            return True

        logger.error(f"对冲开仓失败: order_id={order_id}")
        return False

    def execute_unhedge(self, unit: dict, reason: str) -> bool:
        """平掉对冲单，解锁"""
        success = self._pm.data_provider.close_position(
            unit["hedge_ticket"], self._pm.symbol, unit["hedge_volume"]
        )
        if success:
            self._hedge_units.remove(unit)
            logger.info(
                f"🔓 对冲解锁: Ticket {unit['hedge_ticket']} 已平仓 | 原因: {reason}"
            )
            return True
        logger.error(f"解锁平仓失败: Ticket {unit['hedge_ticket']}")
        return False

    # ═══════════════════════════════════════════════════════════
    # 内部检查
    # ═══════════════════════════════════════════════════════════

    def _check_signal_hedge(self, position, current_signal: float) -> str | None:
        """检查信号是否触发对冲"""
        is_long = position["position_type"] == "long"
        # 持多 + 信号强烈看空 → 对冲
        if is_long and current_signal < -self.signal_hedge_threshold:
            return f"信号对冲(持多, 加权={current_signal:.2f} < -{self.signal_hedge_threshold})"
        # 持空 + 信号强烈看多 → 对冲
        if not is_long and current_signal > self.signal_hedge_threshold:
            return f"信号对冲(持空, 加权={current_signal:.2f} > {self.signal_hedge_threshold})"
        return None

    def _check_drawdown_hedge(self, position, current_price: dict) -> str | None:
        """检查浮亏是否触发锁仓"""
        price = current_price.get("last", 0)
        if price <= 0:
            return None
        pnl_pct = self._pm._calculate_pnl_pct(position, price)
        if pnl_pct <= self.drawdown_hedge_pct:
            return f"回撤锁仓(浮亏={pnl_pct:.2%} <= {self.drawdown_hedge_pct:.2%})"
        return None

    def _should_unhedge(self, unit, original_pos, current_signal: float, current_price: dict) -> bool:
        """判断是否应该解锁对冲"""
        is_drawdown = unit.get("hedge_type") == "drawdown"

        # 条件1：回撤锁仓 → 检查浮亏是否恢复
        if is_drawdown:
            price = current_price.get("last", 0)
            if price > 0:
                pnl_pct = self._pm._calculate_pnl_pct(original_pos, price)
                if pnl_pct > self.drawdown_hedge_pct:  # 浮亏回到阈值以上
                    unit["unhedge_reason"] = f"回撤恢复(浮亏={pnl_pct:.2%} > {self.drawdown_hedge_pct:.2%})"
                    return True

        # 条件2：信号回到中性 (|signal| < unhedge_threshold)
        if abs(current_signal) < self.signal_unhedge_threshold:
            unit["unhedge_reason"] = f"信号中性({current_signal:.2f})"
            return True

        # 条件3：信号与原始仓位同向且有足够力度
        is_long = original_pos["position_type"] == "long"
        if is_long and current_signal > self.signal_unhedge_threshold:
            unit["unhedge_reason"] = f"信号同向做多({current_signal:.2f} > {self.signal_unhedge_threshold})"
            return True
        if not is_long and current_signal < -self.signal_unhedge_threshold:
            unit["unhedge_reason"] = f"信号同向做空({current_signal:.2f} < -{self.signal_unhedge_threshold})"
            return True

        # 条件4：对冲单自身止盈
        price = current_price.get("last", 0)
        if price > 0 and unit.get("entry_price", 0) > 0:
            if unit["hedge_direction"] == "sell":
                hedge_pnl = (unit["entry_price"] - price) / unit["entry_price"]
            else:
                hedge_pnl = (price - unit["entry_price"]) / unit["entry_price"]
            if hedge_pnl >= self.hedge_take_profit_pct:
                unit["unhedge_reason"] = f"对冲单止盈({hedge_pnl:.2%})"
                return True

        return False

    def _can_hedge(self) -> bool:
        """检查是否允许开新对冲（次数限制）"""
        if self.max_hedges_per_day <= 0:
            return True
        return self._daily_hedge_count < self.max_hedges_per_day

    def _find_position(self, ticket):
        """在持仓列表中查找指定 ticket 的仓位"""
        return next((p for p in self._pm.positions if p["ticket"] == ticket), None)

    # ═══════════════════════════════════════════════════════════
    # 状态查询
    # ═══════════════════════════════════════════════════════════

    @property
    def active_hedges(self) -> int:
        return len(self._hedge_units)

    def get_hedge_summary(self) -> dict:
        return {
            "active_hedges": len(self._hedge_units),
            "daily_hedge_count": self._daily_hedge_count,
            "units": [
                {
                    "original": u["original_ticket"],
                    "hedge": u["hedge_ticket"],
                    "type": u["hedge_type"],
                    "volume": u["hedge_volume"],
                }
                for u in self._hedge_units
            ],
        }