Payment-in-kind bond

use chrono::NaiveDate;
use helixio_docs_sheets::Sheet;
use helixrs::{
    AnyInstrument, CollateralSpec, Currency, DayCountFraction, Frequency, MarketContext,
    PaymentInKindBond, PikError, QuoteSheet, YieldBasis, YieldCurve,
};

fn date(year: i32, month: u32, day: u32) -> NaiveDate {
    NaiveDate::from_ymd_opt(year, month, day).expect("a real calendar date")
}

const RATE: f64 = 0.08;
const FACE: f64 = 10_000_000.0;

/// €STR OIS par closes on 3 July 2028, the day the bond is valued.
const EUR_ESTR_JULY_2028: Sheet = &[
    ("EUR-ESTR-OIS", "1Y", 0.025),
    ("EUR-ESTR-OIS", "2Y", 0.026),
    ("EUR-ESTR-OIS", "3Y", 0.027),
    ("EUR-ESTR-OIS", "5Y", 0.029),
];

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let issue = date(2026, 1, 2);
    let maturity = date(2031, 1, 2);
    let eur = Currency::new("EUR").expect("a registered currency");
    let pik = PaymentInKindBond::new(
        eur,
        issue,
        maturity,
        RATE,
        Frequency::Annual,
        DayCountFraction::Act365Fixed,
        FACE,
    )?;

    // Each coupon date adds the period's interest to the face instead of paying it.
    let table = pik.capitalisations();
    println!("date          year frac.  face before      capitalised    face after");
    for row in &table {
        println!(
            "{}    {:.6}    {:.2}    {:.2}    {:.2}",
            row.date,
            row.year_fraction,
            row.face_before,
            row.amount(),
            row.face_after
        );
    }

    // The accreted face on any date: the face at issue, then larger after each
    // capitalisation, and flat in between.
    let probes = [issue, date(2026, 7, 1), date(2027, 1, 2), date(2029, 6, 30), maturity];
    let faces: Vec<f64> = probes.iter().map(|at| pik.current_face(*at)).collect();
    for (at, value) in probes.iter().zip(&faces) {
        println!("face on {at}    {value:.2}");
    }
    let factor = faces[faces.len() - 1] / FACE;
    println!("factor at maturity    {factor:.10}");
    println!("(1 + r)^5             {:.10}", (1.0_f64 + RATE).powf(5.0));
    println!("1 + 5r                {:.10}", 1.0 + 5.0 * RATE);

    // A PIK pays nothing until maturity, when it redeems the accreted face. Its
    // value is that one flow at the curve's discount factor. At a yield, the
    // dirty price per 100 of par face is the redemption discounted.
    let settlement = date(2028, 7, 3);
    let sheet = QuoteSheet::from_rows(EUR_ESTR_JULY_2028.iter().copied())?;
    let market =
        MarketContext::as_of(settlement).with_recipe_quotes(&CollateralSpec::Currency(eur), &sheet)?;
    let redemption = pik.redemption_per_100();
    let lifted = market.lift::<f64>();
    let view = market.view(&lifted)?;
    let value = view.npv(&AnyInstrument::PaymentInKindBond(Box::new(pik.clone())))?;
    let annual = YieldBasis::compounded_at(1.0);
    let price_par = pik.dirty_price_on_par_face(0.10, settlement, annual);
    println!("redemption per 100    {redemption:.6}");
    println!("value off the curve   {value:.2}");
    println!("dirty per 100 at 10%  {price_par:.6}");

    // A zero rate capitalises nothing and a negative one would shrink the face.
    let mut refusals = 0;
    for rate in [0.0, -0.01] {
        let built = PaymentInKindBond::new(
            eur,
            issue,
            maturity,
            rate,
            Frequency::Annual,
            DayCountFraction::Act365Fixed,
            FACE,
        );
        if matches!(built, Err(PikError::NonPositiveRate)) {
            refusals += 1;
        }
    }
    println!("refused {refusals} of 2 non-positive rates");

    Ok(())
}

import datetime as dt

import helixio as hlx

ISSUE = dt.date(2026, 1, 2)
MATURITY = dt.date(2031, 1, 2)
RATE = 0.08
FACE = 10_000_000.0
PIK = hlx.products.payment_in_kind_bond(
    "EUR", ISSUE, MATURITY, rate=RATE, frequency=hlx.dates.Frequency.Annual,
    day_count=hlx.dates.DayCountFraction.Act365Fixed, face=FACE,
)

# €STR OIS par closes on 3 July 2028, the day the bond is valued.
EUR_ESTR_JULY_2028 = {
    "EUR-ESTR-OIS": {"1Y": 0.025, "2Y": 0.026, "3Y": 0.027, "5Y": 0.029},
}

# Each coupon date adds the period's interest to the face instead of paying it.
table = hlx.bonds.capitalisations(PIK).to_dict()
print("date          year frac.  face before      capitalised    face after")
for k, paid in enumerate(table["date"]):
    print(
        f"{paid}    {table['year_fraction'][k]:.6f}    {table['face_before'][k]:.2f}"
        f"    {table['amount'][k]:.2f}    {table['face_after'][k]:.2f}"
    )

# The accreted face on any date: the face at issue, then larger after each
# capitalisation, and flat in between.
probes = [ISSUE, dt.date(2026, 7, 1), dt.date(2027, 1, 2), dt.date(2029, 6, 30), MATURITY]
faces = [hlx.bonds.accreted_face(PIK, at) for at in probes]
for at, value in zip(probes, faces):
    print(f"face on {at}    {value:.2f}")
factor = faces[-1] / FACE
print(f"factor at maturity    {factor:.10f}")
print(f"(1 + r)^5             {(1.0 + RATE) ** 5:.10f}")
print(f"1 + 5r                {1.0 + 5.0 * RATE:.10f}")

# A PIK pays nothing until maturity, when it redeems the accreted face. Its
# value is that one flow at the curve's discount factor. At a yield, the dirty
# price per 100 of par face is the redemption discounted.
settlement = dt.date(2028, 7, 3)
market = hlx.MarketContext(settlement).with_recipe_quotes("EUR", EUR_ESTR_JULY_2028)
redemption = hlx.bonds.accreted_redemption(PIK)
value = PIK.npv(market)
tau = (MATURITY - settlement).days / 365.0
price_par = redemption * (1.0 + 0.10) ** -tau
print(f"redemption per 100    {redemption:.6f}")
print(f"value off the curve   {value:.2f}")
print(f"dirty per 100 at 10%  {price_par:.6f}")

# A zero rate capitalises nothing and a negative one would shrink the face.
refusals = 0
for rate in [0.0, -0.01]:
    try:
        hlx.products.payment_in_kind_bond("EUR", ISSUE, MATURITY, rate=rate, frequency="annual", day_count="ACT/365.FIXED", face=FACE)
    except ValueError:
        refusals += 1
print(f"refused {refusals} of 2 non-positive rates")