use query_flow::{query, QueryContext, QueryError, QueryRuntime};
#[query]
fn add(ctx: &mut QueryContext, a: i32, b: i32) -> Result<i32, QueryError> {
    Ok(a + b)
}
let runtime = QueryRuntime::new();
let result = runtime.query(Add::new(1, 2)).unwrap();
assert_eq!(*result, 3);

use query_flow::{query, QueryContext, QueryError};
// Basic query - generates `Add` struct
#[query]
fn add(ctx: &mut QueryContext, a: i32, b: i32) -> Result<i32, QueryError> {
    Ok(a + b)
}
// Query with dependencies
#[query]
fn double_sum(ctx: &mut QueryContext, a: i32, b: i32) -> Result<i32, QueryError> {
    let sum = ctx.query(Add::new(*a, *b))?;
    Ok(*sum * 2)
}

// Custom durability (0-3, higher = changes less frequently)
#[query(durability = 2)]
fn stable_query(ctx: &mut QueryContext, id: u64) -> Result<Data, QueryError> { ... }
// Selective cache keys - only `id` is part of the key
#[query(keys(id))]
fn fetch_user(ctx: &mut QueryContext, id: u64, include_deleted: bool) -> Result<User, QueryError> {
    // Queries with same `id` share cache, regardless of `include_deleted`
}
// Custom struct name
#[query(name = "FetchUserById")]
fn fetch_user(ctx: &mut QueryContext, id: u64) -> Result<User, QueryError> { ... }
// Custom output equality (for types without PartialEq)
#[query(output_eq = my_custom_eq)]
fn complex_query(ctx: &mut QueryContext) -> Result<ComplexType, QueryError> { ... }

use query_flow::{Query, QueryContext, QueryError, Key};
struct Add { a: i32, b: i32 }
impl Query for Add {
    type CacheKey = (i32, i32);
    type Output = i32;
    fn cache_key(&self) -> Self::CacheKey {
        (self.a, self.b)
    }
    fn query(&self, _ctx: &mut QueryContext) -> Result<Self::Output, QueryError> {
        Ok(self.a + self.b)
    }
    fn output_eq(old: &Self::Output, new: &Self::Output) -> bool {
        old == new
    }
}

// User errors with ? operator - errors are automatically converted
#[query]
fn parse_int(ctx: &mut QueryContext, input: String) -> Result<i32, QueryError> {
    let num: i32 = input.parse()?;  // ParseIntError -> QueryError::UserError
    Ok(num)
}
// System errors propagate automatically
#[query]
fn process(ctx: &mut QueryContext, id: u64) -> Result<Output, QueryError> {
    let data = ctx.query(FetchData::new(id))?;  // Propagates Suspend, Cycle, UserError, etc.
    Ok(transform(*data))
}

let runtime = QueryRuntime::builder()
    .error_comparator(|a, b| {
        // Treat errors as equal if they have the same message
        a.to_string() == b.to_string()
    })
    .build();

use query_flow::{asset_key, AssetKey, DurabilityLevel};
use std::path::PathBuf;
// Using the macro
#[asset_key(asset = String)]
pub struct ConfigFile(pub PathBuf);
// With durability hint
#[asset_key(asset = String, durability = constant)]
pub struct BundledAsset(pub PathBuf);
// Manual implementation
pub struct TextureId(pub u32);
impl AssetKey for TextureId {
    type Asset = ImageData;
    fn asset_eq(old: &Self::Asset, new: &Self::Asset) -> bool {
        old.bytes == new.bytes
    }
    fn durability(&self) -> DurabilityLevel {
        DurabilityLevel::Stable
    }
}

#[query]
fn process_config(ctx: &mut QueryContext, path: PathBuf) -> Result<Config, QueryError> {
    // Get asset - returns LoadingState<Arc<String>>
    let content = ctx.asset(&ConfigFile(path.clone()))?;
    // Suspend if not ready (propagates to caller)
    let content = content.suspend()?;
    // Parse and return
    Ok(parse_config(&content))
}

let runtime = QueryRuntime::new();
// Optional: Register a locator for immediate resolution
runtime.register_asset_locator(MyFileLocator::new());
// Execute query - may return Err(Suspend) if assets are loading
match runtime.query(ProcessConfig::new(path)) {
    Ok(result) => println!("Done: {:?}", result),
    Err(QueryError::Suspend) => {
        // Handle pending assets
        for pending in runtime.pending_assets() {
            if let Some(path) = pending.key::<ConfigFile>() {
                let content = std::fs::read_to_string(&path.0)?;
                runtime.resolve_asset(path.clone(), content);
            }
        }
        // Retry query
        let result = runtime.query(ProcessConfig::new(path))?;
    }
    Err(e) => return Err(e),
}

// File was modified externally
runtime.invalidate_asset(&ConfigFile(path));
// Dependent queries will now suspend until resolved
// Remove asset entirely
runtime.remove_asset(&ConfigFile(path));

/// LoadingState<T> represents async loading state
pub enum LoadingState<T> {
    Loading,
    Ready(T),
}
impl<T> LoadingState<T> {
    /// Convert to Result - Loading becomes Err(Suspend)
    pub fn suspend(self) -> Result<T, QueryError>;
    pub fn is_loading(&self) -> bool;
    pub fn is_ready(&self) -> bool;
    pub fn get(&self) -> Option<&T>;
    pub fn map<U>(self, f: impl FnOnce(T) -> U) -> LoadingState<U>;
}

let runtime = QueryRuntime::new();
// Execute queries
let result = runtime.query(MyQuery::new(...))?;
// Invalidation
runtime.invalidate::<MyQuery>(&cache_key);
runtime.clear_cache();
// Asset management
runtime.register_asset_locator(locator);
runtime.resolve_asset(key, value);
runtime.invalidate_asset(&key);
runtime.remove_asset(&key);
// Pending assets
runtime.pending_assets();           // All pending
runtime.pending_assets_of::<K>();   // Filtered by type
runtime.has_pending_assets();