Fixings: prints and projections

use chrono::NaiveDate;
use helixio_docs_sheets::{SOFR_CLOSE_DATE, USD_SOFR_LADDER, USD_SOFR_PRINTS};
use helixrs::{
    Book, FixingKey, FixingStore, Locator, MarketContext, MarketData, StripQuotes, Termination,
    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 joined(needs: &[(String, NaiveDate)]) -> String {
    needs
        .iter()
        .map(|(_, d)| d.to_string())
        .collect::<Vec<_>>()
        .join(", ")
}

fn main() -> Outcome<()> {
    let close = date(SOFR_CLOSE_DATE);
    let next = date((2026, 10, 2));
    // A two-year SOFR swap traded on 24 September, receiving 4.50% fixed: it pays
    // SOFR from Monday 28 September.
    let swap = template("USD-SOFR-OIS")?
        .swap(date((2026, 9, 24)))?
        .with_maturity("2Y".parse::<Termination>()?)?
        .with_notional(10_000_000.0)
        .with_fixed_rate(0.0450)
        .build()?;

    // On the close, the reset of the close itself is projected: the print comes out
    // the next morning. A day later it is a print the valuation needs.
    let on_close = swap.fixings_needed(close);
    let next_day = swap.fixings_needed(next);
    println!("on {close}  {}", joined(&on_close));
    println!("on {next}  {}", joined(&next_day));

    // The prints arrive through the market's demand, as a fetch would bring them.
    let book = Book::new().add("SOFR-2Y", swap.clone(), 1.0);
    let offline = MarketContext::as_of(close);
    let demand = offline.demand(&book)?;
    let mut strips = Vec::new();
    for asked in &demand.strips {
        let mut entries = Vec::new();
        for (_, locator, quote) in USD_SOFR_LADDER.iter().filter(|(t, _, _)| *t == asked.template) {
            entries.push((Locator::parse(locator)?, *quote));
        }
        strips.push(StripQuotes {
            template: asked.template.clone(),
            observed: close,
            entries,
        });
    }
    let answer = MarketData {
        strips,
        fixings: USD_SOFR_PRINTS
            .iter()
            .map(|(series, day, value)| ((*series).to_owned(), date(*day), *value))
            .collect(),
        fx: Vec::new(),
    };
    let fetched = offline.with_market_data(&demand, &answer)?;
    println!("npv on fetched prints  {:.2}", swap.npv(&fetched)?);

    // A corrected 30 September print, pinned by hand, is read over the fetched one;
    // the fetched version stays in the history.
    let correction = [(
        FixingKey::Typed("USD-SOFR".to_owned()),
        date((2026, 9, 30)),
        0.0395,
    )];
    let corrected = fetched
        .clone()
        .with_fixings(FixingStore::from_observations_checked(&correction)?);
    for (_, day, _, pinned, value) in corrected.fixing_history().versions() {
        let source = if pinned { "pinned" } else { "fetched" };
        println!("{day}  {source:<7}  {value:.4}");
    }
    let read = corrected.try_fixing("USD-SOFR", date((2026, 9, 30))).expect("a print");
    println!("read on 2026-09-30  {read:.4}");
    println!("npv on the correction  {:.2}", swap.npv(&corrected)?);

    Ok(())
}

import datetime as dt

import helixio as hlx
from desk_sheets import SOFR_CLOSE_DATE, USD_SOFR_LADDER, USD_SOFR_PRINTS

# A two-year SOFR swap traded on 24 September, receiving 4.50% fixed: it pays
# SOFR from Monday 28 September.
swap = (
    hlx.templates.get("USD-SOFR-OIS")
    .swap(dt.date(2026, 9, 24))
    .with_maturity("2Y")
    .with_notional(10_000_000.0)
    .with_fixed_rate(0.0450)
    .build()
)

# On the close, the reset of the close itself is projected: the print comes out
# the next morning. A day later it is a print the valuation needs.
on_close = swap.fixings_needed(SOFR_CLOSE_DATE)
next_day = swap.fixings_needed(dt.date(2026, 10, 2))
print(f"on {SOFR_CLOSE_DATE}  {', '.join(d.isoformat() for _, d in on_close)}")
print(f"on 2026-10-02  {', '.join(d.isoformat() for _, d in next_day)}")

# The prints arrive through the market's demand, as a fetch would bring them.
book = hlx.Book().add("SOFR-2Y", swap, 1.0)
offline = hlx.MarketContext(SOFR_CLOSE_DATE)
demand = offline.demand(book)
answer = hlx.MarketData(
    strips=[
        (template, SOFR_CLOSE_DATE, list(USD_SOFR_LADDER[template].items()))
        for template in demand.strips.to_dict()["template"]
    ],
    fixings=list(USD_SOFR_PRINTS),
)
fetched = offline.with_market_data(demand, answer)
print(f"npv on fetched prints  {swap.npv(fetched):.2f}")

# A corrected 30 September print, pinned by hand, is read over the fetched one;
# the fetched version stays in the history.
corrected = fetched.with_fixings([("USD-SOFR", dt.date(2026, 9, 30), 0.0395)])
history = corrected.fixing_history().to_dict()
for day, source, value in zip(history["date"], history["source"], history["value"]):
    print(f"{day}  {source:<7}  {value:.4f}")
read = corrected.fixing("USD-SOFR", dt.date(2026, 9, 30))
print(f"read on 2026-09-30  {read:.4f}")
print(f"npv on the correction  {swap.npv(corrected):.2f}")