"""影子交易器的信号函数——在子进程里跑，不碰事件循环。

单次调用约 0.26s 的纯 CPU，且 chanlun 是纯 Python 受 GIL 限制，放进
Hummingbot 的 asyncio 循环里会把行情处理一起卡住，所以必须隔离到独立进程。

口径与 [aggregate_robustness.run_once] 逐行对齐：同样的 build_htf_zones →
find_fast_bsp3 → attach_htf_context(h1) 链路，同样的 h1_agree 过滤。两边
必须一致，否则影子测出来的滑点没法和 3.9bp 预算对照。

与回测的唯一差别是这里只关心**最后一根已收盘 K 线**上有没有信号——
实盘只能在当下下单，历史信号无意义。

未过滤信号也一并返回：过滤后样本太稀，先用未过滤的当提前读数，
两者都记，靠 h1_agree 字段区分。
"""
from __future__ import annotations

import os
import warnings

warnings.filterwarnings("ignore")
for _v in ("OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS"):
    os.environ.setdefault(_v, "1")


def compute(df_l, df_h) -> dict:
    """在 df_l 的最后一根上找信号。df_l/df_h 都只含已收盘 K 线。

    返回 dict：
      last_idx    最后一根在 chanlun 处理后 dataframe 里的下标
      n_bars      实际参与计算的根数
      hits        命中列表，每项 {direction, h1_agree}
      error       出错时的说明，正常为 None
    """
    import pandas as pd

    try:
        from chanlun import TF_DF
        from lib.fast_bsp3 import find_fast_bsp3
        from lib.fx_signal import extract_fx_signals, signals_to_frame
        from lib.nested_bsp import attach_htf_context, htf_fx_timeline
        from lib.nested_level import build_htf_zones

        chan_l = TF_DF(df_l, 1, "1m")
        cdf = chan_l.dataframe
        last = len(cdf) - 1
        base = {"last_idx": last, "n_bars": int(len(df_l)), "hits": [],
                "error": None}

        zones = build_htf_zones(cdf, "1m", chan=chan_l)
        if zones.empty:
            return base
        sig = find_fast_bsp3(cdf, zones.reset_index(drop=True))
        if sig is None or sig.empty:
            return base

        # 只留落在最后一根上的信号，其余是历史，实盘下不了
        cur = sig[sig["entry_idx"].astype(int) == last]
        if cur.empty:
            return base

        # 5m 同向过滤：算得出就标 h1_agree，算不出就当未过滤照记
        agree_map: dict[int, int] = {}
        if df_h is not None and len(df_h) > 0:
            chan_h = TF_DF(df_h, 1, "5m")
            hdf = chan_h.dataframe
            tl = htf_fx_timeline(
                signals_to_frame(extract_fx_signals(chan_h, hdf)), hdf)
            full = attach_htf_context(sig, cdf, tl, "h1")
            f_cur = full[full["entry_idx"].astype(int) == last]
            for _, r in f_cur.iterrows():
                agree_map[int(r["direction"])] = int(r.get("h1_agree", 0))

        base["hits"] = [{"direction": int(r["direction"]),
                         "h1_agree": agree_map.get(int(r["direction"]), 0)}
                        for _, r in cur.iterrows()]
        return base
    except Exception as e:  # 子进程里异常必须带回主进程，否则只见超时不见原因
        import traceback
        return {"last_idx": -1, "n_bars": int(len(df_l)) if df_l is not None else 0,
                "hits": [], "error": f"{type(e).__name__}: {e}",
                "traceback": traceback.format_exc()}


NUM_COLS = ("timestamp", "open", "high", "low", "close", "volume")


def _rebuild(rows) -> "object":
    """只传数值列，date 在这里按 lib/data.py 的同一规则重建。

    跨进程传 tz-aware 的 datetime 既慢又容易在字符串往返中丢时区，
    而时区若与回测不一致，chanlun 的 K 线标签就会错位。
    """
    import pandas as pd

    df = pd.DataFrame(rows, columns=list(NUM_COLS))
    df["timestamp"] = df["timestamp"].astype("int64")
    date = pd.to_datetime(df["timestamp"], unit="ms", utc=True) \
             .dt.tz_convert("Asia/Shanghai")
    df.insert(1, "date", date)
    return df


def compute_packed(payload: tuple) -> dict:
    """ProcessPoolExecutor 的入口：收 (l_rows, h_rows) 两组数值行。"""
    l_rows, h_rows = payload
    df_l = _rebuild(l_rows)
    df_h = _rebuild(h_rows) if h_rows else None
    return compute(df_l, df_h)