/*
 * advotracker - Hotline tackingtool for Advocats
 *
 * Copyright 2019 Ralf Zerres <ralf.zerres@networkx.de>
 * SPDX-License-Identifier: (0BSD or MIT)
 */

// module: db
#![warn(clippy::pedantic)]
#![warn(clippy::nursery)]

//#[cfg(test)]
use diesel::debug_query;
use diesel::dsl::*;
use diesel::prelude::*;
//use diesel::sql_query;
use diesel::sqlite::Sqlite;
use diesel::sqlite::SqliteConnection;
use dotenv::dotenv;
//use serde_derive;
use serde_json;
use std::env;
use std::error::Error;

// modules
pub mod models;
pub mod schema;
pub mod types;

//use crate::db::models::Users;
use crate::db::models::Harm;
use models::User;
use models::UserRole;
use schema::*;

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

    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    SqliteConnection::establish(&database_url)
        .unwrap_or_else(|_| panic!("Error connecting to {}", &database_url))
    /*
     * WIP: integrate tracing!
    trace!(
        target: "diesel",
        type: "Sqlite3",
        status: "connected"
    );
     */
}

/*
 * base functions
pub fn users_insert_default_values(conn: &SqliteConnection) -> QueryResult<usize> {
    //use schema::users::dsl::*;

    insert_into(users).default_values().execute(conn)
}

#[test]
fn examine_sql_users_insert_default_values() {
    use schema::users::dsl::*;

    let query = insert_into(users).default_values();
    let sql = "INSERT INTO `users` DEFAULT VALUES -- binds: []";
    assert_eq!(sql, debug_query::<Sqlite, _>(&query).to_string());
}

pub fn user_roles_insert_default_values(conn: &SqliteConnection) -> QueryResult<usize> {
    use schema::user_roles::dsl::*;

    insert_into(user_roles).default_values().execute(conn)
}

#[test]
fn examine_sql_user_roles_insert_default_values() {
    use schema::user_roles::dsl::*;

    let query = insert_into(user_roles).default_values();
    let sql = "INSERT INTO `user_roles` DEFAULT VALUES -- binds: []";
    assert_eq!(sql, debug_query::<Sqlite, _>(&query).to_string());
}

pub fn user_harms_insert_default_values(conn: &SqliteConnection) -> QueryResult<usize> {
    use schema::harms::dsl::*;

    insert_into(harms).default_values().execute(conn)
}

#[test]
fn examine_sql_harms_insert_default_values() {
    use schema::harms::dsl::*;

    let query = insert_into(harms).default_values();
    let sql = "INSERT INTO `harms` DEFAULT VALUES -- binds: []";
    assert_eq!(sql, debug_query::<Sqlite, _>(&query).to_string());
}

pub fn users_insert_single_column(conn: &SqliteConnection) -> QueryResult<usize> {
    use schema::users::dsl::*;

    insert_into(users)
        .values(alias.eq("Hiedemann"))
        .execute(conn)
}

#[test]
fn examine_sql_users_insert_single_column() {
    use schema::users::dsl::*;

    let query = insert_into(users).values(alias.eq("Hiedemann"));
    let sql = "INSERT INTO `users` (`alias`) VALUES (?) \
               -- binds: [\"Hiedemann\"]";
    assert_eq!(sql, debug_query::<Sqlite, _>(&query).to_string());
}

pub fn users_insert_multiple_columns(conn: &SqliteConnection) -> QueryResult<usize> {
    use schema::users::dsl::*;

    insert_into(users)
        .values((
            first_name.eq("Lothar"),
            last_name.eq("Schlömer"),
            alias.eq("102"),
        ))
        .execute(conn)
}

#[test]
fn examine_sql_user_insert_multiple_columns() {
    use models::Users;
    //use crate::db::models::Users;
    use crate::db::schema::users::dsl::*;

    let query = insert_into(users).values((
        first_name.eq("Lothar"),
        last_name.eq("Schlömer"),
        alias.eq("102"),
    ));
    let sql = "INSERT INTO `users` (`first_name`, `last_name`, `alias`) \
               VALUES (?, ?, ?) \
               -- binds: [\"Lothar\", \"Schlömer\", \"102\"]";
    assert_eq!(sql, debug_query::<Sqlite, _>(&query).to_string());
}

pub fn user_insert_struct_via_json(conn: &SqliteConnection) -> Result<(), Box<dyn Error>> {
    use models::insert::NewUser;
    use schema::users::dsl::*;

    let json = r#"{ "alias": "Daniela", "first_name": "Daniela","last_name": "Knocke" }"#;
    let user_struct = serde_json::from_str::<NewUser>(json)?;

    insert_into(users).values(&user_struct).execute(conn)?;

    Ok(())
}
*/

/*
#[test]
fn examine_sql_user_insert_struct_via_json() {
    use models::NewUser;
    use schema::users::dsl::*;

    let json = r#"{ "last_name": "Knocke", "first_name": "Daniela", "alias": "Sekretariat" }"#;
    let user_form = serde_json::from_str::<NewUser>(json).unwrap();
    let query = insert_into(users).values(&user_form);
    let sql = "INSERT INTO `users` (`last_name`, `first_name`, `alias`) \
               VALUES (?, ?, ?) \
               -- binds: [\"Knocke\", \"Daniela\", \"Sekretariat\"]";
    assert_eq!(sql, debug_query::<Sqlite, _>(&query).to_string());
}
 */

