"""ALT-OPT — la famiglia opzioni USDC-LINEARE di Deribit, mai guardata dal progetto (2026-08-22).

CONTESTO. Il filone VRP-QUOTE-VERE di questa stessa ondata ha trovato che `collect_chain.py`
interroga `{"currency": "BTC"|"ETH"}`, che su Deribit restituisce le sole opzioni INVERSE
(regolate in BTC/ETH). Il conto e' in USDC. Esiste accanto una famiglia USDC-LINEARE con lotti
molto piu' piccoli, e contando l'open interest sembra che su SOL/XRP/HYPE/AVAX sia molto piu'
popolata di BTC_USDC. Il progetto non l'ha mai misurata.

DOMANDA. Esiste su questa famiglia una struttura a RISCHIO DEFINITO (put credit spread, la stessa
geometria di VRP01: vendi ~-0.28, compri ~-0.10) eseguibile con qualche centinaio di dollari, con
spread e liquidita' che non se la mangino?

IPOTESI DICHIARATA PRIMA DI MISURARE: che il vincolo binding fosse la TAGLIA DEL LOTTO (e' cosi'
che il progetto ha sempre bocciato le opzioni: "BTC min 0.1 = $6.210/lotto -> FUORI a $3.000") e
che le famiglie alt, con lotti da poche decine di dollari, la superassero. Sbagliata due volte:
il lotto non e' il vincolo, e la classifica di liquidita' su cui poggia la domanda si ROVESCIA.

COSA MISURA, in ordine, fermandosi appena un vincolo la uccide:
  0. l'UNITA' dei contratti — due test empirici, perche' leggerla male sposta ogni cifra in
     dollari di un fattore 10-1000 (errore commesso nella prima stesura di questo file);
  1. i fatti del venue (min_trade_amount, tick_size, contract_size, $ di UN lotto);
  2. la liquidita' misurata in DUE modi che danno risposte opposte: open interest vs quote
     effettivamente presenti. E' il risultato principale del file;
  3. la struttura: delta REALIZZATI, credito eseguibile vs credito al mark, spread, fee, max-loss;
  4. il collaterale e quante strutture entrano in $635;
  5. quanto costerebbe raccogliere il dato (perche' il verdetto massimo qui e' LEAD).

COSA NON PUO' FARE, detto prima dei numeri: **non esiste un backtest possibile**. Il nostro
collettore raccoglie solo le inverse BTC/ETH e l'archivio ereditato pure: zero giorni di storia su
queste famiglie. Questo file misura UN ISTANTE.

VINCOLI DI PROGETTO CITATI, non aggirati:
  (a) "niente short-vol da modello in deploy" (19/06). Qui i prezzi sono VERI, non modellati —
      che e' un'altra cosa — ma la regola resta finche' non esiste un campione che contenga uno
      STRESS. Un istante di calma non e' un campione.
  (b) SOL e' escluso dall'universo DIREZIONALE per decisione dell'operatore del 22/08. Quella
      decisione riguarda TP01/SKH01 congelati come terza gamba di TREND, e il suo stesso testo
      dichiara che un meccanismo diverso la riapre; un put credit spread non e' direzionale in
      quel senso. Ma il guardrail sul DATO vale identico: nessun file nuovo in `data/raw/`, e i
      prezzi del sottostante qui vengono da `underlying_price` della catena, mai da `load_data`.
      (Nota: qui SOL non viene proposto — viene BOCCIATO, e sulla misura, non sulla decisione.)
  (c) il gate IV-rank>0.30 e' l'unico alpha misurato di VRP01 e su questi sottostanti NON e'
      calcolabile: non abbiamo un giorno di storia di vol implicita. Senza quel gate la struttura
      non e' VRP01, e' vendere vol a caso.

CONVENZIONE DI UNITA' (la trappola di questo file, verificata al §0): le opzioni INVERSE si
quotano in CRIPTO per contratto, le USDC-LINEARI in USDC per UNITA' DI SOTTOSTANTE; e
`min_trade_amount` e' in unita' di sottostante, NON in contratti — quindi non va moltiplicato per
`contract_size` (farlo gonfia XRP_USDC da $1.469 a $1.469.000 per lotto).

RETE: sole letture pubbliche, nessun ordine, pacing ~2 richieste/s, e il file SI RIFIUTA di
partire nella finestra :24-:29 (e' quando `cron_chain` usa lo stesso IP: il rate limit Deribit e'
per-IP e il progetto ha gia' avuto un guasto per questo, 29/07).

    nice -n 19 timeout 900 uv run python scripts/research/r0822_alt_options.py
    nice -n 19 timeout 900 uv run python scripts/research/r0822_alt_options.py --cache
"""
from __future__ import annotations

import argparse
import json
import math
import time
from datetime import UTC, datetime
from pathlib import Path

import numpy as np
import requests

API = "https://www.deribit.com/api/v2/public"
TIMEOUT = 20
RPS = 2.0
CACHE = Path("/tmp/claude-1001/-opt-docker-PythagorasGoal/"
             "b6cc75e7-14f8-4c32-bd07-ab8a0d2aaee6/scratchpad/altopt_cache.json")

