"""
flow_entry_5losers.py -- [2026-10-22] the user's new entry on the 5 big losers (PCG 9/1, DSP 9/18, AGEN 9/18, QTTB 9/28,
KD 10/1): from 9:30, once 5 bars are done, every minute look at the last 5 finished bars (b1 oldest .. b5 newest):
  volume increasing   mean volume of b4-b5 > mean of b1-b3
  buy share rising    buy share of b4-b5 > buy share of b1-b3, and >= 50%
  price rising        close b5 > close b3 > close b1
= SIGNAL. The buy is ALLOWED only if everything is clear:
  situations   S1, S2, S3 (in window), S6 (3%), S8 (5% room), S9 (prev close)   -- entry_situations.py, holds
  avoid rules  all 13 testable switches ON (avoid_rules.py; sec_avoid is live-only)
  do-not-trade A1 VWAP > 2%, A2 calm ATR < 8%, A3 RVOL so far < 1.5x, A4 not steady (smooth < 0.7 / straight < 0.5),
               A5 > 3% over the open, A6 falling on net selling, A7 after 14:30, A8 before 9:45, A9 heavy volume
               (15-min > 5x), A10 gap > 10%, A11 lower low by 10:30, A12 < 2,000 shares/min, A14 flat bars at the low,
               A15 re-buy under a losing buy (built into the replay), A17-A20 = S2/S3/S8/S9
               (A13 / A16 not computable here; spread not in the bar data)
Keeps trying every minute; exits = the bot's exit_v2 (2% min stop). v2's own decision is NOT used, only its numbers.
Also shown: the same signal with everything clear EXCEPT A2 (all 5 are calm stocks).
    nice -n 19 python3 flow_entry_5losers.py
"""
import gzip
import json
import sys
from collections import Counter
from pathlib import Path

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
import entry_situations as ES  # noqa: E402
import avoid_rules as AV  # noqa: E402
import logging  # noqa: E402
logging.getLogger("trade_bot.entry_situations").setLevel(logging.WARNING)

CASES = [("2026-09-01", "PCG"), ("2026-09-18", "DSP"), ("2026-09-18", "AGEN"), ("2026-09-28", "QTTB"), ("2026-10-01", "KD")]
SIT = {"S1_window_flip": {"enabled": True, "record_only": False}, "S2_spike_confirm": {"enabled": True, "record_only": False},
       "S3_block_print": {"enabled": True, "record_only": False, "mode": "while_in_window"},
       "S6_extended": {"enabled": True, "record_only": False, "mode": "pct", "max_pct": 3.0},
       "S8_resistance": {"enabled": True, "record_only": False, "mode": "pct", "min_room_pct": 5.0},
       "S9_prev_close": {"enabled": True, "record_only": False}}
AVC = {k: {"enabled": True} for k in AV.DEFAULTS if k != "sec_avoid"}
CTX = {}
_orig = R.entry_v2.evaluate


def hm(m):
    return f"{9 + (30 + m) // 60}:{(30 + m) % 60:02d}"


def signal(done, fb, fs, m):
    if len(done) < 5:
        return False
    b = done[-5:]
    v_old, v_new = sum(x["v"] for x in b[:3]) / 3, sum(x["v"] for x in b[3:]) / 2
    bo, so = sum(fb[m - 4:m - 1]), sum(fs[m - 4:m - 1]); bn, sn = sum(fb[m - 1:m + 1]), sum(fs[m - 1:m + 1])
    bs_old = bo / (bo + so) if bo + so else 0; bs_new = bn / (bn + sn) if bn + sn else 0
    return v_new > v_old and bs_new > bs_old and bs_new >= 0.5 and b[4]["c"] > b[2]["c"] > b[0]["c"]


