Quote sheets and recipes

use std::collections::BTreeSet;

use chrono::NaiveDate;
use helixio_docs_sheets::{SOFR_CLOSE_DATE, USD_SOFR_LADDER};
use helixrs::{CollateralSpec, MarketContext, QuoteSheet, YieldCurve};

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 usd = CollateralSpec::Currency("USD".parse()?);

    // A bare market already knows how to build every curve helixio ships a recipe
    // for. Each row is one segment of one curve: which template quotes it, and in
    // which role.
    let base = MarketContext::as_of(close);
    let rows = base.recipes();
    let (key, curve, role, template) = (
        rows["key"].text().expect("text"),
        rows["curve"].text().expect("text"),
        rows["role"].text().expect("text"),
        rows["template"].text().expect("text"),
    );
    let keys: BTreeSet<&str> = key.iter().map(String::as_str).collect();
    println!("recipe keys {}", keys.len());
    for i in 0..rows.len() {
        if key[i] == "USD" {
            println!("USD  {:<17} {:<12} {}", curve[i], role[i], template[i]);
        }
    }

    // The sheet names every segment the USD recipe builds from, short end first: a
    // deposit at a tenor, a policy meeting at its decision date, futures at their
    // contract codes (quoted as prices), and swaps at their tenors.
    let ladder = QuoteSheet::from_rows(USD_SOFR_LADDER.iter().copied())?;
    let market = base.clone().with_recipe_quotes(&usd, &ladder)?;
    let quotes = USD_SOFR_LADDER.len();
    let (discount, _) = market.curve(&"discount(USD)".parse()?).expect("the USD curve");
    println!("quotes      {quotes}");
    println!("parameters  {}", discount.parameter_count());

    // Each quote became a rung: an instrument struck at that quote. The curve was
    // solved so that every rung is worth nothing on it — so pricing each one back
    // is the check that the market says what the sheet said.
    let mut worst: f64 = 0.0;
    for rung in base.recipe_rungs(&usd, &ladder)? {
        let value = rung.instrument.npv(&market)?;
        worst = worst.max(value.abs());
        println!("{}  quote {:.6}", rung.pillar, rung.quote);
    }
    println!("largest rung value per unit notional below 1e-12: {}", if worst < 1e-12 { "yes" } else { "no" });

    // A template the recipe does not list is refused, and the refusal names the
    // templates it does list, so a mistyped sheet fails where it is written.
    let stray = QuoteSheet::from_rows([("USD-LIBOR-3M", "5Y", 0.05)])?;
    let refused = base
        .with_recipe_quotes(&usd, &stray)
        .expect_err("an unlisted template must be refused");
    let names_listed = refused.to_string().contains("USD-SOFR-OIS");
    println!(
        "refused, naming the listed USD-SOFR-OIS: {}",
        if names_listed { "yes" } else { "no" }
    );

    Ok(())
}

import helixio as hlx
from desk_sheets import SOFR_CLOSE_DATE, USD_SOFR_LADDER

# A bare market already knows how to build every curve helixio ships a recipe
# for. Each row is one segment of one curve: which template quotes it, and in
# which role.
base = hlx.MarketContext(SOFR_CLOSE_DATE)
rows = base.recipes().to_dict()
keys = sorted(set(rows["key"]))
print(f"recipe keys {len(keys)}")
for key, curve, role, template in zip(rows["key"], rows["curve"], rows["role"], rows["template"]):
    if key == "USD":
        print(f"USD  {curve:<17} {role:<12} {template}")

# The sheet names every segment the USD recipe builds from, short end first: a
# deposit at a tenor, a policy meeting at its decision date, futures at their
# contract codes (quoted as prices), and swaps at their tenors.
market = base.with_recipe_quotes("USD", USD_SOFR_LADDER)
quotes = sum(len(segment) for segment in USD_SOFR_LADDER.values())
curve = market.curve("discount(USD)")
print(f"quotes      {quotes}")
print(f"parameters  {curve.parameter_count()}")

# Each quote became a rung: an instrument struck at that quote. The curve was
# solved so that every rung is worth nothing on it — so pricing each one back
# is the check that the market says what the sheet said.
worst = 0.0
for rung in base.recipe_rungs("USD", USD_SOFR_LADDER):
    value = rung.instrument().npv(market)
    worst = max(worst, abs(value))
    print(f"{rung.pillar()}  quote {rung.quote():.6f}")
print(f"largest rung value per unit notional below 1e-12: {'yes' if worst < 1e-12 else 'no'}")

# A template the recipe does not list is refused, and the refusal names the
# templates it does list, so a mistyped sheet fails where it is written.
try:
    base.with_recipe_quotes("USD", {"USD-LIBOR-3M": {"5Y": 0.05}})
except ValueError as error:
    unlisted = str(error)
    print(f"refused, naming the listed USD-SOFR-OIS: {'yes' if 'USD-SOFR-OIS' in unlisted else 'no'}")
else:
    raise AssertionError("an unlisted template must be refused")