#[macro_use]
extern crate diesel;
extern crate dotenv;

pub mod schema;
pub mod models;

mod importer;

use diesel::prelude::*;
use dotenv::dotenv;
use std::env;

pub fn establish_connection() -> SqliteConnection {
    dotenv().ok();

    let db_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set !");
    SqliteConnection::establish(&db_url)
        .expect(&format!("Error connecting to {}", db_url))
}

pub mod recipes {
    use crate::models::{Recipe};
    use super::{SqliteConnection, schema};
    use super::diesel::prelude::*;

    /// Loads all recipes from database
    pub fn load_all(conn: &SqliteConnection) -> Vec<Recipe> {
        use self::schema::recipes::dsl::*;
        recipes.load::<Recipe>(conn)
            .expect("Error loading recipe's list")
    }

    pub fn delete(conn: &SqliteConnection, recipe_id: i32) -> bool {
        use self::schema::recipes::dsl::*;

        diesel::delete(recipes.filter(id.eq(recipe_id)))
            .execute(conn)
            .is_ok()
    }
}


pub mod ingredients {
    use crate::models::{Ingredient, NewIngredient};
    use super::{SqliteConnection, schema};
    use super::diesel::prelude::*;

    pub fn find(conn: &SqliteConnection, name: &str) -> Option<Ingredient> {
        use self::schema::ingredients::dsl::*;

        let results = ingredients.filter(alias.like(name))
            .limit(1)
            .load::<Ingredient>(conn)
            .expect("Error finding ingredient");

        if !results.is_empty() {
            Some(results.into_iter().nth(0).unwrap())
        } else {
            None
        }
    }

    pub fn create(conn: &SqliteConnection, name: &str) -> usize {
        use self::schema::ingredients;

        diesel::insert_into(ingredients::table)
            .values(&NewIngredient { alias: name })
            .execute(conn)
            .expect("Error inserting ingredient")
    }
}


#[cfg(test)]
mod tests {
    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }
}