#[macro_use] extern crate log;

use log::LevelFilter;

use yopa::{model, InMemoryStorage};
use yopa::model::DataType;
use yopa::insert::{InsertObj, InsertValue, InsertRel};
use yopa::data::TypedValue;

fn main() {
    simple_logging::log_to_stderr(LevelFilter::Debug);

    main_test_recipes().unwrap();
}

#[allow(non_snake_case)]
fn main_test_recipes() -> anyhow::Result<()> {
    simple_logging::log_to_stderr(LevelFilter::Debug);

    let mut store = yopa::InMemoryStorage::new();

    let Recipe = store.define_object(model::ObjectModel {
        id: Default::default(),
        name: "recipe".to_string(),
        parent: None
    })?;

    let RecipeTitle = store.define_property(model::PropertyModel {
        id: Default::default(),
        object: Recipe,
        name: "title".to_string(),
        optional: false,
        multiple: false,
        data_type: DataType::String,
        default: None
    })?;

    let _PrepHours = store.define_property(model::PropertyModel {
        id: Default::default(),
        object: Recipe,
        name: "prep_hours".to_string(),
        optional: true,
        multiple: false,
        data_type: DataType::Decimal,
        default: None
    })?;

    let Book = store.define_object(model::ObjectModel {
        id: Default::default(),
        name: "book".to_string(),
        parent: None
    })?;

    let BookName = store.define_property(model::PropertyModel {
        id: Default::default(),
        object: Book,
        name: "name".to_string(),
        optional: false,
        multiple: false,
        data_type: DataType::String,
        default: None
    })?;

    let BookToRecipe = store.define_relation(model::RelationModel {
        id: Default::default(),
        object: Recipe,
        name: "book reference".to_string(),
        optional: true,
        multiple: true,
        related: Book
    })?;

    let BookToRecipePage = store.define_property(model::PropertyModel {
        id: Default::default(),
        object: BookToRecipe,
        name: "page".to_string(),
        optional: false,
        multiple: false,
        data_type: DataType::Integer,
        default: None
    })?;

    debug!("{:#?}", store);

    let MyBook1 = store.insert_object(InsertObj {
        model_id: Book,
        values: vec![
            InsertValue::new(BookName, TypedValue::String("Recipe Book 1".into())),
        ],
        relations: vec![],
    })?;

    store.insert_object(InsertObj {
        model_id: Recipe,
        values: vec![
            InsertValue::new(RecipeTitle, TypedValue::String("Pancakes".into())),
        ],
        relations: vec![
            InsertRel {
                model_id: BookToRecipe,
                related_id: MyBook1,
                values: vec![
                    InsertValue::new(BookToRecipePage, TypedValue::Integer(123))
                ]
            }
        ],
    })?;

    debug!("{:#?}", store);

    let as_s = serde_json::to_string_pretty(&store).unwrap();

    println!("{}", as_s);

    let _back : InMemoryStorage = serde_json::from_str(&as_s)?;

    debug!("After unpack: {:#?}", store);

    Ok(())
}