"""r0825_piano_10a_500.py — €500/mese per 10 anni, dal conto VERO di oggi.

DOMANDA (operatore, 2026-08-25): *"dammi strategia a 10 anni con 500 al mese"*.

PERCHE' NON BASTAVA CITARE LA TABELLA. Le tabelle pubblicate del piano partono da **$600/$635**.
Oggi il conto e' **$2.067** (versamento di 1.400 USDC atterrato alle 11:03:35Z). Il lump e' la
leva piu' grande misurata dopo il versamento mensile stesso (*"€10.000 oggi + €250/m porta P(20a)
da 14% a 45%"*), quindi la riga vecchia sottostima il caso di oggi e non si puo' riusare.

LENTE: **L3 CONGIUNTA** di `r0822d_piano_vero` — libro live 75/25, **funding esatto dentro la
serie**, ancora de-luckata x0.89, **fisco d'accumulo** ogni anno dentro il portafoglio (33% sulla
variazione annua di valore, minusvalenze in carry 4 anni, patrimoniale 0,2%). E' la piu' severa
che il progetto abbia, ed e' quella che ha prodotto muro $313k e *"€1.733/mese per 10 anni"*.

⚠️ DIFETTI EREDITATI, dichiarati perche' vanno **a favore del piano** (registrati il 23/08):
  1. `PN.accumula` versa ogni **30 giorni** -> a 10 anni sono **121** versamenti, non 120 (+0,83%);
  2. il contatore `versato` e' uno **scalare che non si ferma al traguardo** -> il "versato" a
     denominatore e' quello dell'INTERO orizzonte, non quello fino all'arrivo.
Non li ho riparati qui: ripararli cambierebbe i numeri di riferimento e li renderebbe non
confrontabili con tutto il resto della memoria. Vanno LETTI, non dimenticati.

⚠️ E IL NUMERO DA NON DIMENTICARE MAI accanto a questi: la SE del drift L3 e' **5,151%/anno**, e
il muro e' `prelievo/perpetua` = un **1/x su una quantita' che va a zero** -> la banda e'
esplosiva e **asimmetrica verso l'alto**: $187k (p90) · **$313k (punto)** · $1,14M (p10) ·
a **−2 SE il traguardo non esiste a nessun capitale**. Percio' la regola del progetto:
**il piano si dimensiona sul VERSAMENTO, che e' certo, non sul muro** (N1).

    uv run python scripts/research/r0825_piano_10a_500.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

# --- lo stato VERO di oggi, non un nominale -------------------------------------------------
START_OGGI = 2066.88          # equity Deribit letta alle 11:47:01Z del 2026-08-25
START_PUBBL = PV.START        # 635.0 — la base delle tabelle pubblicate, per il confronto
DEP = 500.0                   # EUR/mese
ORIZZONTI = (5, 10, 15, 20)
N_PATHS = 3000
SEED = PV.SEED_TRAJ           # 725: stesso seme delle traiettorie pubblicate
BLOCK = PV.BLOCK              # 20 giorni


def rendita_eur_giorno(cap: np.ndarray, perp: float) -> np.ndarray:
    """€/giorno NETTI da un capitale, alla perpetua della lente.

    ⚠️ La perpetua L3 (6,35%) ha gia' le imposte dentro: **non si lordizza una seconda volta**
    (errore corretto il 07/08)."""
    return cap * perp / 365.0 / CC.EURUSD


def main() -> None:
    print("=" * 100)
    print("  r0825 — €500/MESE PER 10 ANNI, dal conto vero di oggi ($2.067)")
    print("=" * 100)

    B = PV.costruisci_serie()
    r = PV.deluck(B["fund"].values.astype(float))       # L3 CONGIUNTA, ancora x0.89
    lente = PV.Lente("L3 congiunta", r, lordizza=False)
    lente.perp, lente.muro = PV.muro_di(lente)

    print(f"\n  serie: {len(r)} giorni · drift {lente.drift:.2%}/anno · vol {lente.vol:.2%}/anno")
    print(f"  perpetua {lente.perp:.2%} · MURO ${lente.muro:,.0f}  "
          f"[banda del progetto: $187k (p90) — $1,14M (p10); a −2 SE non esiste]")
    print(f"  bersaglio di rendita: €{CC.TARGET_EUR_DAY:.0f}/giorno netti")

    print(f"\n{'='*100}\n  (1) €{DEP:.0f}/MESE DA ${START_OGGI:,.0f} — cosa consegna, per orizzonte"
          f"\n{'='*100}")
    print(f"  {'oriz.':>6} {'capitale mediano':>18} {'p10':>12} {'p90':>13} "
          f"{'€/g mediani':>13} {'P(≥50 €/g)':>12} {'versato':>11} {'fin/vers':>9}")
    print("  " + "-" * 98)
    righe = {}
    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]
        out = PN.accumula(paths, DEP, lente.muro, lente.aliq, lente.patr, start=START_OGGI)
        cap, versato = out["cap"], out["versato"]
        eur = rendita_eur_giorno(cap, lente.perp)
        p50 = float((eur >= CC.TARGET_EUR_DAY).mean())
        righe[anni] = dict(med=np.median(cap), eur=np.median(eur), p50=p50, versato=versato)
        print(f"  {anni:>4}a  ${np.median(cap):>16,.0f} ${np.percentile(cap,10):>10,.0f} "
              f"${np.percentile(cap,90):>11,.0f} {np.median(eur):>12.2f} {p50:>11.1%} "
              f"${versato:>9,.0f} {np.median(cap)/versato:>8.2f}x")

    print(f"\n{'='*100}\n  (2) COSA HA COMPRATO IL VERSAMENTO DI OGGI — $635 (tabelle pubbl.) vs "
          f"$2.067 (reale)\n{'='*100}")
    print(f"  {'oriz.':>6} {'da $635':>14} {'da $2.067':>14} {'guadagno':>11} "
          f"{'€/g da $635':>13} {'€/g da $2.067':>15}")
    print("  " + "-" * 78)
    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_PUBBL)["cap"]
        b = PN.accumula(paths, DEP, lente.muro, lente.aliq, lente.patr, start=START_OGGI)["cap"]
        ea, eb = rendita_eur_giorno(a, lente.perp), rendita_eur_giorno(b, lente.perp)
        print(f"  {anni:>4}a  ${np.median(a):>12,.0f} ${np.median(b):>12,.0f} "
              f"{np.median(b)/np.median(a)-1:>10.1%} {np.median(ea):>12.2f} {np.median(eb):>14.2f}")

    print(f"\n{'='*100}\n  (3) QUANDO ARRIVA IL BERSAGLIO (€50/g = ${lente.muro:,.0f})"
          f"\n{'='*100}")
    rng = np.random.default_rng(SEED)
    ii = DT.boot_idx(len(r), N_PATHS, 25 * 365, BLOCK, rng)
    paths25 = r[ii]
    for dep in (0, 250, 500, 800, 1_000):
        out = PN.accumula(paths25, float(dep), lente.muro, lente.aliq, lente.patr,
                          start=START_OGGI)
        d = PV.leggi(out["colpito"], anni_sim=25)
        med = "mai" if not np.isfinite(d["med"]) else f"{d['med']:.1f}a"
        cond = "n/d" if not np.isfinite(d["med_cond"]) else f"{d['med_cond']:.1f}a"
        print(f"  €{dep:>5}/m -> mediana {med:>6} (condizionata all'arrivo {cond:>6}, "
              f"arriva il {d['p_arr']:.0%}) · P(entro 20a) {d['p20']:>5.0%}")

    print(f"\n{'='*100}\n  (4) IL VERSAMENTO CHE SERVE DAVVERO PER €50/g, da ${START_OGGI:,.0f}"
          f"\n{'='*100}")
    for anni in (10, 15, 20):
        rng = np.random.default_rng(PV.SEED_DEP)
        ii = DT.boot_idx(len(r), PV.N_DEP, anni * 365, BLOCK, rng)
        p = r[ii]
        riga = []
        for conf in (0.50, 0.75, 0.90):
            d, tot = PV.dep_per_conf(p, lente, conf, start=START_OGGI)
            riga.append(f"P={conf:.0%}: €{d:,.0f}/m" + (f" (tot ${tot:,.0f})" if conf == 0.90 else ""))
        print(f"  {anni:>2} anni -> " + " · ".join(riga))

    print(f"\n{'='*100}\n  VERDETTO (calcolato a runtime, non scritto a mano)\n{'='*100}")
    d10 = righe[10]
    print(f"  €500/mese per 10 anni da ${START_OGGI:,.0f}:")
    print(f"    capitale mediano ${d10['med']:,.0f} · rendita mediana {d10['eur']:.2f} €/giorno")
    print(f"    P(≥50 €/g a 10 anni) = {d10['p50']:.1%}")
    print(f"    versato ${d10['versato']:,.0f} -> il rendimento fa il "
          f"{max(0.0, 1 - d10['versato']/d10['med']):.0%} del risultato, i bonifici il resto")
    verdetto = ("CENTRA" if d10["p50"] >= 0.5 else "NON CENTRA")
    print(f"\n  => a 10 anni €500/mese {verdetto} il bersaglio €50/giorno.")
    print(f"  => quello che centra a 10 anni sta nella sezione (4); quello che €500/mese centra,")
    print(f"     e quando, sta nella (3).")


if __name__ == "__main__":
    main()