"""RotationWorker (ROT02): dual-momentum top-k risk-gated, ribilancio giornaliero.
Replica live di honest_improve2._rot_daily_equity (lookback 60, top_k 3, gross 0.45, SMA100 gate)."""
from __future__ import annotations

import json
from datetime import datetime, timezone
from pathlib import Path

import numpy as np
import pandas as pd

FEE_RT = 0.001


def _panel(data: dict, universe: list):
    """Allinea {asset: df} sui timestamp comuni -> (df_panel, cols presenti).

    Scarta la barra IN FORMAZIONE (riga -1 = candela in corso finche' non e'
    trascorsa la sua durata): ROT02/TSM01 valutavano momentum/regime e bookavano
    il return sulla barra 1d parziale al primo poll dopo mezzanotte UTC, poi
    last_bar_ts bloccava la rivalutazione a giorno chiuso. Stessa lezione EXIT-16
    gia' applicata a fade/TR01/Pairs (detection condivisa src.live.bars)."""
    from src.live.bars import last_bar_is_forming
    frames = {}
    for a in universe:
        df = data.get(a)
        if df is not None and len(df):
            frames[a] = df[["timestamp", "close"]].rename(columns={"close": a})
    if not frames:
        return None, []
    panel = None
    for a, f in frames.items():
        panel = f if panel is None else panel.merge(f, on="timestamp", how="inner")
    panel = panel.sort_values("timestamp").reset_index(drop=True)
    if len(panel) and last_bar_is_forming(panel["timestamp"].values):
        panel = panel.iloc[:-1].reset_index(drop=True)
    cols = [a for a in universe if a in frames]
    return panel, cols


def _warn_panel_short(worker_id: str, panel, cols: list, need: int,
                      last_bar_ts: int, already_warned: bool) -> bool:
    """WARN (log + Telegram) quando il panel inner-join e' troncato sotto il lookback
    richiesto e tick() salterebbe in SILENZIO (worker inerte senza segnale di vita).
    Gated su last_bar_ts != 0 ("era gia' operativo") per evitare falsi positivi al
    cold-start; una notifica per episodio. Ritorna il nuovo flag warned."""
    if not last_bar_ts:                       # mai stato operativo: cold-start, non un guasto
        return already_warned
    if already_warned:
        return True
    from src.live.telegram_notifier import notify_event
    got = 0 if panel is None else len(panel)
    msg = {"worker": worker_id, "panel_rows": got, "need": need,
           "assets": cols or "nessuno (BTC mancante?)"}
    print(f"  [{worker_id}] WARN panel corto: {got}/{need} righe — tick saltato")
    notify_event("PANEL_SHORT", msg)
    return True


class RotationWorker:
    def __init__(self, universe, lookback=60, top_k=3, gross=0.45, regime_n=100,
                 tf="1d", capital=1000.0, fee_rt=FEE_RT, name="ROT02_rot",
                 data_dir=Path("data/portfolio_paper")):
        self.universe = list(universe)
        self.lookback = lookback
        self.top_k = top_k
        self.gross = gross
        self.regime_n = regime_n
        self.tf = tf
        self.initial_capital = capital
        self.capital = capital
        self.fee_rt = fee_rt
        self.worker_id = f"{name}__{tf}"
        self.work_dir = Path(data_dir) / self.worker_id
        self.work_dir.mkdir(parents=True, exist_ok=True)
        self.status_path = self.work_dir / "status.json"
        self.trades_path = self.work_dir / "trades.jsonl"
        self.weights = {a: 0.0 for a in self.universe}
        self.last_bar_ts = 0
        self.in_position = False
        self._panel_warned = False   # dedup WARN panel corto (per episodio, non persistito)
        self._load()

    def _load(self):
        if self.status_path.exists():
            s = json.loads(self.status_path.read_text())
            self.capital = s.get("capital", self.capital)
            self.weights = {**{a: 0.0 for a in self.universe}, **s.get("weights", {})}
            self.last_bar_ts = s.get("last_bar_ts", 0)
        self.in_position = any(v > 0 for v in self.weights.values())

    def _save(self):
        self.status_path.write_text(json.dumps({
            "capital": round(self.capital, 2), "weights": self.weights,
            "in_position": self.in_position,      # per hourly_report (osservabilita')
            "last_bar_ts": self.last_bar_ts,
            "ts": datetime.now(timezone.utc).isoformat()}, indent=2))

    def tick(self, data: dict):
        need = max(self.lookback + 1, self.regime_n + 1)
        panel, cols = _panel(data, self.universe)
        if panel is None or len(panel) < need or "BTC" not in cols:
            self._panel_warned = _warn_panel_short(
                self.worker_id, panel, cols, need, self.last_bar_ts, self._panel_warned)
            return
        self._panel_warned = False
        P = panel[cols].values
        bar_ts = int(panel["timestamp"].iloc[-1])
        # 1) realizza il rendimento dei pesi correnti sull'ultima barra chiusa
        if self.last_bar_ts and bar_ts > self.last_bar_ts:
            day_ret = P[-1] / P[-2] - 1.0
            port_r = sum(self.weights.get(cols[k], 0.0) * day_ret[k] for k in range(len(cols)))
            self.capital = max(self.capital * (1.0 + float(port_r)), 10.0)
        # 2) ricalcola pesi target
        btc = P[:, cols.index("BTC")]
        bma = pd.Series(btc).rolling(self.regime_n).mean().values
        risk_on = btc[-1] > bma[-1] if not np.isnan(bma[-1]) else False
        mom = P[-1] / P[-1 - self.lookback] - 1.0
        order = np.argsort(mom)[::-1]
        chosen = [k for k in order if mom[k] > 0][: self.top_k] if risk_on else []
        nw = {a: 0.0 for a in self.universe}
        for k in chosen:
            nw[cols[k]] = self.gross / len(chosen)
        # 3) fee sul turnover
        turnover = sum(abs(nw[a] - self.weights.get(a, 0.0)) for a in self.universe)
        self.capital -= self.capital * turnover * (self.fee_rt / 2)
        if turnover > 0:
            self._log(nw, float(self.capital))
        self.weights = nw
        self.last_bar_ts = bar_ts
        self.in_position = any(v > 0 for v in nw.values())
        self._save()

    def _log(self, weights, cap):
        with open(self.trades_path, "a") as f:
            f.write(json.dumps({"ts": datetime.now(timezone.utc).isoformat(),
                                "weights": {a: round(w, 4) for a, w in weights.items() if w > 0},
                                "capital": round(cap, 2)}) + "\n")

    @property
    def status_summary(self):
        held = {a: round(w, 3) for a, w in self.weights.items() if w > 0}
        return f"{self.worker_id}: cap={self.capital:.0f} held={held}"