SHORT_DELTA, LONG_DELTA = -0.28, -0.10      # la geometria di VRP01, non ri-scelta qui
DTE_LO, DTE_HI = 4.0, 45.0                  # dal settimanale di VRP01 (4-10) a ~1.5 mesi
OI_MIN = 100.0                              # la soglia che usa collect_chain.py, qui sotto esame
CAPITAL = 635.0                             # il conto vero
RISK_BUDGET = 0.20                          # quota di conto a rischio, per la capacita'
TAKER_CAP = 0.125                           # cap fee opzioni Deribit: 12.5% del premio

LINEAR = ("ETH_USDC", "BTC_USDC", "SOL_USDC", "XRP_USDC", "HYPE_USDC", "AVAX_USDC")
INVERSE = ("BTC", "ETH")                    # termine di paragone: il progetto le conosce
FAMS = LINEAR + INVERSE

# ---------------------------------------------------------------- rete (parca, sola lettura)


class Budget:
    def __init__(self, rps: float = RPS) -> None:
        self.rps, self._next, self.calls, self.err, self.r429 = rps, 0.0, 0, 0, 0

    def wait(self) -> None:
        now = time.monotonic()
        if now < self._next:
            time.sleep(self._next - now)
        self._next = max(now, self._next) + 1.0 / self.rps


def guardia_finestra() -> None:
    m = datetime.now(UTC).minute
    if 24 <= m <= 29:
        raise SystemExit(f"minuto {m}: finestra di cron_chain (:25-:29). Rilancia dopo il :30.")


def get(path: str, params: dict, b: Budget, tries: int = 3):
    for k in range(tries):
        b.wait()
        b.calls += 1
        try:
            r = requests.get(f"{API}/{path}", params=params, timeout=TIMEOUT)
        except Exception:
            b.err += 1
            time.sleep(1.5 * (k + 1))
            continue
        if r.status_code == 429:
            b.r429 += 1
            time.sleep(2.0 * (k + 1))
            continue
        if r.status_code != 200:
            b.err += 1
            time.sleep(1.0 * (k + 1))
            continue
        try:
            return r.json()["result"]
        except Exception:
            b.err += 1
            return None
    return None


def fetch_all(b: Budget) -> dict:
    """6 chiamate: instruments + book_summary per USDC, BTC, ETH. Niente per-strumento."""
    out = {}
    for cur in ("USDC", "BTC", "ETH"):
        out[f"inst_{cur}"] = get("get_instruments",
                                 {"currency": cur, "kind": "option", "expired": "false"}, b) or []
        out[f"summ_{cur}"] = get("get_book_summary_by_currency",
                                 {"currency": cur, "kind": "option"}, b) or []
    return out


# ---------------------------------------------------------------- Black-Scholes (r=0, come il sleeve)


def put_delta(S: float, K: float, T: float, sig: float) -> float:
    if not (S > 0 and K > 0 and T > 0 and sig > 0):
        return float("nan")
    d1 = (math.log(S / K) + 0.5 * sig * sig * T) / (sig * math.sqrt(T))
    return 0.5 * (1.0 + math.erf(d1 / math.sqrt(2.0))) - 1.0


# ---------------------------------------------------------------- unita'


def is_inv(fam: str) -> bool:
    return fam in INVERSE


def usd(price: float | None, r: dict) -> float:
    """Prezzo di UN LOTTO MINIMO, in dollari.

    Lineare: il prezzo e' gia' in USDC per unita' di sottostante -> x min_trade_amount.
    Inverse: il prezzo e' in CRIPTO per contratto -> x min_trade_amount x sottostante.
    `contract_size` NON entra: `min_trade_amount` e' gia' in unita' di sottostante (§0).
    """
    if price is None:
        return float("nan")
    return price * r["minamt"] * (r["S"] if is_inv(r["fam"]) else 1.0)


def loss_usd(Ks: float, Kl: float, r: dict) -> float:
    """Perdita massima strutturale, per un lotto minimo.

    Lineare: esatta, (Ks-Kl) x quantita'. Inverse: il payoff e' in cripto (max(0,K-S)/S), il caso
    peggiore e' a S=Kl e vale (Ks-Kl)/Kl cripto = (Ks-Kl) dollari A QUEL PREZZO -> stessa formula,
    ma APPROSSIMATA (il valore in dollari dipende da dove finisce S). Dichiarata, non nascosta.
    """
    return (Ks - Kl) * r["minamt"]


# ---------------------------------------------------------------- margine (FONTE SECONDARIA)


def im_short_put(S: float, K: float, mark_lot: float, r: dict) -> float:
    """Initial margin di una short put, in USDC, per UN LOTTO, formula PUBBLICATA da Deribit:
        IM = max(max(0.15 - OTM/S, 0.10), 0.075) x S  + mark    [per unita' di sottostante]

    ⚠️ FONTE SECONDARIA, dichiarata: l'API PUBBLICA non espone il margine. E il numero che decide
    davvero — se Deribit NETTA le due gambe di uno spread in margine standard — non e' leggibile
    da qui: si conferma con `private/get_margins`, che richiede una chiave (lettura, ma non
    pubblica) e quindi NON e' stato usato.
    """
    if not (S > 0 and K > 0):
        return float("nan")
    otm = max(0.0, S - K) / S                       # una put e' OTM quando K < S
    return max(max(0.15 - otm, 0.10), 0.075) * S * r["minamt"] + max(0.0, mark_lot)


# ---------------------------------------------------------------- vista


