mod errors;
mod store;
mod structs;

pub use crate::errors::NoteStoreError;
pub use crate::store::NoteStore;

#[cfg(test)]
mod tests {
    use super::*;
    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
    }

    #[tokio::test(threaded_scheduler)]
    async fn fetching_unfound_page_works() {
        let storagepool = fresh_inmemory_database().await;
        let unfoundpage = storagepool.fetch_raw_page("nonexistent-page").await;
        assert!(unfoundpage.is_err());
    }

    #[tokio::test(threaded_scheduler)]
    async fn fetching_unfound_note_works() {
        let storagepool = fresh_inmemory_database().await;
        let unfoundnote = storagepool.fetch_raw_note("nonexistent-note").await;
        assert!(unfoundnote.is_err());
    }

    #[tokio::test(threaded_scheduler)]
    async fn cloning_storagepool_is_ok() {
        let storagepool = fresh_inmemory_database().await;
        let storagepool2 = storagepool.clone();
        let unfoundnote = storagepool2.fetch_raw_note("nonexistent-note").await;
        assert!(unfoundnote.is_err());
        let unfoundnote = storagepool.fetch_raw_note("nonexistent-note").await;
        assert!(unfoundnote.is_err());
    }

    #[tokio::test(threaded_scheduler)]
    async fn can_save_a_note() {
        let storagepool = fresh_inmemory_database().await;
        let note_id = storagepool.insert_note("noteid", "notecontent", "note").await;
        assert!(note_id.is_ok(), "{:?}", note_id);
        let note_id = note_id.unwrap();
        assert!(note_id > 0);

        let foundnote = storagepool.fetch_raw_note("noteid").await;
        assert!(foundnote.is_ok(), "{:?}", foundnote);
        let foundnote = foundnote.unwrap();
        assert_eq!(foundnote.content, "notecontent");
        assert_eq!(foundnote.notetype, "note");
    }

    #[tokio::test(threaded_scheduler)]
    async fn can_save_a_page() {
        let storagepool = fresh_inmemory_database().await;
        let page_id = storagepool.insert_page("pageid", "Test page").await;
        assert!(page_id.is_ok(), "{:?}", page_id);

        let page = storagepool.fetch_raw_page("pageid").await;
        assert!(page.is_ok(), "{:?}", page);
        let page = page.unwrap();
        assert_eq!(page.title, "Test page");
        assert!(page.note_id > 0);
    }

    #[tokio::test(threaded_scheduler)]
    async fn reports_note_update_failure() {
        let storagepool = fresh_inmemory_database().await;
        let note_id = storagepool.insert_note("noteid", "notecontent", "note").await;
        assert!(note_id.is_ok(), "{:?}", note_id);

		let update = storagepool.update_raw_note("badnote", "Bad Note Content").await;
		assert!(update.is_err());
	}


    #[tokio::test(threaded_scheduler)]
    async fn can_update_a_note() {
        let storagepool = fresh_inmemory_database().await;
        let note_id = storagepool.insert_note("noteid", "notecontent", "note").await;
        assert!(note_id.is_ok(), "{:?}", note_id);

		let update = storagepool.update_raw_note("noteid", "Good Note Content").await;
		assert!(update.is_ok(), "{:?}", update);

		let note = storagepool.fetch_raw_note("noteid").await;
		assert!(note.is_ok(), "{:?}", note);
		let note = note.unwrap();
		assert_eq!(note.content, "Good Note Content");
    }
}