spekkio/src/main.rs

mod commands;
mod data_loader;
mod utils;

use std::collections::HashSet;

use serenity::async_trait;
use serenity::prelude::*;
use serenity::model::prelude::*;
use serenity::model::channel::Message;
use serenity::model::gateway::Ready;
use serenity::http::Http;

struct Handler;

#[async_trait]
impl EventHandler for Handler 
{
    // Set a handler for the `message` event - so that whenever a new message
    // is received - the closure (or function) passed will be called.
    //
    // Event handlers are dispatched through a threadpool, and so multiple
    // events can be dispatched simultaneously.
    async fn message(&self, ctx: Context, msg: Message) 
    {
       commands::parse(ctx, msg).await;
        
    }

    // Set a handler to be called on the `ready` event. This is called when a
    // shard is booted, and a READY payload is sent by Discord. This payload
    // contains data like the current user's guild Ids, current user data,
    // private channels, and more.
    //
    // In this case, just print what the current user's username is.
    async fn ready(&self, _: Context, ready: Ready) {
        println!("{} is connected!", ready.user.name);
    }
}


#[tokio::main]
async fn main() 
{
    let token = match data_loader::load_token("secrets/test.txt")
    {
        Ok(t) => t,
        Err(why) => panic!("Could not load app token: {}", why),
    };

     // Fetch the application owner id
     let http = Http::new(&token);
     let owner = match http.get_current_application_info().await 
     {
        Ok(info) => info.owner.id,
        Err(why) => panic!("Could not access application info: {:?}", why),
    };



    println!("Connecting...");

    let intents = GatewayIntents::GUILD_MESSAGES
        | GatewayIntents::DIRECT_MESSAGES
        | GatewayIntents::MESSAGE_CONTENT;

    // Create a new instance of the Client, logging in as a bot. This will
    // automatically prepend your bot token with "Bot ", which is a requirement
    // by Discord for bot users.
    let mut client = Client::builder(&token, intents).event_handler(Handler).await.expect("Err creating client");

    // TODO: See link for how to add global data to the client:
    // https://github.com/serenity-rs/serenity/blob/current/examples/e12_global_data/src/main.rs
    // client.data.write().await.insert::<UserId>(owner);

    // Finally, start a single shard, and start listening to events.
    //
    // Shards will automatically attempt to reconnect, and will perform
    // exponential backoff until it reconnects.
    if let Err(why) = client.start().await 
    {
        println!("Client error: {:?}", why);
    }
    
}