crypto_monitor/lib/hedge_plan/hedge_plan_register.py

"""OKX 对冲计划:P0 测算页与 API 注册."""
from __future__ import annotations

import os
from typing import Any, Optional

from flask import Flask, jsonify, request
from jinja2 import ChoiceLoader, FileSystemLoader

from lib.hedge_plan.hedge_plan_calc_lib import (
    build_options_options_preview,
    build_perp_options_preview,
    floor_contracts_to_precision,
    gate_status,
    option_premium_total,
    suggest_contracts_from_notional,
)
from lib.hub.hub_calculator_market_lib import amount_decimals_from_exchange
from lib.trade.position_sizing_lib import (
    compute_full_margin_sizing,
    load_position_sizing_mode,
)


def _env_bool(key: str, default: bool = False) -> bool:
    raw = (os.getenv(key) or "").strip().lower()
    if not raw:
        return default
    return raw in ("1", "true", "yes", "on")


def attach_hedge_plan_templates(app: Flask, repo_root: str) -> None:
    tpl_dir = os.path.join(repo_root, "lib", "hedge_plan", "templates")
    if not os.path.isdir(tpl_dir):
        return
    existing = app.jinja_loader
    loaders = [FileSystemLoader(tpl_dir)]
    if existing is not None:
        if isinstance(existing, ChoiceLoader):
            loaders = list(existing.loaders) + loaders
        else:
            loaders.insert(0, existing)
    app.jinja_loader = ChoiceLoader(loaders)


def install_hedge_plan(app: Flask, repo_root: str, app_module: Any) -> None:
    attach_hedge_plan_templates(app, repo_root)
    cfg = _build_cfg(app_module)
    app.extensions["hedge_plan_cfg"] = cfg
    register_hedge_plan_routes(app, cfg)
    _maybe_start_monitor(cfg)


def _build_cfg(app_module: Any) -> dict[str, Any]:
    from lib.exchange.okx_options_lib import (
        build_option_chain,
        fetch_index_price,
        options_header_balances,
        place_option_limit_order,
        quote_option_contract,
        td_mode_for_option_buy,
    )

    def _amount_to_precision(sym: str, amt: float) -> float:
        ex = getattr(app_module, "exchange", None)
        if ex is None:
            return float(amt)
        return float(ex.amount_to_precision(sym, amt))

    return {
        "get_db": app_module.get_db,
        "login_required": app_module.login_required,
        "render_main_page": app_module.render_main_page,
        "exchange": getattr(app_module, "exchange", None),
        "exchange_options": getattr(app_module, "exchange_options", None),
        "get_available_trading_usdt": getattr(app_module, "get_available_trading_usdt", None),
        "get_contract_size": getattr(app_module, "get_contract_size", None),
        "normalize_exchange_symbol": getattr(app_module, "normalize_exchange_symbol", None),
        "ensure_markets_loaded": getattr(app_module, "ensure_markets_loaded", None),
        "ensure_okx_live_ready": getattr(app_module, "ensure_okx_live_ready", None),
        "place_exchange_order": getattr(app_module, "place_exchange_order", None),
        "get_live_position_contracts": getattr(app_module, "get_live_position_contracts", None),
        "amount_to_precision": _amount_to_precision,
        "build_option_chain": build_option_chain,
        "options_header_balances": options_header_balances,
        "quote_option_contract": quote_option_contract,
        "place_option_limit_order": place_option_limit_order,
        "td_mode_for_option_buy": td_mode_for_option_buy,
        "fetch_index_price": fetch_index_price,
        "options_td_mode": (os.getenv("OKX_OPTIONS_TD_MODE") or "isolated").strip(),
        "btc_leverage": int(getattr(app_module, "BTC_LEVERAGE", 10) or 10),
        "alt_leverage": int(getattr(app_module, "ALT_LEVERAGE", 5) or 5),
        "full_margin_buffer": float(getattr(app_module, "FULL_MARGIN_BUFFER_RATIO", 0.98) or 0.98),
        "funds_decimals": int(getattr(app_module, "FUNDS_DECIMALS", 2) or 2),
        "options_enabled": _env_bool("OKX_OPTIONS_ENABLED", False),
        "default_underly": (os.getenv("OKX_OPTIONS_DEFAULT_UNDERLY") or "ETH").strip().upper(),
        "chain_max_dte": float(os.getenv("OKX_OPTIONS_CHAIN_MAX_DTE_DAYS") or os.getenv("OKX_OPTIONS_MAX_DTE_DAYS") or "14"),
        "perp_account_label": (os.getenv("OKX_ACCOUNT_LABEL") or "合约账户").strip(),
        "options_account_label": (os.getenv("OKX_OPTIONS_ACCOUNT_LABEL") or "期权账户").strip(),
        "trade_budget_usdc": float(os.getenv("OKX_OPTIONS_TRADE_BUDGET_USDC") or "10"),
        # 对冲专用缓冲;与期权页 OKX_OPTIONS_BUDGET_BUFFER 独立
        "budget_buffer": float(os.getenv("HEDGE_PLAN_BUDGET_BUFFER") or "0.95"),
        "oo_bias_split_by": _oo_bias_split_by(),
        "oo_bias_ratio": _oo_bias_ratio(),
        "live_trading": _env_bool("LIVE_TRADING_ENABLED", False),
        "send_wechat": getattr(app_module, "send_wechat_msg", None),
    }


