feat:ctd: add inactivity timer

Author: kroos47

src/main.rs

@@ -2,9 +2,15 @@ use dotenv::dotenv;
 
 use poise::serenity_prelude::GatewayIntents;
 use reqwest::Client as HttpClient;
-use serenity::client::Client;
-use serenity::model::id::GuildId;
+use serenity::async_trait;
+use serenity::client::{Client, Context, EventHandler};
+use serenity::model::gateway::Ready;
+use serenity::model::id::{ChannelId, GuildId};
+use serenity::model::voice::VoiceState;
 use serenity::prelude::TypeMapKey;
+use songbird::{Event, EventContext, EventHandler as SongbirdEventHandler, TrackEvent};
+// use songbird::id::ChannelId;
+
 use songbird::{
     SerenityInit,
     input::{Compose, YoutubeDl},
@@ -18,8 +24,8 @@ use std::time::{Duration, Instant};
 use std::{collections::HashMap, env, sync::Arc};
 type Error = Box<dyn std::error::Error + Send + Sync>;
 type Contx<'a> = poise::Context<'a, Data, Error>;
-const INACTIVITY_TIMEOUT: Duration = Duration::from_secs(5 * 60); // 5 minutes
-const ALONE_TIMEOUT: Duration = Duration::from_secs(2 * 60); // 2 minutes when alone
+const INACTIVITY_TIMEOUT: Duration = Duration::from_secs(300); // 5 minutes
+const ALONE_TIMEOUT: Duration = Duration::from_secs(120); // 2 minutes when alone
 #[poise::command(prefix_command, slash_command)]
 async fn help(
     ctx: Contx<'_>,
@@ -64,7 +70,7 @@ impl AutoDisconnectManager {
             guild_timer: RwLock::new(HashMap::new()),
         }
     }
-    async fn start_timer(&self, ctx: Contx<'_>, guild_id: GuildId, duration: Duration) {
+    async fn start_timer(&self, ctx: Context, guild_id: GuildId, duration: Duration) {
         let mut timers = self.guild_timer.write().await;
 
         //abort if already existing timer
@@ -85,7 +91,7 @@ impl AutoDisconnectManager {
 
         guild_timer.last_activity = Instant::now();
 
-        let ctx_ser_clone = ctx.serenity_context().clone();
+        let ctx_ser_clone = ctx.clone();
 
         // let ctx_clone = ctx.clone();
         let task =
@@ -100,13 +106,7 @@ impl AutoDisconnectManager {
                         if queue_check {
                             drop(handler);
                             let _ = manager.remove(guild_id).await;
-                            // ctx_clone
-                            //     .say(format!(
-                            //         "🔇 Left voice channel due to {} minutes of {}",
-                            //         duration.as_secs() / 60,
-                            //         "time name"
-                            //     ))
-                            //     .await;
+
                             if let Ok(channels) =
                                 ctx_ser_clone.http.get_channels(guild_id.into()).await
                             {
@@ -144,14 +144,109 @@ impl AutoDisconnectManager {
     }
 
     // Start inactivity timer when queue becomes empty
-    pub async fn start_inactivity_timer(&self, guild_id: GuildId, ctx: Contx<'_>) {
+    pub async fn start_inactivity_timer(&self, guild_id: GuildId, ctx: Context) {
         self.start_timer(ctx, guild_id, INACTIVITY_TIMEOUT).await;
     }
 
     // Start timer when bot is alone in voice channel
-    pub async fn start_alone_timer(&self, guild_id: GuildId, ctx: Contx<'_>) {
+    pub async fn start_alone_timer(&self, guild_id: GuildId, ctx: Context) {
         self.start_timer(ctx, guild_id, ALONE_TIMEOUT).await;
     }
+
+    pub async fn cancel_timers(&self, guild_id: GuildId) {
+        let mut timers = self.guild_timer.write().await;
+        if let Some(guild_timer) = timers.remove(&guild_id) {
+            if let Some(task) = guild_timer.timer_task {
+                task.abort();
+            }
+            info!("Cancelled timers for guild {}", guild_id);
+        }
+    }
+    pub async fn check_if_alone(&self, ctx: &Context, guild_id: GuildId) {
+        if let Some(manager) = songbird::get(ctx).await {
+            if let Some(handler_lock) = manager.get(guild_id) {
+                let handler = handler_lock.lock().await;
+
+                if let Some(current_channel) = handler.current_channel() {
+                    let channel_id = ChannelId::from(current_channel.0);
+
+                    // Get current bot's user ID
+                    let bot_user_id = ctx.cache.current_user().id;
+
+                    // Count non-bot users in the voice channel
+                    let human_count = match ctx.cache.guild(guild_id) {
+                        Some(guild) => {
+                            guild
+                                .voice_states
+                                .values()
+                                .filter(|vs| vs.channel_id == Some(channel_id))
+                                .filter(|vs| vs.user_id != bot_user_id) // Exclude our bot
+                                .filter_map(|vs| guild.members.get(&vs.user_id))
+                                .filter(|member| !member.user.bot) // Exclude all bots
+                                .count()
+                        }
+                        None => {
+                            // If guild not in cache, make HTTP request
+                            info!(
+                                "Guild {} not in cache, cannot determine voice states reliably",
+                                guild_id
+                            );
+                            return;
+                        }
+                    };
+
+                    if human_count == 0 {
+                        info!(
+                            "Bot is alone in voice channel (found {} humans), starting alone timer",
+                            human_count
+                        );
+                        drop(handler);
+                        self.start_alone_timer(guild_id, ctx.clone()).await;
+                    } else {
+                        info!("Found {} human(s) in voice channel, not alone", human_count);
+                    }
+                }
+            }
+        }
+    }
+
+    pub async fn handle_voice_join(&self, guild_id: GuildId, ctx: &Context) {
+        // Update activity first (cancels any existing timers)
+        self.update_activity(guild_id).await;
+
+        // Check if alone (starts 2-minute timer if alone)
+        self.check_if_alone(ctx, guild_id).await;
+
+        // If not alone, start inactivity timer (5 minutes) since no music is playing
+        // Note: check_if_alone will override this with a shorter timer if bot is alone
+        self.start_inactivity_timer(guild_id, ctx.clone()).await;
+    }
+}
+
+pub struct BotEventHandler {
+    auto_disconnect: Arc<AutoDisconnectManager>,
+}
+
+impl BotEventHandler {
+    pub fn new(auto_disconnect: Arc<AutoDisconnectManager>) -> Self {
+        Self { auto_disconnect }
+    }
+}
+
+#[async_trait]
+impl EventHandler for BotEventHandler {
+    async fn ready(&self, _ctx: Context, ready: Ready) {
+        info!("{} is connected!", ready.user.name);
+    }
+
+    async fn voice_state_update(&self, ctx: Context, _old: Option<VoiceState>, new: VoiceState) {
+        // Check if someone left and if bot might be alone now
+        if let Some(guild_id) = new.guild_id {
+            // Small delay to let voice states update
+            tokio::time::sleep(Duration::from_millis(500)).await;
+            self.auto_disconnect.check_if_alone(&ctx, guild_id).await;
+        }
+    }
 }
 
 fn format_duration(duration: Duration) -> String {
@@ -166,6 +261,35 @@ fn format_duration(duration: Duration) -> String {
     }
 }
 
+pub struct MusicEventHandler {
+    pub guild_id: GuildId,
+    pub auto_disconnect: Arc<AutoDisconnectManager>,
+    pub ctx: Context,
+}
+
+#[async_trait]
+impl SongbirdEventHandler for MusicEventHandler {
+    async fn act(&self, _ctx: &EventContext<'_>) -> Option<Event> {
+        info!("Track ended in guild {}", self.guild_id);
+
+        // Check if queue is now empty
+        if let Some(manager) = songbird::get(&self.ctx).await {
+            if let Some(handler_lock) = manager.get(self.guild_id) {
+                let handler = handler_lock.lock().await;
+                if handler.queue().is_empty() {
+                    info!("Queue is empty after track end, starting inactivity timer");
+                    drop(handler); // Release lock before async call
+                    self.auto_disconnect
+                        .start_inactivity_timer(self.guild_id, self.ctx.clone())
+                        .await;
+                }
+            }
+        }
+
+        None
+    }
+}
+
 /// Join your voice channel
 #[poise::command(slash_command, guild_only)]
 async fn join(ctx: Contx<'_>) -> Result<(), Error> {
@@ -195,7 +319,21 @@ async fn join(ctx: Contx<'_>) -> Result<(), Error> {
         Ok(handler_lock) => {
             let mut handler = handler_lock.lock().await;
             handler.deafen(true).await?;
+            handler.add_global_event(
+                Event::Track(TrackEvent::End),
+                MusicEventHandler {
+                    guild_id,
+                    auto_disconnect: ctx.data().auto_disconnect.clone(),
+                    ctx: ctx.serenity_context().clone(),
+                },
+            );
+
+            drop(handler); // Release lock
 
+            ctx.data()
+                .auto_disconnect
+                .handle_voice_join(guild_id, ctx.serenity_context())
+                .await;
             ctx.say(format!("✅ Joined <#{}>!", connect_to)).await?;
         }
         Err(e) => {
@@ -244,6 +382,15 @@ async fn play(
                 Ok(handler_lock) => {
                     let mut handler = handler_lock.lock().await;
                     handler.deafen(true).await?;
+
+                    handler.add_global_event(
+                        Event::Track(TrackEvent::End),
+                        MusicEventHandler {
+                            guild_id,
+                            auto_disconnect: ctx.data().auto_disconnect.clone(),
+                            ctx: ctx.serenity_context().clone(),
+                        },
+                    );
                 }
                 Err(e) => {
                     ctx.say(format!("❌ Couldn't join your voice channel: {:?}", e))
@@ -341,7 +488,7 @@ async fn stop(ctx: Contx<'_>) -> Result<(), Error> {
         drop(handler);
         ctx.data()
             .auto_disconnect
-            .start_inactivity_timer(guild_id, ctx)
+            .start_inactivity_timer(guild_id, ctx.serenity_context().clone())
             .await;
 
         ctx.say("⏹️ Stopped playback and cleared queue").await?;
@@ -362,7 +509,9 @@ async fn main() -> Result<()> {
 
     let intents = GatewayIntents::non_privileged()
         | GatewayIntents::GUILD_VOICE_STATES
-        | GatewayIntents::MESSAGE_CONTENT;
+        | GatewayIntents::MESSAGE_CONTENT
+        | GatewayIntents::GUILDS;
+
     let framework = poise::Framework::builder()
         .options(poise::FrameworkOptions {
             commands: vec![help(), join(), play(), stop()],