def build(raw: dict) -> list[dict]:
    inst, summ = {}, {}
    for cur in ("USDC", "BTC", "ETH"):
        for i in raw.get(f"inst_{cur}") or []:
            inst[i["instrument_name"]] = i
        for s in raw.get(f"summ_{cur}") or []:
            summ[s["instrument_name"]] = s
    rows, now_ms = [], datetime.now(UTC).timestamp() * 1000.0
    for name, i in inst.items():
        s = summ.get(name)
        if s is None:
            continue
        fam = name.split("-")[0]
        dte = (float(i.get("expiration_timestamp") or 0) - now_ms) / 86400_000.0
        bid, ask = s.get("bid_price"), s.get("ask_price")
        bid = float(bid) if bid else None            # Deribit manda 0/None per "nessun lato"
        ask = float(ask) if ask else None
        iv, S = s.get("mark_iv"), s.get("underlying_price")
        K, T = float(i.get("strike") or 0), max(dte, 0.0) / 365.25
        typ = "P" if i.get("option_type") == "put" else "C"
        rows.append(dict(
            name=name, fam=fam, typ=typ, K=K, dte=dte, S=float(S) if S else float("nan"),
            iv=float(iv) if iv else float("nan"),
            delta=(put_delta(float(S), K, T, float(iv) / 100.0)
                   if (S and iv and K and T > 0 and typ == "P") else float("nan")),
            bid=bid, ask=ask, mid=((bid + ask) / 2 if (bid and ask) else None),
            mark=float(s.get("mark_price") or 0.0),
            oi=float(s.get("open_interest") or 0.0), vol=float(s.get("volume") or 0.0),
            vol_usd=float(s.get("volume_usd") or 0.0),
            tick=float(i.get("tick_size") or 0.0), minamt=float(i.get("min_trade_amount") or 0.0),
            csize=float(i.get("contract_size") or 0.0),
            blockmin=float(i.get("block_trade_min_trade_amount") or 0.0),
            taker=float(i.get("taker_commission") or 0.0003), settle=i.get("settlement_currency"),
        ))
    return rows


def rel_spread(r: dict) -> float:
    if r["bid"] is None or r["ask"] is None or not r["mid"]:
        return float("nan")
    return (r["ask"] - r["bid"]) / r["mid"]


# ---------------------------------------------------------------- §0 le unita'


def unita(rows: list[dict], b: Budget, rete: bool) -> None:
    print("\n" + "=" * 104)
    print("0. L'UNITA' DEI CONTRATTI — due test empirici, prima di qualunque cifra in dollari")
    print("=" * 104)
    print("  Test 1 (dai dati gia' scaricati): `volume_usd / (volume x mark_price)`.")
    print("  = 1 se `volume` e' in UNITA' DI SOTTOSTANTE; = contract_size se e' in CONTRATTI;")
    print("  = prezzo del sottostante se il mark e' in cripto (inverse).")
    print(f"\n  {'famiglia':<10} {'n oss':>6} {'vol_usd/(vol*mark)':>20} {'c_size':>8} "
          f"{'sottost.':>10} {'lettura':>26}")
    for f in FAMS:
        rr = [r for r in rows if r["fam"] == f and r["vol"] > 0 and r["mark"] > 0]
        if not rr:
            continue
        q = float(np.median([r["vol_usd"] / (r["vol"] * r["mark"]) for r in rr]))
        cs, S = rr[0]["csize"], float(np.nanmedian([r["S"] for r in rr]))
        if abs(q - 1.0) < 0.35:
            lettura = "unita' di sottostante"
        elif abs(q - cs) / max(cs, 1) < 0.35:
            lettura = "CONTRATTI"
        elif abs(q - S) / max(S, 1) < 0.35:
            lettura = "cripto/contratto (inverse)"
        else:
            lettura = "?? non concludente"
        print(f"  {f:<10} {len(rr):>6} {q:>20.4f} {cs:>8g} {S:>10.2f} {lettura:>26}")

    if not rete:
        print("\n  Test 2 (size minima nel book): non girato (--cache non usa la rete).")
        return
    print("\n  Test 2 (rete): la size MINIMA presente nel book. Se compare esattamente")
    print("  `min_trade_amount`, allora e' quello il lotto minimo IN UNITA' DI SOTTOSTANTE.")
    print(f"\n  {'famiglia':<10} {'min_amt':>9} {'c_size':>8} {'min size vista':>15} "
          f"{'libri':>6} {'verdetto':>12}")
    for f in LINEAR:
        cand = sorted([r for r in rows if r["fam"] == f and (r["bid"] or r["ask"])],
                      key=lambda r: -r["oi"])[:4]
        sizes, nb = [], 0
        for r in cand:
            ob = get("get_order_book", {"instrument_name": r["name"], "depth": 10}, b)
            if not ob:
                continue
            nb += 1
            for side in ("bids", "asks"):
                sizes += [float(l[1]) for l in (ob.get(side) or [])]
        if not sizes:
            continue
        mn, ma, cs = min(sizes), cand[0]["minamt"], cand[0]["csize"]
        v = "confermato" if abs(mn - ma) < 1e-9 else ("CONTRATTI" if abs(mn - ma * cs) < 1e-9
                                                      else "non concl.")
        print(f"  {f:<10} {ma:>9g} {cs:>8g} {mn:>15g} {nb:>6} {v:>12}")
    print("\n  ⚠️ Errore commesso e corretto in sessione: la prima stesura moltiplicava")
    print("  min_trade_amount x contract_size, e dava XRP_USDC a $1.468.900 di nozionale per")
    print("  lotto. Un numero assurdo e' un test: nessun venue retail quota un minimo da $1,5M.")


