"""
avoid_rules_test.py -- [2026-10-12] The user: test every DO-NOT-TRADE rule (trade/avoid_rules.py) against 2 years.
2-year bar replay with the REAL entry_v2 + exit_v2 code (v2_bar_replay.run_stock: every signal, no slot limit,
the daily top-30 lists, Oct 2024 - Oct 2026), the rule applied the moment v2 says BUY -- exactly as live.
Runs: BASE (all rules off; every rule's hits recorded on each trade), then each rule ON alone (a real replay: a
blocked buy can be replaced by a later one), then ALL rules ON. sec_avoid can't be tested (no SEC history).
Scored at the real 0.2% round-trip cost; both halves; also ATR >= 8% stocks and v3 picks.
    python3 avoid_rules_test.py [START..END]      -> avoid_rules_test.jsonl ;   --report
"""
import gzip
import json
import sys
from collections import defaultdict
from pathlib import Path

import numpy as np

HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(HERE)); sys.path.insert(0, str(HERE.parent / "open_window")); sys.path.insert(0, "/var/www/screener/trade")
import v2_bar_replay as R  # noqa: E402
import avoid_rules as AR  # noqa: E402
from up2_styles_build import v3_top30  # noqa: E402

OUT = HERE / "avoid_rules_test.jsonl"
COST = 0.2
RULES = [k for k in AR.DEFAULTS if k != "sec_avoid"]
RUNS = ["BASE"] + RULES + ["ALL ON"]
_orig = R.entry_v2.evaluate
ACTIVE = {}
V2CFG = {}


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)
    if d.should_enter:
        blocked, hits = AR.check(sym, view, ref, d.metrics, R.minute(as_of), cfg=ACTIVE, v2cfg=V2CFG)
        d.metrics["avoid_hits"] = [h.split(":")[0] for h in hits]
        if blocked:
            d.should_enter = False
    return d


R.entry_v2.evaluate = wrapped


def run(rng):
    global ACTIVE, V2CFG
    a, b = rng.split("..")
    cfg = R.get_config()
    ecfg = {**(cfg.get("entry_v2") or {}), "confirm_checks": 1}; V2CFG = ecfg
    xcfg = {**(cfg.get("exit_v2") or {}), "enabled": True}
    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); v3 = v3_top30(day)
            k = defaultdict(int)
            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())
                atrp = ref["atr14"] / ref["prev_close"] * 100 if ref.get("atr14") and ref.get("prev_close") else None
                for run_name in RUNS:
                    if run_name == "BASE":
                        ACTIVE = {}
                    elif run_name == "ALL ON":
                        ACTIVE = {r: {"enabled": True} for r in RULES}
                    else:
                        ACTIVE = {run_name: {"enabled": True}}
                    for t in R.run_stock(day, s, d["symbols"][s]["bars"], flow, ref, bench, ecfg, xcfg):
                        out.write(json.dumps({"run": run_name, "day": day, "sym": s, "buy_m": t["buy_m"], "pl_gross": t["pl"] + R.COST,
                                              "hits": (t.get("feat") or {}).get("avoid_hits") or [], "atr": atrp, "v3": s in v3}) + "\n")
                        k[run_name] += 1
            R.REF._CACHE.clear(); del d
            print(day, k.get("BASE", 0), "base trades", flush=True)
    print("AVOID_TEST_DONE")


def report():
    T = [json.loads(l) for l in open(OUT)]
    days = sorted({t["day"] for t in T}); half = days[len(days) // 2]
    base = [t for t in T if t["run"] == "BASE"]
    pl = lambda X: np.array([t["pl_gross"] - COST for t in X])
    print(f"{len(days)} days {days[0]}..{days[-1]}; per trade after {COST}% cost; every v2 signal, no slot limit\n")
    print("A. FIRST LOOK on the BASE trades: what each rule would block (the trades it hits) vs the trades it keeps")
    print(f"   {'rule':22} {'blocks':>7} {'blocked: per trade':>19} {'kept: per trade':>16} {'kept total':>11}")
    b = pl(base)
    for r in RULES:
        hit = [t for t in base if r in t["hits"]]; keep = [t for t in base if r not in t["hits"]]
        print(f"   {r:22} {len(hit):7} {pl(hit).mean() if hit else 0:+18.3f}% {pl(keep).mean() if keep else 0:+15.3f}% {pl(keep).sum():+10.1f}%")
    print(f"   {'(base, no rule)':22} {len(base):7} {'':19} {b.mean():+15.3f}% {b.sum():+10.1f}%")
    print("\nB. REAL REPLAY with each rule ON (a blocked buy can be followed by another one later)")
    print(f"   {'run':22} {'trades':>7} {'per trade':>10} {'total':>9} {'win':>5} | {'half 1':>8} {'half 2':>8} | {'ATR>=8%':>16} | {'v3 picks':>16}")
    for r in RUNS:
        X = [t for t in T if t["run"] == r]
        if not X:
            print(f"   {r:22} {0:7}  (blocks every buy)"); continue
        p = pl(X); h = np.array([t["day"] < half for t in X])
        hi = pl([t for t in X if (t["atr"] or 0) >= 8]); v3 = pl([t for t in X if t["v3"]])
        f = lambda z: f"{len(z):5} {z.mean():+.3f}%" if len(z) else "    0      -"
        print(f"   {r:22} {len(p):7} {p.mean():+9.3f}% {p.sum():+8.1f}% {np.mean(p > 0):4.0%} | {p[h].mean():+7.3f}% {p[~h].mean():+7.3f}% | "
              f"{f(hi):>16} | {f(v3):>16}")


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")
        report()
