use chrono::Utc;
use rocket_contrib::json::{Json, JsonValue};
use crate::rand_utils::{new_user_id, new_key};
use crate::models::{User, USER_ONLINE, USER_OFFLINE};
use crate::payload::NewUserResponse;
use crate::{DBConn, schema};
use diesel::{self, prelude::*};
use diesel::result::Error;

pub fn create_new_user(conn: DBConn, name: String) -> User {
    use schema::users::dsl::*;
    use diesel::result::Error;
    use crate::models::InsertableUser;

    let ins = InsertableUser {
        name: name,
        secret: new_key(),
        date: time,
        status: USER_ONLINE,
    };
    // insert the nwe user data then return usable user data to the client
    diesel::insert_into(users::table)
        .values(&ins)
        .execute(&conn.0);

    let new_user_data : Result<User, diesel::result::Error> = users
        .filter(userid.eq(ins.id))
        .first(&conn.0);

    new_user_data.unwrap()
}


pub fn new_user_response(user: &Option<User>, msg: Option<&'static str>) -> NewUserResponse {
    if let Some(u) = user {
        NewUserResponse {
            userid: Some(u.userid),
            username: Some(u.username.clone()),
            key: Some(u.key.clone()),
            err: None
        }
    }
    else{
        NewUserResponse {
            userid: None,
            username: None,
            key: None, 
            err: Some(msg.unwrap())
        }
    }
}

#[delete("/remove/<hash>")]
pub fn remove_user(hash: u64, conn: DBConn) -> JsonValue {
    // Attempt to remove the user first
    use schema::users::dsl::*;
    use diesel::result::Error;

    let res: Result<usize, Error> = diesel::delete(users.filter(userid.eq(hash))).execute(&conn.0);
    match res {
        Ok(_res) => json!({"staus":"ok"}),
        Err(_e) => json!({"status":"err"}),
    }
}


// TODO: optional paramter where we can specify getting the offline users as well
// TODO: More optionally specify what kind of users we want online/offline/away etc.
#[get("/list")]
pub fn get_user_list(conn: DBConn) -> Json<Vec<(u64, String, i32)>> {
    use schema::users::dsl::*;

    let db_response: Result<Vec<(u64, String, i32)>, Error> = users.select((userid, username, status))
        .filter(status.ne(USER_OFFLINE))
        .load::<(u64, String, i32)>(&conn.0);

    match db_response {
        Ok(data) => Json(data),
        Err(_e) => Json(vec!())
    }
}

#[cfg(test)]
mod user_tests {
    use super::create_new_user;
    use super::*;
    use rocket;
    use rocket::local::Client;
    use rocket::http::Status;

    macro_rules!  rocket_inst {
        ($func:expr) => {
            rocket::ignite()
                .mount("/users", routes![$func])
                .attach(DBConn::fairing())
        }
    }

    #[test]
    fn generate_bs_users() {
        use diesel::mysql::MysqlConnection;
        // please don't ask me why this is here it just is
        let conn = MysqlConnection::establish("mysql://freechat_dev:password@localhost:3306/freechat")
            .unwrap();
        for _i in 0..100 {
            let user = create_new_user();
            let _bs = diesel::insert_into(schema::users::table)
                .values(&user)
                .execute(&conn);
        }
    }

    #[test]
    fn get_user_list() {
        let app = rocket_inst!(get_user_list);
        let client = Client::new(app).expect("Bad rocket instance");

        let mut response = client.get("/users/list").dispatch();
        let body: String = response.body_string().unwrap();
        assert_eq!(response.status(), Status::Ok);
        println!("{}", body);
    }


    #[test]
    fn user_struct() {
        println!("{:?}", create_new_user());
    }

    #[test]
    fn remove_user_pass() {
        let user = create_new_user();
        println!("Client to remove: {:?}", user);

        let app = rocket_inst!(remove_user);
        let client = Client::new(app).expect("Bad rocket instance");

        let mut response = client.delete(format!("/users/remove/{}", user.userid)).dispatch();
        let body: String = response.body_string().unwrap();

        assert_eq!(response.status(), Status::Ok);
        println!("{}", body);
    }
    //TODO: fail case for removing users
}