"""
star_live.py -- [2026-10-04] STAR FOLLOW, LIVE ENGINE for the Star bot (the user's design, 2026-10-04).

The trade bot's v2 entry rules only QUALIFY a stock (it is handed to Star for the rest of the day);
Star Follow decides the buy and the sell:

  LIBRARY   playbook library v3 (trade/data/playbook/library_v3.npz): 7 channels per minute
            P, W, X (price vs open / VWAP per ATR%, volume vs 14-day normal), SPY, IWM, GAP, FL (15-min
            net buy/sell flow). Only GOOD days (a confirmed buy mark: day_labels_confirmed.jsonl) and only
            days before today. Whole-day distance = mean over minutes 0..m of the squared channel
            differences (running sum, same as the backtests).
  SIMILAR   "90% similar" = distance <= (1 - similarity) x TYPICAL[m], where TYPICAL[m] is the median
            distance between two unrelated library days at that minute (precomputed).
  BUY       qualified by v2, >= min_refs (30) good days 90% similar, AND Star's buy signal among them:
            reference buy marks in the last 5 min >= max(min_buys, 2 x the normal rate x n refs).
            9:35-15:15. One position per stock; may buy again after a sell.
  SELL      sf3 "latest" rules (count mode): every finished minute count the good days still within
            the buy-time threshold (the 150th-closest distance at the buy). Fewer than 80 for 2 minutes:
            not climbing -> sell; climbing -> hold until a close breaks below the prior 5-minute low.
            While matching: sell on the references' sell signal (>= max(6, 2 x normal) among the 150
            closest). 15:55 sell-all by the bot. The v2 stop stays as an emergency floor (monitor.py).
"""
import json
import threading
from datetime import datetime
from pathlib import Path
from zoneinfo import ZoneInfo

import math
import numpy as np

ET = ZoneInfo("America/New_York")
N = 390
LIB = Path("/var/www/screener/trade/data/playbook/library_v3.npz")
MARKS = Path("/var/www/screener/trade/data/playbook/day_labels_confirmed.jsonl")
TYPICAL_CACHE = Path("/var/www/screener/trade/data/playbook/library_v3_typical.npy")

DEFAULTS = {
    "similarity": 0.90, "min_refs": 30, "min_buys": 3, "buy_ratio": 2.0, "win": 5,
    "first_buy_m": 5, "last_buy_m": 345,
    "k": 150, "min_match": 80, "out_min": 2, "sell_min_n": 6, "sell_ratio": 2.0,
    "flow_win": 15,
}


def minute_of(t):
    t = t.astimezone(ET)
    return (t.hour - 9) * 60 + t.minute - 30


