"""
momentum_entry_test.py -- [2026-10-22] 2-year test of momentum_entry.py (the user's 5-bar flow entry + situations +
momentum override). Every top-30 stock, every day, real bar replay with exit_v2 (2% stop under the buy), 0.2% cost.
  SIG     the 5-bar signal alone (no blockers)
  BLOCK   signal; WAIT on any HARD / EXTENDED / SOFT blocker
  OVR     signal; HARD / EXTENDED wait; SOFT overruled by momentum (M1-M4)    <- the user's design
  (today's v2 for reference: 2,012 buys, -0.133%/trade, total -267.5%)
Also split: OVR buys that were overrides vs all-clear.
    nice -n 19 python3 momentum_entry_test.py [START..END]  -> momentum_entry_test.jsonl + .log
"""
import gzip
import json
import sys
from collections import Counter
from pathlib import Path

import numpy as np

HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(HERE)); sys.path.insert(0, "/var/www/screener/trade")
import v2_bar_replay as R  # noqa: E402
import entry_situations as ES  # noqa: E402
import momentum_entry as ME  # noqa: E402
import logging  # noqa: E402
logging.getLogger("trade_bot.entry_situations").setLevel(logging.WARNING)

OUT = HERE / "momentum_entry_test.jsonl"; SPLIT = "2025-10-01"
RUNS = ["SIG", "BLOCK", "OVR"]
SIT = {"S1_window_flip": {"enabled": True, "record_only": False}, "S2_spike_confirm": {"enabled": True, "record_only": False},
       "S3_block_print": {"enabled": True, "record_only": False, "mode": "while_in_window"},
       "S6_extended": {"enabled": True, "record_only": False, "mode": "pct", "max_pct": 3.0},
       "S8_resistance": {"enabled": True, "record_only": False, "mode": "pct", "min_room_pct": 5.0},
       "S9_prev_close": {"enabled": True, "record_only": False}}
CTX = {}
_orig = R.entry_v2.evaluate


def wrapped(sym, view, ref, f15, pers, as_of=None, cfg=None, quote=None):
    d = _orig(sym, view, ref, f15, pers, as_of=as_of, cfg=cfg, quote=quote)
    m = R.minute(as_of) - 1; day = CTX["day"]; run = CTX["run"]; done = view[:-1]
    fb, fs = CTX["flow"]["buy"], CTX["flow"]["sell"]
    ES.record(day, sym, m, d.metrics, passed=bool(d.should_enter))
    d.should_enter = False
    if len(done) < 5:
        return d
    flow5 = [(fb[k], fs[k]) if 0 <= k < 390 else None for k in range(m - 4, m + 1)]
    ok, _ = ME.signal(done, flow5, ME.DEFAULTS)
    if not ok:
        return d
    if run == "SIG":
        act, why, info = "BUY", "signal", {}
    else:
        held = []
        if len(done) >= 20:
            fm = {k: (fb[k], fs[k]) for k in range(0, m + 1)}
            tags, det = ES.tag(day, sym, m, view, ref, d.metrics, cfg=SIT, flow_by_min=fm); det["_flowm"] = fm
            held = [h.split(" ")[0] for h in ES.check(day, sym, m, view, ref, d.metrics, tags, det, cfg=SIT)]
        act, why, info = ME.decide(done, flow5, ref, m, d.metrics, sit_held=held, cfg={"override": run == "OVR"})
    if act == "BUY":
        px = view[-1]["o"]
        d.metrics["stage3"] = {"stop": px * 0.98}
        d.should_enter = True
        CTX["why"][m + 1] = why
    else:
        CTX["wait"][why.split(":")[0]] += 1
        for b in (info.get("hard", []) + info.get("ext", []) + info.get("soft", [])):
            CTX["blk"][b] += 1
    return d


R.entry_v2.evaluate = wrapped


