Templates and builders

use chrono::{Datelike, NaiveDate};
use helixio_docs_sheets::{SOFR_CLOSE_DATE, USD_SOFR_CLOSE};
use helixrs::{
    AnyTemplate, CollateralSpec, MarketContext, QuoteSheet, Side, Termination, spot_effective_date,
    template,
};

type Outcome<T> = Result<T, Box<dyn std::error::Error>>;

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

fn main() -> Outcome<()> {
    let close = date(SOFR_CLOSE_DATE);
    let sheet = QuoteSheet::from_rows(USD_SOFR_CLOSE.iter().copied())?;
    let market =
        MarketContext::as_of(close).with_recipe_quotes(&CollateralSpec::Currency("USD".parse()?), &sheet)?;
    let sofr = template("USD-SOFR-OIS")?;

    // The draft starts at the template's spot date and runs the stated tenor.
    let AnyTemplate::Ois(ois) = &sofr else { unreachable!("an overnight template") };
    let spot = spot_effective_date(&ois.calendar, close, ois.spot_lag, ois.business_day_convention);
    let swap = sofr
        .swap(close)?
        .with_maturity("5Y".parse::<Termination>()?)?
        .with_notional(25_000_000.0)
        .with_side(Side::Payer)
        .with_fixed_rate(0.0465)
        .build()?;
    let dates = swap.contract_dates();
    println!("spot          {spot}");
    println!("effective     {}", dates[0].1);
    println!("termination   {}", dates[1].1);

    // A forward tenor `2Y3Y` starts two years after spot and runs three; a stated
    // termination date ends the swap on that date instead of a tenor.
    let forward = sofr
        .swap(close)?
        .with_maturity("2Y3Y".parse::<Termination>()?)?
        .with_fixed_rate(0.0470)
        .build()?;
    let dated = sofr
        .swap(close)?
        .with_termination(date((2031, 10, 7)))?
        .with_fixed_rate(0.0470)
        .build()?;
    let (forward_dates, dated_dates) = (forward.contract_dates(), dated.contract_dates());
    println!("2Y3Y          {} to {}", forward_dates[0].1, forward_dates[1].1);
    println!("to a date     {} to {}", dated_dates[0].1, dated_dates[1].1);

    // The one term the market decides is the rate: `at_par` strikes it.
    let fair = sofr
        .swap(close)?
        .with_maturity("5Y".parse::<Termination>()?)?
        .with_notional(25_000_000.0)
        .with_side(Side::Payer)
        .at_par(&market)?;
    let par = fair.par_rate(&market)?;
    println!("struck at     {par:.8}");
    // Its value on that market is nothing, to the cent; abs drops the sign of rounding.
    println!("worth         {:.2}", fair.npv(&market)?.abs());

    // A draft with no rate and no market to strike it on refuses, and says how to
    // state one.
    let refused = sofr
        .swap(close)?
        .with_maturity("5Y".parse::<Termination>()?)?
        .build()
        .expect_err("a draft with no rate must refuse");
    let names_at_par = refused.to_string().contains("at_par");
    println!("refused, pointing at at_par: {}", if names_at_par { "yes" } else { "no" });

    Ok(())
}

import datetime as dt

import helixio as hlx
from desk_sheets import SOFR_CLOSE_DATE, USD_SOFR_CLOSE

market = hlx.MarketContext(SOFR_CLOSE_DATE).with_recipe_quotes("USD", USD_SOFR_CLOSE)
sofr = hlx.templates.get("USD-SOFR-OIS")

# The draft starts at the template's spot date and runs the stated tenor.
spot = sofr.spot_date(SOFR_CLOSE_DATE)
swap = (
    sofr.swap(SOFR_CLOSE_DATE)
    .with_maturity("5Y")
    .with_notional(25_000_000.0)
    .with_side("payer")
    .with_fixed_rate(0.0465)
    .build()
)
dates = dict(swap.contract_dates())
print(f"spot          {spot}")
print(f"effective     {dates['effective']}")
print(f"termination   {dates['termination']}")

# A forward tenor `2Y3Y` starts two years after spot and runs three; a stated
# termination date ends the swap on that date instead of a tenor.
forward = sofr.swap(SOFR_CLOSE_DATE).with_maturity("2Y3Y").with_fixed_rate(0.0470).build()
dated = sofr.swap(SOFR_CLOSE_DATE).with_termination(dt.date(2031, 10, 7)).with_fixed_rate(0.0470).build()
forward_dates, dated_dates = dict(forward.contract_dates()), dict(dated.contract_dates())
print(f"2Y3Y          {forward_dates['effective']} to {forward_dates['termination']}")
print(f"to a date     {dated_dates['effective']} to {dated_dates['termination']}")

# The one term the market decides is the rate: `at_par` strikes it.
fair = sofr.swap(SOFR_CLOSE_DATE).with_maturity("5Y").with_notional(25_000_000.0).with_side("payer").at_par(market)
par = fair.par_rate(market)
print(f"struck at     {par:.8f}")
# Its value on that market is nothing, to the cent; abs drops the sign of rounding.
print(f"worth         {abs(fair.npv(market)):.2f}")

# A draft with no rate and no market to strike it on refuses, and says how to
# state one.
try:
    sofr.swap(SOFR_CLOSE_DATE).with_maturity("5Y").build()
except ValueError as refused:
    no_rate = str(refused)
    print(f"refused, pointing at at_par: {'yes' if 'at_par' in no_rate else 'no'}")
else:
    raise AssertionError("a draft with no rate must refuse")