def _hedge_enabled() -> bool:
    from lib.hedge_plan.okx_trade_mode_lib import hedge_module_enabled

    return hedge_module_enabled()


def _show_perp_options() -> bool:
    from lib.hedge_plan.okx_trade_mode_lib import show_perp_options

    return show_perp_options()


def _show_options_options() -> bool:
    from lib.hedge_plan.okx_trade_mode_lib import show_options_options

    return show_options_options()


def _oo_close_mode_enabled() -> bool:
    return _env_bool("HEDGE_PLAN_OO_CLOSE_MODE_ENABLED", True)


def _oo_bias_split_by() -> str:
    from lib.hedge_plan.hedge_plan_calc_lib import _normalize_oo_bias_split_by

    return _normalize_oo_bias_split_by(os.getenv("HEDGE_PLAN_OO_BIAS_SPLIT_BY") or "budget")


def _oo_bias_ratio() -> float:
    from lib.hedge_plan.hedge_plan_calc_lib import _clamp_oo_bias_ratio

    return _clamp_oo_bias_ratio(os.getenv("HEDGE_PLAN_OO_BIAS_RATIO") or "0.7")


def _normalize_oo_close_mode(raw: Any) -> str:
    """方案C关闭时强制 hold_expiry;开启时默认 close_all."""
    if not _oo_close_mode_enabled():
        return "hold_expiry"
    v = str(raw or "close_all").strip().lower()
    if v in ("hold_expiry", "hold_to_expiry", "expiry", "到期平"):
        return "hold_expiry"
    return "close_all"


def _live_order() -> bool:
    return _env_bool("HEDGE_PLAN_LIVE_ORDER", False)


def _max_active() -> int:
    try:
        return max(1, int(os.getenv("MAX_ACTIVE_HEDGE_PLANS") or "1"))
    except ValueError:
        return 1


def _gates_dict(cfg: dict[str, Any], plan_type: str) -> dict[str, Any]:
    active = 0
    has_standalone = False
    mutual = True
    try:
        from lib.hedge_plan.hedge_options_exclusive_lib import (
            has_standalone_option_position,
            mutual_exclusive_enabled,
        )
        from lib.hedge_plan.hedge_plan_db import count_active_plans, init_hedge_plan_tables

        mutual = mutual_exclusive_enabled()
        conn = cfg["get_db"]()
        try:
            init_hedge_plan_tables(conn)
            active = count_active_plans(conn)
            if mutual:
                try:
                    from lib.exchange.okx_options_lib import fetch_option_positions

                    ex = cfg.get("exchange_options") or cfg.get("exchange")
                    raw = fetch_option_positions(ex) if ex is not None else []
                    has_standalone = has_standalone_option_position(conn, raw or [])
                except Exception:
                    has_standalone = True  # fail-closed
            conn.commit()
        finally:
            conn.close()
    except Exception:
        # fail-closed:探测失败视为不可开仓
        active = 10**9
        has_standalone = True
    return gate_status(
        hedge_enabled=_hedge_enabled(),
        sizing_mode=load_position_sizing_mode(),
        plan_type=plan_type,
        options_enabled=bool(cfg.get("options_enabled")),
        live_order=_live_order(),
        live_trading=bool(cfg.get("live_trading")) or _env_bool("LIVE_TRADING_ENABLED", False),
        active_count=active,
        max_active=_max_active(),
        show_perp_options=_show_perp_options(),
        show_options_options=_show_options_options(),
        mutual_exclusive=mutual,
        has_standalone_option=has_standalone,
    )


def _gates_public(cfg: dict[str, Any], plan_type: str) -> dict[str, Any]:
    g = _gates_dict(cfg, plan_type)
    g["oo_close_mode_enabled"] = _oo_close_mode_enabled()
    g["oo_close_mode_default"] = "close_all" if _oo_close_mode_enabled() else "hold_expiry"
    g["oo_bias_split_by"] = _oo_bias_split_by()
    g["oo_bias_ratio"] = _oo_bias_ratio()
    g["budget_buffer"] = float(cfg.get("budget_buffer") or 0.95)
    return g


def _maybe_start_monitor(cfg: dict[str, Any]) -> None:
    # 始终启动监控线程:单独期权模式下仍需收口遗留 active/partial 计划
    with _hedge_start_lock():
        if cfg.get("hedge_monitor_thread") is not None:
            return
        try:
            secs = float(os.getenv("HEDGE_PLAN_MONITOR_POLL_SECONDS") or "15")
        except ValueError:
            secs = 15.0
        secs = max(5.0, secs)

        def _loop() -> None:
            import time

            from lib.hedge_plan.hedge_plan_monitor_lib import tick_active_plans

            while True:
                try:
                    tick_active_plans(cfg)
                except Exception:
                    pass
                time.sleep(secs)

        import threading

        t = threading.Thread(target=_loop, name="hedge-plan-monitor", daemon=True)
        t.start()
        cfg["hedge_monitor_thread"] = t


_start_lock = None


