"""
queue_test.py -- [2026-10-23] the user: "test everything on the queue". 2 years (2024-10-01..2026-10-02), NO look-ahead: setups and
the X1 / climax sells decide at a finished bar's close and act at the next open; stop and give-back intrabar as the live bot.
0.2% cost. YEAR 1 2024-10..2025-09 | YEAR 2 2025-10..2026-10.
PART A  EXITS on the 833 EV3 buys (and the 535 kept by N2+N3): GB2 (live), C3 (live from 10/26: GB2 + X1 takes control when
        buyers made the run), X1, and each + the CLIMAX sell (exit_climax.py) on top; climax grid on C3.
PART B  NEW SETUPS scanned on every top-30 stock-day: R1C (as built -- the user: no changes), R1D spring (grid; N2 exemption
        checked), R1E selling exhaustion (grid). Buy next open, stop under the setup support (x0.998, 0.5-4%), exits GB2 / C3 /
        C3+climax, with and without the N2+N3 gate.
PART C  N3 for R1A measured from the flush low onward (the flush sits in the 15-min window and blocked JOBY / HELP).
    nice -n 19 python3 queue_test.py   -> queue_test.json + queue_test.log
"""
import bisect, gzip, json, sys, itertools
from collections import defaultdict
from pathlib import Path
import numpy as np
HERE = Path(__file__).resolve().parent
sys.path.insert(0, "/var/www/screener/trade/reports/playbook"); sys.path.insert(0, "/var/www/screener/trade")
import v2_bar_replay as R
import r1b_setup, r1c_setup, r1d_setup, r1e_setup, exit_x1, exit_climax
from exit_pepg import MODS
MODS = {**MODS, "R1B": r1b_setup}
COST = 0.2; SPLIT = "2025-10-01"
CL0 = dict(exit_climax.DEFAULTS)
CLGRID = {f"v{v}h{h}s{int(sb * 100)}": {**CL0, "vwap_pct": v, "heavy_min": h, "seller_bs": sb}
          for v in (6, 8, 10) for h in (4, 5) for sb in (0.40, 0.45)}
R1D_GRID = {f"u{u}x{x}a{int(a * 100)}": {"undercut_pct": u, "heavy_x": x, "absorb_bs": a}
            for u in (0.2, 0.3, 0.5) for x in (2.0, 2.5, 3.0) for a in (0.40, 0.45, 0.50)}
R1E_GRID = {f"n{n}d{int(dd * 100)}x{x}": {"bleed_n": n, "div_up": dd, "bleed_x": x}
            for n in (8, 10, 12) for dd in (0.05, 0.08, 0.10) for x in (1.3, 1.5)}


