"""
swings_study.py -- [2026-10-25] the user: group the 2 years' trades by EV3 entry setup; the ones no setup matches -> group them and
study one by one until the rules cover all pattern styles.
OPPORTUNITY ("trade") = an up-leg of >= RISE (3%) from a swing low (zigzag, 1.5% reversal) in the daily old-score top 30 (the trade
bot's list), 2024-10-01..2026-10-02, low before 15:00. Entry window = from 5 min before the low until 40% of the rise is done.
MATCHED = a setup trigger (buy minute = trigger bar + 1) inside the window: R1 R1A R3 R4 R5 R7 R8 R9 (setups_2y.jsonl), R1B
(giveback_2y.jsonl), R1C / R1D (live setting) / R1E (live setting) (queue_test.json).
Unmatched legs -> features at the low (finished bars up to the low) -> pattern groups.
    nice python3 swings_study.py -> swings.json + swings_report.log
"""
import gzip, json, sys
from collections import Counter, 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
OW = R.OW; RISE = 3.0; REV = 1.5


def zigzag(c):
    """up-legs (low_i, high_i) with a >= REV% reversal between legs"""
    legs = []; lo_i = hi_i = 0; up = None
    for i in range(1, len(c)):
        if up is None:
            if c[i] >= c[lo_i] * (1 + REV / 100): up = True; hi_i = i
            elif c[i] <= c[hi_i] * (1 - REV / 100): up = False; lo_i = i
            if c[i] < c[lo_i]: lo_i = i
            if c[i] > c[hi_i]: hi_i = i
            continue
        if up:
            if c[i] > c[hi_i]: hi_i = i
            elif c[i] <= c[hi_i] * (1 - REV / 100):
                legs.append((lo_i, hi_i)); up = False; lo_i = i
        else:
            if c[i] < c[lo_i]: lo_i = i
            elif c[i] >= c[lo_i] * (1 + REV / 100):
                up = True; hi_i = i
    if up:
        legs.append((lo_i, hi_i))
    return legs


def triggers():
    T = defaultdict(list)
    for l in open(HERE.parent / "playbook" / "setups_2y.jsonl"):
        t = json.loads(l)
        if t["setup"] in ("R1", "R1A", "R3", "R4", "R5", "R7", "R8", "R9"):
            T[(t["day"], t["sym"])].append((t["setup"], t["m"] + 1))
    for l in open(HERE.parent / "playbook" / "giveback_2y.jsonl"):
        t = json.loads(l)
        if t["setup"] == "R1B":
            T[(t["day"], t["sym"])].append(("R1B", t["m"] + 1))
    for r in json.load(open(HERE / "queue_test.json"))["B"]:
        if (r["setup"], r["var"]) in (("R1C", "def"), ("R1D", "u0.3x3.0a45"), ("R1E", "n8d10x1.5")):
            T[(r["day"], r["sym"])].append((r["setup"], r["m"] + 1))
    return T


def feats(b, M, fl, ref, a, legs_before):
    """readings at the swing low bar a (finished bars 0..a)"""
    done = b[:a + 1]; P = done[-1]["c"]; O = done[0]["o"]; m = M[a]
    pv = sum((x["h"] + x["l"] + x["c"]) / 3 * x["v"] for x in done); cv = sum(x["v"] for x in done); vw = pv / cv
    pc = ref.get("prev_close"); atr = ref.get("atr14")
    hi = max(x["h"] for x in done); lo = min(x["l"] for x in done)
    def bs(n):
        B = sum(fl["buy"][max(0, m - n + 1):m + 1]); S = sum(fl["sell"][max(0, m - n + 1):m + 1]); return B / (B + S) if B + S else None
    vpm = ref.get("vol_per_min") or []
    n15 = sum(vpm[max(0, m - 14):m + 1]) if len(vpm) > m else 0
    v15 = sum(x["v"] for x in done[-15:])
    rng = lambda w: (max(x["h"] for x in w) / min(x["l"] for x in w) - 1) * 100 if w else 0
    return {"m": m, "gap": (O / pc - 1) * 100 if pc else None, "vs_open": (P / O - 1) * 100, "vs_vwap": (P / vw - 1) * 100,
            "atr": atr / pc * 100 if pc and atr else None, "drop15": (P / done[max(0, a - 15)]["c"] - 1) * 100,
            "day_low": P <= lo * 1.002, "off_high": (P / hi - 1) * 100,
            "vs_prev_close": (P / pc - 1) * 100 if pc else None,
            "vs_prev_low": (P / ref["prev_low"] - 1) * 100 if ref.get("prev_low") else None,
            "vol15x": v15 / n15 if n15 else None, "bs5": bs(5), "bs15": bs(15),
            "range30": rng(done[-30:]), "legs_before": legs_before}