def dnt(done, ref, mt, fb, fs, m):
    """do-not-trade checks that can be computed -> list of hit names"""
    h = []
    atrp = ref["atr14"] / ref["prev_close"] * 100 if ref.get("atr14") and ref.get("prev_close") else None
    if (mt.get("vwap_pct") or 0) > 2: h.append("A1 VWAP>2%")
    if atrp is not None and atrp < 8: h.append("A2 calm")
    if mt.get("rvol_sofar") is not None and mt["rvol_sofar"] < 1.5: h.append("A3 RVOL<1.5")
    if m + 1 < 15 or (mt.get("r2_15") is not None and mt["r2_15"] < 0.7) or (mt.get("eff15") is not None and mt["eff15"] < 0.5):
        h.append("A4 not steady")
    if (done[-1]["c"] / done[0]["o"] - 1) * 100 > 3: h.append("A5 >3% open")
    if m >= 15 and (done[-1]["c"] / done[-16]["c"] - 1) * 100 <= -1:
        b_, s_ = sum(fb[m - 14:m + 1]), sum(fs[m - 14:m + 1])
        if b_ + s_ and b_ / (b_ + s_) < 0.5: h.append("A6 net selling")
    if m + 1 >= 300: h.append("A7 after 14:30")
    if m + 1 < 15: h.append("A8 before 9:45")
    if (mt.get("vol15_x") or 0) > 5: h.append("A9 heavy volume")
    if ref.get("prev_close") and (done[0]["o"] / ref["prev_close"] - 1) * 100 > 10: h.append("A10 gap>10%")
    if m >= 60 and min(x["l"] for x in done[30:60]) < min(x["l"] for x in done[:30]): h.append("A11 lower low")
    if len(done) >= 15 and sum(x["v"] for x in done[-15:]) / 15 < 2000: h.append("A12 thin")
    lo30 = min(x["l"] for x in done[-30:])
    if sum(1 for x in done[-5:] if x["h"] == x["l"] and x["v"] > 0) >= 2 and done[-1]["c"] <= lo30 * 1.01: h.append("A14 flat at low")
    return h


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)
    m = R.minute(as_of) - 1; day = CTX["day"]; done = view[:-1]
    fb, fs = CTX["flow"]["buy"], CTX["flow"]["sell"]
    fm = {k: (fb[k], fs[k]) for k in range(0, m + 1)}
    mt = d.metrics
    ES.record(day, sym, m, mt, passed=bool(d.should_enter))
    d.should_enter = False
    if not signal(done, fb, fs, m):
        return d
    tags, det = ES.tag(day, sym, m, view, ref, mt, cfg=SIT, flow_by_min=fm)
    det["_flowm"] = fm
    held = [h.split(":")[0] for h in ES.check(day, sym, m, view, ref, mt, tags, det, cfg=SIT)] if len(done) >= 20 else []
    _, avh = AV.check(sym, view, ref, mt, m + 1, cfg=AVC, v2cfg=cfg, day=None, live=False)
    avh = ["AV " + x.split(":")[0] for x in avh]
    dn = dnt(done, ref, mt, fb, fs, m)
    blockers = held + avh + dn
    if CTX["mode"] == "none":
        blockers = []
    if CTX["mode"] == "noA2":
        blockers = [b for b in blockers if b not in ("A2 calm", "AV min_atr_pct")]
    CTX["sig"].append((m, blockers))
    if not blockers:
        st = (mt.get("stage3") or {}).get("stop")
        px = view[-1]["o"]
        mt["stage3"] = {**(mt.get("stage3") or {}), "stop": st if st and st < px * 0.98 else px * 0.98}
        d.should_enter = True
    return d


R.entry_v2.evaluate = wrapped


def main():
    cfg = R.get_config(); ecfg = {**(cfg.get("entry_v2") or {}), "confirm_checks": 1}; xcfg = {**(cfg.get("exit_v2") or {}), "enabled": True}
    tot = {"all": 0.0, "noA2": 0.0, "none": 0.0}
    for day, s in CASES:
        d = json.load(gzip.open(R.OW / "bars" / f"bars_{day}.json.gz", "rt")); ref = R.REF.load(day, s); bench = R.bench_pct(day)
        flow = json.loads((R.OW / "flow" / day / f"{s}.json").read_text())
        print(f"\n=== {day} {s}")
        for mode in ("all", "noA2", "none"):
            CTX.update(day=day, flow=flow, sig=[], mode=mode)
            for z in (ES._hist, ES._pending, ES._streak, ES._c3ep, ES._s1, ES._s2, ES._s3):
                z.clear()
            tr = R.run_stock(day, s, d["symbols"][s]["bars"], flow, ref, bench, ecfg, xcfg)
            pl = sum(x["pl"] + R.COST - 0.2 for x in tr); tot[mode] += pl
            sig = CTX["sig"]; clear = [m for m, b in sig if not b]
            cnt = Counter(b for _, bl in sig for b in bl)
            lab = {"all": "EVERYTHING must be clear", "noA2": "everything except A2 (calm stock)", "none": "signal only, NO filters"}[mode]
            print(f"  [{lab}] signals {len(sig)} (first {hm(sig[0][0] + 1) if sig else '-'}), all clear {len(clear)}"
                  + (f" at {', '.join(hm(m + 1) for m in clear[:6])}" if clear else ""))
            print(f"     trades: " + ("; ".join(f"buy {hm(x['buy_m'])} {x['buy']:.2f} -> {hm(x['sell_m'])} {x['sell']:.2f} {x['pl'] + R.COST - 0.2:+.2f}% [{x['why']}]" for x in tr) or "none")
                  + f" | total {pl:+.2f}%")
            print("     what blocked the signals (count of signal minutes): " + ", ".join(f"{k} {v}" for k, v in cnt.most_common(10)))
        R.REF._CACHE.clear()
    print(f"\nTOTAL 5 stock-days (sum of trade %, 0.2% cost): everything clear {tot['all']:+.2f}% | everything except A2 {tot['noA2']:+.2f}% | signal only, no filters {tot['none']:+.2f}%  "
          f"(the bot's v2 on these days: +0.41%; the 5 losing buys: -3.53%)")


if __name__ == "__main__":
    main()