def _hedge_start_lock():
    global _start_lock
    if _start_lock is None:
        import threading

        _start_lock = threading.Lock()
    return _start_lock


def _start_body_json(body: dict[str, Any], missing_leg: Optional[str] = None) -> str:
    import json

    try:
        return json.dumps(
            {"start_body": body, "missing_leg": missing_leg},
            ensure_ascii=False,
        )[:8000]
    except Exception:
        return ""


def _persist_po(cfg: dict[str, Any], result: dict[str, Any], body: dict[str, Any]) -> int:
    from lib.hedge_plan.hedge_plan_db import (
        get_plan,
        get_plan_legs,
        init_hedge_plan_tables,
        insert_leg,
        insert_plan,
    )
    from lib.hedge_plan.hedge_plan_notify_lib import notify_plan_start

    conn = cfg["get_db"]()
    try:
        init_hedge_plan_tables(conn)
        is_partial = bool(result.get("partial"))
        missing = str(result.get("missing_leg") or "") if is_partial else ""
        opt = result.get("option") or {}
        perp = result.get("perp") or {}
        if is_partial:
            opt_ok = missing != "option_hedge" and bool(result.get("option"))
            perp_ok = missing != "perp" and bool(result.get("perp"))
        else:
            opt_ok = True
            perp_ok = True
        premium = float((opt or {}).get("premium") or 0) if opt_ok else 0.0
        plan_id = insert_plan(
            conn,
            {
                "plan_type": "perp_options",
                "status": "partial" if is_partial else "active",
                "underlying": str(body.get("underlying") or "ETH").upper(),
                "direction": str(body.get("direction") or "long"),
                "entry_mark": float(body.get("entry") or 0),
                "tp": float(body.get("tp") or 0),
                "sl": float(body.get("sl") or 0),
                "sizing_mode_at_open": load_position_sizing_mode(),
                "perp_size": float((perp or {}).get("contracts") or body.get("contracts") or 0),
                "margin": body.get("margin"),
                "leverage": float(body.get("leverage") or 10),
                "premium_total": premium,
                "preview_json": _start_body_json(body, missing or None),
                "close_reason": "partial_fail" if is_partial else None,
                "opened_at": result.get("opened_at"),
                "note": (result.get("msg") or "")[:500] if is_partial else None,
            },
        )
        insert_leg(
            conn,
            {
                "plan_id": plan_id,
                "leg_role": "perp",
                "symbol": str(body.get("exchange_symbol") or ""),
                "side": str(body.get("direction") or "long"),
                "size": float((perp or {}).get("contracts") or body.get("contracts") or 0),
                "avg_open": float(body.get("entry") or 0) if perp_ok else None,
                "status": "open" if perp_ok else "pending",
                "exchange_ord_id": str((perp or {}).get("exchange_ord_id") or ""),
                "opened_at": result.get("opened_at") if perp_ok else None,
            },
        )
        insert_leg(
            conn,
            {
                "plan_id": plan_id,
                "leg_role": "option_hedge",
                "inst_id": str((opt or {}).get("inst_id") or body.get("opt_inst_id") or ""),
                "opt_type": str((opt or {}).get("opt_type") or body.get("opt_type") or ""),
                "strike": (opt or {}).get("strike") or body.get("strike"),
                "side": "buy",
                "size": float((opt or {}).get("sheets") or body.get("sheets") or 1),
                "avg_open": float((opt or {}).get("ask") or 0) if opt_ok else None,
                "premium": premium if opt_ok else 0,
                "status": "open" if opt_ok else "pending",
                "exchange_ord_id": str((opt or {}).get("exchange_ord_id") or ""),
                "opened_at": result.get("opened_at") if opt_ok else None,
            },
        )
        conn.commit()
        if not is_partial:
            plan = get_plan(conn, plan_id)
            legs = get_plan_legs(conn, plan_id)
            if plan:
                notify_plan_start(cfg, conn, plan, legs)
                conn.commit()
        return plan_id
    finally:
        conn.close()


