manifold/src/events.rs

use std::sync::atomic::AtomicBool;

use serenity::async_trait;
use serenity::model::{
    gateway::Ready,
    id::ChannelId,
};
use serenity::prelude::{Context, EventHandler};
use crate::ManifoldConfig;

use crate::responses::Responses;

pub struct Handler {
    pub timer_running: AtomicBool,
}

impl Handler {
    pub fn new() -> Self {
        Handler {
            timer_running: AtomicBool::from(false)
        }
    }

    pub async fn standard_startup(ctx: &Context, data_about_bot: Ready) {
        let data = ctx.data.read().await;
        let config = match data.get::<ManifoldConfig>() {
            Some(c) => c.lock().await,
            None => return
        };

        let responses = match data.get::<Responses>() {
            Some(r) => r.lock().await,
            None => return
        };

        let greeting = match responses.get_response(&"bot startup".to_string()) {
            Some(g) => g.replace("{NAME}", &*ctx.cache.current_user().name).replace("{COFFEE_TYPE}", "espresso").to_string(),
            None => "Manifold bot connected to discord and ready to begin broadcast operations.".to_string(),
        };

        let bot_nickname = config.get_value(&"BotNickname".to_string()).unwrap_or("BrokenManifoldBot".to_string());
        let channel: ChannelId = config.get_channel(&"Log".to_string()).expect("Specified log channel invalid or unavailable");
        for guild in data_about_bot.guilds {
            match guild.id.edit_nickname(&ctx, Some(&*bot_nickname)).await {
                Ok(()) => (),
                Err(e) => {
                    error!("Error setting bot nickname (lack permission?): {:?}", e);
                }
            }
        }

        channel.say(&ctx, greeting).await.expect("Couldn't message log channel!");
    }
}

#[async_trait]
impl EventHandler for Handler {
    async fn ready(&self, ctx: Context, data_about_bot: Ready) {
        Handler::standard_startup(&ctx, data_about_bot).await;
    }
}