use serde::Deserialize;
use serde::Serialize;

use rusqlite::Connection;
use rusqlite::Error;
use rusqlite::Result;
use ulid::Ulid;

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct User {
    pub id: u32,
    pub email: String,
    pub real_name: String,
    pub name: String,
}

impl User {
    // const TYPE:&str = "user";

    pub fn lookup_by_eid(&self, sqlite: &Connection) -> Option<Ulid> {
        let result: Result<String> = sqlite.query_row(
            "SELECT id FROM nodes WHERE type = 'user' AND eid = ?1",
            [self.id],
            |row| row.get(0),
        );
        match result {
            Ok(s) => Some(Ulid::from_string(&s).unwrap()),
            Err(error) => match error {
                Error::QueryReturnedNoRows => None,
                x => panic!("Error while getting user {:?}", x),
            },
        }
    }

    pub fn insert(&self, sqlite: &Connection) -> Ulid {

        if let Some(ulid) = self.lookup_by_eid(sqlite) {
            return ulid;
        }

        let ulid = Ulid::new();
        let json = serde_json::to_string(&self).unwrap();
        match sqlite
            .execute(
                "INSERT INTO nodes (id, type,   eid, raw)
                VALUES             (?1, 'user', ?2,  ?3)",
                (ulid.to_string(), self.id, &json),
            ) {
                Ok(_) => (),
                Err(err) => panic!("insert failed: {}", err),
        }

        sqlite
            .execute(
                "INSERT INTO users (id, email, real_name, name)
                VALUES             (?1, ?2,    ?3,        ?4)",
                (ulid.to_string(), &self.email, &self.real_name, &self.name),
            )
            .unwrap();

        ulid
    }
}