mod errors;
mod reference_parser;
mod store;
mod store_private;
mod structs;

pub use crate::errors::NoteStoreError;
pub use crate::store::NoteStore;
pub use crate::structs::{Note, NoteKind};

#[cfg(test)]
mod tests {
    use super::*;
    use chrono;
    use tokio;

    async fn fresh_inmemory_database() -> NoteStore {
        let storagepool = NoteStore::new("sqlite://:memory:").await;
        assert!(storagepool.is_ok(), "{:?}", storagepool);
        let storagepool = storagepool.unwrap();
        let reset = storagepool.reset_database().await;
        assert!(reset.is_ok(), "{:?}", reset);
        storagepool
    }

    // Request for the page by slug.  If the page exists, return it.
    // If the page doesn't, return NotFound
    //
    #[tokio::test(threaded_scheduler)]
    async fn fetching_unfound_page_by_slug_works() {
        let storagepool = fresh_inmemory_database().await;
        let foundkasten = storagepool.get_kasten_by_slug("nonexistent-kasten").await;
        assert!(foundkasten.is_err());
    }

    // Request for the page by title.  If the page exists, return it.
    // If the page doesn't exist, create it then return it anyway.
    // There should be at least one note, the root note.

    #[tokio::test(threaded_scheduler)]
    async fn fetching_unfound_page_by_title_works() {
        let title = "Nonexistent Page";
        let now = chrono::Utc::now();
        let storagepool = fresh_inmemory_database().await;
        let newpageresult = storagepool.get_kasten_by_title(&title).await;

        assert!(newpageresult.is_ok(), "{:?}", newpageresult);
        let (newpages, _) = newpageresult.unwrap();

        assert_eq!(newpages.len(), 1);
        let newpage = newpages.iter().next().unwrap();

        assert_eq!(newpage.content, title, "{:?}", newpage.content);
        assert_eq!(newpage.id, "nonexistent-page");
        assert_eq!(newpage.kind, NoteKind::Kasten);
        assert!((newpage.creation_date - now).num_minutes() < 1);
        assert!((newpage.updated_date - now).num_minutes() < 1);
        assert!((newpage.lastview_date - now).num_minutes() < 1);
        assert!(newpage.deleted_date.is_none());
    }

    fn make_new_note(content: &str) -> structs::NewNote {
        structs::NewNoteBuilder::default()
            .content(content.to_string())
            .build()
            .unwrap()
    }

    #[tokio::test(threaded_scheduler)]
    async fn can_nest_notes() {
        let title = "Nonexistent Page";
        let storagepool = fresh_inmemory_database().await;
        let newpageresult = storagepool.get_kasten_by_title(&title).await;

        assert!(newpageresult.is_ok(), "{:?}", newpageresult);
        let (newpages, _) = newpageresult.unwrap();
        assert_eq!(newpages.len(), 1);
        let root = &newpages[0];

        // root <- 1 <- 3
        //      <- 2 <- 4

        let note1 = make_new_note("1");
        let note1_id = storagepool.add_note(&note1, &root.id, 0).await;
        assert!(note1_id.is_ok(), "{:?}", note1_id);
        let note1_id = note1_id.unwrap();

        let note2 = make_new_note("2");
        let note2_id = storagepool.add_note(&note2, &root.id, 0).await;
        assert!(note2_id.is_ok(), "{:?}", note2_id);
        let note2_id = note2_id.unwrap();

        let note3 = make_new_note("3");
        let note3_id = storagepool.add_note(&note3, &note1_id, 0).await;
        assert!(note3_id.is_ok(), "{:?}", note3_id);
        let _note3_id = note3_id.unwrap();

        let note4 = make_new_note("4");
        let note4_id = storagepool.add_note(&note4, &note2_id, 0).await;
        assert!(note4_id.is_ok(), "{:?}", note4_id);
        let _note4_id = note4_id.unwrap();

        let newpageresult = storagepool.get_kasten_by_title(&title).await;
        assert!(newpageresult.is_ok(), "{:?}", newpageresult);
        let (newpages, _) = newpageresult.unwrap();

        assert_eq!(newpages.len(), 5);
        let newroot = newpages.iter().next().unwrap();

        assert_eq!(newroot.content, title, "{:?}", newroot.content);
        assert_eq!(newroot.id, "nonexistent-page");

        assert_eq!(newpages[1].parent_id, Some(newroot.id.clone()));
        assert_eq!(newpages[2].parent_id, Some(newpages[1].id.clone()));
    }

	
}