"""r0724_goal50_math — la matematica ONESTA del target 50 EUR/giorno (2026-07-24).

Domanda del goal: "rendita aggiuntiva che entro qualche mese arrivi a 50 EUR/giorno".
Questo script NON cerca un edge nuovo: quantifica le vie possibili col book che ABBIAMO,
usando i rendimenti giornalieri REALI del book Deribit (TP01 0.75 + SKH01 0.25) e
scenari de-luckati. Quattro parti:

  A) IL MURO — capitale richiesto per 50 EUR/g ai CAGR onesti; tempo da 600$ con depositi.
  B) LA LEVA NON E' LA SCORCIATOIA — vol/DD implicati dal target su capitale piccolo.
  C) PROP-FIRM EVAL — Monte Carlo (block bootstrap dei ritorni reali del book) di una
     evaluation tipo crypto-prop: P(pass), giorni mediani, poi fase funded su 100k$:
     distribuzione EUR/giorno e P(perdere il conto entro 1 anno).
  D) VAULT / COPY — TVL necessario per 50 EUR/g a perf-share 10%.

Onesta': i ritorni del book sono MODELLATI (il path live SKH01 e' peggiore: FULL 1.19/
HOLD 1.15/DD~25% vs modellato ~1.4-1.6) -> ogni scenario gira anche con haircut sul
drift (x0.6) per il de-luck. EURUSD assunto 1.09 (parametro).
"""
from __future__ import annotations

import sys
from pathlib import Path

import numpy as np
import pandas as pd

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

from src.portfolio.portfolio import StrategyPortfolio, metrics  # noqa: E402
from src.portfolio.sleeves import deribit_book_sleeves  # noqa: E402

EURUSD = 1.09          # 1 EUR = 1.09 USD (assunzione dichiarata)
TARGET_EUR_DAY = 50.0
TARGET_EUR_YR = TARGET_EUR_DAY * 365
TARGET_USD_YR = TARGET_EUR_YR * EURUSD
RNG = np.random.default_rng(724)


def eur_day(usd_yr: float) -> float:
    return usd_yr / EURUSD / 365.0


# ----------------------------------------------------------------------------- A
def part_a() -> None:
    print("=" * 100)
    print(f"  A) IL MURO — 50 EUR/g = {TARGET_EUR_YR:,.0f} EUR/anno = ${TARGET_USD_YR:,.0f}/anno")
    print("=" * 100)
    print("  capitale richiesto (rendita = capitale x CAGR netto):")
    for cagr in (0.08, 0.10, 0.15, 0.20, 0.25):
        cap = TARGET_USD_YR / cagr
        print(f"    CAGR {cagr:>4.0%}  ->  capitale ${cap:>10,.0f}  (~EUR {cap / EURUSD:,.0f})")
    print("\n  tempo per arrivarci da $600 (compounding mensile + deposito mensile, CAGR 15%):")
    for dep in (0, 500, 1000, 2000, 5000):
        eq, months = 600.0, 0
        target_cap = TARGET_USD_YR / 0.15
        while eq < target_cap and months < 12 * 60:
            eq = eq * (1 + 0.15) ** (1 / 12) + dep * EURUSD
            months += 1
        yrs = months / 12
        lab = f"{yrs:.1f} anni" if months < 720 else ">60 anni"
        print(f"    deposito EUR {dep:>5}/mese  ->  {lab}")
    print("\n  VERDETTO A: da $600, 'qualche mese' per compounding NON esiste. Il capitale")
    print("  proprio arriva al target solo con depositi da migliaia/mese per molti anni.")


# ----------------------------------------------------------------------------- B
def part_b(book: pd.Series) -> None:
    m = metrics(book)
    print("\n" + "=" * 100)
    print("  B) LA LEVA NON E' LA SCORCIATOIA")
    print("=" * 100)
    sh = m["sharpe"]
    vol = book.std() * np.sqrt(365)
    cagr = (1 + book).prod() ** (365 / len(book)) - 1
    print(f"  book Deribit (TP01 .75 + SKH01 .25) modellato: Sharpe {sh:.2f}  vol {vol:.0%}  CAGR {cagr:.1%}")
    for cap_usd in (600, 2000, 5000, 20000):
        need = TARGET_USD_YR / cap_usd            # rendimento annuo richiesto
        lev = need / max(cagr, 1e-9)              # multiplo di leva sul book
        vol_imp = vol * lev
        print(f"    su ${cap_usd:>6,}: servono {need:>7.0%}/anno -> leva ~{lev:>5.1f}x il book "
              f"-> vol implicita ~{vol_imp:>6.0%} -> rovina quasi certa" if lev > 3 else
              f"    su ${cap_usd:>6,}: servono {need:>7.0%}/anno -> leva ~{lev:>5.1f}x il book "
              f"-> vol implicita ~{vol_imp:>6.0%}")
    print("  VERDETTO B: il target su capitale piccolo implica vol a 3 cifre = rovina.")
    print("  (Kelly gia' documentato: il book gira a ~0.01-0.27 Kelly a seconda dello sleeve.)")


# ----------------------------------------------------------------------------- C
def _block_bootstrap_paths(r: np.ndarray, n_days: int, n_paths: int, block: int = 20,
                           drift_scale: float = 1.0) -> np.ndarray:
    """Percorsi bootstrap a blocchi dai ritorni giornalieri reali del book.

    drift_scale < 1 = haircut de-luck: riduce la media conservando la vol
    (r' = (r - mu) + mu*scale).
    """
    mu = r.mean()
    r_adj = (r - mu) + mu * drift_scale
    n = len(r_adj)
    n_blocks = int(np.ceil(n_days / block))
    starts = RNG.integers(0, n - block, size=(n_paths, n_blocks))
    idx = (starts[:, :, None] + np.arange(block)[None, None, :]).reshape(n_paths, -1)[:, :n_days]
    return r_adj[idx]


