use mysql_async::{self, from_row_opt, params, prelude::*, Pool};

use sha1::{Digest, Sha1};

    pool: Pool,

    pub fn new(url: &str) -> Self {

        Self {

            pool: Pool::new(url),

    pub async fn get_is_registered(&mut self, nick: &str) -> mysql_async::Result<bool> {

        let mut connection = self.pool.get_conn().await?;

        let result = CHECK_ACCOUNT_EXISTS_QUERY

            .with(params! { "username" => nick })

            .first(&mut connection)

            .await?;

        Ok(!result.is_empty())

    }

    pub async fn get_account(

    ) -> mysql_async::Result<Option<AccountInfo>> {

        let mut connection = self.pool.get_conn().await?;

        if let Some((mut password, is_admin, is_contributor)) = GET_ACCOUNT_QUERY

            .with(params! { "username" => nick })

            .first::<(String, i32, i32), _>(&mut connection)

            .await?

        {

            let client_hash = get_hash(protocol, &password, &client_salt, &server_salt);

            let server_hash = get_hash(protocol, &password, &server_salt, &client_salt);

            password.replace_range(.., "🦔🦔🦔🦔🦔🦔🦔🦔");

            if client_hash == password_hash {

                Ok(Some(AccountInfo {

                    is_registered: true,

                    is_admin: is_admin == 1,

                    is_contributor: is_contributor == 1,

                    server_hash,

                }))

            Ok(None)

    pub async fn get_checker_account(

    ) -> mysql_async::Result<bool> {

        let mut connection = self.pool.get_conn().await?;

        if let Some((password, _, _)) = GET_ACCOUNT_QUERY

            .with(params! { "username" => nick })

            .first::<(String, i32, i32), _>(&mut connection)

            .await?

        {

            Ok(checker_password == password)

            Ok(false)

    pub async fn store_stats(&mut self, stats: &ServerStatistics) -> mysql_async::Result<()> {

        let mut connection = self.pool.get_conn().await?;

        STORE_STATS_QUERY

            .with(params! {

                "players" => stats.players,

                "rooms" => stats.rooms,

            })

            .ignore(&mut connection)

            .await

    pub async fn store_achievements(&mut self, achievements: &Achievements) -> mysql_async::Result<()> {

    pub async fn get_replay_name(&mut self, replay_id: u32) -> mysql_async::Result<Option<String>> {

        let mut connection = self.pool.get_conn().await?;

        GET_REPLAY_NAME_QUERY

            .with(params! { "id" => replay_id })

            .first::<String, _>(&mut connection)

            .await

    let data = format!(

    let mut sha1 = Sha1::new();

    sha1.update(&data);

    Sha1Digest::new(sha1.finalize().try_into().unwrap())