#!/usr/bin/env python3
"""
us_momentum_web_backtest.py — 해외 모멘텀 웹 백테 (국내 API 와 완전 분리)

※ 국내 ``/api/backtest/momentum`` · ``api_backtest_scalping`` 에 market=US if 를
  넣지 말 것. 해외는 이 모듈 + ``/api/backtest/us_momentum`` 만 사용.
"""
from __future__ import annotations

from typing import Any, Dict, List, Optional, Tuple

from kis_trader.backtest import scalping_backtest_common as sbc
from kis_trader.utils.env import get_env_float


def _arg(args: Dict[str, Any], key: str, default: Any = None) -> Any:
    v = args.get(key, default)
    if v is None or v == "":
        return default
    return v


def _f(args: Dict[str, Any], key: str, default: float) -> float:
    v = _arg(args, key, None)
    if v is None:
        return float(default)
    return float(v)


def _i(args: Dict[str, Any], key: str, default: int) -> int:
    v = _arg(args, key, None)
    if v is None:
        return int(default)
    return int(float(v))


def _b(args: Dict[str, Any], key: str, default: bool = False) -> bool:
    v = _arg(args, key, None)
    if v is None:
        return bool(default)
    return str(v).strip().lower() in ("1", "true", "t", "y", "yes", "on")


def build_us_momentum_engine_params(
    args: Dict[str, Any],
    *,
    ui_def: Dict[str, Any],
) -> Dict[str, Any]:
    """폼/쿼리 → momentum_engine 파라미터 (US 전용)."""
    d = ui_def

    def pct_ratio(key: str, def_ui: float) -> float:
        """UI % → 엔진 비율."""
        return abs(_f(args, key, def_ui)) / 100.0

    sl = pct_ratio("sl_pct", float(d.get("sl_pct", 1.5)))
    tp = pct_ratio("tp_pct", float(d.get("tp_pct", 2.5)))
    tp_max = pct_ratio("tp_max_pct", float(d.get("tp_max_pct", 2.0)))
    time_start = _i(args, "time_start", int(d.get("mom_time_start_hm") or d.get("time_start") or 2230))
    time_end = _i(
        args, "time_end",
        int(d.get("mom_time_end_hm") or d.get("time_end") or 500),
    )
    mom_time_end = _i(args, "mom_time_end", time_end)

    params: Dict[str, Any] = {
        "market": "US",
        "sl_pct": sl,
        "tp_pct": tp,
        "tp_max_pct": tp_max,
        "shoulder_min_high": pct_ratio("shoulder_min_high", float(d.get("shoulder_min_high", 0.5))),
        "shoulder_cut_pct": pct_ratio("shoulder_cut_pct", float(d.get("shoulder_cut_pct", 0.3))),
        "trail_pct": pct_ratio("trail_pct", float(d.get("trail_pct", 0.0))),
        "trail_arm_pct": pct_ratio("trail_arm_pct", float(d.get("trail_arm_pct", 0.0))),
        "max_hold_bars": _i(args, "max_hold_bars", int(d.get("max_hold_bars") or 0)),
        "ratchet_tiers": str(_arg(args, "ratchet_tiers", d.get("ratchet_tiers") or "") or "").strip(),
        "cooldown_min": _f(args, "cooldown_min", float(d.get("cooldown_min") or 5)),
        "time_start_hm": time_start,
        "time_end_hm": time_end,
        "mom_time_end_hm": mom_time_end,
        "max_daily": _i(args, "max_daily", int(d.get("max_daily") or 5)),
        "high_chase_thr": _f(args, "high_chase_thr", float(d.get("high_chase_thr") or 0.96)),
        "max_daily_chg": _f(args, "max_daily_chg", float(d.get("max_daily_chg") or 20)),
        "min_price": _f(args, "min_price", float(d.get("min_price") or 1)),
        "max_loss_krw": _f(args, "max_loss_krw", float(d.get("max_loss_krw") or 0)),
        "min_margin": _f(args, "min_margin", float(d.get("min_margin") or 0.2)),
        "use_defense_filters": _b(args, "use_defense_filters", bool(d.get("use_defense_filters", True))),
        "use_high_chase_filter": _b(args, "use_high_chase_filter", False),
        "use_daily_range_filter": _b(args, "use_daily_range_filter", False),
        "use_ema_filter": _b(args, "use_ema_filter", bool(d.get("use_ema_filter", True))),
        "use_rsi_max_filter": _b(args, "use_rsi_max_filter", False),
        "pattern_breakout": _b(args, "pattern_breakout", True),
        "pattern_pullback": _b(args, "pattern_pullback", True),
        "chase_lookback_min": _i(args, "chase_lookback_min", int(d.get("chase_lookback_min") or 10)),
        "pullback_lookback_min": _i(args, "pullback_lookback_min", int(d.get("pullback_lookback_min") or 15)),
        "pullback_min_pct": _f(args, "pullback_min_pct", float(d.get("pullback_min_pct") or 0.3)),
        "pullback_max_pct": _f(args, "pullback_max_pct", float(d.get("pullback_max_pct") or 3.0)),
        "setup_vol_max_mult": _f(args, "setup_vol_max_mult", float(d.get("setup_vol_max_mult") or 0.8)),
        "setup_bear_bars_min": _i(args, "setup_bear_bars_min", int(d.get("setup_bear_bars_min") or 1)),
        "ema_fast_period": _i(args, "ema_fast_period", int(d.get("ema_fast_period") or 9)),
        "ema_slow_period": _i(args, "ema_slow_period", int(d.get("ema_slow_period") or 21)),
        "mom_rsi_min": _f(args, "mom_rsi_min", float(d.get("mom_rsi_min") or 50)),
        "mom_rsi_max": _f(args, "mom_rsi_max", float(d.get("mom_rsi_max") or 90)),
        "mom_vol_mult": _f(args, "mom_vol_mult", float(d.get("mom_vol_mult") or 1.5)),
        "mom_vol_win": _i(args, "mom_vol_win", int(d.get("mom_vol_win") or 5)),
        "mom_max_from_open_pct": _f(args, "mom_max_from_open_pct", float(d.get("mom_max_from_open_pct") or 999)),
        "mom_min_from_open_pct": _f(args, "mom_min_from_open_pct", float(d.get("mom_min_from_open_pct") or -999)),
        "eod_enabled": _b(args, "eod_enabled", bool(d.get("eod_enabled", False))),
        "eod_hm": str(_arg(args, "eod_hm", d.get("eod_hm") or "05:00") or "05:00").strip(),
        "slot_money": _f(args, "slot_money", float(d.get("slot_money") or 200000)),
        # US 고정 플래그
        "_orderbook_filter_enabled": False,
        "_program_filter_enabled": False,
        "_session_wrap_midnight": True,
        "skip_hts_scan_dupes": True,
        "fee_rate": 0.0025,
        "sell_tax": 0.0000206,
        "fx_fee_rate": 0.0005,
        "scan_interval_min": 5,
        "backtest_skip_pre_subscribe": _b(args, "backtest_skip_pre_subscribe", False),
    }
    try:
        from kis_trader.engine.us_momentum_env_keys import us_momentum_trading_cost_rates
        _c = us_momentum_trading_cost_rates()
        params["fee_rate"] = float(_c["fee_rate"])
        params["sell_tax"] = float(_c["sell_tax"])
        params["fx_fee_rate"] = float(_c["fx_fee_rate"])
    except Exception:
        params["fee_rate"] = float(get_env_float("US_MOMENTUM_FEE_RATE", 0.0025))
        params["sell_tax"] = float(get_env_float("US_MOMENTUM_SELL_TAX", 0.0000206))
        params["fx_fee_rate"] = float(get_env_float("US_MOMENTUM_FX_FEE_RATE", 0.0005))
    return params


