use crate::commands::GENERAL_GROUP;
use crate::passive::Handler;
use env_logger;
use log::error;
use serenity::client::{validate_token, Client};
use serenity::framework::standard::StandardFramework;
use std::env;
use util::{db::DbConnPool, error::KuranteError};

mod commands;
mod passive;
mod util;

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

#[tokio::main]
async fn main() {
    std::process::exit(match run().await {
        Ok(_) => 0,
        Err(_) => 1,
    });
}

async fn run() -> Result<(), KuranteError> {
    // Init dotenv vars before the env logger
    dotenv::dotenv().ok();
    env_logger::init();

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

    let token = match env::var("DISCORD_TOKEN") {
        Ok(token) => match validate_token(&token) {
            Ok(_) => token,
            Err(_) => {
                error!("Provided token was invalid.");
                return Err(KuranteError::InvalidToken);
            }
        },
        Err(e) => {
            error!("`DISCORD_TOKEN` environment variable was not set. Unable to start bot!");
            return Err(e.into());
        }
    };

    let mut client = Client::new(token)
        .event_handler(Handler::default())
        .framework(framework)
        .await?;

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

    if let Err(why) = client.start().await {
        error!("An error occurred while running the client: {:?}", why);
    }

    Ok(())
}