"""
s2_study.py -- [2026-10-21] S2 (spike) deep study, the user: "let's work on S2". Goal like S1: find WHICH spikes are
noise (pop-and-fade: the bot buys the top) so S2 holds only that moment and the next bars decide.
2 years, the real v2 bar replay (every signal, BASE rules). For every v2 BUY whose last 2 finished bars hold a spike
(range > 2x the average range of the 15 bars before it) the spike is described:
  dir up/down, size x normal range, move %, volume x normal, the spike bar's buy share, share of the last 15 min volume
  (single print), lag (spike = last bar / the bar before), VWAP % and open % at the buy, wick (close position in the bar)
OUTCOME: faded = a close under the spike's midpoint in the 2 bars after the buy; worst low in 3 bars; the trade P/L.
    nice -n 19 python3 s2_study.py   -> s2_study.jsonl + s2_study.log
"""
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, "/var/www/screener/trade")
import v2_bar_replay as R  # noqa: E402

OUT = HERE / "s2_study.jsonl"; COST = 0.2; SPLIT = "2025-10-01"
CTX = {}
_orig = R.entry_v2.evaluate


def spike_feat(view, m, ref, flow):
    done = view[:-1]
    if len(done) < 20:
        return None
    rng = [b["h"] - b["l"] for b in done]
    best = None
    for lag in (0, 1):
        i = len(done) - 1 - lag
        avg = sum(rng[i - 15:i]) / 15
        if avg > 0 and rng[i] > 2 * avg and (best is None or rng[i] / avg > best[1]):
            best = (i, rng[i] / avg, lag)
    if not best:
        return None
    i, x, lag = best; b = done[i]; mi = m - lag                  # minute index of the spike bar
    vpm = ref.get("vol_per_min") or []
    fb, fs = CTX["flow"]["buy"][mi], CTX["flow"]["sell"][mi]
    v15 = sum(x_["v"] for x_ in done[-15:])
    pv = sum((x_["h"] + x_["l"] + x_["c"]) / 3 * x_["v"] for x_ in done); cv = sum(x_["v"] for x_ in done)
    P = done[-1]["c"]
    return {"x": x, "lag": lag, "up": b["c"] > b["o"], "move": (b["c"] / b["o"] - 1) * 100,
            "volx": b["v"] / max(vpm[mi], 1) if mi < len(vpm) and vpm[mi] else None,
            "bs": fb / (fb + fs) if fb + fs else None, "vshare": b["v"] / v15 if v15 else None,
            "pos": (b["c"] - b["l"]) / (b["h"] - b["l"]) if b["h"] > b["l"] else 0.5,
            "mid": (b["h"] + b["l"]) / 2, "vwap": (P / (pv / cv) - 1) * 100 if cv else None,
            "open": (P / done[0]["o"] - 1) * 100, "m": m}


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:
        m = R.minute(as_of) - 1
        try:
            CTX["sig"][m] = spike_feat(view, m, ref, CTX["flow"])
        except Exception:
            CTX["sig"][m] = None
    return d


R.entry_v2.evaluate = wrapped


def run():
    cfg = R.get_config(); ecfg = {**(cfg.get("entry_v2") or {}), "confirm_checks": 1}; 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 day > "2026-10-02":
                continue
            d = json.load(gzip.open(p, "rt")); bench = R.bench_pct(day); k = 0
            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
                CTX["flow"] = json.loads(fp.read_text()); CTX["sig"] = {}
                bars = [b for b in R.bars_of(d["symbols"][s]["bars"]) if 0 <= R.minute(b["t"]) < 390]
                by = {R.minute(b["t"]): b for b in bars}
                for t in R.run_stock(day, s, d["symbols"][s]["bars"], CTX["flow"], ref, bench, ecfg, xcfg):
                    f = CTX["sig"].get(t["buy_m"] - 1)
                    bm, bp = t["buy_m"], t["buy"]
                    nxt = [by[j] for j in range(bm, bm + 2) if j in by]
                    n3 = [by[j] for j in range(bm, bm + 3) if j in by]
                    rec = {"day": day, "sym": s, "buy_m": bm, "pl": t["pl"], "why": t["why"], "spike": f}
                    if f:
                        rec["faded"] = any(b["c"] < f["mid"] for b in nxt)
                        rec["low3"] = (min(b["l"] for b in n3) / bp - 1) * 100 if n3 else None
                        rec["buy_vs_mid"] = (bp / f["mid"] - 1) * 100
                    out.write(json.dumps(rec) + "\n"); k += 1
            R.REF._CACHE.clear(); del d
            print(day, k, "trades", flush=True)
    report()


def report():
    T = [json.loads(l) for l in open(OUT)]
    S = [t for t in T if t["spike"]]
    def line(lab, X):
        if len(X) < 5:
            print(f"   {lab:40} {len(X):5}"); return
        p = np.array([t["pl"] for t in X]); y1 = np.array([t["day"] < SPLIT for t in X])
        fd = np.mean([t.get("faded", False) for t in X]) if X[0].get("spike") else float("nan")
        print(f"   {lab:40} {len(p):5} {p.mean():+7.3f}% win {np.mean(p > 0):4.0%} | y1 {p[y1].mean() if y1.any() else 0:+7.3f} "
              f"y2 {p[~y1].mean() if (~y1).any() else 0:+7.3f} | faded {fd:4.0%} | stop {np.mean([t['why'] == 'stop' for t in X]):4.0%}")
    print(f"\n2 years, v2 bar replay, every signal; P/L after {COST}% cost | trades, per trade, win, year 1, year 2, faded under the spike's middle within 2 bars, stopped out")
    line("ALL base buys", T); line("no spike", [t for t in T if not t["spike"]]); line("SPIKE buys (S2)", S)
    line("   spike faded within 2 bars", [t for t in S if t["faded"]]); line("   spike held", [t for t in S if not t["faded"]])
    g = lambda k: [t for t in S if t["spike"].get(k) is not None]
    def split(lab, key, cuts, fmt=lambda v: f"{v:g}"):
        X = g(key)
        print(f"  {lab}:")
        for lo, hi in zip(cuts, cuts[1:]):
            line(f"   {fmt(lo)}..{fmt(hi)}", [t for t in X if lo <= t["spike"][key] < hi])
    print("  direction:"); line("   UP spike", [t for t in S if t["spike"]["up"]]); line("   DOWN spike", [t for t in S if not t["spike"]["up"]])
    print("  spike = last bar / the bar before:"); line("   last bar (lag 0)", [t for t in S if t["spike"]["lag"] == 0]); line("   bar before (lag 1)", [t for t in S if t["spike"]["lag"] == 1])
    split("size x normal range", "x", [2, 3, 4, 6, 99])
    split("spike move %", "move", [-99, -1, 0, 0.5, 1, 2, 99])
    split("spike volume x normal", "volx", [0, 1, 2, 5, 10, 9999])
    split("spike bar's buy share", "bs", [0, 0.4, 0.5, 0.6, 0.7, 1.01])
    split("spike share of 15-min volume", "vshare", [0, 0.1, 0.2, 0.3, 0.5, 1.01])
    split("close position in the bar (0 low .. 1 high)", "pos", [0, 0.33, 0.66, 1.01])
    split("VWAP % at the buy", "vwap", [-99, 0, 0.5, 1, 1.5, 2, 99])
    split("over the open % at the buy", "open", [-99, 0, 1.5, 3, 99])
    split("time (min since 9:30)", "m", [0, 30, 60, 150, 270, 400])
    print("S2STUDY_DONE")


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