def _persist_oo(cfg: dict[str, Any], result: dict[str, Any], body: dict[str, Any]) -> int:
    from lib.hedge_plan.hedge_plan_db import (
        get_plan,
        get_plan_legs,
        init_hedge_plan_tables,
        insert_leg,
        insert_plan,
    )
    from lib.hedge_plan.hedge_plan_notify_lib import notify_plan_start

    conn = cfg["get_db"]()
    try:
        init_hedge_plan_tables(conn)
        is_partial = bool(result.get("partial"))
        missing = str(result.get("missing_leg") or "") if is_partial else ""
        a = result.get("leg_a") or {}
        b = result.get("leg_b") or {}
        a_ok = True if not is_partial else bool(result.get("leg_a"))
        b_ok = True if not is_partial else (missing != "option_b" and bool(result.get("leg_b")))
        premium = (float(a.get("premium") or 0) if a_ok else 0.0) + (
            float(b.get("premium") or 0) if b_ok else 0.0
        )
        plan_id = insert_plan(
            conn,
            {
                "plan_type": "options_options",
                "status": "partial" if is_partial else "active",
                "underlying": str(body.get("underlying") or "ETH").upper(),
                "target_price": float(
                    body.get("target_price_up")
                    or body.get("target_price")
                    or 0
                ),
                "target_price_up": float(
                    body.get("target_price_up")
                    or body.get("target_price")
                    or 0
                ),
                "target_price_down": float(
                    body.get("target_price_down")
                    or body.get("target_price")
                    or 0
                ),
                "sizing_mode_at_open": load_position_sizing_mode(),
                "premium_total": premium,
                "oo_close_mode": _normalize_oo_close_mode(body.get("oo_close_mode")),
                "preview_json": _start_body_json(body, missing or None),
                "close_reason": "partial_fail" if is_partial else None,
                "opened_at": result.get("opened_at"),
                "note": (result.get("msg") or "")[:500] if is_partial else None,
            },
        )
        for role, res, src, ok in (
            ("option_a", a, body.get("leg_a") or {}, a_ok),
            ("option_b", b, body.get("leg_b") or {}, b_ok),
        ):
            insert_leg(
                conn,
                {
                    "plan_id": plan_id,
                    "leg_role": role,
                    "inst_id": str((res or {}).get("inst_id") or src.get("inst_id") or ""),
                    "opt_type": str((res or {}).get("opt_type") or src.get("opt_type") or ""),
                    "strike": (res or {}).get("strike") or src.get("strike"),
                    "side": "buy",
                    "size": float((res or {}).get("sheets") or src.get("sheets") or 1),
                    "avg_open": float((res or {}).get("ask") or 0) if ok else None,
                    "premium": float((res or {}).get("premium") or 0) if ok else 0,
                    "status": "open" if ok else "pending",
                    "exchange_ord_id": str((res or {}).get("exchange_ord_id") or ""),
                    "opened_at": result.get("opened_at") if ok else None,
                },
            )
        conn.commit()
        if not is_partial:
            plan = get_plan(conn, plan_id)
            legs = get_plan_legs(conn, plan_id)
            if plan:
                notify_plan_start(cfg, conn, plan, legs)
                conn.commit()
        return plan_id
    finally:
        conn.close()


