Data sources

use std::sync::Arc;

use chrono::NaiveDate;
use helixio_docs_sheets::{SOFR_CLOSE_DATE, Sheet, USD_SOFR_LADDER, USD_SOFR_PRINTS};
use helixrs::{
    Book, DataSource, Demand, Locator, MarketContext, MarketData, MarketDataSource, SourceError,
    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")
}

// The source answers from the desk's sheet: every pillar of every strip it is
// asked for, observed on the day, and the prints it holds.
struct DeskSheet {
    sheet: Vec<(&'static str, &'static str, f64)>,
}

impl MarketDataSource for DeskSheet {
    fn fetch(&self, demand: &Demand, as_of: NaiveDate) -> Result<MarketData, SourceError> {
        let unreadable = |message: String| SourceError::Source {
            source: "desk sheet".to_owned(),
            message,
        };
        let mut strips = Vec::new();
        for asked in &demand.strips {
            let mut entries = Vec::new();
            for (_, locator, quote) in self.sheet.iter().filter(|(t, _, _)| *t == asked.template) {
                let at = Locator::parse(locator).map_err(|e| unreadable(e.to_string()))?;
                entries.push((at, *quote));
            }
            if !entries.is_empty() {
                strips.push(StripQuotes {
                    template: asked.template.clone(),
                    observed: as_of,
                    entries,
                });
            }
        }
        let fixings = USD_SOFR_PRINTS
            .iter()
            .map(|(series, day, value)| ((*series).to_owned(), date(*day), *value))
            .collect();
        Ok(MarketData {
            strips,
            fixings,
            fx: Vec::new(),
        })
    }
}

fn sourced(close: NaiveDate, sheet: Sheet, only: Option<&str>) -> MarketContext {
    let sheet = sheet
        .iter()
        .copied()
        .filter(|(template, _, _)| only.is_none_or(|kept| kept == *template))
        .collect();
    MarketContext::as_of(close).with_data_source(Some(DataSource::new(Arc::new(DeskSheet { sheet }))))
}

fn main() -> Outcome<()> {
    let close = date(SOFR_CLOSE_DATE);

    // A swap traded on 24 September has accrued three days by the close, so the
    // book reads three prints, and the USD recipe reads four strips.
    let seasoned = template("USD-SOFR-OIS")?
        .swap(date((2026, 9, 24)))?
        .with_maturity("5Y".parse::<Termination>()?)?
        .with_notional(50_000_000.0)
        .with_fixed_rate(0.0466)
        .build()?;
    let book = Book::new().add("SOFR-5Y", seasoned.clone(), 1.0);
    let market = sourced(close, USD_SOFR_LADDER, None);
    let demand = market.demand(&book)?;
    for strip in &demand.strips {
        println!("strip   {}", strip.template);
    }
    for (series, day) in &demand.fixings {
        println!("fixing  {series} {day}");
    }

    // Attaching the market, then fetching its date: Rust fetches nothing until
    // asked. The report says what came back.
    let mut book = book.attach_market(market);
    book.fetch_market_data(close)?;
    let npv = book.npv(close)?;
    let rows = &book.fetch_report().rows;
    let (answered, fetched) =
        (rows.iter().filter(|(_, _, status)| *status == "answered").count(), rows.len());
    println!("answered {answered} of {fetched}");
    println!("npv      {npv:.2}");

    // A valuation on 2 October reads the 1 October print, which the source does
    // not hold, so the fetch for that date is refused. The book is left where it
    // was: on the close, holding the close's snapshot alone, and still pricing.
    let next_day = date((2026, 10, 2));
    let fetch_refusal = book
        .fetch_market_data(next_day)
        .expect_err("the 1 October print is not on the source")
        .to_string();
    let held = book.market_context().expect("attached");
    let (held_as_of, held_dates) = (held.reference_date(), held.dates());
    let yes = |found: bool| if found { "yes" } else { "no" };
    println!(
        "refused, naming the 2026-10-01 print: {}",
        yes(fetch_refusal.contains("2026-10-01"))
    );
    println!("as of    {held_as_of}");
    println!("dates    {}", held_dates.len());
    let again = book.npv(close)?;
    println!("npv      {again:.2}");

    Ok(())
}

import datetime as dt

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

# The source answers from the desk's sheet: every pillar of every strip it is
# asked for, observed on the day, and the prints it holds.
class DeskSheet:
    def __init__(self, sheet):
        self.sheet = sheet

    def fetch(self, demand, as_of):
        asked = demand.strips.to_dict()["template"]
        strips = [
            (template, as_of, list(self.sheet[template].items()))
            for template in asked
            if template in self.sheet
        ]
        return hlx.MarketData(strips=strips, fixings=list(USD_SOFR_PRINTS))

# A swap traded on 24 September has accrued three days by the close, so the
# book reads three prints, and the USD recipe reads four strips.
seasoned = (
    hlx.templates.get("USD-SOFR-OIS")
    .swap(dt.date(2026, 9, 24))
    .with_maturity("5Y")
    .with_notional(50_000_000.0)
    .with_fixed_rate(0.0466)
    .build()
)
book = hlx.Book().add("SOFR-5Y", seasoned, 1.0)
market = hlx.MarketContext(SOFR_CLOSE_DATE).with_data_source(DeskSheet(USD_SOFR_LADDER))
demand = market.demand(book)
for template in demand.strips.to_dict()["template"]:
    print(f"strip   {template}")
for series, day in zip(demand.fixings.to_dict()["series"], demand.fixings.to_dict()["date"]):
    print(f"fixing  {series} {day}")

# Attaching the market fetches the market's own date; the report says what
# came back.
book.attach_market(market)
npv = book.npv(as_of=SOFR_CLOSE_DATE)
report = book.fetch_report().to_dict()
print(f"answered {report['status'].count('answered')} of {len(report['status'])}")
print(f"npv      {npv:.2f}")

# A valuation on 2 October reads the 1 October print, which the source does not
# hold, so the fetch for that date is refused. The book is left where it was:
# on the close, holding the close's snapshot alone, and still pricing — a verb
# with no date values on the close.
NEXT_DAY = dt.date(2026, 10, 2)
try:
    book.fetch_market_data(NEXT_DAY)
except hlx.SnapshotError as error:
    fetch_refusal = str(error)
else:
    raise AssertionError("the 1 October print is not on the source")
held = book.market_context
print(f"refused, naming the 2026-10-01 print: {'yes' if '2026-10-01' in fetch_refusal else 'no'}")
print(f"as of    {held.as_of()}")
print(f"dates    {len(held.dates())}")
again = book.npv()
print(f"npv      {again:.2f}")