def _simulate_eval(paths: np.ndarray, target: float, max_dd: float, daily_loss: float,
                   trailing: bool, max_days: int) -> dict:
    """Simula una evaluation: passa se equity tocca (1+target) prima di violare
    il max drawdown (statico da 1.0 o trailing dal max) o il daily loss limit."""
    n_paths, n_days = paths.shape
    eq = np.cumprod(1 + paths, axis=1)
    hwm = np.maximum.accumulate(np.maximum(eq, 1.0), axis=1) if trailing else 1.0
    dd_breach = eq < (hwm * (1 - max_dd) if trailing else (1 - max_dd))
    dl_breach = paths < -daily_loss
    fail = dd_breach | dl_breach
    passed = eq >= 1 + target

    first_fail = np.where(fail.any(axis=1), fail.argmax(axis=1), max_days + 1)
    first_pass = np.where(passed.any(axis=1), passed.argmax(axis=1), max_days + 1)
    ok = first_pass < first_fail
    p_pass = ok.mean()
    days = np.median(first_pass[ok]) if ok.any() else np.nan
    return {"p_pass": p_pass, "median_days": days,
            "p_fail": (first_fail <= np.minimum(first_pass, max_days)).mean()}


def part_c(book: pd.Series) -> None:
    print("\n" + "=" * 100)
    print("  C) PROP-FIRM EVALUATION — Monte Carlo sui ritorni REALI del book (block bootstrap 20g)")
    print("=" * 100)
    r = book.to_numpy()
    n_paths, max_days = 20_000, 365

    rules = [
        ("target 8% / DD 10% statico / daily 4%", 0.08, 0.10, 0.04, False),
        ("target 10% / DD 10% statico / daily 5%", 0.10, 0.10, 0.05, False),
        ("target 10% / DD 10% TRAILING / daily 5%", 0.10, 0.10, 0.05, True),
    ]
    for drift_scale, lab in ((1.0, "book modellato"), (0.6, "de-luck x0.6 (onesto)")):
        base = _block_bootstrap_paths(r, max_days, n_paths, drift_scale=drift_scale)
        for lev in (1.0, 1.5, 2.0):
            paths = base * lev
            print(f"\n  --- {lab}, leva eval x{lev:.1f} (vol ~{book.std() * np.sqrt(365) * lev:.0%}) ---")
            for name, tgt, dd, dl, tr in rules:
                res = _simulate_eval(paths, tgt, dd, dl, tr, max_days)
                d = f"{res['median_days']:.0f}g" if np.isfinite(res["median_days"]) else "n/a"
                print(f"    {name:<44} P(pass entro 1a) {res['p_pass']:>5.1%}   mediana {d}")

    # fase funded: 100k, split 80%, anno di ritorni; conto perso se DD>10%
    print("\n  --- fase FUNDED: $100k nozionale, split 80%, orizzonte 1 anno ---")
    for drift_scale, lab in ((1.0, "book modellato"), (0.6, "de-luck x0.6")):
        paths = _block_bootstrap_paths(r, 365, n_paths, drift_scale=drift_scale)
        eq = np.cumprod(1 + paths, axis=1)
        hwm = np.maximum.accumulate(np.maximum(eq, 1.0), axis=1)
        blown = (eq < hwm * 0.90) | (paths < -0.05)
        alive = ~blown.any(axis=1)
        pnl = (eq[:, -1] - 1) * 100_000 * 0.80
        pnl_alive = pnl[alive]
        q = np.percentile(pnl_alive, [10, 50, 90]) if alive.any() else [np.nan] * 3
        print(f"    {lab:<24} P(conto vivo a 1a) {alive.mean():>5.1%}   payout se vivo "
              f"p10/p50/p90: EUR {eur_day(q[0]) :>5.1f} / {eur_day(q[1]):>5.1f} / {eur_day(q[2]):>5.1f} al giorno")
    print("\n  NB: regole reali (consistency, min trading days, no-bot) possono uccidere lo stile")
    print("  low-frequency — il verdetto finale dipende dalla ricerca web sulle firm 2026.")


# ----------------------------------------------------------------------------- D
def part_d() -> None:
    print("\n" + "=" * 100)
    print("  D) VAULT / COPY-TRADING — perf-share 10% sopra HWM")
    print("=" * 100)
    for cagr in (0.10, 0.15, 0.20):
        tvl = TARGET_USD_YR / (cagr * 0.10)
        print(f"    CAGR {cagr:.0%}: per 50 EUR/g servono ${tvl / 1e6:,.1f}M di TVL altrui")
    print("  VERDETTO D: TVL a 7 cifre richiede anni di track record pubblico, non mesi.")


def main() -> None:
    port = StrategyPortfolio(deribit_book_sleeves())
    book = port.combined_daily().dropna()
    book = book[book.index >= "2019-03-01"]
    m = metrics(book)
    print(f"book Deribit live (modellato): {len(book)} giorni  {book.index[0].date()} -> "
          f"{book.index[-1].date()}  Sharpe {m['sharpe']:.2f}  maxDD {m['maxdd']:.1%}")
    part_a()
    part_b(book)
    part_c(book)
    part_d()
    print("\n" + "=" * 100)
    print("  SINTESI ONESTA: 50 EUR/g in qualche mese e' fuori portata del capitale proprio.")
    print("  L'unica via quantificabile in MESI e' moltiplicare il nozionale gestito (prop/")
    print("  funded), con P(successo) e regole da verificare; tutto il resto e' anni+capitale.")
    print("=" * 100)


if __name__ == "__main__":
    main()