# ---------------------------------------------------------------- §1 fatti del venue


def famiglie(rows: list[dict]) -> dict:
    print("\n" + "=" * 104)
    print("1. I FATTI DEL VENUE — public/get_instruments + get_book_summary_by_currency")
    print("=" * 104)
    print(f"{'famiglia':<10} {'strum':>6} {'min_amt':>9} {'c_size':>7} {'tick':>9} "
          f"{'sottost.$':>11} {'$/lotto':>9} {'taker':>7} {'settle':>7}")
    tab = {}
    for f in FAMS:
        sub = [r for r in rows if r["fam"] == f]
        if not sub:
            continue
        S = float(np.nanmedian([r["S"] for r in sub]))
        a = sub[0]
        tab[f] = dict(n=len(sub), minamt=a["minamt"], csize=a["csize"], tick=a["tick"], S=S,
                      lot=a["minamt"] * S, taker=a["taker"],
                      nliq=sum(1 for r in sub if r["oi"] >= OI_MIN))
        print(f"{f:<10} {len(sub):>6} {a['minamt']:>9.4g} {a['csize']:>7.4g} {a['tick']:>9.5g} "
              f"{S:>11.2f} {tab[f]['lot']:>9.2f} {a['taker']:>7.4g} {str(a['settle']):>7}")
    print("\n  `$/lotto` = min_trade_amount x sottostante = il NOZIONALE di un lotto (NON il premio,")
    print("  che e' molto minore). E' la granularita' minima imposta dal venue.")
    print("  `taker` per le opzioni Deribit e' una frazione del SOTTOSTANTE con cap al 12.5% del")
    print("  premio: sull'ala molto OTM morde il CAP, non la percentuale.")
    print("  📌 Il lotto minimo NON e' il vincolo: da $242 (ETH_USDC) a $1.469 (XRP_USDC), contro")
    print("  i $7.738 di BTC inverse su cui il progetto aveva costruito il muro delle opzioni.")
    return tab


# ---------------------------------------------------------------- §2 liquidita', due modi


def liquidita(rows: list[dict], tab: dict) -> None:
    print("\n" + "=" * 104)
    print("2. LA LIQUIDITA', MISURATA IN DUE MODI CHE DANNO RISPOSTE OPPOSTE")
    print("=" * 104)
    print("  A) open interest >= 100 = quante POSIZIONI sono aperte (il filtro che usa")
    print("     `collect_chain.py`, ereditato da bite, e la misura su cui poggia la domanda).")
    print("  B) quote a DUE LATI presenti adesso = quanti strumenti sono NEGOZIABILI a un prezzo")
    print("     noto. Sui soli put nella finestra 4-45 giorni, cioe' dove vive la struttura.")
    print(f"\n{'famiglia':<10} {'A: OI>=100':>11} {'rango A':>8} {'put 4-45g':>10} "
          f"{'B: 2 lati':>10} {'% quotati':>10} {'rango B':>8}")
    stat = {}
    for f in FAMS:
        puts = [r for r in rows if r["fam"] == f and r["typ"] == "P" and DTE_LO <= r["dte"] <= DTE_HI]
        two = [r for r in puts if r["bid"] is not None and r["ask"] is not None]
        stat[f] = dict(oi=tab[f]["nliq"], puts=len(puts), two=len(two),
                       pct=(len(two) / len(puts) if puts else float("nan")))
    rA = {f: i + 1 for i, f in enumerate(sorted(stat, key=lambda x: -stat[x]["oi"]))}
    rB = {f: i + 1 for i, f in enumerate(sorted(stat, key=lambda x: -stat[x]["pct"]))}
    for f in sorted(FAMS, key=lambda x: -stat[x]["oi"]):
        s = stat[f]
        print(f"{f:<10} {s['oi']:>11} {rA[f]:>8} {s['puts']:>10} {s['two']:>10} "
              f"{s['pct']:>9.0%} {rB[f]:>8}")
    # la correlazione di rango si CALCOLA, non si racconta: sulle sole famiglie lineari,
    # cioe' quelle su cui la domanda del filone e' stata posta.
    a = np.array([rA[f] for f in LINEAR], float)
    c = np.array([rB[f] for f in LINEAR], float)
    rho = float(np.corrcoef(a, c)[0, 1])
    print(f"\n  📌 LA CLASSIFICA SI ROVESCIA. Correlazione di rango fra i due criteri sulle sei")
    print(f"  famiglie lineari: {rho:+.2f}. SOL_USDC e' 1ª per open interest fra le lineari e")
    print("  ULTIMA di tutte per quote presenti; BTC_USDC, dichiarato 'praticamente morto' (5")
    print("  strumenti con OI>=100), ha quasi tutti i put quotati a due lati. L'open interest")
    print("  misura posizioni ACCUMULATE,")
    print("  non la possibilita' di negoziare ADESSO — e sull'universo lineare le due cose non")
    print("  hanno quasi nulla a che vedere.")
    print("  ⚠️ Ricaduta sul codice di produzione: `collect_chain.py` prefiltra a OI>=100. Sulle")
    print("  inverse non fa danno (sono quotate comunque), ma NON e' un filtro di liquidita' e il")
    print("  suo nome lo lascia credere. 4ª occorrenza di 'una riga presente non e' un dato")
    print("  presente' — qui in versione: 'una posizione aperta non e' un prezzo negoziabile'.")

    print("\n" + "-" * 104)
    print("2b. E ALLORA DOV'E' LA LIQUIDITA' CHE SI VEDE NEL VOLUME? Nel mercato a BLOCCHI,")
    print("    che ha un minimo d'ordine suo — e non e' raggiungibile con $635.")
    print("-" * 104)
    print(f"{'famiglia':<10} {'con volume 24h':>15} {'volume 24h $':>14} {'blocco min':>11} "
          f"{'blocco min $':>13} {'x il conto':>11}")
    for f in FAMS:
        sub = [r for r in rows if r["fam"] == f]
        if not sub:
            continue
        nv = sum(1 for r in sub if r["vol"] > 0)
        vusd = sum(r["vol_usd"] for r in sub)
        bm = sub[0]["blockmin"]
        bm_usd = bm * tab[f]["S"] * (1.0 if not is_inv(f) else 1.0)
        print(f"{f:<10} {nv:>15} {vusd:>14,.0f} {bm:>11g} {bm_usd:>13,.0f} "
              f"{bm_usd/CAPITAL:>10.0f}x")
    print("\n  📌 SOL_USDC ha molti piu' strumenti con volume nelle ultime 24h che quotati a due")
    print("  lati: quelle opzioni si negoziano, ma via blocchi/RFQ. Il minimo di blocco e' un")
    print("  fatto del venue, non un'opinione, e a $635 e' fuori portata di due ordini di")
    print("  grandezza. **Non si conclude che il mercato alt non esista: si conclude che la parte")
    print("  a cui questo conto ha accesso — il book continuo — e' quella sottile.**")


