path: root/src/main.rs

use std::{sync::Mutex, time::Duration};

use dotenv::dotenv;
use sqlx::{postgres::PgPoolOptions, PgPool};
use tracing::{info, instrument};

type Error = Box<dyn std::error::Error + Send + Sync>;
type Context<'a> = poise::Context<'a, Data, Error>;

mod commands;
mod handler;
mod models;

pub struct Data {
    pg: Mutex<PgPool>,
}

/// Show help menu
#[poise::command(prefix_command, slash_command)]
async fn help(
    ctx: Context<'_>,
    #[description = "Command to get help for"] command: Option<String>,
) -> Result<(), Error> {
    poise::builtins::help(
        ctx,
        command.as_deref(),
        poise::builtins::HelpConfiguration::default(),
    )
    .await?;
    Ok(())
}

async fn on_error(error: poise::FrameworkError<'_, Data, Error>) {
    match error {
        poise::FrameworkError::Setup { error } => panic!("Failed to start bot: {:?}", error),
        poise::FrameworkError::Command { error, ctx } => {
            println!("Error in command {}: {:?}", ctx.command().name, error);
            ctx.say(format!("Whoops! Something went wrong: {:?}", error))
                .await
                .unwrap();
        }
        error => {
            if let Err(e) = poise::builtins::on_error(error).await {
                println!("Error handling error: {}", e);
            }
        }
    }
}

/// Register application commands in this guild or globally
///
/// Run with no arguments to register in guild, run with argument "global" to register globally.
#[poise::command(prefix_command, hide_in_help)]
async fn register(ctx: Context<'_>, #[flag] global: bool) -> Result<(), Error> {
    poise::builtins::register_application_commands(ctx, global).await?;

    Ok(())
}

#[tokio::main]
#[instrument]
async fn main() {
    dotenv().unwrap();
    tracing_subscriber::fmt::init();
    info!("Initialized logging");
    let options = poise::FrameworkOptions {
        commands: vec![
            help(),
            register(),
            commands::meta::ping(),
            commands::meta::about(),
            commands::meta::userinfo(),
            commands::actions::boop(),
            commands::actions::hug(),
            commands::pony::randpony(),
            commands::pony::tpony(),
            commands::pony::ponybyid(),
            commands::osu::osup(),
            commands::osu::osubm(),
            poise::Command {
                subcommands: vec![
                    commands::reactionroles::init(),
                    commands::reactionroles::add(),
                    commands::reactionroles::del(),
                ],
                ..commands::reactionroles::rroles()
            },
        ],
        on_error: |error| Box::pin(on_error(error)),
        pre_command: |ctx| {
            Box::pin(async move {
                println!("Executing command {}...", ctx.command().name);
            })
        },
        post_command: |ctx| {
            Box::pin(async move {
                println!("Done executing command {}!", ctx.command().name);
            })
        },

        prefix_options: poise::PrefixFrameworkOptions {
            prefix: Some("~".into()),
            edit_tracker: Some(poise::EditTracker::for_timespan(Duration::from_secs(3600))),
            additional_prefixes: vec![
                poise::Prefix::Literal("hey glitch"),
                poise::Prefix::Literal("hey glitch,"),
            ],
            ..Default::default()
        },
        listener: |ctx, event, _, data| Box::pin(handler::event_handler(ctx, event, data)),
        ..Default::default()
    };

    poise::Framework::build()
        .token(std::env::var("DISCORD_TOKEN").unwrap_or("BAD-TOKEN".into()))
        .user_data_setup(move |_ctx, _ready, _framework| {
            Box::pin(async move {
                let pool = PgPoolOptions::new()
                    .max_connections(5)
                    .connect(
                        &std::env::var("DATABASE_URL")
                            .unwrap_or("postgres://postgres@localhost/glitch".to_string()),
                    )
                    .await
                    .expect("Couldn't connect to postgresql");
                sqlx::migrate!("./migrations")
                    .run(&pool)
                    .await.unwrap();
                Ok(Data {
                    pg: Mutex::new(pool),
                })
            })
        })
        .options(options)
        .run()
        .await
        .unwrap();
}