"""
star_replay.py -- [2026-10-04] Replay of the Star bot design on past days with the REAL star_live engine.
  - stocks: each day's 9:28 list (reports/open_window/tick20/cands) -- the live bot uses the top 50
  - qualification: the minute of v2's first buy signal per stock (every-signal tick replay,
    tick20/out/entry1002_live_<day>.out); Star may buy from the next minute
  - per minute: Star engine update (bars, SPY/IWM, buy/sell flow from reports/open_window/flow)
  - BUY at the next minute's open when Star says buy (>= min_refs good days 90% similar + buy signal)
  - SELL at the next minute's open on Star's sell; safety stop 1% below the buy (intrabar low); 15:55
  - 5 slots, $1,640 per trade, 0.1% cost. Library days before the replayed day only.
    python3 star_replay.py [--sim 0.9 --refs 30] [DAY ...]
"""
import argparse
import gzip
import json
import re
import sys
from datetime import datetime, timedelta, timezone
from pathlib import Path
from zoneinfo import ZoneInfo

import numpy as np

sys.path.insert(0, "/var/www/screener/premarket")
import star_live

ET = ZoneInfo("America/New_York")
OW = Path("/var/www/screener/trade/reports/open_window")
REFD = Path("/var/www/screener/trade/data/reference")
LINE = re.compile(r"\s+(\d\d):(\d\d):\d\d (\S+)\s+BUY")
SIZE, SLOTS, COST = 1640.0, 5, 0.1
STOP = 1.0


def rows_to_bars(rows):
    out = []
    for r in rows:
        t = r[0] if isinstance(r[0], datetime) else datetime.fromtimestamp(r[0], timezone.utc)
        out.append({"t": t, "o": r[1], "h": r[2], "l": r[3], "c": r[4], "v": r[5]})
    return out


def qualified(day):
    q = {}
    p = OW / "tick20/out" / f"entry1002_live_{day}.out"
    if p.exists():
        for l in open(p):
            g = LINE.match(l)
            if g:
                m = (int(g.group(1)) - 4) * 60 + int(g.group(2)) - 570
                q[g.group(3)] = min(q.get(g.group(3), 999), m)
    return q