def run(rng):
    a, b = rng.split("..")
    cfg = R.get_config(); ecfg = {**(cfg.get("entry_v2") or {}), "confirm_checks": 1}; xcfg = {**(cfg.get("exit_v2") or {}), "enabled": True}
    CTX["blk"] = Counter(); CTX["wait"] = Counter()
    with open(OUT, "w") as out:
        for p in sorted(R.OW.glob("bars/bars_20*.json.gz")):
            day = p.name[5:15]
            if not (a <= day <= b):
                continue
            d = json.load(gzip.open(p, "rt")); bench = R.bench_pct(day); k = Counter()
            for s in d["top30_current"]:
                fp = R.OW / "flow" / day / f"{s}.json"; ref = R.REF.load(day, s)
                if s not in d["symbols"] or not fp.exists() or not ref:
                    continue
                flow = json.loads(fp.read_text())
                for rn in RUNS:
                    CTX.update(day=day, run=rn, flow=flow, why={})
                    for z in (ES._hist, ES._pending, ES._streak, ES._c3ep, ES._s1, ES._s2, ES._s3):
                        z.clear()
                    for t in R.run_stock(day, s, d["symbols"][s]["bars"], flow, ref, bench, ecfg, xcfg):
                        out.write(json.dumps({"run": rn, "day": day, "sym": s, "buy_m": t["buy_m"], "pl": t["pl"] + R.COST - 0.2,
                                              "why": t["why"], "entry": CTX["why"].get(t["buy_m"], "")}) + "\n"); k[rn] += 1
            R.REF._CACHE.clear(); del d
            print(day, dict(k), flush=True)
    json.dump({"blk": CTX["blk"], "wait": CTX["wait"]}, open(HERE / "momentum_entry_test_blk.json", "w"))
    report()


def report():
    T = [json.loads(l) for l in open(OUT)]
    days = sorted({t["day"] for t in T})
    def line(lab, X):
        if not X:
            print(f"   {lab:46} 0"); return
        p = np.array([t["pl"] for t in X]); y = np.array([t["day"] < SPLIT for t in X])
        print(f"   {lab:46} {len(p):6} {p.mean():+8.3f}% win {np.mean(p > 0):4.0%} | y1 {p[y].mean() if y.any() else 0:+7.3f}% "
              f"y2 {p[~y].mean() if (~y).any() else 0:+7.3f}% | total {p.sum():+8.1f}% | {len(p) / len(days):.1f}/day")
    print(f"\n{len(days)} days {days[0]}..{days[-1]}; per trade after 0.2% cost; exit_v2, 2% stop | today's v2: 2,012 buys -0.133%, total -267.5%")
    for rn, lab in (("SIG", "SIG    5-bar signal alone"), ("BLOCK", "BLOCK  signal + every blocker"), ("OVR", "OVR    signal + blockers + momentum override")):
        line(lab, [t for t in T if t["run"] == rn])
    O = [t for t in T if t["run"] == "OVR"]
    line("   OVR: all-clear buys", [t for t in O if t["entry"] == "all clear"])
    line("   OVR: momentum OVERRIDE buys", [t for t in O if t["entry"].startswith("momentum")])
    for lo, hi, lab in ((0, 15, "9:35-9:45"), (15, 60, "9:45-10:30"), (60, 150, "10:30-12:00"), (150, 300, "12:00-14:30")):
        line(f"   OVR bought {lab}", [t for t in O if lo <= t["buy_m"] - 1 < hi])
    sb = Counter()
    for t in O:
        if t["entry"].startswith("momentum"):
            for x in t["entry"].split(": ", 1)[1].split(", "):
                sb[x] += 1
    print("   soft blockers the momentum overrode:", ", ".join(f"{k} {v}" for k, v in sb.most_common()))
    try:
        B = json.load(open(HERE / "momentum_entry_test_blk.json"))
        print("   WAIT reasons (signal minutes, all 3 runs):", ", ".join(f"{k} {v}" for k, v in Counter(B["wait"]).most_common(6)))
        print("   blockers seen:", ", ".join(f"{k} {v}" for k, v in Counter(B["blk"]).most_common(14)))
    except Exception:
        pass
    print("MOMENTRY_DONE")


if __name__ == "__main__":
    if "--report" in sys.argv:
        report()
    else:
        run(sys.argv[1] if len(sys.argv) > 1 else "2024-10-01..2026-10-02")
