use mysql::prelude::Queryable;
use mysql::{params, Error as MysqlError};
use r2d2::{Error as R2D2Error, Pool};
use r2d2_mysql::MySqlConnectionManager;
use thiserror::Error;

use crate::models::user::User;

#[derive(Error, Debug)]
pub enum UserRepositoryError {
    #[error("mysql error: {0}")]
    MySqlError(#[from] MysqlError),

    #[error("Connection pool error: {0}")]
    PoolError(#[from] R2D2Error),
}

pub struct UserRepository {
    pool: Pool<MySqlConnectionManager>,
}

impl UserRepository {
    pub fn new(pool: Pool<MySqlConnectionManager>) -> Self {
        UserRepository { pool }
    }

    /**
     * 新建用户
     */
    pub fn insert_user(
        &self,
        account: &str,
        name: &str,
        password: &str,
    ) -> Result<(), UserRepositoryError> {
        let mut conn = self.pool.get().map_err(UserRepositoryError::PoolError)?;
        let sql = "INSERT INTO users (account, name, password) VALUES (:account, :name, :password)";
        conn.exec_drop(
            sql,
            params! {"account" => account, "name" => name, "password" => password},
        )
        .map_err(UserRepositoryError::MySqlError)?;
        Ok(())
    }

    /**
     * 根据account查询用户
     */
    pub fn query_user_by_account(
        &self,
        account: &str,
    ) -> Result<Option<User>, UserRepositoryError> {
        let mut conn = self
            .pool
            .get()
            .map_err(|e| UserRepositoryError::PoolError(e))?;

        let sql = "SELECT account, name FROM users WHERE account = :account";

        match conn.exec_first(sql, params! {"account" => account}) {
            Ok(Some(row)) => {
                let (account, name) = mysql::from_row(row);
                Ok(Some(User {
                    id: None,
                    name,
                    password: None,
                    account,
                    birth: None,
                    email: None,
                    phone: None,
                    status: None,
                    created_time: None,
                    updated_time: None,
                }))
            }
            Ok(None) => Ok(None),
            Err(e) => Err(UserRepositoryError::MySqlError(e)),
        }
    }

    // /**
    //  * 删除用户
    //  */
    // pub fn delete_user(&mut self, user: &User) -> Result<(), mysql::Error> {
    //     let mut conn = self.pool.get().unwrap();
    //     conn.exec_drop(
    //         r"DELETE FROM users WHERE id = :id",
    //         params! {
    //             "id" => &user.id,
    //         },
    //     )
    // }

    // /**
    //  * 更新用户
    //  */
    // pub fn update_user(&mut self, user: &User) -> Result<(), mysql::Error> {
    //     let mut conn = self.pool.get().unwrap();
    //     conn.exec_drop(
    //         r"UPDATE users SET name = :name, age = :age, email = :email, password = :password WHERE id = :id",
    //         params! {
    //             "id" => &user.id,
    //             "name" => &user.name,
    //             "age" => &user.age,
    //             "email" => &user.email,
    //             "password" => &user.password,
    //         },
    //     )
    // }

    // /**
    //  * 查询所有用户
    //  */
    // pub fn query_all_user(&mut self) -> Result<Vec<User>, mysql::Error> {
    //     let mut conn = self.pool.get().unwrap();
    //     conn.query_map(
    //         "SELECT id, name, age, email, password FROM users",
    //         |(id, name, age, email, password)| User {
    //             id,
    //             name,
    //             age,
    //             email,
    //             password,
    //         },
    //     )
    // }

    // /**
    //  * 根据用户名查询用户
    //  */
    // pub fn query_user_by_name(&self, name: &str) -> Result<Option<User>, UserRepositoryError> {
    //     let mut conn = self.pool.get().map_err(UserRepositoryError::PoolError)?;
    //     conn.exec_first(
    //         "SELECT id, name, age, email, password FROM users WHERE name = :name",
    //         params! {
    //             "name" => name,
    //         },
    //     )
    // }

    // /**
    //  * 根据邮箱查询用户
    //  */
    // pub fn query_user_by_email(&self, email: &str) -> Result<Option<User>, UserRepositoryError> {
    //     let mut conn = self.pool.get().map_err(UserRepositoryError::PoolError)?;

    //     conn.exec_first(
    //         "SELECT id, name, age, email, password FROM users WHERE email = :email",
    //         params! {
    //             "email" => email,
    //         },
    //     )
    // }
}