use diesel::prelude::*;
use serde::Serialize;

use crate::schema::users::dsl;
use uuid::Uuid;

use crate::password;

use super::DbError;

#[derive(Queryable, Selectable, Debug, Clone, Serialize)]
#[diesel(table_name = crate::schema::users)]
#[diesel(check_for_backend(diesel::sqlite::Sqlite))]
pub struct User {
    pub id: String,
    pub username: String,
    pub password_hash: String,
    pub email: String,
    pub name: String,
    #[serde(skip)]
    pub created: chrono::NaiveDateTime,
    #[serde(skip)]
    pub updated: chrono::NaiveDateTime,
}

#[derive(Insertable)]
#[diesel(table_name = crate::schema::users)]
pub struct NewUser {
    pub id: String,
    pub name: String,
    pub username: String,
    pub email: String,
    pub password_hash: String,
}

impl NewUser {
    pub fn new(name: String, username: String, email: String, password: String) -> Self {
        let password_hash = password::hash(&password);
        Self {
            id: Uuid::new_v4().to_string(),
            name,
            username,
            email,
            password_hash,
        }
    }
}

pub struct Query<'a> {
    db: &'a mut SqliteConnection,
}
impl<'a> Query<'a> {
    pub fn new(db: &'a mut SqliteConnection) -> Self {
        Self { db }
    }

    pub fn all(&mut self) -> Result<Vec<User>, DbError> {

        let user_list = dsl::users.load::<User>(self.db)?;
        Ok(user_list)
    }

    pub fn by_id(&mut self, id: &str) -> Result<User, DbError> {
        let user = dsl::users.filter(dsl::id.eq(id)).first::<User>(self.db)?;
        Ok(user)
    }

    pub fn by_username(&mut self, username: &str) -> Result<User, DbError> {
        let user = dsl::users.filter(dsl::username.eq(username)).first::<User>(self.db)?;
        Ok(user)
    }

    pub fn create(&mut self, new_user: NewUser) -> Result<User, DbError> {
        let _ = diesel::insert_into(dsl::users)
            .values(&new_user)
            .execute(self.db)?;

        let new_user = dsl::users.filter(dsl::id.eq(&new_user.id)).first::<User>(self.db)?;

        Ok(new_user)
    }
}