# ---------------------------------------------------------------- §3 la struttura


def scegli(rows: list[dict], fam: str, eseguibile: bool) -> list[dict]:
    """Per ogni scadenza: la put piu' vicina a -0.28 (corta) e a -0.10 (lunga).

    `eseguibile=False` -> fra TUTTI gli strike (la struttura che si vorrebbe).
    `eseguibile=True`  -> solo fra gli strike che hanno il LATO che serve: per APRIRE bisogna
                          vendere la corta al BID e comprare l'ala all'ASK. E' una restrizione
                          asimmetrica, ed e' quella giusta: un book a un lato solo non e' un
                          book vuoto, e' un book che serve solo una direzione.
    """
    puts = [r for r in rows if r["fam"] == fam and r["typ"] == "P"
            and DTE_LO <= r["dte"] <= DTE_HI and np.isfinite(r["delta"])]
    out = []
    for e in sorted({round(r["dte"], 4) for r in puts}):
        g = [r for r in puts if round(r["dte"], 4) == e]
        gs = [r for r in g if r["bid"] is not None] if eseguibile else g
        gl = [r for r in g if r["ask"] is not None] if eseguibile else g
        if not gs or not gl:
            continue
        s = min(gs, key=lambda r: abs(r["delta"] - SHORT_DELTA))
        lo = min(gl, key=lambda r: abs(r["delta"] - LONG_DELTA))
        if s["K"] > lo["K"]:
            out.append({"dte": e, "short": s, "long": lo, "n": len(g)})
    return out


def fee_lotto(r: dict) -> float:
    """Fee taker di UNA gamba, un lotto: min(0.03% del nozionale, 12.5% del premio)."""
    return min(r["taker"] * r["S"] * r["minamt"], TAKER_CAP * usd(r["mark"], r))