def group(f):
    """first matching pattern style (readable, ordered)"""
    m = f["m"]; g = f["gap"] or 0
    if m < 15 and f["vs_open"] <= -1.5:
        return "G1 opening flush low (first 15 min, >= 1.5% under the open)"
    if m < 15:
        return "G2 early dip (first 15 min, shallow)"
    if g <= -1 and f["vs_vwap"] < 0 and m < 120:
        return "G3 gap-down, low under VWAP before 11:30 (R10 family)"
    if f["vs_open"] >= 1 and abs(f["vs_vwap"]) <= 1 and f["day_low"] is False:
        return "G4 pullback to VWAP in an up-day (above the open)"
    if f["range30"] <= 1.5 and not f["day_low"]:
        return "G5 tight base (30-min range <= 1.5%), not at the day low"
    if f["day_low"] and f["drop15"] <= -2:
        return "G6 new day low after a fast drop (>= 2% in 15 min)"
    if f["day_low"]:
        return "G7 new day low, slow"
    if f["vs_vwap"] < -1:
        return "G8 higher low under VWAP"
    if m >= 240:
        return "G9 afternoon (after 13:30) other"
    return "G10 other mid-day"


def main():
    T = triggers(); legs_all = []
    for p in sorted(OW.glob("bars/bars_20*.json.gz")):
        day = p.name[5:15]
        if not ("2024-10-01" <= day <= "2026-10-02"):
            continue
        d = json.load(gzip.open(p, "rt"))
        for s in d["top30_current"]:
            fp = 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"):
                continue
            b = [x for x in R.bars_of(d["symbols"][s]["bars"]) if 0 <= R.minute(x["t"]) < 390]
            if len(b) < 100:
                continue
            M = [R.minute(x["t"]) for x in b]; c = [x["c"] for x in b]; fl = json.loads(fp.read_text())
            trig = T.get((day, s), [])
            for n_leg, (a, h) in enumerate(zigzag(c)):
                L, H = c[a], c[h]; rise = (H / L - 1) * 100
                if rise < RISE or M[a] >= 330:
                    continue
                w0 = M[a] - 5
                w1 = next((M[i] for i in range(a, h + 1) if c[i] >= L + 0.4 * (H - L)), M[h])
                hit = sorted({st for st, bm in trig if w0 <= bm <= w1})
                f = feats(b, M, fl, ref, a, n_leg)
                legs_all.append({"day": day, "sym": s, "low_m": M[a], "high_m": M[h], "rise": round(rise, 2), "dur": M[h] - M[a],
                                 "win_end": w1, "setups": hit, "group": group(f), **{k: (round(v, 3) if isinstance(v, float) else v) for k, v in f.items()}})
        R.REF._CACHE.clear(); del d
        print(day, len(legs_all), flush=True)
    json.dump(legs_all, open(HERE / "swings.json", "w"))
    report()


def report():
    X = json.load(open(HERE / "swings.json")); n = len(X)
    print(f"\n{n} rises >= {RISE}% in 2 years (old-score top 30), {len({(x['day'], x['sym']) for x in X})} stock-days; median rise "
          f"{np.median([x['rise'] for x in X]):.1f}%, median {np.median([x['dur'] for x in X]):.0f} min low->high")
    mt = [x for x in X if x["setups"]]
    print(f"MATCHED by at least one setup: {len(mt)} ({len(mt) / n:.0%});  unmatched {n - len(mt)} ({(n - len(mt)) / n:.0%})")
    c = Counter(s for x in mt for s in x["setups"])
    print("  per setup (rises it catches): " + ", ".join(f"{k} {v}" for k, v in c.most_common()))
    live = {"R1A", "R1D", "R3", "R4"}
    print(f"  caught by the LIVE setups (R1A R1D R3 R4): {sum(1 for x in X if live & set(x['setups']))} ({sum(1 for x in X if live & set(x['setups'])) / n:.0%})")
    print("\nALL rises by pattern group (n, share, median rise, caught by any setup / by live setups):")
    G = defaultdict(list)
    for x in X:
        G[x["group"]].append(x)
    for g in sorted(G, key=lambda k: -len(G[k])):
        Y = G[g]; any_ = sum(1 for x in Y if x["setups"]); lv = sum(1 for x in Y if live & set(x["setups"]))
        print(f"  {g:62} {len(Y):5} {len(Y) / n:4.0%}  rise {np.median([x['rise'] for x in Y]):4.1f}%  caught {any_ / len(Y):4.0%} / live {lv / len(Y):4.0%}"
              f"  | median time {9 + (30 + int(np.median([x['low_m'] for x in Y]))) // 60}:{(30 + int(np.median([x['low_m'] for x in Y]))) % 60:02d}"
              f" gap {np.median([x['gap'] or 0 for x in Y]):+.1f}% vwap {np.median([x['vs_vwap'] for x in Y]):+.1f}% bs15 {np.nanmedian([x['bs15'] if x['bs15'] is not None else np.nan for x in Y]):.2f}")
    print("\nUNMATCHED examples per group (biggest rises):")
    for g in sorted(G, key=lambda k: -len(G[k])):
        U = sorted([x for x in G[g] if not x["setups"]], key=lambda x: -x["rise"])[:4]
        print(f"  {g}: " + "; ".join(f"{x['sym']} {x['day']} {9 + (30 + x['low_m']) // 60}:{(30 + x['low_m']) % 60:02d} +{x['rise']:.1f}%" for x in U))
    print("SWINGS_DONE")


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