"""r0825_versamento_3k.py — cosa compra un versamento di $3.000 ADESSO, dal conto vero.

DOMANDA (operatore, 2026-08-25 sera): *"rianalizza e vediamo come procedere. potrei versare a
breve altri 3k"*. Il conto passerebbe da ~$2.065 a ~$5.065 — esattamente a cavallo della soglia
$5k su cui sta scritto il criterio di capitale del gate XSR01 (23/10), e a un terzo del muro
$15-20k che e' insieme il C* vero di Hyperliquid E la soglia della decisione vincolante
"100% Deribit fino a $20k" (26/07).

ASSUNZIONI DICHIARATE:
  - "3k" = 3.000 USDC = $3.000 (i versamenti precedenti dell'operatore sono in USDC);
  - il lump atterra OGGI. "A breve" puo' voler dire fra settimane: ritardarlo di un mese sposta
    i numeri di poco e sempre nello stesso verso (un po' meno beneficio). Non lo modello.
  - equity di partenza: 2.065,00 — letta dal watermark alle 18:47:13Z di oggi (l'istante
    dell'evento, non l'istante della scrittura).

LENTE: L3 CONGIUNTA (funding esatto + fisco d'accumulo + ancora de-luckata), la stessa di
`r0825_piano_10a_500` — stessi semi, stessi path: ogni confronto qui e' APPAIATO (M22).
⚠️ Stessi difetti ereditati e dichiarati la': 121 versamenti in 10 anni, `versato` scalare.
⚠️ M23: N_PATHS 3000, blocchi 20g. La banda del muro resta [$187k – $1,14M]: i numeri assoluti
qui sotto stanno sulla lente `hourly`+L3 e vanno letti con quella etichetta (P7).

    uv run python scripts/research/r0825_versamento_3k.py
"""
from __future__ import annotations

import sys
from pathlib import Path

import numpy as np

ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT))
sys.path.insert(0, str(ROOT / "scripts" / "research"))

import r0725_capcurve as CC              # noqa: E402
import r0807_piano_netto as PN           # noqa: E402
import r0822d_piano_vero as PV           # noqa: E402
import r0823_deposit_timing as DT        # noqa: E402

START_OGGI = 2065.00          # watermark 2026-08-25T18:47:13Z
LUMP_USD = 3000.0             # il versamento ipotizzato, in USD
START_LUMP = START_OGGI + LUMP_USD
DEP = 500.0                   # EUR/mese, il piano dichiarato
ORIZZONTI = (5, 10, 15, 20)
N_PATHS = 3000
SEED = PV.SEED_TRAJ
BLOCK = PV.BLOCK
GATE_XSR = 59                 # giorni da oggi al 2026-10-23 (25/08 -> 23/10)
MILESTONE = (5_000.0, 15_000.0, 20_000.0)   # criterio gate · C* Hyperliquid · muro "100% Deribit"


def sez(t: str) -> None:
    print(f"\n{'='*100}\n  {t}\n{'='*100}")


def eur_g(cap: np.ndarray, perp: float) -> np.ndarray:
    return cap * perp / 365.0 / CC.EURUSD


