//! `minimal_cache_only` — the smallest runnable JouleClaw cascade.
//!
//! Boots a default stack, asks one question twice, and shows that the
//! L0 cache served the second hit at floor energy. The Bloom-tier
//! framing's *Remember* category in action.
//!
//! Run with:
//!     cargo run -p jouleclaw-stack --example minimal_cache_only

use jouleclaw_cascade::tier::Runtime;
use jouleclaw_cascade::types::{
    ContextRef, JouleBudget, QualityFloor, Query, QueryInput,
};
use jouleclaw_stack::JouleClawStack;

fn make_query(text: &str) -> Query {
    Query {
        input: QueryInput::Text(text.to_string()),
        budget: JouleBudget::expensive(),
        quality: QualityFloor::any(),
        context: ContextRef::fresh(),
        deadline: None,
    }
}

fn main() {
    let mut stack = JouleClawStack::with_defaults();
    let question = "what is the magic word?";

    println!("first ask  → walks the full cascade");
    let r1 = first_ask(&mut stack.runtime, question);

    println!("second ask → should be a cache hit");
    let r2 = first_ask(&mut stack.runtime, question);

    println!("\nresults:");
    println!("  ask 1: tier={}  joules={:.6}", r1.tier, r1.joules);
    println!("  ask 2: tier={}  joules={:.6}", r2.tier, r2.joules);
    if r2.joules <= r1.joules {
        println!("\n✓ cascade preferred the cheaper tier on repeat.");
    }
}

struct Resolved {
    tier: String,
    joules: f64,
}

fn first_ask(runtime: &mut Runtime, question: &str) -> Resolved {
    let answer = runtime.answer(make_query(question)).expect("cascade walks");
    Resolved {
        tier: answer.tier_used.wire_tag().to_string(),
        joules: answer.joules_spent,
    }
}