def register_hedge_plan_routes(app: Flask, cfg: dict[str, Any]) -> None:
    lr = cfg["login_required"]

    @app.route("/hedge-plan")
    @lr
    def page_hedge_plan():
        from lib.instance.instance_embed_lib import redirect_to_embed_shell_if_enabled

        redir = redirect_to_embed_shell_if_enabled("hedge_plan")
        if redir is not None:
            return redir
        return cfg["render_main_page"]("hedge_plan")

    @app.route("/api/hedge-plan/gates")
    @lr
    def api_hedge_gates():
        plan_type = (request.args.get("plan_type") or "perp_options").strip()
        return jsonify({"ok": True, **_gates_public(cfg, plan_type)})

    @app.route("/api/hedge-plan/market")
    @lr
    def api_hedge_market():
        base = (request.args.get("base") or cfg.get("default_underly") or "ETH").strip().upper()
        if base not in ("BTC", "ETH"):
            return jsonify({"ok": False, "msg": "对冲计划仅支持 BTC/ETH"}), 400
        direction = (request.args.get("direction") or "long").strip().lower()
        if direction not in ("long", "short"):
            direction = "long"
        data, err = _fetch_perp_market(cfg, base)
        if err:
            return jsonify({"ok": False, "msg": err}), 400
        sizing_mode = load_position_sizing_mode()
        gates = _gates_dict(cfg, "perp_options")
        out = {
            "ok": True,
            "base": base,
            "direction": direction,
            "suggested_opt_type": "P" if direction == "long" else "C",
            **data,
            "gates": gates,
            "sizing_mode": sizing_mode,
            "account_kind": "perp",
            "account_label": cfg.get("perp_account_label") or "合约账户",
            "account_note": "永续腿使用合约(交易)账户可用 USDT",
        }
        return jsonify(out)

    @app.route("/api/hedge-plan/options-chain")
    @lr
    def api_hedge_options_chain():
        if not cfg.get("options_enabled"):
            return jsonify({"ok": False, "msg": "期权模块未启用"}), 400
        ex = cfg.get("exchange_options")
        if ex is None:
            return jsonify({"ok": False, "msg": "期权交易所未初始化"}), 400
        u = (request.args.get("underlying") or cfg.get("default_underly") or "ETH").upper()
        try:
            chain = cfg["build_option_chain"](
                ex,
                u,
                max_dte_days=float(cfg.get("chain_max_dte") or 14),
                itm_only=False,
                itm_max_dist_usd=float(os.getenv("OKX_OPTIONS_ITM_MAX_DIST_USD") or "30"),
            )
        except Exception as e:
            return jsonify({"ok": False, "msg": f"拉取期权链失败: {e}"}), 500
        opt_acct = _options_account_snapshot(cfg)
        return jsonify(
            {
                "ok": True,
                **chain,
                "underlying": u,
                "chain_max_dte_days": cfg.get("chain_max_dte"),
                "account_kind": "options",
                "account_label": cfg.get("options_account_label") or "期权账户",
                "account_note": "期权腿使用期权账户(交易 USDC)",
                "options_account": opt_acct,
                "trade_budget_usdc": cfg.get("trade_budget_usdc"),
                "budget_buffer": cfg.get("budget_buffer"),
            }
        )

    @app.route("/api/hedge-plan/preview", methods=["POST"])
    @lr
    def api_hedge_preview():
        body = request.get_json(silent=True) or {}
        plan_type = (body.get("plan_type") or "perp_options").strip().lower()
        gates = _gates_dict(cfg, plan_type)
        if not gates.get("can_preview"):
            return jsonify({"ok": False, "msg": "; ".join(gates.get("reasons") or ["不可测算"]), "gates": gates}), 400
        try:
            if plan_type == "options_options":
                data = _preview_oo(body)
            else:
                data = _preview_po(body)
        except ValueError as e:
            return jsonify({"ok": False, "msg": str(e)}), 400
        except Exception as e:
            return jsonify({"ok": False, "msg": f"测算失败: {e}"}), 500
        return jsonify({"ok": True, "gates": gates, **data})

    @app.route("/api/hedge-plan/validate-path", methods=["POST"])
    @lr
    def api_hedge_validate_path():
        """只校验下单路径(强制 dry_run),不真实成交."""
        from lib.hedge_plan.hedge_plan_orders_lib import (
            execute_options_options_start,
            execute_perp_options_start,
            validate_start_body,
        )

        body = request.get_json(silent=True) or {}
        plan_type = (body.get("plan_type") or "perp_options").strip().lower()
        err = validate_start_body(plan_type, body)
        if err:
            return jsonify({"ok": False, "msg": err}), 400
        if plan_type == "options_options":
            out = execute_options_options_start(cfg, body, dry_run=True)
        else:
            out = execute_perp_options_start(cfg, body, dry_run=True)
        return jsonify(out), (200 if out.get("ok") else 400)

    @app.route("/api/hedge-plan/start", methods=["POST"])
    @lr
    def api_hedge_start():
        from lib.hedge_plan.hedge_plan_orders_lib import (
            execute_options_options_start,
            execute_perp_options_start,
            validate_start_body,
        )

        body = request.get_json(silent=True) or {}
        plan_type = (body.get("plan_type") or "perp_options").strip().lower()
        dry_run = bool(body.get("dry_run")) or _env_bool("HEDGE_PLAN_DRY_RUN", False)
        with _hedge_start_lock():
            gates = _gates_dict(cfg, plan_type)
            if not dry_run and not gates.get("can_start"):
                return jsonify(
                    {"ok": False, "msg": "; ".join(gates.get("reasons") or ["不可开仓"]), "gates": gates}
                ), 400
            err = validate_start_body(plan_type, body)
            if err:
                return jsonify({"ok": False, "msg": err, "gates": gates}), 400
            # 补齐永续杠杆
            if plan_type == "perp_options" and not body.get("leverage"):
                base = str(body.get("underlying") or "ETH").upper()
                body["leverage"] = cfg.get("btc_leverage") if base == "BTC" else (cfg.get("btc_leverage") or 10)
                # ETH 也用 BTC 档 10x 按方案;ALT 为 alt_leverage 仅非 BTC/ETH
                if base in ("BTC", "ETH"):
                    body["leverage"] = int(cfg.get("btc_leverage") or 10)
            if plan_type == "options_options":
                out = execute_options_options_start(
                    cfg,
                    body,
                    dry_run=dry_run,
                    persist=(None if dry_run else (lambda r, b: _persist_oo(cfg, r, b))),
                )
            else:
                out = execute_perp_options_start(
                    cfg,
                    body,
                    dry_run=dry_run,
                    persist=(None if dry_run else (lambda r, b: _persist_po(cfg, r, b))),
                )
            out["gates"] = gates
            return jsonify(out), (200 if out.get("ok") else 400)

    @app.route("/api/hedge-plan/<int:plan_id>/end", methods=["POST"])
    @lr
    def api_hedge_end_plan(plan_id: int):
        """人工结束进行中计划:不自动平仓;未成交腿改为 cancelled."""
        from lib.hedge_plan.hedge_plan_db import init_hedge_plan_tables
        from lib.hedge_plan.hedge_plan_orders_lib import execute_manual_end_plan

        conn = cfg["get_db"]()
        try:
            init_hedge_plan_tables(conn)
            out = execute_manual_end_plan(cfg, conn, plan_id)
            if not out.get("ok"):
                return jsonify(out), 400
            conn.commit()
        finally:
            conn.close()
        return jsonify(out)

    @app.route("/api/hedge-plan/<int:plan_id>/complete-leg", methods=["POST"])
    @lr
    def api_hedge_complete_leg(plan_id: int):
        """半腿待补:手动补开缺失腿,成功后升为 active."""
        import json

        from lib.hedge_plan.hedge_plan_db import (
            get_plan,
            get_plan_legs,
            init_hedge_plan_tables,
            update_leg,
            update_plan,
        )
        from lib.hedge_plan.hedge_plan_notify_lib import notify_plan_start
        from lib.hedge_plan.hedge_plan_orders_lib import execute_complete_missing_leg

        body = request.get_json(silent=True) or {}
        dry_run = bool(body.get("dry_run")) or _env_bool("HEDGE_PLAN_DRY_RUN", False)
        if not dry_run and not _hedge_enabled():
            return jsonify({"ok": False, "msg": "当前交易模式为单独期权,不可补开对冲腿"}), 400
        conn = cfg["get_db"]()
        try:
            init_hedge_plan_tables(conn)
            plan = get_plan(conn, plan_id)
            if not plan:
                return jsonify({"ok": False, "msg": "计划不存在"}), 404
            pt = str(plan.get("plan_type") or "")
            if pt == "perp_options" and not _show_perp_options():
                return jsonify({"ok": False, "msg": "当前模式非永期对冲,不可补开"}), 400
            if pt == "options_options" and not _show_options_options():
                return jsonify({"ok": False, "msg": "当前模式非期期对冲,不可补开"}), 400
            if str(plan.get("status") or "") != "partial":
                return jsonify({"ok": False, "msg": "仅半腿待补(partial)计划可补开"}), 400
            legs = get_plan_legs(conn, plan_id)
            start_body: dict[str, Any] = {}
            try:
                meta = json.loads(plan.get("preview_json") or "{}")
                if isinstance(meta, dict):
                    start_body = dict(meta.get("start_body") or {})
            except Exception:
                start_body = {}
            if not start_body:
                return jsonify({"ok": False, "msg": "缺少开仓参数,无法补开"}), 400
            # 允许请求体覆盖少量字段
            for k in ("contracts", "leverage", "sheets", "tp", "sl"):
                if body.get(k) not in (None, ""):
                    start_body[k] = body.get(k)
            out = execute_complete_missing_leg(
                cfg, plan, legs, start_body, dry_run=dry_run
            )
            if not out.get("ok"):
                return jsonify(out), 400
            if dry_run:
                return jsonify(out)
            fill = out.get("fill") or {}
            leg_id = out.get("leg_id")
            role = str(out.get("leg_role") or "")
            opened_at = out.get("opened_at")
            if leg_id:
                if role == "perp":
                    update_leg(
                        conn,
                        int(leg_id),
                        status="open",
                        size=float(fill.get("contracts") or start_body.get("contracts") or 0),
                        avg_open=float(start_body.get("entry") or plan.get("entry_mark") or 0),
                        exchange_ord_id=str(fill.get("exchange_ord_id") or ""),
                        opened_at=opened_at,
                    )
                    update_plan(
                        conn,
                        plan_id,
                        status="active",
                        close_reason=None,
                        note=None,
                        perp_size=float(fill.get("contracts") or start_body.get("contracts") or 0),
                    )
                else:
                    prem = float(fill.get("premium") or 0)
                    update_leg(
                        conn,
                        int(leg_id),
                        status="open",
                        size=float(fill.get("sheets") or start_body.get("sheets") or 1),
                        avg_open=float(fill.get("ask") or 0),
                        premium=prem,
                        exchange_ord_id=str(fill.get("exchange_ord_id") or ""),
                        opened_at=opened_at,
                        inst_id=str(fill.get("inst_id") or ""),
                    )
                    old_prem = float(plan.get("premium_total") or 0)
                    update_plan(
                        conn,
                        plan_id,
                        status="active",
                        close_reason=None,
                        note=None,
                        premium_total=old_prem + prem,
                    )
            conn.commit()
            plan2 = get_plan(conn, plan_id)
            legs2 = get_plan_legs(conn, plan_id)
            if plan2:
                notify_plan_start(cfg, conn, plan2, legs2)
                conn.commit()
            out["plan_id"] = plan_id
            out["status"] = "active"
            out["plan"] = plan2
            out["legs"] = legs2
            return jsonify(out)
        finally:
            conn.close()

    @app.route("/api/hedge-plan/list")
    @lr
    def api_hedge_list():
        from lib.hedge_plan.hedge_plan_db import init_hedge_plan_tables, list_plans

        status = (request.args.get("status") or "").strip() or None
        plan_type = (request.args.get("plan_type") or "").strip() or None
        underlying = (request.args.get("underlying") or "").strip() or None
        conn = cfg["get_db"]()
        try:
            init_hedge_plan_tables(conn)
            rows = list_plans(
                conn, status=status, plan_type=plan_type, underlying=underlying, limit=80
            )
            conn.commit()
        finally:
            conn.close()
        return jsonify({"ok": True, "plans": rows})

    @app.route("/api/hedge-plan/history")
    @lr
    def api_hedge_history():
        from lib.hedge_plan.hedge_plan_db import (
            attach_legs_to_plans,
            init_hedge_plan_tables,
            list_plans,
        )

        conn = cfg["get_db"]()
        try:
            init_hedge_plan_tables(conn)
            rows = list_plans(conn, status="closed", limit=100)
            failed = list_plans(conn, status="failed", limit=50)
            cancelled = list_plans(conn, status="cancelled", limit=50)
            merged = attach_legs_to_plans(conn, rows + failed + cancelled)
            conn.commit()
        finally:
            conn.close()
        return jsonify({"ok": True, "plans": merged})

    @app.route("/api/hedge-plan/active")
    @lr
    def api_hedge_active():
        from lib.hedge_plan.hedge_plan_db import (
            attach_legs_to_plans,
            init_hedge_plan_tables,
            list_plans,
        )
        from lib.hedge_plan.hedge_plan_orders_lib import reconcile_unfilled_option_legs

        conn = cfg["get_db"]()
        try:
            init_hedge_plan_tables(conn)
            rows = []
            for status in ("opening", "active", "partial"):
                rows.extend(list_plans(conn, status=status, limit=80))
            rows.sort(key=lambda row: int(row.get("id") or 0), reverse=True)
            for row in rows:
                try:
                    reconcile_unfilled_option_legs(cfg, conn, int(row["id"]))
                except Exception:
                    pass
            # 校正后可能 status 变化,重新拉一遍
            rows = []
            for status in ("opening", "active", "partial"):
                rows.extend(list_plans(conn, status=status, limit=80))
            rows.sort(key=lambda row: int(row.get("id") or 0), reverse=True)
            plans = attach_legs_to_plans(conn, rows)
            conn.commit()
        finally:
            conn.close()
        return jsonify({"ok": True, "plans": plans})

    @app.route("/api/hedge-plan/stats")
    @lr
    def api_hedge_stats():
        from lib.hedge_plan.hedge_plan_db import init_hedge_plan_tables, stats_summary

        conn = cfg["get_db"]()
        try:
            init_hedge_plan_tables(conn)
            s = stats_summary(conn)
            conn.commit()
        finally:
            conn.close()
        return jsonify({"ok": True, **s})

    @app.route("/api/hedge-plan/<int:plan_id>")
    @lr
    def api_hedge_detail(plan_id: int):
        from lib.hedge_plan.hedge_plan_db import (
            get_plan,
            get_plan_legs,
            init_hedge_plan_tables,
            legs_contract_summary,
        )
        from lib.hedge_plan.hedge_plan_orders_lib import reconcile_unfilled_option_legs

        conn = cfg["get_db"]()
        try:
            init_hedge_plan_tables(conn)
            plan = get_plan(conn, plan_id)
            if not plan:
                return jsonify({"ok": False, "msg": "计划不存在"}), 404
            # 打开细节时校正:无成交却标 open → cancelled
            if str(plan.get("status") or "") in ("opening", "active", "partial"):
                reconcile_unfilled_option_legs(cfg, conn, plan_id)
                plan = get_plan(conn, plan_id) or plan
            legs = get_plan_legs(conn, plan_id)
            conn.commit()
        finally:
            conn.close()
        return jsonify(
            {
                "ok": True,
                "plan": plan,
                "legs": legs,
                "contracts_summary": legs_contract_summary(legs),
            }
        )

    @app.route("/api/hedge-plan/<int:plan_id>", methods=["DELETE"])
    @lr
    def api_hedge_delete(plan_id: int):
        from lib.hedge_plan.hedge_plan_db import delete_plan, init_hedge_plan_tables

        conn = cfg["get_db"]()
        try:
            init_hedge_plan_tables(conn)
            out = delete_plan(conn, plan_id)
            if not out.get("ok"):
                return jsonify(out), 400
            conn.commit()
        finally:
            conn.close()
        return jsonify(out)

    @app.route("/api/hedge-plan/monitor-tick", methods=["POST"])
    @lr
    def api_hedge_monitor_tick():
        from lib.hedge_plan.hedge_plan_monitor_lib import tick_active_plans

        return jsonify(tick_active_plans(cfg))