def struttura(rows: list[dict]) -> dict:
    print("\n" + "=" * 104)
    print(f"3. LA STRUTTURA — put credit spread {SHORT_DELTA}/{LONG_DELTA}, finestra "
          f"{DTE_LO:.0f}-{DTE_HI:.0f} giorni, per UN LOTTO MINIMO")
    print("=" * 104)
    print("  `f_venue` = (bid_corta - ask_ala) / (mark_corta - mark_ala) = quanta parte del")
    print("  credito che il venue stesso considera equo resta dopo aver attraversato lo spread.")
    print("  E' il gemello del `f` misurato dal progetto il 30/07 (0,73 = errore del MODELLO):")
    print("  qui il modello non c'entra, il riferimento e' il mark del venue.")
    print(f"\n{'famiglia':<10} {'scad':>4} {'d corta':>8} {'d ala':>7} {'spr% corta':>11} "
          f"{'spr% ala':>9} {'cred mark$':>11} {'cred eseg$':>11} {'f_venue':>8} "
          f"{'fee/cred':>9} {'maxloss$':>9}")
    res = {}
    for f in FAMS:
        gg = scegli(rows, f, eseguibile=True)
        if not gg:
            print(f"{f:<10} {'0':>4}   nessuna scadenza con corta-bid E ala-ask presenti")
            continue
        acc = {k: [] for k in ("ds", "dl", "ss", "sl", "cm", "ce", "fee", "ml")}
        for g in gg:
            s, lo = g["short"], g["long"]
            cm = usd(s["mark"], s) - usd(lo["mark"], lo)
            ce = usd(s["bid"], s) - usd(lo["ask"], lo)
            if cm <= 0:
                continue
            acc["ds"].append(s["delta"]); acc["dl"].append(lo["delta"])
            acc["ss"].append(rel_spread(s)); acc["sl"].append(rel_spread(lo))
            acc["cm"].append(cm); acc["ce"].append(ce)
            acc["fee"].append(2.0 * (fee_lotto(s) + fee_lotto(lo)) / cm)
            acc["ml"].append(loss_usd(s["K"], lo["K"], s) - ce)
        if not acc["cm"]:
            print(f"{f:<10} {len(gg):>4}   nessuna struttura con credito positivo al mark")
            continue
        m = {k: float(np.nanmedian(v)) if v else float("nan") for k, v in acc.items()}
        m["fv"] = float(np.median([e / c for e, c in zip(acc["ce"], acc["cm"])]))
        m["n"] = len(acc["cm"])
        res[f] = m
        print(f"{f:<10} {m['n']:>4} {m['ds']:>8.3f} {m['dl']:>7.3f} {m['ss']*100:>10.1f}% "
              f"{m['sl']*100:>8.1f}% {m['cm']:>11.2f} {m['ce']:>11.2f} {m['fv']:>8.3f} "
              f"{m['fee']*100:>8.1f}% {m['ml']:>9.2f}")
    print("\n  ⚠️ `spr%` puo' essere NaN quando la gamba ha un lato solo: e' negoziabile per")
    print("  aprire (il lato che serve c'e') ma non ha un mid, quindi non ha uno spread definito.")
    print("  `fee/cred` = 2 gambe x (apertura + chiusura) col cap 12.5%. VRP01 tiene FINO A")
    print("  SCADENZA (nessuna gestione infra-settimana, il profit-take e' REFUTED il 30/07),")
    print("  quindi il costo realistico e' ~la META' di questa colonna + la delivery fee.")

    print(f"\n  --- controllo: gli STESSI strike scelti fra TUTTI gli strike (non solo quotati) ---")
    print(f"  {'famiglia':<10} {'ideale d corta':>15} {'eseg. d corta':>14} {'ideale d ala':>13} "
          f"{'eseg. d ala':>12} {'scad ideali':>12} {'scad eseg.':>11}")
    for f in FAMS:
        gi, ge = scegli(rows, f, False), scegli(rows, f, True)
        if not gi:
            continue
        di = float(np.median([g["short"]["delta"] for g in gi]))
        li = float(np.median([g["long"]["delta"] for g in gi]))
        de = float(np.median([g["short"]["delta"] for g in ge])) if ge else float("nan")
        le = float(np.median([g["long"]["delta"] for g in ge])) if ge else float("nan")
        print(f"  {f:<10} {di:>15.3f} {de:>14.3f} {li:>13.3f} {le:>12.3f} "
              f"{len(gi):>12} {len(ge):>11}")
    print("  Se la colonna `eseg.` si allontana dal target -0.28/-0.10, la struttura che si")
    print("  comprerebbe NON e' quella richiesta: la griglia degli strike quotati la deforma.")

    print("\n  --- CONTROLLO POSITIVO: questo snapshot e' di SABATO. E' atipico? ---")
    print("  Non posso aspettare una settimana, ma posso puntare lo stesso strumento su una")
    print("  grandezza che il progetto ha GIA' misurato su 19 settimane di giorni feriali:")
    print("  attraversare lo spread sul canonico BTC/ETH inverse costa ~10% del credito (30/07).")
    for f in INVERSE:
        if f in res:
            print(f"    {f:<4} inverse: costo di attraversamento oggi = "
                  f"{(1-res[f]['fv'])*100:5.1f}% del credito  (atteso ~10%)")
    print("  Se coincide, il sabato non sta degradando i book che il progetto conosce, e la")
    print("  lettura sulle famiglie nuove non e' un artefatto del giorno. **E' un controllo")
    print("  debole** (una grandezza sola, un istante), non una prova di tipicita'.")
    robustezza_dte(rows)
    return res


def robustezza_dte(rows: list[dict]) -> None:
    """L'UNICO grado di liberta' di questo file, esposto invece che nascosto.

    VRP01 e' settimanale (tenor 7g, finestra 4-10). Qui la finestra e' stata allargata a 4-45
    per dare piu' scadenze alle famiglie alt, che ne hanno poche. Allargare una finestra e'
    una scelta, e una scelta va misurata: se la conclusione dipendesse da essa, sarebbe la
    conclusione a essere stata scelta.
    """
    global DTE_HI
    print("\n  --- ROBUSTEZZA: la finestra DTE e' il mio unico grado di liberta' ---")
    print(f"  {'famiglia':<10} {'finestra':>9} {'scad':>5} {'f_venue':>8} {'spr% corta':>11} "
          f"{'cred eseg$':>11} {'maxloss$':>9}")
    orig = DTE_HI
    try:
        for hi in (10.0, 45.0):
            DTE_HI = hi
            for f in FAMS:
                gg = scegli(rows, f, eseguibile=True)
                fv, ss, ce, ml = [], [], [], []
                for g in gg:
                    s, lo = g["short"], g["long"]
                    cm = usd(s["mark"], s) - usd(lo["mark"], lo)
                    c = usd(s["bid"], s) - usd(lo["ask"], lo)
                    if cm <= 0:
                        continue
                    fv.append(c / cm); ss.append(rel_spread(s)); ce.append(c)
                    ml.append(loss_usd(s["K"], lo["K"], s) - c)
                w = f"{DTE_LO:.0f}-{hi:.0f}g"
                if not fv:
                    print(f"  {f:<10} {w:>9} {len(gg):>5} {'n/d':>8}")
                    continue
                print(f"  {f:<10} {w:>9} {len(fv):>5} {np.median(fv):>8.3f} "
                      f"{np.nanmedian(ss)*100:>10.1f}% {np.median(ce):>11.2f} "
                      f"{np.median(ml):>9.2f}")
            print()
    finally:
        DTE_HI = orig
    print("  📌 Da leggere sull'ORDINE, non sulla terza cifra: le quote si muovono fra un giro e")
    print("  l'altro (su tre snapshot a pochi minuti ETH_USDC ha dato 0.947-0.983, le inverse")
    print("  0.847-0.942, le alt 0.79-0.87, SOL sempre negativo). Cio' che NON si muove e' la")
    print("  graduatoria, e alla finestra VERA di VRP01 (4-10g) e' piu' netta, non meno.")