def load_us_candles(
    db: Any,
    start: str,
    end: str,
    codes_filter: Optional[List[str]] = None,
) -> Tuple[Dict[str, List[Dict]], str, str, List[str]]:
    """ws_candles.market=US + 영구구독 US 교집합. codes_filter 있으면 해당 종목만."""
    start_key = (start.replace("-", "") + "0000") if start else "20260101"
    end_key = (end.replace("-", "") + "2359") if end else "999912312359"
    rows = db.conn.execute(
        "SELECT DISTINCT code FROM ws_candles WHERE timeframe=1 AND market=%s "
        "AND candle_time >= %s AND candle_time <= %s ORDER BY code",
        ["US", start_key, end_key],
    ).fetchall()
    codes = [r["code"] for r in rows]
    try:
        from permanent_subs import codes_by_market as _perm_us
        us_perm = {str(r.get("code") or "").upper() for r in _perm_us(db, "US")}
        if us_perm:
            codes = [c for c in codes if str(c).upper() in us_perm] or codes
    except Exception:
        pass
    if codes_filter:
        want = {str(c).strip().upper() for c in codes_filter if str(c).strip()}
        if want:
            codes = [c for c in codes if str(c).upper() in want]

    codes_candles: Dict[str, List[Dict]] = {}
    for code in codes:
        crow = db.conn.execute(
            "SELECT candle_time, open, high, low, close, volume "
            "FROM ws_candles "
            "WHERE timeframe=1 AND code=%s AND market=%s "
            "AND candle_time >= %s AND candle_time <= %s "
            "AND is_confirmed=1 "
            "ORDER BY candle_time ASC",
            [code, "US", start_key, end_key],
        ).fetchall()
        if not crow:
            continue
        codes_candles[str(code)] = [dict(x) for x in crow]
    return codes_candles, start_key, end_key, list(codes_candles.keys())