def _preview_po(body: dict[str, Any]) -> dict[str, Any]:
    direction = str(body.get("direction") or "long").lower()
    entry = float(body["entry"])
    tp = float(body["tp"])
    sl = float(body["sl"])
    contracts = float(body["contracts"])
    contract_size = float(body.get("contract_size") or 0.01)
    opt_type = str(body.get("opt_type") or ("P" if direction == "long" else "C"))
    strike = float(body["strike"])
    sheets = float(body.get("sheets") or 1)
    ct_mult = float(body.get("ct_mult") or 0.01)
    ask = body.get("ask")
    premium = body.get("premium_paid")
    if premium is None:
        if ask is None:
            raise ValueError("缺少权利金或卖一价")
        premium = option_premium_total(ask=float(ask), sheets=sheets, ct_mult=ct_mult)
    index_px = body.get("index_px")
    return build_perp_options_preview(
        direction=direction,
        entry=entry,
        tp=tp,
        sl=sl,
        contracts=contracts,
        contract_size=contract_size,
        opt_type=opt_type,
        strike=strike,
        sheets=sheets,
        ct_mult=ct_mult,
        premium_paid=float(premium),
        index_px=float(index_px) if index_px is not None else None,
    )


def _preview_oo(body: dict[str, Any]) -> dict[str, Any]:
    up = body.get("target_price_up")
    down = body.get("target_price_down")
    legacy = body.get("target_price")
    if up in (None, "") and legacy not in (None, ""):
        up = legacy
    if down in (None, "") and legacy not in (None, ""):
        down = legacy
    if up in (None, "") or down in (None, ""):
        raise ValueError("请填写上破与下破目标价")
    up_f = float(up)
    down_f = float(down)
    if up_f <= down_f:
        raise ValueError("上破目标价必须大于下破目标价")
    index_px = float(body.get("index_px") or ((up_f + down_f) / 2))
    leg_a = body.get("leg_a") or {}
    leg_b = body.get("leg_b") or {}
    for name, leg in (("leg_a", leg_a), ("leg_b", leg_b)):
        if not leg.get("strike"):
            raise ValueError(f"缺少 {name} 行权价")
        if leg.get("premium_paid") is None and leg.get("ask") is not None:
            leg["premium_paid"] = option_premium_total(
                ask=float(leg["ask"]),
                sheets=float(leg.get("sheets") or 1),
                ct_mult=float(leg.get("ct_mult") or 0.01),
            )
        if leg.get("premium_paid") is None:
            raise ValueError(f"缺少 {name} 权利金")
    return build_options_options_preview(
        target_price_up=up_f,
        target_price_down=down_f,
        index_px=index_px,
        leg_a=leg_a,
        leg_b=leg_b,
    )


