#!/usr/bin/env python3
"""Independent Senior-tranche loss estimate for the Spot / Ikon Pass refund book (to 18 Jan 2027).

This is NOT Ensuro's pricing model. It is an independent, simplified estimate written for this bundle.

Loss driver: final refund rate R of the on-chain Ikon book, as a share of sum insured.
Each refund pays 100% of the insured amount (Ensuro statement). R = K / n with
K ~ Beta-Binomial(n, a = p*kappa, b = (1-p)*kappa): mean p, pairwise correlation 1/(kappa+1).

Variants for the Senior loss L (USD):
  A  design layers (Ensuro's stated structure, on-chain policy parameters):
     Senior layer = 10% .. 22% of sum insured  ->  L = clip(R - 10%, 0, 12%) * SI
  B  as A, with the Senior loss capped at the Spot premiums account srLoanLimit (300k on-chain).
     Above the cap, the Senior loan reverts (all-or-nothing in PremiumsAccount._borrowFromEtk), so those
     payouts are not processed through the Senior unless governance raises the limit.
  C  economic: uses the Spot premiums account state on-chain (surplus, active pure premiums) instead of
     nominal layers, the on-chain jrLoanLimit for the Junior, and the Senior capped at Spot's Senior SCR.
     Non-Ikon Spot business is assumed to break even from here (an assumption, not data).
  C_cap  as C, with the 300k srLoanLimit cap.

Inputs: pinned snapshot metrics/history/2026-11-17.json (override with MODEL_SNAPSHOT) + IKON block below (on-chain aggregates of the Ikon
risk-module policies via Ensuro's public offchain-v3 indexer, pulled 2026-11-12 13:34 America/Buenos_Aires).
Output: metrics/model/senior-risk-model.json. Deterministic: same inputs -> same outputs.
"""
from __future__ import annotations

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

ROOT = Path(__file__).resolve().parent.parent

IKON = {
    "as_of": "2026-11-12T13:34:00-03:00",
    "source": "offchain-v3.ensuro.co policies endpoint for the Spot risk module 0x95eC92eE7539D2Fe38f68d593f1451fa88452891, "
              "Ikon policies (expiration 2027-01-18T06:59:59Z); aggregates only",
    "policies_on_chain": 7674,
    "sum_insured": 8741692.66,
    "active_pure_premiums_ikon": 697664.26,
    "refunds_paid_amount": 253485.46,
    "refunds_paid_count": 221,
}
HORIZON_END = datetime(2027, 1, 18, 6, 59, 59, tzinfo=timezone.utc)
JR_ATTACH, SR_ATTACH, SR_EXHAUST = 0.087145, 0.10, 0.22
NEW_DEPOSIT = 500_000.0


def lbeta(a, b):
    return math.lgamma(a) + math.lgamma(b) - math.lgamma(a + b)


def bb_dist(n, p, kappa):
    a, b = p * kappa, (1 - p) * kappa
    c = math.lgamma(n + 1) - lbeta(a, b)
    out = []
    for k in range(n + 1):
        lp = c - math.lgamma(k + 1) - math.lgamma(n - k + 1) + lbeta(k + a, n - k + b)
        out.append((k / n, math.exp(lp)))
    s = sum(q for _, q in out)
    return [(r, q / s) for r, q in out]


def tail_stats(dist, loss_fn, denom):
    el = sum(q * loss_fn(r) for r, q in dist)
    p_hit = sum(q for r, q in dist if loss_fn(r) > 1e-9)
    srt = sorted(((loss_fn(r), q) for r, q in dist), key=lambda x: x[0], reverse=True)

    def es(alpha):
        tail, acc, tot = 1 - alpha, 0.0, 0.0
        for l, q in srt:
            take = min(q, tail - acc)
            if take <= 0:
                break
            tot += take * l
            acc += take
        return tot / tail

    def var(alpha):
        acc = 0.0
        for l, q in sorted(((loss_fn(r), q) for r, q in dist), key=lambda x: x[0]):
            acc += q
            if acc >= alpha:
                return l
        return srt[0][0]

    return {
        "p_senior_hit": p_hit,
        "expected_loss_usd": el,
        "expected_loss_pct_tvl": el / denom,
        "var99_usd": var(0.99),
        "es99_usd": es(0.99),
        "es99_pct_tvl": es(0.99) / denom,
        "es999_pct_tvl": es(0.999) / denom,
    }