def run_day(eng, day, log):
    d = json.load(gzip.open(OW / "bars" / f"bars_{day}.json.gz", "rt"))
    bj = OW / "bars" / f"bench_{day}.json.gz"
    bench = json.load(gzip.open(bj, "rt")) if bj.exists() else {}
    bench = (rows_to_bars(bench.get("SPY", [])), rows_to_bars(bench.get("IWM", [])))
    q = qualified(day)
    eng.set_day(day)
    syms = [s for s in d["top30_current"] if s in d["symbols"]]
    data = {}
    for s in syms:
        rp = REFD / day / f"{s}.json"
        fp = OW / "flow" / day / f"{s}.json"
        if not rp.exists() or not fp.exists():
            continue
        fl = json.loads(fp.read_text())
        bars = rows_to_bars(d["symbols"][s]["bars"])
        by = {star_live.minute_of(b["t"]): b for b in bars}
        data[s] = {"bars": bars, "by": by, "ref": json.loads(rp.read_text()),
                   "flow": {m: (fl["buy"][m], fl["sell"][m]) for m in range(390)}}
    d0 = datetime.fromisoformat(day).replace(tzinfo=ET)
    pos, trades, waits = {}, [], {}
    for m in range(0, 386):
        now = d0.replace(hour=9, minute=30) + timedelta(minutes=m + 1)    # minute m just finished
        nxt = m + 1
        for s, x in data.items():
            eng.update(s, [b for b in x["bars"] if star_live.minute_of(b["t"]) <= m], x["ref"],
                       tuple([b for b in bb if star_live.minute_of(b["t"]) <= m] for bb in bench), x["flow"], now)
            if s in q and m >= q[s] and s in eng.state:
                eng.state[s]["qualified"] = True
        # exits first (safety stop inside minute m, then Star's sell at the next open)
        for s in list(pos):
            p = pos[s]; b = data[s]["by"].get(m)
            if b and b["l"] <= p["stop"] and m >= p["buy_m"]:
                trades.append({**p, "sell_m": m, "sell": p["stop"], "why": "safety stop"}); del pos[s]
                eng.close_position(s); continue
            if m >= 385:
                last = [x for k, x in data[s]["by"].items() if k <= m]
                trades.append({**p, "sell_m": m, "sell": max(last, key=lambda x: x["t"])["c"] if last else p["buy"], "why": "15:55"})
                del pos[s]; continue
            sell, why = eng.sell_check(s)
            if sell and data[s]["by"].get(nxt):
                trades.append({**p, "sell_m": nxt, "sell": data[s]["by"][nxt]["o"], "why": why}); del pos[s]
                eng.close_position(s)
        if m >= 385:
            break
        for s in data:
            if s in pos or len(pos) >= SLOTS or s not in q or m < q[s]:
                continue
            ok, info = eng.buy_check(s)
            waits.setdefault(s, []).append(info.get("refs", 0))
            if ok and data[s]["by"].get(nxt):
                e = data[s]["by"][nxt]["o"]
                pos[s] = {"day": day, "sym": s, "buy_m": nxt, "buy": e, "stop": e * (1 - STOP / 100) if STOP else 0.0, "refs": info["refs"], "buys": info["buys"]}
                eng.open_position(s)
    for t in trades:
        t["pl"] = (t["sell"] / t["buy"] - 1) * 100 - COST
    qual = [s for s in q if s in data]
    reach = sum(1 for s in qual if max(waits.get(s, [0]) or [0]) >= eng.c["min_refs"])
    log(f"{day}: qualified {len(qual)}, reached {eng.c['min_refs']}+ similar refs {reach}, trades {len(trades)}, "
        f"${sum(t['pl'] for t in trades) * SIZE / 100:+.2f}")
    return trades, {"qualified": len(qual), "reached": reach,
                    "max_refs": {s: max(waits.get(s, [0]) or [0]) for s in qual}}


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("days", nargs="*")
    ap.add_argument("--sim", type=float, default=0.90)
    ap.add_argument("--refs", type=int, default=30)
    ap.add_argument("--stop", type=float, default=1.0, help="safety stop %% below the buy; 0 = none")
    a = ap.parse_args()
    global STOP
    STOP = a.stop
    days = a.days or sorted(p.name[15:25] for p in (OW / "tick20/out").glob("entry1002_live_*.out"))
    eng = star_live.StarEngine({"similarity": a.sim, "min_refs": a.refs}, today="2099-01-01")
    allT, stats = [], {}
    for day in days:
        T, st = run_day(eng, day, lambda x: print(x, flush=True))
        allT += T; stats[day] = st
    p = np.array([t["pl"] for t in allT]) if allT else np.zeros(1)
    half = days[len(days) // 2]
    h1 = sum(t["pl"] for t in allT if t["day"] < half) * SIZE / 100; h2 = sum(t["pl"] for t in allT if t["day"] >= half) * SIZE / 100
    print(f"\nSTAR BOT REPLAY sim {a.sim:.0%} refs>={a.refs} stop {a.stop:g}%: {len(allT)} trades, win {(p > 0).mean():.0%}, "
          f"total ${p.sum() * SIZE / 100:+.2f} (halves ${h1:+.0f} / ${h2:+.0f})")
    mr = [v for st in stats.values() for v in st["max_refs"].values()]
    if mr:
        print(f"qualified stocks: {len(mr)}; most similar refs reached per stock: median {np.median(mr):.0f}, "
              f">= {a.refs}: {sum(x >= a.refs for x in mr)}")
    for t in allT:
        print(f"  {t['day']} {t['sym']:5} buy m{t['buy_m']} {t['buy']:.2f} -> m{t['sell_m']} {t['sell']:.2f} "
              f"{t['pl']:+.2f}% [{t['why']}] refs {t['refs']}")
    json.dump({"trades": allT, "stats": stats}, open(f"/var/www/screener/premarket/data/star_replay_{int(a.sim * 100)}_{a.refs}_stop{a.stop:g}.json", "w"), default=float)


if __name__ == "__main__":
    main()