class StarEngine:
    def __init__(self, cfg=None, today=None, log=None):
        self.c = {**DEFAULTS, **(cfg or {})}
        self.log = log
        self.today = str(today or datetime.now(ET).date())
        z = np.load(LIB, allow_pickle=True)
        keys = list(z["keys"])
        marks = {}
        for r in map(json.loads, open(MARKS)):
            mk = [(x["entry_m"], x["exit_m"]) for x in (r.get("buy"), r.get("leg2")) if x]
            if mk:
                marks[f"{r['date']}|{r['symbol']}"] = mk
        idx = [i for i, k in enumerate(keys) if k in marks and k.split("|")[0] < self.today]
        self.dates = np.array([keys[i].split("|")[0] for i in idx])
        self.block = np.zeros(len(idx))     # +inf for library days not usable (replays: days >= the replayed day)
        self.F = z["F"][idx]                                           # good days only
        self.keys = [keys[i] for i in idx]
        self.marks = [marks[k] for k in self.keys]
        del z
        n = len(self.keys)
        # per day and minute: a buy mark in the last `win` minutes / a sell of an earlier buy in that window
        W = self.c["win"]
        self.buy_win = np.zeros((n, N), bool); self.sell_win = np.zeros((n, N), bool)
        for i, mk in enumerate(self.marks):
            for bm, sm in mk:
                self.buy_win[i, max(bm, 0):min(bm + W, N)] = True
                for m in range(max(sm, 0), min(sm + W, N)):
                    if bm < m - W + 1:
                        self.sell_win[i, m] = True
        self.nb_rate = self.buy_win.mean(0)            # normal share of good days "buying" at minute m
        self.ns = self.sell_win.mean(0) * self.c["k"]  # normal sells among k references
        self.typical = self._typical()
        self.Fm = np.ascontiguousarray(self.F.transpose(1, 0, 2))      # (minute, day, channel) for fast updates
        del self.F
        self.state = {}
        self._lock = threading.Lock()
        if log:
            log.info(f"[STAR] library: {n} good days before {self.today}, {self.Fm.shape[2]} channels; "
                     f"typical distance 10:00 {self.typical[30]:.3f}, 12:00 {self.typical[150]:.3f}")

    # ------------------------------------------------------------------
    def _typical(self):
        if TYPICAL_CACHE.exists():
            return np.load(TYPICAL_CACHE)
        rng = np.random.default_rng(7)
        n = len(self.keys)
        a = rng.integers(0, n, 3000); b = rng.integers(0, n, 3000)
        d = ((self.F[a] - self.F[b]) ** 2).sum(2).cumsum(1) / np.arange(1, N + 1)
        t = np.median(d, axis=0).astype(np.float64)
        np.save(TYPICAL_CACHE, t)
        return t

    # ------------------------------------------------------------------
    @staticmethod
    def features(bars, ref, bench, flow, upto):
        """Feature rows for minutes 0..upto (finished minutes only), same formulas as lib_v2/lib_v3.
        bars: list of {"t","o","h","l","c","v"}; bench: (spy_bars, iwm_bars); flow: {minute: [buy, sell]}"""
        by = {}
        for b in bars:
            m = minute_of(b["t"])
            if 0 <= m <= upto:
                by[m] = b
        if not by:
            return None
        o = by[min(by)]["o"]
        atrp = ref["atr14"] / ref["prev_close"] * 100 if ref.get("atr14") and ref.get("prev_close") else 5.0
        gap = (o / ref["prev_close"] - 1) * 100 / atrp if ref.get("prev_close") else 0.0
        bpath = []
        for bb in bench:
            bmap = {minute_of(x["t"]): x for x in bb if 0 <= minute_of(x["t"]) <= upto}
            arr = np.zeros(upto + 1)
            if bmap:
                bo = bmap[min(bmap)]["o"]; last = bo
                for m in range(upto + 1):
                    if m in bmap:
                        last = bmap[m]["c"]
                    arr[m] = (last / bo - 1) * 100
            bpath.append(arr)
        buy = np.array([flow.get(m, (0, 0))[0] for m in range(upto + 1)], float)
        sell = np.array([flow.get(m, (0, 0))[1] for m in range(upto + 1)], float)
        W = DEFAULTS["flow_win"]
        bc, sc = np.cumsum(buy), np.cumsum(sell)
        bw = bc - np.concatenate([np.zeros(W), bc[:-W]])[:upto + 1] if upto + 1 > W else bc
        sw = sc - np.concatenate([np.zeros(W), sc[:-W]])[:upto + 1] if upto + 1 > W else sc
        fl = np.where(bw + sw > 0, (bw - sw) / np.maximum(bw + sw, 1e-9), 0.0)
        F = np.zeros((upto + 1, 7), np.float32)
        C = np.zeros(upto + 1); L = np.zeros(upto + 1)
        last, pv, cv = o, 0.0, 0.0
        for m in range(upto + 1):
            b = by.get(m); v = 0.0
            if b:
                L[m], last, v = b["l"], b["c"], b["v"]
                pv += (b["h"] + b["l"] + b["c"]) / 3 * v; cv += v
            else:
                L[m] = last
            C[m] = last
            vw = pv / cv if cv else last
            F[m] = ((last / o - 1) * 100 / atrp, (last / vw - 1) * 100 / atrp,
                    0.5 * math.log1p(v / max(ref["vol_per_min"][m], 1)), bpath[0][m], bpath[1][m] / 1.3, gap, fl[m])
        return F, C, L

    def update(self, symbol, bars, ref, bench, flow, now):
        """Add every newly finished minute to the symbol's running distance. Returns the last finished minute."""
        m_fin = min(minute_of(now) - 1, N - 1)
        if m_fin < 0 or ref is None:
            return None
        st = self.state.get(symbol)
        if st is None:
            st = self.state[symbol] = {"D": np.zeros(len(self.keys)), "m": -1, "pos": None, "qualified": False}
        if st["m"] >= m_fin:
            return m_fin
        out = self.features(bars, ref, bench, flow, m_fin)
        if out is None:
            return None
        F, C, L = out
        for m in range(st["m"] + 1, m_fin + 1):
            st["D"] += ((self.Fm[m] - F[m][None, :]) ** 2).sum(1)
        st["m"], st["C"], st["L"] = m_fin, C, L
        return m_fin

    def set_day(self, day):
        """Replays only: use library days before `day` and start fresh."""
        self.block = np.where(self.dates < str(day), 0.0, np.inf)
        self.state = {}

    # ------------------------------------------------------------------
    def similar(self, symbol):
        st = self.state[symbol]; m = st["m"]
        mean = st["D"] / (m + 1) + self.block
        mask = mean <= (1 - self.c["similarity"]) * self.typical[m]
        return mean, mask

    def buy_check(self, symbol):
        """-> (buy: bool, info dict) at the last finished minute"""
        st = self.state.get(symbol)
        if not st or st["m"] < self.c["first_buy_m"] or st["pos"] is not None:
            return False, {}
        m = st["m"]
        mean, mask = self.similar(symbol)
        n = int(mask.sum())
        buys = int(self.buy_win[mask, m].sum()) if n else 0
        need = max(self.c["min_buys"], math.ceil(self.c["buy_ratio"] * self.nb_rate[m] * n))
        info = {"m": m, "refs": n, "buys": buys, "need": need}
        ok = st["qualified"] and m <= self.c["last_buy_m"] and n >= self.c["min_refs"] and buys >= need
        return ok, info

    def open_position(self, symbol):
        st = self.state[symbol]; m = st["m"]
        mean = st["D"] / (m + 1) + self.block
        k = self.c["k"]
        thr = float(np.partition(mean, k)[k - 1])
        st["pos"] = {"m0": m, "thr": thr, "out": 0, "diverged": False, "climb": False}

    def close_position(self, symbol):
        if symbol in self.state:
            self.state[symbol]["pos"] = None

    def sell_check(self, symbol):
        """-> (sell: bool, reason) at the last finished minute (sf3 'latest' count-mode rules)"""
        st = self.state.get(symbol)
        if not st or not st["pos"]:
            return False, ""
        p, m = st["pos"], st["m"]
        if m <= p["m0"]:
            return False, ""
        if p.get("checked_m") == m:
            return False, ""
        p["checked_m"] = m
        mean = st["D"] / (m + 1) + self.block
        n_match = int((mean <= p["thr"]).sum())
        k = self.c["k"]
        near = np.argpartition(mean, k)[:k]
        sells = int(self.sell_win[near, m].sum())
        C, L = st["C"], st["L"]
        if not p["diverged"]:
            p["out"] = p["out"] + 1 if n_match < self.c["min_match"] else 0
            if p["out"] >= self.c["out_min"]:
                p["diverged"] = True
                if m >= 2 and C[m] > C[m - 2]:
                    p["climb"] = True
                    return False, ""
                return True, f"STAR: no longer matching ({n_match} refs), not climbing"
            if sells >= max(self.c["sell_min_n"], self.c["sell_ratio"] * self.ns[m]):
                return True, f"STAR: references sell ({sells} of {k})"
        elif p["climb"] and m >= 5 and C[m] < min(L[m - 5:m]):
            return True, "STAR: no longer matching, climb ended (close under the prior 5-min low)"
        return False, ""
