use serde::{Deserialize, Serialize};
use surrealdb::opt::Resource;
use utoipa::ToSchema;

use super::init::DB;

const USERIMAGE: &str = "userimage";

#[derive(Debug, Serialize, Deserialize, Clone, ToSchema)]
pub struct User {
    pub server_id: u64,
    pub user_id: u64,
    pub enable: bool,
}

impl User {
    pub fn new(server_id: u64, user_id: u64, enable: bool) -> Result<Self, surrealdb::Error> {
        Ok(Self {
            server_id,
            user_id,
            enable,
        })
    }

    pub async fn create(&self) -> Result<(), surrealdb::Error> {
        match DB.create(Resource::from(USERIMAGE)).content(&self).await {
            Ok(_) => {}
            Err(e) => {
                return Err(e);
            }
        };
        Ok(())
    }

    pub async fn update(&self) -> Result<(), surrealdb::Error> {
        let sql = format!(
            "UPDATE {} SET enable = {} WHERE server_id = {} AND user_id = {}",
            USERIMAGE, self.enable, self.server_id, self.user_id
        );
        match DB.query(sql).await {
            Ok(res) => {
                println!("{:?}", res);
            }
            Err(e) => {
                return Err(e);
            }
        };
        Ok(())
    }

    pub async fn find_by_server_id_user_id(
        server_id: &u64,
        user_id: &u64,
    ) -> Result<Option<User>, surrealdb::Error> {
        let sql = format!(
            "SELECT * FROM {} WHERE server_id = {} AND user_id = {}",
            USERIMAGE, server_id, user_id
        );
        let mut results = match DB.query(&sql).await {
            Ok(results) => results,
            Err(e) => {
                return Err(e);
            }
        };
        let user_image: User = match results.take(0) {
            Ok(Some(user_image)) => user_image,
            Ok(None) => {
                return Ok(None);
            }
            Err(err) => {
                return Err(err);
            }
        };
        Ok(Some(user_image))
    }

    // find a user image by server_id and user_id
}