use log::LevelFilter;
use poise::serenity_prelude as serenity;
use simple_logger::SimpleLogger;

pub struct Data {} // User data, which is stored and accessible in all command invocations
type Error = Box<dyn std::error::Error + Send + Sync>;
type Context<'a> = poise::Context<'a, Data, Error>;

pub mod event_handlers;
pub mod apis;

/// Ping command with latency measurement
#[poise::command(slash_command, prefix_command)]
async fn ping(ctx: Context<'_>) -> Result<(), Error> {
    let original_msg_timestamp = ctx.created_at();
    let msg = ctx.say("Pong!").await?.into_message().await?;
    let latency = msg.timestamp.timestamp_millis() - original_msg_timestamp.timestamp_millis();
    ctx.say(format!("Latency: {}ms", latency)).await?;
    Ok(())
}

#[tokio::main]
async fn main() {
    SimpleLogger::new()
        .with_level(LevelFilter::Off)
        .with_module_level("sauce_connoisseur", LevelFilter::Info)
        .init()
        .unwrap();
    let token = std::env::var("DISCORD_TOKEN").expect("missing DISCORD_TOKEN");
    let intents =
        serenity::GatewayIntents::non_privileged().union(serenity::GatewayIntents::MESSAGE_CONTENT);

    let framework = poise::Framework::builder()
        .options(poise::FrameworkOptions {
            prefix_options: poise::PrefixFrameworkOptions {
                prefix: Some(String::from("!")),
                ..Default::default()
            },
            commands: vec![ping()],
            event_handler: |ctx, event, framework, data| {
                Box::pin(event_handlers::sc_event_handler(
                    ctx, event, framework, data,
                ))
            },
            ..Default::default()
        })
        .setup(|ctx, _ready, framework| {
            Box::pin(async move {
                poise::builtins::register_globally(ctx, &framework.options().commands).await?;
                Ok(Data {})
            })
        })
        .build();

    let client = serenity::ClientBuilder::new(token, intents)
        .framework(framework)
        .await;
    client.unwrap().start().await.unwrap();
}