use crate::commands::GENERAL_GROUP;
use crate::passive::Handler;
use serenity::client::Client;
use serenity::framework::standard::StandardFramework;
use serenity::prelude::TypeMapKey;
use sqlx::sqlite::SqlitePool;
use std::env;

mod commands;
mod passive;

pub(crate) const COMMAND_PREFIX: &str = "~";

pub(crate) struct DbConnPool {
    pool: sqlx::pool::Pool<sqlx::sqlite::SqliteConnection>,
}

impl DbConnPool {
    async fn get_heck(&self) -> i32 {
        sqlx::query!("UPDATE Heck SET count = count + 1")
            .execute(&self.pool)
            .await
            .unwrap();

        sqlx::query!("SELECT count FROM Heck")
            .fetch_one(&self.pool)
            .await
            .unwrap()
            .count
    }
}

impl TypeMapKey for DbConnPool {
    type Value = Self;
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenv::dotenv().ok();

    let framework = StandardFramework::new()
        .configure(|c| c.prefix(COMMAND_PREFIX))
        .group(&GENERAL_GROUP);

    // Login with a bot token from the environment
    let mut client =
        Client::new_with_extras(&env::var("DISCORD_TOKEN").expect("token"), |extras| {
            extras
                .event_handler(Handler::default())
                .framework(framework)
        })
        .await
        .expect("Error creating client");

    let pool = SqlitePool::builder()
        .build(&env::var("DATABASE_URL").unwrap())
        .await?;

    init_pool(&pool).await;

    {
        let mut data = client.data.write().await;
        data.insert::<DbConnPool>(DbConnPool { pool });
    }

    // start listening for events by starting a single shard
    if let Err(why) = client.start().await {
        println!("An error occurred while running the client: {:?}", why);
    }

    Ok(())
}

async fn init_pool(pool: &sqlx::pool::Pool<sqlx::sqlite::SqliteConnection>) {
    sqlx::query!(
        "CREATE TABLE IF NOT EXISTS Heck (id INTEGER PRIMARY KEY NOT NULL, count INTEGER NOT NULL)"
    )
    .execute(pool)
    .await
    .unwrap();

    if sqlx::query!("SELECT count FROM Heck")
        .fetch_all(pool)
        .await
        .unwrap()
        .is_empty()
    {
        sqlx::query!("INSERT INTO Heck VALUES (1, 0)")
            .execute(pool)
            .await
            .unwrap();
    }
}