def main() -> None:
    print("=" * 100)
    print(f"  r0825 — IL VERSAMENTO DA $3.000: ${START_OGGI:,.0f} -> ${START_LUMP:,.0f}")
    print("=" * 100)

    B = PV.costruisci_serie()
    r = PV.deluck(B["fund"].values.astype(float))
    lente = PV.Lente("L3 congiunta", r, lordizza=False)
    lente.perp, lente.muro = PV.muro_di(lente)
    print(f"\n  lente L3: drift {lente.drift:.2%} · vol {lente.vol:.2%} · perpetua {lente.perp:.2%}"
          f" · muro ${lente.muro:,.0f}")

    # ---------------------------------------------------- (1) cosa compra il lump, appaiato
    sez(f"(1) COSA COMPRA IL LUMP — €{DEP:.0f}/mese, stessi path, da ${START_OGGI:,.0f} vs "
        f"${START_LUMP:,.0f}")
    print(f"  {'oriz.':>6} {'senza lump':>13} {'con lump':>13} {'guadagno':>10} "
          f"{'€/g senza':>11} {'€/g con':>9} {'P(50) senza':>12} {'P(50) con':>10}")
    print("  " + "-" * 92)
    d10 = {}
    for anni in ORIZZONTI:
        rng = np.random.default_rng(SEED)
        ii = DT.boot_idx(len(r), N_PATHS, anni * 365, BLOCK, rng)
        paths = r[ii]
        a = PN.accumula(paths, DEP, lente.muro, lente.aliq, lente.patr, start=START_OGGI)
        b = PN.accumula(paths, DEP, lente.muro, lente.aliq, lente.patr, start=START_LUMP)
        ea, eb = eur_g(a["cap"], lente.perp), eur_g(b["cap"], lente.perp)
        pa, pb = float((ea >= 50).mean()), float((eb >= 50).mean())
        if anni == 10:
            d10 = dict(a=a, b=b, ea=ea, eb=eb, pa=pa, pb=pb)
        print(f"  {anni:>4}a  ${np.median(a['cap']):>11,.0f} ${np.median(b['cap']):>11,.0f} "
              f"{np.median(b['cap'])/np.median(a['cap'])-1:>9.1%} {np.median(ea):>10.2f} "
              f"{np.median(eb):>8.2f} {pa:>11.1%} {pb:>9.1%}")
    lump_in_mesi = LUMP_USD / CC.EURUSD / DEP
    print(f"\n  il lump equivale a {lump_in_mesi:.1f} mesi di versamenti anticipati in un colpo.")
    print(f"  N3: la leva 'versare' resta la prima — questo lump E' quella leva, esercitata.")

    # ---------------------------------------------------- (2) pietre miliari
    sez("(2) QUANDO ARRIVANO LE PIETRE MILIARI (€500/mese, primo passaggio, 10 anni di path)")
    rng = np.random.default_rng(SEED)
    ii = DT.boot_idx(len(r), N_PATHS, 10 * 365, BLOCK, rng)
    paths10 = r[ii]
    print(f"  {'soglia':>9} {'cosa sblocca':<44} {'senza lump':>11} {'con lump':>9}")
    print("  " + "-" * 82)
    naming = {5_000: "criterio di capitale del gate XSR01",
              15_000: "C* vero di Hyperliquid (pavimento misurato)",
              20_000: "decisione '100% Deribit fino a $20k' si riapre"}
    for ms in MILESTONE:
        riga = []
        for st in (START_OGGI, START_LUMP):
            out = PN.accumula(paths10, DEP, ms, lente.aliq, lente.patr, start=st)
            if st >= ms:
                riga.append("gia' li'")
                continue
            d = PV.leggi(out["colpito"], anni_sim=10)
            riga.append("oltre 10a" if not np.isfinite(d["med"]) else f"{d['med']:.1f}a")
        print(f"  ${ms:>7,.0f} {naming[int(ms)]:<44} {riga[0]:>11} {riga[1]:>9}")

    # ---------------------------------------------------- (3) il gate del 23/10
    sez(f"(3) GATE XSR01 (2026-10-23, fra {GATE_XSR} giorni) — P(capitale >= $5.000 quel giorno)")
    rng = np.random.default_rng(SEED)
    ii = DT.boot_idx(len(r), N_PATHS, GATE_XSR, BLOCK, rng)
    pg = r[ii]
    for st, nome in ((START_OGGI, "senza lump"), (START_LUMP, "con lump")):
        out = PN.accumula(pg, DEP, 5_000.0, lente.aliq, lente.patr, start=st)
        p = float((out["cap"] >= 5_000.0).mean())
        print(f"  {nome:<11} start ${st:>7,.0f} -> P(>= $5k al 23/10) = {p:>6.1%}   "
              f"(mediana ${np.median(out['cap']):,.0f}, p10 ${np.percentile(out['cap'],10):,.0f})")
    print(f"\n  ⚠️ Il criterio FORMALE diventa raggiungibile col lump — ma il C* VERO del venue e'")
    print(f"     $15.000-20.000 (§5.3), il 25% a ${START_LUMP:,.0f} sono ${START_LUMP*0.25:,.0f} su")
    print(f"     Hyperliquid, e la decisione vincolante del 26/07 dice 100% Deribit fino a $20k.")
    print(f"     Il lump rende il gate LEGGIBILE, non rende XSR01 comprabile.")

    # ---------------------------------------------------- (4) meccanica live a $5.065
    sez(f"(4) COSA CAMBIA NELLA MECCANICA LIVE, DA SOLO, A ${START_LUMP:,.0f}")
    print(f"  cap per-asset (equity x 0,5, nessun tetto assoluto sul percorso normale):")
    print(f"    ${START_OGGI*0.5:,.0f} -> ${START_LUMP*0.5:,.0f} per asset — nessuna config da toccare,")
    print(f"    il profilo di rischio RELATIVO non cambia (leva lorda max resta 1,0x; realizzata")
    print(f"    max 0,52x: il vincolo e' il segnale, non il cap)")
    print(f"  min_order $5: passa dal {5/(START_OGGI*0.5):.2%} al {5/(START_LUMP*0.5):.2%} del cap")
    print(f"    per-asset (C2: un parametro in valuta assoluta pesa meno al crescere del conto)")
    print(f"  fallback a equity illeggibile: min($3.000, watermark x 0,5) = "
          f"min(3000, {START_LUMP*0.5:,.0f}) -> ${min(3000.0, START_LUMP*0.5):,.0f}")
    print(f"  disaster-SL -30%: invariato — resta rotolante e simmetrico (peggior DD misurato")
    print(f"    dall'ingresso -60,6%/-61,5%: il nome inganna anche a $5k)")
    print(f"  ⚠️ slip-audit: misurato su fill a $597-2.067; a ${START_LUMP:,.0f} la taglia relativa")
    print(f"    raddoppia -> la misura VA RIFATTA dopo i primi fill alla taglia nuova (C2/C5),")
    print(f"    lo script c'e' gia' (`r0822_slip_audit.py`, normalizzazione per-fill)")

    # ---------------------------------------------------- verdetto
    sez("VERDETTO (runtime)")
    med_a, med_b = np.median(d10["a"]["cap"]), np.median(d10["b"]["cap"])
    print(f"  a 10 anni con €500/mese: ${med_a:,.0f} -> ${med_b:,.0f} ({med_b/med_a-1:+.1%}), "
          f"€/g {np.median(d10['ea']):.2f} -> {np.median(d10['eb']):.2f}")
    print(f"  P(>=50 €/g a 10a): {d10['pa']:.1%} -> {d10['pb']:.1%}")
    print(f"  il lump anticipa il piano di ~{lump_in_mesi:.0f} mesi e rende leggibile il gate del")
    print(f"  23/10; NON rende comprabile XSR01 (C* $15-20k) e NON riapre la scelta del venue ($20k).")


if __name__ == "__main__":
    main()