def main():
    m = json.loads((ROOT / os.environ.get("MODEL_SNAPSHOT", "metrics/history/2026-11-17.json")).read_text())
    sr, sp = m["senior_etoken"], m["spot_program"]
    tvl = sr["total_supply"]["value"]
    sr_loan_limit = sp["sr_loan_limit"]["value"]
    jr_loan_limit = sp["jr_loan_limit"]["value"]
    surplus = sp["surplus"]["value"]
    as_of = datetime.fromisoformat(m["as_of"]["utc"].replace("Z", "+00:00"))
    days = (HORIZON_END - as_of).total_seconds() / 86400
    SI = IKON["sum_insured"]
    n = IKON["policies_on_chain"]
    spot_sr_scr_ikon = (SR_EXHAUST - SR_ATTACH) * SI  # nominal Senior layer for the Ikon book

    # economic attachment (variant C)
    budget_before_jr = surplus + IKON["active_pure_premiums_ikon"] + IKON["refunds_paid_amount"]
    r_jr_econ = budget_before_jr / SI
    r_sr_econ = (budget_before_jr + jr_loan_limit) / SI

    variants = {
        "A_design": lambda r: min(max(r - SR_ATTACH, 0.0), SR_EXHAUST - SR_ATTACH) * SI,
        "B_design_cap300k": lambda r: min(min(max(r - SR_ATTACH, 0.0), SR_EXHAUST - SR_ATTACH) * SI, sr_loan_limit),
        "C_economic": lambda r: min(max(r * SI - budget_before_jr - jr_loan_limit, 0.0), spot_sr_scr_ikon),
        "C_economic_cap300k": lambda r: min(max(r * SI - budget_before_jr - jr_loan_limit, 0.0), sr_loan_limit),
    }

    ry = {w["window_days"]: w["apy_percent"] / 100 for w in m.get("senior_realized_yield", {}).get("windows", [])}
    carry_rates = {
        "realized_90d_apy": ry.get(90),
        "current_token_interest_rate": sr["token_interest_rate"]["value"] / 100,
    }

    runs = {}
    for label, p, kappa in [
        ("ensuro_mean_5.2_kappa99", 0.052, 99), ("mean_5.2_kappa49", 0.052, 49),
        ("mean_7.0_kappa99", 0.07, 99), ("mean_8.7145_kappa99", 0.087145, 99),
        ("mean_9.01_kappa99", 0.0901, 99),
    ]:
        dist = bb_dist(n, p, kappa)
        run = {
            "mean_refund_rate": p, "kappa": kappa, "pairwise_correlation": 1 / (kappa + 1),
            "p_R_above_jr_attach_8.7145": sum(q for r, q in dist if r > JR_ATTACH),
            "p_R_above_sr_attach_10": sum(q for r, q in dist if r > SR_ATTACH),
            "p_R_above_22": sum(q for r, q in dist if r > SR_EXHAUST),
            "R_p99": next(r for r, c in _cum(dist) if c >= 0.99),
            "R_p999": next(r for r, c in _cum(dist) if c >= 0.999),
            "variants": {},
        }
        for vname, fn in variants.items():
            st = tail_stats(dist, fn, tvl)
            st["expected_loss_pct_tvl_plus_500k"] = st["expected_loss_usd"] / (tvl + NEW_DEPOSIT)
            st["es99_pct_tvl_plus_500k"] = st["es99_usd"] / (tvl + NEW_DEPOSIT)
            ra = {}
            for cname, rate in carry_rates.items():
                if rate is None:
                    continue
                carry = (1 + rate) ** (days / 365) - 1
                net = carry - st["expected_loss_pct_tvl"]
                ra[cname] = {
                    "carry_to_horizon": carry,
                    "net_expected_return_to_horizon": net,
                    "net_expected_return_annualized": (1 + net) ** (365 / days) - 1 if net > -1 else None,
                    "net_return_per_unit_es99": net / st["es99_pct_tvl"] if st["es99_pct_tvl"] > 0 else None,
                }
            st["risk_adjusted"] = ra
            run["variants"][vname] = st
        runs[label] = run

    scen = []
    for R in (0.0288, 0.04, 0.052, 0.07, 0.087145, 0.10, 0.11, 0.12, 0.15, 0.18, 0.22):
        row = {"refund_rate": R}
        for vname, fn in variants.items():
            row[vname + "_loss_usd"] = fn(R)
            row[vname + "_loss_pct_tvl"] = fn(R) / tvl
        scen.append(row)

    out = {
        "document": "Independent Senior-tranche loss estimate (not Ensuro's model)",
        "computed_from_snapshot": m["as_of"],
        "horizon_end_utc": HORIZON_END.strftime("%Y-%m-%dT%H:%M:%SZ"),
        "horizon_days": round(days, 2),
        "inputs": {
            "ikon_onchain_aggregates": IKON,
            "senior_total_supply": tvl,
            "spot_surplus": surplus,
            "sr_loan_limit": sr_loan_limit,
            "jr_loan_limit": jr_loan_limit,
            "design_layers": {"jr_attach": JR_ATTACH, "sr_attach": SR_ATTACH, "sr_exhaust": SR_EXHAUST},
            "nominal_senior_layer_usd_ikon": spot_sr_scr_ikon,
            "economic_budget_before_junior_usd": budget_before_jr,
            "economic_refund_rate_junior_attach": r_jr_econ,
            "economic_refund_rate_senior_attach": r_sr_econ,
            "carry_rates": carry_rates,
            "new_deposit_for_dilution_view": NEW_DEPOSIT,
        },
        "assumptions": [
            "Refund pays 100% of sum insured (Ensuro statement); every policy has the same sum insured (average).",
            "Final refund rate R ~ Beta-Binomial(n=7674, mean p, kappa); kappa=99 means 1% pairwise correlation between policies.",
            "Only the 7,674 Ikon policies on-chain at 2026-11-12 are modelled; policies not yet uploaded and non-Ikon Spot business are excluded.",
            "Losses are pooled in the Spot premiums account (portfolio-level layers), not per policy.",
            "Senior internal loans are treated as permanent losses to Senior holders (no later repayment from new premiums).",
            "No asset-management (MSV) losses, no smart-contract failure, no operational error are modelled here.",
            "Carry uses the Senior's realized 90-day APY and, as a lower reference, the current on-chain tokenInterestRate; neither is a forecast.",
        ],
        "runs": runs,
        "deterministic_scenarios": scen,
    }
    path = Path(os.environ["MODEL_OUT"]) if os.environ.get("MODEL_OUT") else ROOT / "metrics" / "model" / "senior-risk-model.json"
    path.write_text(json.dumps(out, indent=1) + "\n")
    base = runs["ensuro_mean_5.2_kappa99"]
    print(json.dumps({k: base[k] for k in base if k != "variants"}, indent=1))
    for v, st in base["variants"].items():
        print(v, {k: (round(x, 6) if isinstance(x, float) else x) for k, x in st.items() if k != "risk_adjusted"})
        print("   ", json.dumps(st["risk_adjusted"]))


def _cum(dist):
    c = 0.0
    for r, q in dist:
        c += q
        yield r, c


if __name__ == "__main__":
    main()
