use diesel::prelude::*;
use std::collections::HashMap;
use diesel::{insert_into, update};

use crate::schema::*;
use crate::schema::userinfo::dsl as userinfo_dsl;
use crate::Db;
use crate::error::{ManifoldError, ManifoldResult};

#[derive(Identifiable, Insertable, AsChangeset, Debug, Queryable, Serialize, Clone)]
#[diesel(primary_key(user_id))]
#[diesel(table_name = userinfo)]
pub struct UserInfo {
    pub(crate) user_id: i64,
    pub username: String,
    pub weather_location: Option<String>,
    pub weather_units: Option<String>,
    pub timezone: Option<String>,
    pub last_seen: Option<i64>,
}

pub type ManifoldUserInfo = HashMap<u64, UserInfo>;

impl UserInfo {
    pub fn load(conn: &Db) -> ManifoldResult<ManifoldUserInfo> {
        let data = userinfo_dsl::userinfo
            .get_results::<Self>(&mut conn.get()?);

        debug!("{:?}", data);

        let mut loaded_userinfo = ManifoldUserInfo::new();

        match data {
            Ok(d) => {
                for user in d {
                    loaded_userinfo.insert(user.user_id as u64, user.clone());
                };
            }
            Err(e) => {
                error!("Couldn't load user data! {:?}", e);
                Err("Couldn't load user data")?
            }
        };

        Ok(loaded_userinfo)
    }

    pub fn insert(&self, conn: &Db) -> ManifoldResult<usize> {
        insert_into(userinfo_dsl::userinfo)
            .values(self)
            .execute(&mut conn.get()?)
            .map_err(|e| ManifoldError::from(e))
    }

    pub fn save(&self, conn: &Db) -> ManifoldResult<usize> {
        update(userinfo_dsl::userinfo)
            .filter(userinfo::user_id.eq(self.user_id))
            .set(self)
            .execute(&mut conn.get()?)
            .map_err(|e| ManifoldError::from(e))
    }
}