class Day:
    """per stock-day arrays for fast VWAP / median volume / range (the climax sell)"""
    def __init__(self, bars, mins, fl, ref):
        self.b, self.m, self.fl, self.ref = bars, mins, fl, ref
        n = len(bars); self.vw = []; pv = cv = 0.0
        for x in bars:
            pv += (x["h"] + x["l"] + x["c"]) / 3 * x["v"]; cv += x["v"]; self.vw.append(pv / cv if cv else x["c"])
        self.med = [0.0] * (n + 1); srt = []          # med[i] = median volume of bars[0:i]
        for i in range(n):
            self.med[i] = srt[len(srt) // 2] if srt else 0.0
            bisect.insort(srt, bars[i]["v"])
        self.med[n] = srt[len(srt) // 2]
        self.rg = [0.0]
        for x in bars:
            self.rg.append(self.rg[-1] + x["h"] - x["l"])

    def climax(self, j, P, c):
        """exit_climax.check(bars[:j+1], ...) without re-scanning"""
        b = self.b[j]; n = c["heavy_n"]
        if j + 1 < max(n + 15, 46) or b["c"] < P * (1 + c["min_gain"] / 100):
            return False
        vw = self.vw[j]; atr = self.ref.get("atr14")
        if not ((b["c"] / vw - 1) * 100 >= c["vwap_pct"] or (atr and b["c"] - vw >= c["atr_k"] * atr)):
            return False
        base = self.med[j + 1 - n]
        if not base or sum(1 for x in self.b[j + 1 - n:j + 1] if x["v"] >= c["heavy_x"] * base) < c["heavy_min"]:
            return False
        r_now = (self.rg[j + 1] - self.rg[j - 14]) / 15; r_then = (self.rg[j - 29] - self.rg[j - 44]) / 15
        if not r_then or r_now < c["range_x"] * r_then:
            return False
        m = self.m[j]; B, S = self.fl["buy"][m], self.fl["sell"][m]
        return (B / (B + S) if B + S else 0.5) < c["seller_bs"] and b["v"] >= c["seller_vol_x"] * base


def bsr(fl, m0, m1):
    B = sum(fl["buy"][max(0, m0):m1 + 1]); S = sum(fl["sell"][max(0, m0):m1 + 1]); return B / (B + S) if B + S else 0.5


def c3(D, bi, k, P, peak):
    bars, mins, fl = D.b, D.m, D.fl
    if bsr(fl, mins[bi], mins[k]) < 0.55 or bi < 1:
        return False
    if not bsr(fl, mins[k] - 14, mins[k]) > bsr(fl, mins[bi - 1] - 14, mins[bi - 1]):
        return False
    ups = [bars[i]["c"] - bars[i - 1]["c"] for i in range(bi + 1, k + 1)] + [bars[bi]["c"] - P]
    if peak - P <= 0 or max(ups) > 0.60 * (peak - P):
        return False
    w = bars[max(0, k - 15):k]
    return not (w and bars[k]["v"] > sum(x["v"] for x in w) / len(w))


def sim(D, bi, P, stop, mode, cl=None):
    bars, mins, fl = D.b, D.m, D.fl
    peak = P; x1 = mode == "X1"
    for j in range(bi, len(bars)):
        b = bars[j]
        if b["l"] <= stop:
            return (min(stop, b["o"]) if j > bi else stop) / P * 100 - 100 - COST, "stop"
        if not x1 and j > bi:
            gain = peak - P
            if gain >= P * 0.02:
                x = min(peak - 0.25 * gain, bars[j - 1]["c"] * 0.9999)
                if b["l"] <= x:
                    if mode == "C3" and c3(D, bi, j - 1, P, peak):
                        x1 = True
                    else:
                        return min(x, b["o"]) / P * 100 - 100 - COST, "give-back"
        peak = max(peak, b["h"])
        if mins[j] >= 385:
            return b["c"] / P * 100 - 100 - COST, "15:55"
        if j + 1 < len(bars):
            if cl and D.climax(j, P, cl):
                return bars[j + 1]["o"] / P * 100 - 100 - COST, "climax"
            if x1:
                sell, why = exit_x1.check(bars[:j + 1], fl, P, bi)
                if sell:
                    return bars[j + 1]["o"] / P * 100 - 100 - COST, "X1"
    return bars[-1]["c"] / P * 100 - 100 - COST, "end"


def gates(D, k, P):
    m = D.m[k]; pl = D.ref.get("prev_low")
    return {"N2": bool(pl) and P < pl, "N3": bsr(D.fl, m - 14, m) < 0.45}


def stop_of(sup, P):
    return min(max(sup * 0.998, P * 0.96), P * 0.995)


def main():
    trig = defaultdict(list)
    for l in open("/var/www/screener/trade/reports/playbook/giveback_2y.jsonl"):
        t = json.loads(l)
        if t["setup"] in ("R1A", "R1B", "R4") or (t["setup"] == "R3" and 6 <= t["atr"] < 10):
            trig[t["day"]].append(t)
    A, B = [], []
    for p in sorted(R.OW.glob("bars/bars_20*.json.gz")):
        day = p.name[5:15]
        if day < "2024-10-01" or day > "2026-10-02":
            continue
        d = json.load(gzip.open(p, "rt")); cache = {}
        def load(s):
            if s not in cache:
                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 or not ref.get("atr14"):
                    cache[s] = None
                else:
                    bars = [b for b in R.bars_of(d["symbols"][s]["bars"]) if 0 <= R.minute(b["t"]) < 390]
                    cache[s] = Day(bars, [R.minute(b["t"]) for b in bars], json.loads(fp.read_text()), ref) if len(bars) > 20 else None
            return cache[s]
        # PART A + C: the EV3 buys
        for t in trig.get(day, []):
            D = load(t["sym"])
            if not D:
                continue
            ti = next((i for i, m in enumerate(D.m) if m == t["m"]), None)
            if ti is None or ti + 1 >= len(D.b):
                continue
            bi = ti + 1; P = D.b[bi]["o"]
            ok, info = MODS[t["setup"]].check(D.b[:ti + 1], D.fl, D.ref, t["m"])
            stop = stop_of((info or {}).get("support") or P * 0.99, P)
            g = gates(D, ti, D.b[ti]["c"])
            r = {"setup": t["setup"], "day": day, "sym": t["sym"], "m": t["m"], **g}
            if t["setup"] == "R1A" and info and info.get("support_m") is not None:
                r["bs_flush"] = round(bsr(D.fl, info["support_m"], t["m"]), 4)
            for mode in ("GB2", "C3", "X1"):
                r[mode] = sim(D, bi, P, stop, mode)
                r[mode + "+CL"] = sim(D, bi, P, stop, mode, CL0)
            for k_, cl in CLGRID.items():
                r["C3+" + k_] = sim(D, bi, P, stop, "C3", cl)[0]
            A.append(r)
        # PART B: the new setups on every top-30 stock
        for s in d["top30_current"]:
            D = load(s)
            if not D or len(D.b) < 100:
                continue
            bars, mins, ref = D.b, D.m, D.ref
            O = bars[0]["o"]; atr = ref["atr14"]
            last = defaultdict(lambda: -9999)
            lo, lj = 1e18, 0
            for i in range(len(bars) - 1):
                m = mins[i]
                if m >= 300:
                    break
                prior_lo = lo
                if bars[i]["l"] < lo:
                    lo, lj = bars[i]["l"], i
                cands = []
                if 1 <= i - lj <= 2 and O - lo >= r1c_setup.DEFAULTS["drop_atr"] * atr and m - last["R1C"] >= 20:
                    cands.append(("R1C", "def", r1c_setup, None))
                if i >= 5 and bars[i]["l"] < prior_lo * 0.998 and O - bars[i]["l"] >= atr:
                    for k_, cc in R1D_GRID.items():
                        if m - last["R1D" + k_] >= 20:
                            cands.append(("R1D", k_, r1d_setup, cc))
                    for k_, cc in R1E_GRID.items():
                        if m - last["R1E" + k_] >= 20:
                            cands.append(("R1E", k_, r1e_setup, cc))
                elif i >= 5 and bars[i]["l"] < prior_lo and O - bars[i]["l"] >= atr:
                    for k_, cc in R1E_GRID.items():
                        if m - last["R1E" + k_] >= 20:
                            cands.append(("R1E", k_, r1e_setup, cc))
                for st, k_, mod, cc in cands:
                    ok, info = mod.check(bars[:i + 1], D.fl, ref, m, cc)
                    if not ok:
                        continue
                    last[st + (k_ if st != "R1C" else "")] = m
                    bi = i + 1; P = bars[bi]["o"]; stop = stop_of(info["support"], P)
                    r = {"setup": st, "var": k_, "day": day, "sym": s, "m": m, **gates(D, i, bars[i]["c"]),
                         "atr": round(atr / ref["prev_close"] * 100, 1)}
                    for mode in ("GB2", "C3"):
                        r[mode] = sim(D, bi, P, stop, mode)[0]
                    r["C3+CL"] = sim(D, bi, P, stop, "C3", CL0)[0]
                    B.append(r)
        R.REF._CACHE.clear(); del d, cache
        print(day, len(A), len(B), flush=True)
    json.dump({"A": A, "B": B}, open(HERE / "queue_test.json", "w"))
    report()


def stats(X, k):
    if not X:
        return "  -"
    a = np.array([x[k][0] if isinstance(x[k], list) else x[k] for x in X]); y = np.array([x["day"] < SPLIT for x in X])
    return (f"{a.mean():+.3f}% ({a[y].mean() if y.any() else 0:+.3f} / {a[~y].mean() if (~y).any() else 0:+.3f}) "
            f"n {len(X)} win {np.mean(a > 0):.0%}")


def report():
    Q = json.load(open(HERE / "queue_test.json")); A, B = Q["A"], Q["B"]
    kept = [r for r in A if not (r["N2"] or r["N3"])]
    print(f"\n========== PART A -- exits on the EV3 buys (per trade after {COST}% cost: all (year 1 / year 2))")
    for lab, X in (("all 833", A), ("kept by N2+N3", kept)):
        print(f" {lab}:")
        for k in ("GB2", "GB2+CL", "C3", "C3+CL", "X1", "X1+CL"):
            print(f"   {k:7} {stats(X, k)}")
    print(" climax grid on C3 (kept): v = % over VWAP, h = heavy bars of 6, s = seller bar buyers <")
    for k in CLGRID:
        print(f"   C3+{k:10} {stats(kept, 'C3+' + k)}")
    n_cl = sum(1 for r in kept if r["C3+CL"][1] == "climax")
    print(f"   (default climax fired on {n_cl} of {len(kept)} kept trades)")
    print(f"\n========== PART C -- N3 for R1A measured from the flush low (C3 exit)")
    ra = [r for r in A if r["setup"] == "R1A" and "bs_flush" in r]
    for lab, f in (("N2+N3 (live)", lambda r: r["N2"] or r["N3"]),
                   ("N2 + flush-low buy share < 45%", lambda r: r["N2"] or r["bs_flush"] < 0.45),
                   ("N2 + flush-low buy share < 50%", lambda r: r["N2"] or r["bs_flush"] < 0.50),
                   ("N2 only", lambda r: r["N2"])):
        k_ = [r for r in ra if not f(r)]; b_ = [r for r in ra if f(r)]
        print(f"   {lab:32} kept {stats(k_, 'C3')} | blocked {stats(b_, 'C3')}")
    for s_, d_ in (("JOBY", "2024-10-23"), ("HELP", "2025-07-03"), ("RDW", "2025-09-15"), ("FCEL", "2025-09-19"), ("QBTS", "2025-02-24")):
        for r in ra:
            if r["sym"] == s_ and r["day"] == d_:
                print(f"     {s_} {d_} m{r['m']}: 15-min N3 {'BLOCK' if r['N3'] else 'ok'}, flush-low buy share {r['bs_flush']:.0%}, N2 {r['N2']}, C3 {r['C3'][0]:+.2f}%")
    print(f"\n========== PART B -- new setups, 2 years (C3 exit unless noted)")
    for st, grid in (("R1C", {"def": None}), ("R1D", R1D_GRID), ("R1E", R1E_GRID)):
        print(f" {st}:  {'variant':12} | all buys (C3)                          | kept by N2+N3 (C3)                     | GB2 all | C3+CL all"
              + (" | N3 only (N2 exempt)" if st == "R1D" else ""))
        rows = []
        for k_ in grid:
            X = [r for r in B if r["setup"] == st and r["var"] == k_]
            if not X:
                continue
            K = [r for r in X if not (r["N2"] or r["N3"])]
            line = f"   {k_:12} | {stats(X, 'C3'):38} | {stats(K, 'C3'):38} | {np.mean([r['GB2'] for r in X]):+.3f} | {np.mean([r['C3+CL'] for r in X]):+.3f}"
            if st == "R1D":
                line += f" | {stats([r for r in X if not r['N3']], 'C3')}"
            rows.append((np.mean([r["C3"] for r in X]), line))
        for _, line in sorted(rows, key=lambda z: -z[0]):
            print(line)
        dflt = "def" if st == "R1C" else ("u0.3x2.5a45" if st == "R1D" else "n10d8x1.5")
        X = [r for r in B if r["setup"] == st and r["var"] == dflt]
        for lab, lo, hi in (("ATR <6%", 0, 6), ("ATR 6-10%", 6, 10), ("ATR >=10%", 10, 999)):
            Z = [r for r in X if lo <= r["atr"] < hi]
            print(f"     default {dflt} {lab:9}: {stats(Z, 'C3')}")
    for s_, d_ in (("CERT", "2025-02-27"), ("RKT", "2025-02-28"), ("QUBT", "2025-05-20")):
        hits = [f"{r['setup']}:{r['var']} m{r['m']} C3 {r['C3']:+.2f}" for r in B if r["sym"] == s_ and r["day"] == d_ and r["var"] in ("def", "u0.3x2.5a45", "n10d8x1.5")]
        print(f"   {s_} {d_}: {hits}")
    print("QUEUE_DONE")


if __name__ == "__main__":
    report() if "--report" in sys.argv else main()
