use owl::{db::model::person::Person, prelude::*};
#[relation("receiver", Person, "payer", Person, RelationKind::Bidirectional)]
pub struct LoanRelation {
    debt: f64,
}

pub fn lend_money(who: &Model<Person>, from: &Model<Person>, amount: f64, db: &Database) {
    LoanRelation { debt: amount }.add(who, from, None, db)
}

pub fn pay_off(who: &Model<Person>, to: &Model<Person>, amount: f64, db: &Database) {
    let mut loan = LoanRelation::get(who, to, db).unwrap();
    loan.write(db, |loan| {
        loan.alter_meta(|x: &mut _| {
            x.debt -= amount;
        });
    });
}

pub fn main() {
    env_logger::init();

    let db = Database::filesystem("./db");
    let p = db.save(Person::new_id("myperson", "first", "last"));
    let p2 = db.save(Person::new_id("secperson", "second", "last"));
    let banker = db.save(Person::new_id("banker", "boss", "bank"));

    lend_money(&p, &banker, 250.0, &db);

    lend_money(&p2, &p, 100.0, &db);

    lend_money(&p2, &banker, 150.0, &db);

    let financer: Vec<_> = LoanRelation::get_payer_of(&p2, &db)
        .into_iter()
        .map(|x| LoanRelation::payer(&x.dereference(&db), &db))
        .map(|x| x.read().first_name.current().cloned().unwrap())
        .collect();
    println!(
        "{} is financed by {:?}",
        p2.read().first_name.current().unwrap(),
        financer
    );

    let brokers = LoanRelation::get_receiver_of(&p, &db);
    dbg!(&brokers);
    let brokers = dereference(&brokers, &db);

    brokers.iter().for_each(|x| println!("{:?}", x.read()));

    pay_off(&p2, &p, 100.0, &db);

    let brokers = dereference(&LoanRelation::get_receiver_of(&p, &db), &db);
    brokers.iter().for_each(|x| println!("{:?}", x.read()));
}