/*
pub fn user_insert_struct_json_option(conn: &SqliteConnection) -> Result<(), Box<dyn Error>> {
    use models::NewUser;
    use schema::users::dsl::*;

    let json = r#"{ "alias": "Networkx", "email_confirmed": true,
    "email": "support@networkx.de", "first_name": null, "last_name": null }"#; let user_form =
    serde_json::from_str::<NewUser>(json)?;

    insert_into(users).values(&user_form).execute(conn)?;

    Ok(())
}
 */

/*
#[test]
fn examine_sql_user_insert_struct_json_option() {
    use schema::users::dsl::*;
    use models::NewUser;

    let json = r#"{ "alias": "Networkx", "email_confirmed": true, "email": "support@networkx.de", "first_name": null, "last_name": null }"#;
    let user_form = serde_json::from_str::<NewUser>(json).unwrap();
    let query = insert_into(users).values(&user_form);
    let sql = "INSERT INTO `users` (`alias`, `email`, `email_confirmed`) \
               VALUES (?, ?, ?) \
               -- binds: [\"Networkx\", \"support@networkx.de\", \"$true\"]";
    assert_eq!(sql, debug_query::<Sqlite, _>(&query).to_string());
}
*/

// WIP
/*
#[test]
fn examine_sql_users_insert_get_results() {
    use diesel::result::Error;

    let conn = establish_connection();
    conn.test_transaction::<_, Error, _>(|| {
        use diesel::select;
        use chrono::NaiveDateTime;
        use schema::users::dsl::*;
        //use schema::users::*;

        let now = select(diesel::dsl::now).get_result::<NaiveDateTime>(&conn)?;

        let inserted_users = conn.transaction::<_, Error, _>(|| {
            let inserted_count = insert_into(users)
                .values(&vec![
                    (id.eq(1), last_name.eq("Hiedemann"), first_name.eq("Eric")),
                    (id.eq(2), last_name.eq("Schlömer"), first_name.eq("Lothar")),
                    //(id.eq(1), first_name.eq("Eric"), last_name.eq("Hiedemann"), alias.eq("Eric.Hiedemann")),
                    //(id.eq(2), first_name.eq("Lothar"), last_name.eq("Schlömer"), alias.eq("othar.Schlömer")),
                ])
                .execute(&conn)?;

            /*
            Ok(users
                .order(id.desc())
                .limit(inserted_count as i64)
                .load(&conn)?
                .into_iter()
                .rev()
                .collect::<Vec<_>>())
            */
        })?;

        /*
        let expected_users = vec![
            User {
                id: 1,
                last_name: "Hiedemann".into(),
                first_name: "Eric".into(),
                alias: "Eric.Hiedemann".into(),
                email: None,
                email_confirmed: false,
                password_hash: None,
                initials: None,
                date_created: now,
                date_updated: now,
            },
            User {
                id: 2,
                last_name: "Schlömer".into(),
                first_name: "Lothar".into(),
                alias: "Lothar.Schlömer".into(),
                email: None,
                email_confirmed: false,
                password_hash: None,
                initials: None,
                date_created: now,
                date_updated: now,
            },
        ];
        assert_eq!(expected_users, inserted_users);
         */

        Ok(())
    });
}
*/

/*
pub fn create_numberharm<'a>(connection: &SqliteConnection, NumberHarm: &'a str) {
    let numberHarm = models::NewNumberHarm { NumberHarm };

    diesel::insert_into(schema::NumberHarm::table)
        .values(&numberHarm)
        .execute(connection)
        .expect("Error inserting new task");
}
 */

/*
pub fn create_userid<'a>(connection: &SqliteConnection, User: &'a str) {
    let user = models::NewUser { User };

    diesel::insert_into(schema::User::table)
        .values(&user)
        .execute(connection)
        .expect("Error inserting new task");
}
 */

/*
pub fn create_userclaimid<'a>(connection: &SqliteConnection, UserClaim: &'a str) {
    let userClaim = models::NewUserClaim { UserClaim };

    diesel::insert_into(schema::UserClaim::table)
        .values(&userClaim)
        .execute(connection)
        .expect("Error inserting new task");
}

pub fn create_userrole<'a>(connection: &SqliteConnection, UserRole: &'a str) {
    let userRole = models::NewUserRole { UserRole };

    diesel::insert_into(schema::UserRole::table)
        .values(&userRole)
        .execute(connection)
        .expect("Error inserting new task");
}

pub fn create_useruserrole<'a>(connection: &SqliteConnection, UserUserRole: &'a str) {
    let userUserRole = models::NewUserUserRole { UserUserRole };

    diesel::insert_into(schema::UserUserRole::table)
        .values(&userUserRole)
        .execute(connection)
        .expect("Error inserting new task");
}
*/