use owl::prelude::*;

#[model]
#[derive(Debug)]
pub struct Item {
    pub id: Id,
    pub cost: f64,
    pub strength: f64,
}

pub fn main() {
    // Init
    let db = Database::in_memory();

    // Save
    let item = Item {
        id: Id::new_ulid(),
        cost: 1.80,
        strength: 0.4,
    };

    let first_id = item.id.clone();

    dbg!(&item);
    let item = db.save(item);

    // Get
    let i: Model<Item> = db.get(item.read().id.clone()).unwrap();

    dbg!(&i.read());

    db.save(Item {
        id: Id::new_ulid(),
        cost: 0.3,
        strength: 2.4,
    });

    db.save(Item {
        id: Id::new_ulid(),
        cost: 3.4,
        strength: 0.4,
    });

    db.save(Item {
        id: Id::new_ulid(),
        cost: 20.0,
        strength: 200.5,
    });

    db.save(Item {
        id: Id::new_ulid(),
        cost: 4.2,
        strength: 4.2,
    });

    // Query
    let res = db.query(|x: &Item| x.cost > 1.5);
    dbg!(&res
        .into_iter()
        .map(|x| format!("{:?}", x.read()))
        .collect::<Vec<_>>());

    // Update
    db.update(&mut db.query(|x: &Item| x.cost > 1.5), |x: &mut Item| {
        x.cost += 1.0;
    });

    let item: Model<Item> = db.get(first_id.to_string().as_str()).unwrap();
    dbg!(&item.read());
    assert_eq!(item.read().cost, 2.80);

    // Aggregates
    let count = db.query(|x: &Item| x.cost > 1.5).len();
    let sum: f64 = db
        .query(|x: &Item| x.cost > 1.5)
        .iter()
        .map(|x| x.read().cost)
        .sum();
    dbg!(count);
    dbg!(sum);
}