def run_us_momentum_web_backtest(
    args: Dict[str, Any],
    *,
    db: Any,
    ui_def: Dict[str, Any],
    enrich_trades_fn: Optional[Any] = None,
    enrich_names_fn: Optional[Any] = None,
    trades_recent_fn: Optional[Any] = None,
    period_days_fn: Optional[Any] = None,
) -> Dict[str, Any]:
    """
    해외 모멘텀 웹 백테 실행 → jsonify 용 dict.
    enrich_* 는 backtest_web 헬퍼를 주입 (순환 import 방지).
    """
    start = str(_arg(args, "start", "") or "")
    end = str(_arg(args, "end", "") or "")
    params = build_us_momentum_engine_params(args, ui_def=ui_def)
    # 종목 필터: symbol / code / codes (쉼표)
    filt: List[str] = []
    for k in ("symbol", "code", "codes"):
        raw = _arg(args, k, None)
        if raw in (None, ""):
            continue
        if isinstance(raw, (list, tuple)):
            filt.extend(str(x).strip() for x in raw if str(x).strip())
        else:
            filt.extend(p.strip() for p in str(raw).split(",") if p.strip())
    codes_candles, start_key, end_key, codes = load_us_candles(
        db, start, end, codes_filter=filt or None,
    )
    # 웹 폼이 소스 오브 트루스.
    # (구) 단일종목이면 stock_config 로 폼을 덮어써서 Optuna·폼 수정과 백테가 어긋남.
    # 종목행 → 폼 로드는 UI(usmomOnStockSelect)에서. 실매 오버레이는 전략 엔진 경로.
    use_stock_cfg = _b(args, "use_stock_cfg", False) or _b(args, "apply_stock_cfg", False)
    stock_overlay_applied = False
    if use_stock_cfg and len(codes) == 1:
        try:
            from kis_trader.strategies.us_momentum_stock_cfg import (
                apply_us_momentum_stock_overlay,
            )
            params = apply_us_momentum_stock_overlay(db, codes[0], params)
            stock_overlay_applied = bool(params.get("_us_stock_cfg"))
        except Exception:
            pass

    env_row: Dict[str, Any] = {}
    try:
        latest = db.get_latest_env()
        env_row = dict(latest["snapshot"]) if latest else {}
    except Exception:
        env_row = {}

    slot_money_v = float(params.get("slot_money") or 200000)
    max_stocks_req = _arg(args, "max_stocks", None)
    if max_stocks_req in (None, ""):
        max_stocks_req = _arg(args, "slots", None)
    max_stocks_req_i = (
        int(float(max_stocks_req)) if max_stocks_req not in (None, "") else None
    )
    tb_raw = _arg(args, "total_budget_krw", None)
    total_budget_req = float(tb_raw) if tb_raw not in (None, "") else None

    portfolio = sbc.resolve_scalp_portfolio_params(
        env_row,
        None,
        strategy="US_MOMENTUM",
        slot_money=slot_money_v,
        max_stocks=max_stocks_req_i,
        total_budget_krw=total_budget_req,
    )
    max_stocks_v = int(portfolio["max_stocks"])
    total_budget_v = float(portfolio["total_budget_krw"])
    slot_money_v = float(portfolio["slot_money"])
    fee_rate_v = float(params.get("fee_rate") or 0.0)
    sell_tax_v = float(params.get("sell_tax") or 0.0)

    bt_meta: Dict[str, Any] = {
        "db": db,
        "start_key": start_key,
        "end_key": end_key,
        "backtest_env_timeline": False,
    }
    trades = sbc.run_scalping_backtest_web_aligned(
        codes_candles,
        params,
        None,  # permanent US — 슬롯 유니버스 없음
        slot_money=slot_money_v,
        fee_rate=fee_rate_v,
        sell_tax=sell_tax_v,
        max_stocks=max_stocks_v,
        total_budget_krw=total_budget_v,
        mode="momentum",
        meta_out=bt_meta,
    )

    period_days = 1
    if callable(period_days_fn):
        period_days = int(period_days_fn(start, end, fallback=1) or 1)
    stats = sbc.summarize_scalp_trades(
        trades,
        total_budget_krw=total_budget_v,
        period_days=period_days,
    )
    total = int(stats["total_trades"])
    # 해외 USD — summarize_trades 의 int(total_pnl) 대신 거래 합산(소수 유지)
    total_pnl = float(sum(float(t.get("pnl") or 0) for t in trades))
    wins_n = int(stats["wins"])
    losses_n = int(stats["losses"])
    avg_hold = float(stats.get("avg_hold_min") or 0)
    # summarize_trades 키는 pf (profit_factor 아님) — 국내 모멘텀 웹과 동일
    pf = float(stats.get("pf") or stats.get("profit_factor") or 0)
    bot_pct = float(stats.get("bot_pct") or 0)
    daily_avg_pct = float(stats.get("daily_avg_pct") or 0)

    equity = []
    peak, mdd, cum = 0.0, 0.0, 0.0
    peak_cum_at = ""
    for t in sorted(trades, key=lambda x: str(x.get("sell_time") or "")):
        cum += float(t.get("pnl") or 0)
        if cum > peak:
            peak = cum
            peak_cum_at = str(t.get("sell_time") or "")
        dd = peak - cum
        if dd > mdd:
            mdd = dd
        st = str(t.get("sell_time") or "")
        day = st[:8]
        if len(day) == 8:
            day_fmt = f"{day[:4]}-{day[4:6]}-{day[6:]}"
        else:
            day_fmt = day
        equity.append({"date": day_fmt, "cum_pnl": round(cum, 2), "pnl": float(t.get("pnl") or 0)})

    reasons: Dict[str, int] = {}
    for t in trades:
        rk = str(t.get("sell_reason") or "unknown")
        reasons[rk] = reasons.get(rk, 0) + 1

    daily: Dict[str, float] = {}
    for t in trades:
        d8 = str(t.get("sell_time") or "")[:8]
        if len(d8) == 8:
            daily[d8] = daily.get(d8, 0.0) + float(t.get("pnl") or 0)
    daily_list = [
        {"date": f"{d[:4]}-{d[4:6]}-{d[6:]}", "pnl": round(v, 2)}
        for d, v in sorted(daily.items())
    ]

    if callable(enrich_trades_fn):
        enrich_trades_fn(trades, total_budget_krw=total_budget_v, with_tick_debug=False)
    trades_out = trades
    if callable(trades_recent_fn):
        trades_out = trades_recent_fn(trades, 200)
    if callable(enrich_names_fn):
        enrich_names_fn(db, trades_out)

    ts = int(params["time_start_hm"])
    te = int(params["mom_time_end_hm"])
    out = {
        "params": {
            "market": "US",
            "sl_pct": params["sl_pct"] * 100,
            "tp_pct": params["tp_pct"] * 100,
            "tp_max_pct": params["tp_max_pct"] * 100,
            "slot_money": slot_money_v,
            "max_stocks": max_stocks_v,
            "total_budget_krw": total_budget_v,
            "cooldown_min": params["cooldown_min"],
            "time_window": f"{ts:04d}-{te:04d}",
            "time_start_hm": ts,
            "time_end_hm": te,
            "mom_time_end": te,
            "mom_time_end_hm": te,
            "mom_rsi_min": params["mom_rsi_min"],
            "mom_rsi_max": params["mom_rsi_max"],
            "mom_vol_mult": params["mom_vol_mult"],
            "mom_vol_win": params["mom_vol_win"],
            "max_hold_bars": params["max_hold_bars"],
            "ratchet_tiers": params["ratchet_tiers"],
            "trail_pct": params["trail_pct"] * 100,
            "trail_arm_pct": params["trail_arm_pct"] * 100,
            "shoulder_min_high": params["shoulder_min_high"] * 100,
            "shoulder_cut_pct": params["shoulder_cut_pct"] * 100,
            "codes_analyzed": len(codes),
            "universe_source": "permanent_us",
            "universe_history_slots": 0,
            "universe": "all",
            "strategy_id": "US_MOMENTUM",
            "mode": "momentum",
            "start": start,
            "end": end,
            "stock_overlay": stock_overlay_applied,
            "exit_priority": "ratchet/shoulder→trail→sl→time→loss_cap→tp_max→eod",
        },
        "summary": {
            "total_trades": total,
            "win_trades": wins_n,
            "loss_trades": losses_n,
            "win_rate": float(stats["win_rate"]),
            "total_pnl": total_pnl,
            "avg_hold_min": round(avg_hold, 1),
            "profit_factor": round(pf, 2),
            "max_drawdown": round(float(mdd), 2),
            "peak_cum_pnl": round(float(peak), 2),
            "peak_cum_at": peak_cum_at[:19] if peak_cum_at else "",
            "bot_pct": bot_pct,
            "daily_avg_pct": daily_avg_pct,
            "backtest_days": period_days,
        },
        "equity": equity,
        "daily": daily_list,
        "reasons": reasons,
        "trades": trades_out,
    }
    # 표시용: USD 금액 + 청산일(또는 매수일) 환율로 원 환산
    try:
        from kis_trader.utils.usd_krw_fx import enrich_payload_with_usd_krw_fx

        enrich_payload_with_usd_krw_fx(out)
    except Exception:
        out["currency"] = "USD"
    return out