def profondita(rows: list[dict], fams: list[str], b: Budget) -> None:
    print("\n" + "=" * 104)
    print("3b. PROFONDITA' IN CIMA AL BOOK (public/get_order_book depth=5) sulle gambe scelte")
    print("=" * 104)
    print(f"{'famiglia':<10} {'gamba':<6} {'n':>3} {'lotti al best':>14} {'$ premio al best':>17} "
          f"{'prezzo/tick':>12} {'max|d venue-BS|':>17}")
    for f in fams:
        gg = scegli(rows, f, eseguibile=True)[:4]        # max 4 scadenze: budget di rete
        for lato, key, side in (("corta", "short", "bids"), ("ala", "long", "asks")):
            lots, prem, tk, dd = [], [], [], []
            for g in gg:
                r = g[key]
                ob = get("get_order_book", {"instrument_name": r["name"], "depth": 5}, b)
                if not ob or not (ob.get(side) or []):
                    continue
                px, sz = float(ob[side][0][0]), float(ob[side][0][1])
                lots.append(sz / r["minamt"] if r["minamt"] else float("nan"))
                prem.append(usd(px, r) * (sz / max(r["minamt"], 1e-12)))
                if r["tick"]:
                    tk.append(px / r["tick"])
                gv = (ob.get("greeks") or {}).get("delta")
                if gv is not None and np.isfinite(r["delta"]):
                    dd.append(abs(float(gv) - r["delta"]))
            if not lots:
                print(f"{f:<10} {lato:<6} {'0':>3}   book vuoto sul lato che serve")
                continue
            print(f"{f:<10} {lato:<6} {len(lots):>3} {np.median(lots):>14.1f} "
                  f"{np.median(prem):>17.2f} {(np.median(tk) if tk else float('nan')):>12.1f} "
                  f"{(max(dd) if dd else float('nan')):>17.4f}")
    print("\n  `lotti al best` = size in cima al book / lotto minimo: quante strutture minime")
    print("  entrano senza muovere il prezzo. `prezzo/tick` e' il controllo d'artefatto del")
    print("  30/07: un prezzo a 1-2 tick e' una griglia, non un prezzo.")
    print("  `max|d venue-BS|` valida il MIO delta contro le greche del venue: se non e' piccolo,")
    print("  tutta la selezione degli strike qui sopra e' sbagliata.")


# ---------------------------------------------------------------- §4 collaterale e capacita'


def collaterale(rows: list[dict], res: dict) -> None:
    print("\n" + "=" * 104)
    print(f"4. COLLATERALE E CAPACITA' — conto reale ${CAPITAL:.0f}")
    print("=" * 104)
    print(f"{'famiglia':<10} {'IM corta+ala$':>14} {'max-loss$':>10} {'n @IM':>7} "
          f"{'n @maxloss':>11} {'n a budget 20%':>15} {'credito lordo$':>15}")
    for f, m in res.items():
        gg = scegli(rows, f, eseguibile=True)
        ims = []
        for g in gg:
            s, lo = g["short"], g["long"]
            if lo["ask"] is None:
                continue
            ims.append(im_short_put(s["S"], s["K"], usd(s["mark"], s), s) + usd(lo["ask"], lo))
        if not ims:
            continue
        im, ml = float(np.median(ims)), m["ml"]
        n_budget = math.floor(RISK_BUDGET * CAPITAL / ml) if ml > 0 else 0
        print(f"{f:<10} {im:>14.2f} {ml:>10.2f} {CAPITAL/im:>7.1f} {CAPITAL/ml:>11.1f} "
              f"{n_budget:>15} {n_budget*m['ce']:>15.2f}")
    print("\n  `IM corta+ala` = margine iniziale della sola put venduta (formula PUBBLICATA dal")
    print("  venue, FONTE SECONDARIA) + il premio dell'ala, che si paga in contanti = il")
    print("  fabbisogno se il venue NON netta le gambe. `max-loss` = il fabbisogno se LE NETTA.")
    print("  ⚠️ Quale dei due valga NON e' leggibile dall'API pubblica: si chiude con")
    print("  `private/get_margins` (lettura autenticata, fuori dal perimetro di questo file).")
    print("  Ma la conclusione NON dipende da quale sia: il collaterale non e' il vincolo in")
    print("  nessuna delle due letture.")
    print(f"  `n a budget 20%` = strutture che stanno in {RISK_BUDGET:.0%} del conto a max-loss;")
    print("  `credito lordo` = il loro credito ESEGUIBILE sommato, per un ciclo. E' un incasso")
    print("  LORDO PRIMA DI QUALUNQUE PERDITA, non un rendimento atteso: la struttura perde fino")
    print("  a ~7x il credito quando va male (misura del progetto sul canonico BTC/ETH).")