def _fetch_perp_market(cfg: dict[str, Any], base: str) -> tuple[dict[str, Any], str | None]:
    ex = cfg.get("exchange")
    if ex is None:
        return {}, "永续交易所未初始化"
    ensure = cfg.get("ensure_markets_loaded")
    if callable(ensure):
        try:
            ensure()
        except Exception as e:
            return {}, f"加载市场失败: {e}"
    norm = cfg.get("normalize_exchange_symbol")
    sym = f"{base}/USDT:USDT"
    if callable(norm):
        try:
            sym = norm(f"{base}/USDT")
        except Exception:
            sym = f"{base}/USDT:USDT"
    mark = bid = ask = last = None
    try:
        t = ex.fetch_ticker(sym)
        last = _sf(t.get("last"))
        mark = _sf(t.get("info", {}).get("markPx")) if isinstance(t.get("info"), dict) else None
        if mark is None:
            mark = _sf(t.get("mark")) or last
        bid = _sf(t.get("bid"))
        ask = _sf(t.get("ask"))
    except Exception as e:
        return {}, f"拉永续行情失败: {e}"

    cs = 0.01
    get_cs = cfg.get("get_contract_size")
    if callable(get_cs):
        try:
            cs = float(get_cs(sym) or 0.01)
        except Exception:
            cs = 0.01

    available = None
    get_av = cfg.get("get_available_trading_usdt")
    if callable(get_av):
        try:
            available = get_av()
        except Exception:
            available = None

    entry = float(mark or last or 0)
    sizing = None
    suggest_contracts = None
    amount_precision = 4
    try:
        amount_precision = int(amount_decimals_from_exchange(ex, sym))
    except Exception:
        amount_precision = 4
    if available is not None and entry > 0:
        sizing, _serr = compute_full_margin_sizing(
            symbol=sym,
            available_usdt=float(available),
            capital_base=float(available),
            buffer_ratio=float(cfg.get("full_margin_buffer") or 0.98),
            btc_leverage=int(cfg.get("btc_leverage") or 10),
            alt_leverage=int(cfg.get("alt_leverage") or 5),
            funds_decimals=int(cfg.get("funds_decimals") or 2),
        )
        if sizing:
            raw_contracts = suggest_contracts_from_notional(
                notional=float(sizing["notional_value"]),
                entry=entry,
                contract_size=cs,
            )
            # 优先走交易所 amount_to_precision;失败则按精度位数向下取整
            suggest_contracts = None
            try:
                precise = float(ex.amount_to_precision(sym, raw_contracts))
                if precise > raw_contracts + 1e-12:
                    precise = floor_contracts_to_precision(raw_contracts, amount_precision)
                suggest_contracts = precise
            except Exception:
                suggest_contracts = floor_contracts_to_precision(raw_contracts, amount_precision)

    return {
        "exchange_symbol": sym,
        "mark": mark,
        "last": last,
        "bid": bid,
        "ask": ask,
        "contract_size": cs,
        "available_usdt": available,
        "full_margin_sizing": sizing,
        "suggest_contracts": suggest_contracts,
        "amount_precision": amount_precision,
        "unit_quote": "USDT",
        "unit_contracts": "合约张",
        "unit_note": "价格单位 USDT;张数=交易所永续合约张(与下单精度一致);名义≈张数×面值×价格",
        "entry_ref": entry or None,
    }, None


def _options_account_snapshot(cfg: dict[str, Any]) -> dict[str, Any]:
    """期权账户资金快照(与期权页同源: exchange_options)."""
    out: dict[str, Any] = {
        "label": cfg.get("options_account_label") or "期权账户",
        "trading_usdc": None,
        "funding_usdc": None,
        "trading_usdt": None,
        "funding_usdt": None,
    }
    ex = cfg.get("exchange_options")
    hdr = cfg.get("options_header_balances")
    if ex is None or not callable(hdr):
        return out
    try:
        trading_usdc, funding_usdc, funding_usdt, trading_usdt = hdr(ex, force=False)
        out.update(
            {
                "trading_usdc": trading_usdc,
                "funding_usdc": funding_usdc,
                "trading_usdt": trading_usdt,
                "funding_usdt": funding_usdt,
            }
        )
    except Exception:
        pass
    return out


def _sf(v: Any) -> float | None:
    if v is None or v == "":
        return None
    try:
        return float(v)
    except (TypeError, ValueError):
        return None