def costo_raccolta(rows: list[dict], tab: dict) -> None:
    print("\n" + "=" * 104)
    print("5. COSTO DI RACCOLTA — cosa costerebbe aggiungere una famiglia al giro esistente")
    print("=" * 104)
    print("  `collect_chain.py` oggi: ~650 chiamate in ~160s a 4 rps (BTC+ETH inverse), al :25.")
    print(f"{'famiglia':<10} {'a OI>=100':>10} {'a 2-lati':>9} {'+s a 4rps (2-lati)':>19} "
          f"{'+% sul giro':>12}")
    for f in LINEAR:
        sub = [r for r in rows if r["fam"] == f]
        two = sum(1 for r in sub if r["bid"] is not None and r["ask"] is not None)
        print(f"{f:<10} {tab[f]['nliq']:>10} {two:>9} {(two+2)/4.0:>19.1f} "
              f"{(two+2)/650*100:>11.0f}%")
    print("\n  ⚠️ Il vincolo non e' la CPU ma il rate limit Deribit PER-IP, gia' costato un guasto")
    print("  il 29/07 (fallback silenzioso del feed 5m di SKH01). Ogni famiglia aggiunta allunga")
    print("  la finestra in cui il giro occupa l'IP.")


# ---------------------------------------------------------------- main


def main() -> int:
    ap = argparse.ArgumentParser()
    ap.add_argument("--cache", action="store_true", help="riusa lo snapshot su disco (niente rete)")
    a = ap.parse_args()

    print("=" * 104)
    print("ALT-OPT — opzioni USDC-LINEARI su Deribit: c'e' una struttura eseguibile a $635?")
    print("=" * 104)
    print("Sola lettura pubblica, nessun ordine. UNO SNAPSHOT: qui non esiste un backtest.")

    b, rete = Budget(), not a.cache
    if a.cache and CACHE.exists():
        raw = json.loads(CACHE.read_text())
        print(f"\n[cache] {CACHE}")
    else:
        guardia_finestra()
        t0 = time.time()
        raw = fetch_all(b)
        CACHE.parent.mkdir(parents=True, exist_ok=True)
        CACHE.write_text(json.dumps(raw))
        print(f"\n[rete] {b.calls} chiamate, {b.err} errori, {b.r429} 429, {time.time()-t0:.0f}s")

    rows = build(raw)
    print(f"[dato] {len(rows)} strumenti con specifiche E quote — snapshot "
          f"{datetime.now(UTC):%Y-%m-%d %H:%M} UTC")
    if not rows:
        print("NESSUN DATO: il venue non ha risposto. Verdetto: non misurabile.")
        return 1

    unita(rows, b, rete)
    tab = famiglie(rows)
    liquidita(rows, tab)
    res = struttura(rows)

    vive = [f for f in res if res[f]["n"] >= 2]
    if rete and vive:
        guardia_finestra()
        profondita(rows, vive, b)
    else:
        print("\n3b. PROFONDITA': non girata (--cache, oppure nessuna famiglia con >=2 strutture).")

    collaterale(rows, res)
    costo_raccolta(rows, tab)

    print("\n" + "=" * 104)
    print("6. COSA QUESTO FILE NON PUO' DIRE (dichiarato prima di qualunque verdetto)")
    print("=" * 104)
    print("  * Non c'e' STORIA: il collettore raccoglie BTC/ETH inverse, l'archivio ereditato")
    print("    pure. Zero giorni di catena su queste famiglie -> nessun backtest, nessun hold-out,")
    print("    nessun deflated-Sharpe. Il verdetto massimo ottenibile e' LEAD.")
    print("  * Non c'e' IV-RANK: il gate>0.30 e' l'unico alpha misurato di VRP01 e richiede la")
    print("    distribuzione storica della vol implicita del sottostante. Senza, la struttura non")
    print("    e' VRP01: e' vendere vol a caso. (Su BTC/ETH quel gate e' passato 0/19 settimane.)")
    print("  * Non c'e' STRESS nel campione: la regola 'niente short-vol da modello in deploy' e'")
    print("    del 19/06 e la condizione dichiarata per rivalutarla e' un crash CATTURATO.")
    print("  * Il margine e' da FORMULA PUBBLICATA, non dall'API, e il netting delle gambe non e'")
    print("    leggibile pubblicamente.")
    print("  * E' UN ISTANTE, per giunta di SABATO pomeriggio: uno spread relativo mediano a")
    print("    un'ora del fine settimana non e' la sua distribuzione. Un book alt puo' essere")
    print("    molto piu' quotato in settimana. Servirebbe almeno un ciclo settimanale.")
    print(f"\n[rete, totale] {b.calls} chiamate, {b.err} errori, {b.r429} risposte 429")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())