fix: bot stuck when forcefully disconnected without using command

Cargo.toml

@@ -1,12 +1,12 @@
 [package]
 name = "moover_rust"
-version = "3.4.0"
+version = "3.4.2"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-rand = "0.8.5"
+rand = "0.9.0"
 anyhow = "1.0.95"
 tokio-cron-scheduler = "0.13.0"
 dotenv = "0.15.0"
@@ -26,7 +26,7 @@ reqwest = "0.11.27" # songbird depends on ^0.11
 radiobrowser = { path = "./radiobrowser-lib-rust" }
 
 [dependencies.symphonia]
-version = "0.5.2"
+version = "0.5.4"
 features = ["aac", "mp3", "isomp4", "alac"]
 
 [features]

README.md

@@ -14,10 +14,6 @@
 Make sure you have cargo installed!
 Edit .env.example and rename to .env
 
-Check if you have `openssl` (libssl-dev Ubuntu, openssl-devel Fedora)
-audiopus_sys requires `cmake`
-some dependencies require `build-essential`
-
 Compile debug version
 ```
 make dev
@@ -37,3 +33,16 @@ Run release version
 ```
 make run_rel
 ```
+
+## Dependencies
+Check if you have `openssl` (libssl-dev Ubuntu, openssl-devel Fedora)
+
+audiopus_sys requires `cmake`
+
+some dependencies require `build-essential`
+
+`yt-dlp` used for general_player
+
+Look at [yt-dlp dependencies](https://github.com/yt-dlp/yt-dlp?tab=readme-ov-file#dependencies) if something's not working
+
+`ffmpeg` for yt-dlp

src/commands/help.rs

@@ -5,7 +5,11 @@ use crate::types::Context;
 type Error = Box<dyn std::error::Error + Send + Sync>;
 
 /// Show help message
-#[poise::command(slash_command, track_edits, category = "Utility")]
+#[poise::command(
+    slash_command,
+    track_edits,
+    category = "Help")
+]
 pub async fn help(
     ctx: Context<'_>,
     #[description = "Command to get help for"]

src/commands/moover/gif.rs

@@ -1,7 +1,7 @@
 use poise;
 use serenity::all::{Embed, User};
 
-use crate::types::{Error, Context};
+use crate::types::{Context, ContextExt, Error};
 
 #[poise::command(
     slash_command,
@@ -15,6 +15,6 @@ pub async fn gif(ctx: Context<'_>,
 ) -> Result<(), Error> {
     // let embed;
     // send_with_embed(ctx, "hug", &title, &desc).await?;
-    ctx.reply("Done!").await?;
+    ctx.reply_ephemeral("Done!").await?;
     Ok(())
 }

src/commands/moover/moove.rs

@@ -1,4 +1,4 @@
-use std::sync::Arc;
+use std::sync::{Arc, LazyLock};
 use std::time::Duration;
 
 use anyhow::Context;
@@ -6,17 +6,19 @@ use serenity::builder::{CreateAttachment, CreateEmbed, CreateMessage};
 use serenity::http::Http;
 use serenity::model::channel::Message;
 use tokio::time::sleep;
-use regex::Regex;
 use serenity::model::id::ChannelId;
 
+use regex::Regex;
+
+static RE_CHANNEL_ID: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"<#[0-9]*>$").unwrap());
+
 
 /// Checks if the message should be mooved
 /// If the message should be mooved, try to move it and return Ok if mooved succesfully
 pub async fn moove_check(msg: &Message) -> Option<u64> {
     let word_count = msg.content.trim().split_whitespace().count();
-    let re = Regex::new(r"<#[0-9]*>$").unwrap();
 
-    if word_count != 1 || re.captures(&msg.content).is_none() {
+    if word_count != 1 || RE_CHANNEL_ID.captures(&msg.content).is_none() {
         return None
     }
 
@@ -49,7 +51,7 @@ pub async fn moove(http: Arc<Http>, msg: Message, m_channel_id: u64) -> anyhow::
         .map(| embed | CreateEmbed::from(embed))
         .collect();
 
-    
+
     let mut new_content = format!("Sent by {}\n mooved {}\n", msg_to_moove.author, msg.author);
     let mut new_msg = CreateMessage::new();
 
@@ -66,7 +68,7 @@ pub async fn moove(http: Arc<Http>, msg: Message, m_channel_id: u64) -> anyhow::
         let embed = CreateEmbed::new()
         .field("MOO", new_content, false)
         .field("Message:\n", msg_to_moove.content.clone(), false);
-    
+
         new_msg = new_msg.add_embed(embed);
     }
 

src/commands/user_interactions/headpat.rs

@@ -1,12 +1,12 @@
-use poise;
 use serenity::all::User;
 
 use super::interaction::send_with_embed;
-use crate::types::{Error, Context};
+use crate::types::{Context, Error};
 
 #[poise::command(
     slash_command,
-    description_localized("en-US", "Headpat all your friends!")
+    description_localized("en-US", "Headpat all your friends!"),
+    category = "Interaction"
 )]
 pub async fn headpat(ctx: Context<'_>,
     #[description = "Who is the lucky one?"]
@@ -15,6 +15,5 @@ pub async fn headpat(ctx: Context<'_>,
     let title = "HEADPATS!";
     let desc = format!("{} headpats {}", ctx.author(), user);
     send_with_embed(ctx, "headpat", &title, &desc).await?;
-    ctx.reply("Done!").await?;
     Ok(())
-}
+}

src/commands/user_interactions/hug.rs

@@ -2,11 +2,12 @@ use poise;
 use serenity::all::User;
 
 use super::interaction::send_with_embed;
-use crate::types::{Error, Context};
+use crate::types::{Context, Error};
 
 #[poise::command(
     slash_command,
-    description_localized("en-US", "Hug all your friends!")
+    description_localized("en-US", "Hug all your friends!"),
+    category = "Interaction"
 )]
 pub async fn hug(ctx: Context<'_>,
     #[description = "Who is the lucky one?"]
@@ -15,6 +16,5 @@ pub async fn hug(ctx: Context<'_>,
     let title = "HUGS!";
     let desc = format!("{} hugs {}", ctx.author(), user);
     send_with_embed(ctx, "hug", &title, &desc).await?;
-    ctx.reply("Done!").await?;
     Ok(())
 }

src/commands/user_interactions/interaction.rs

@@ -1,8 +1,8 @@
-use anyhow::anyhow;
-use serenity::all::{Colour, CreateEmbed, CreateMessage};
+use poise::CreateReply;
+use serenity::all::{Colour, CreateEmbed};
 use tenorv2::tenor_builder::Tenor;
 
-use crate::{types::Context, utils::{gifs::get_random_tenor_gif, utilities}};
+use crate::{types::Context, utils::gifs::get_random_tenor_gif};
 
 /// Sends embed with random tenor gif from searched query
 /// title and desc are used in the embed
@@ -20,17 +20,7 @@ pub(super) async fn send_with_embed(ctx: Context<'_>, query: &str, title: &str,
         .description(desc)
         .image(url.as_str());
 
-    if ctx.guild_id().is_none() {
-        return Err(anyhow!("Guild id not available in context"));
-    }
-
-    utilities::get_system_channel(
-        ctx.guild_id().unwrap(), ctx.http()
-    ).await?
-    .send_message(
-        ctx.http(),
-        CreateMessage::new().add_embed(embed)
-    ).await?;
+    ctx.send(CreateReply::default().embed(embed)).await?;
 
     Ok(())
 }

src/commands/voice.rs

@@ -5,8 +5,3 @@ pub mod player_common;
 pub mod radio;
 pub mod general_player;
 pub mod voice_types;
-
-// ! not working
-// pub mod yt;
-// TODO implement
-// pub mod spotify;

src/commands/voice/general_player.rs

@@ -1,6 +1,7 @@
 use std::vec;
 
 use songbird::input::YoutubeDl;
+use songbird::TrackEvent;
 
 use crate::types::{Context, ContextExt, Error};
 use crate::commands::voice::voice_utils::autocomplete_channel;
@@ -10,7 +11,9 @@ use super::connect;
 // For list of supported URLs visit https://github.com/yt-dlp/yt-dlp/blob/master/supportedsites.md
 #[poise::command(
     slash_command,
-    description_localized("en-US", "Plays music from supported URL")
+    description_localized("en-US", "Plays music from supported URL"),
+    category = "Voice",
+    guild_only
 )]
 pub async fn play(ctx: Context<'_>,
     #[autocomplete = "autocomplete_channel"]
@@ -19,34 +22,20 @@ pub async fn play(ctx: Context<'_>,
     #[description = "Source URL: "]
     url: String,
 ) -> Result<(), Error> {
-
-    if ctx.guild().is_none() {
-        ctx.reply_ephemeral("Can't use this outside of guild").await?;
-        return Ok(());
-    }
-
-    let manager = songbird::get(ctx.serenity_context())
-        .await
-        .expect("Songbird Voice client placed in at initialisation.")
-        .clone();
-
-    let Some(guild_id) = ctx.guild_id() else {
-        ctx.reply_ephemeral("Guild id not found").await?;
-        return Ok(())
-    };
-
-    let http_client = &ctx.data().http_client;
-
-    if manager.get(guild_id).is_none() {
-        if let Err(e) = connect(&ctx, guild_id, channel).await {
+    let events = vec![TrackEvent::End];
+    let (manager, guild_id) = match connect(&ctx, channel, events).await {
+        Ok(result) => result,
+        Err(e) => {
             ctx.reply_ephemeral(&e.to_string()).await?;
+            println!("SONGBIRD MANAGER ERROR: {}", e.to_string());
             return Ok(())
         }
-    }
-
+    };
+    
     if let Some(handler_lock) = manager.get(guild_id) {
         let mut handler = handler_lock.lock().await;
-
+        
+        let http_client = &ctx.data().http_client;
         let src = YoutubeDl::new(http_client.clone(), url);
         handler.enqueue_input(src.into()).await;
     }

src/commands/voice/player_common.rs

@@ -2,6 +2,7 @@ use std::vec;
 
 use poise::CreateReply;
 use songbird::input::{File, Input};
+use songbird::TrackEvent;
 
 use crate::utils::debug::send_error;
 use crate::types::{Context, ContextExt, Error};
@@ -17,7 +18,9 @@ use super::voice_utils::{connect, autocomplete_channel};
 /// Disconnect bot from voice channel
 #[poise::command(
     slash_command,
-    description_localized("en-US", "Disconnect from voice channel")
+    description_localized("en-US", "Disconnect from voice channel"),
+    category = "Voice",
+    guild_only
 )]
 pub async fn disconnect(
     ctx: Context<'_>
@@ -36,7 +39,7 @@ pub async fn disconnect(
     let has_handler = manager.get(guild_id).is_some();
 
     if ! has_handler {
-        ctx.reply("I am not connected to a channel!").await?;
+        ctx.reply_ephemeral("I am not connected to a channel!").await?;
         return Ok(())
     }
 
@@ -66,7 +69,9 @@ async fn autocomplete_song(
 
 #[poise::command(
     slash_command,
-    description_localized("en-US", "Play song from server storage")
+    description_localized("en-US", "Play song from server storage"),
+    category = "Voice",
+    guild_only
 )]
 pub async fn play_local(ctx: Context<'_>,
     #[autocomplete = "autocomplete_channel"]
@@ -76,31 +81,15 @@ pub async fn play_local(ctx: Context<'_>,
     #[description = "Filename of local song: "]
     file_name: String
 ) -> Result<(), Error> {
-
-    if ctx.guild().is_none() {
-        ctx.reply_ephemeral("Can't use this outside of guild").await?;
-        return Ok(());
-    }
-
-    let manager = songbird::get(ctx.serenity_context())
-        .await
-        .expect("Songbird Voice client placed in at initialisation.")
-        .clone();
-
-    let Some(guild_id) = ctx.guild_id() else {
-        ctx.reply_ephemeral("Guild id not found").await?;
-        return Ok(())
-    };
-
-    if manager.get(guild_id).is_none() {
-        match connect(&ctx, guild_id, channel).await {
-            Ok(_) => (),
-            Err(e) => {
-                ctx.reply_ephemeral(&e.to_string()).await?;
-                return Ok(())
-            }
+    let events = vec![TrackEvent::End];
+    let (manager, guild_id) = match connect(&ctx, channel, events).await {
+        Ok(result) => result,
+        Err(e) => {
+            ctx.reply_ephemeral(&e.to_string()).await?;
+            println!("SONGBIRD MANAGER ERROR: {}", e.to_string());
+            return Ok(())
         }
-    }
+    };
 
     if let Some(handler_lock) = manager.get(guild_id) {
         let mut handler = handler_lock.lock().await;
@@ -121,7 +110,9 @@ pub async fn play_local(ctx: Context<'_>,
 /// Sends embed with some info about currently playing source
 #[poise::command(
     slash_command,
-    description_localized("en-US", "Display currently playing info")
+    description_localized("en-US", "Display currently playing info"),
+    category = "Voice",
+    guild_only
 )]
 pub async fn playing(ctx: Context<'_>) -> Result<(), Error> {
 
@@ -150,8 +141,6 @@ pub async fn playing(ctx: Context<'_>) -> Result<(), Error> {
         playing_info.generate_embed().await    
     };
 
-    dbg!(&embed);
-
     ctx.send(
         CreateReply::default()
             .embed(embed)

src/commands/voice/radio/radio_player.rs

@@ -5,6 +5,7 @@ use reqwest::Client;
 
 use songbird::input::Input;
 use songbird::input::HttpRequest;
+use songbird::TrackEvent;
 
 use super::super::connect;
 use super::link_or_string;
@@ -21,7 +22,8 @@ use crate::commands::voice::voice_utils::autocomplete_channel;
 #[poise::command(
     slash_command,
     description_localized("en-US", "Plays music from URL source"),
-    subcommands("search", "play")
+    subcommands("search", "play"),
+    guild_only
 )]
 pub async fn radio(_ctx: Context<'_>) -> Result<(), Error> {
     Ok(())
@@ -30,7 +32,8 @@ pub async fn radio(_ctx: Context<'_>) -> Result<(), Error> {
 /// Play online radio stream directly from URL or autocompleted string
 #[poise::command(
     slash_command,
-    description_localized("en-US", "Plays music from URL source")
+    description_localized("en-US", "Plays music from URL source"),
+    category = "Voice"
 )]
 pub async fn play(ctx: Context<'_>,
     #[autocomplete = "autocomplete_channel"]
@@ -40,12 +43,6 @@ pub async fn play(ctx: Context<'_>,
     #[description = "Radio station: "]
     name: String,
 ) -> Result<(), Error> {
-
-    if ctx.guild().is_none() {
-        ctx.reply_ephemeral("Can't use this outside of guild").await?;
-        return Ok(());
-    }
-
     let api = &ctx.data().radio_browser;
     
     let stations_result = match link_or_string(&name) {
@@ -87,23 +84,15 @@ pub async fn play(ctx: Context<'_>,
         return Ok(())
     };
 
-    let manager = songbird::get(ctx.serenity_context())
-        .await
-        .expect("Songbird Voice client placed in at initialisation.")
-        .clone();
-
-    let Some(guild_id) = ctx.guild_id() else {
-        ctx.reply_ephemeral("Guild id not found").await?;
-        return Ok(())
-    };
-
-    if manager.get(guild_id).is_none() {
-        if let Err(e) = connect(&ctx, guild_id, channel).await {
+    let events = vec![TrackEvent::End];
+    let (manager, guild_id) = match connect(&ctx, channel, events).await {
+        Ok(result) => result,
+        Err(e) => {
             ctx.reply_ephemeral(&e.to_string()).await?;
             println!("SONGBIRD MANAGER ERROR: {}", e.to_string());
             return Ok(())
         }
-    }
+    };
 
     if let Some(handler_lock) = manager.get(guild_id) {
         let mut handler = handler_lock.lock().await;
@@ -153,7 +142,8 @@ async fn autocomplete_radio(
 /// Search online radios (you can use stream URL from output for /play) 
 #[poise::command(
     slash_command,
-    description_localized("en-US", "Search for a radio")
+    description_localized("en-US", "Search for a radio"),
+    category = "Voice"
 )]
 pub async fn search(ctx: Context<'_>,
     #[description = "Radio station: "]

src/commands/voice/radio/radio_utils.rs

@@ -1,45 +1,47 @@
+use std::sync::LazyLock;
+
 use poise::CreateReply;
 use radiobrowser::{ApiStation, StationSearchBuilder};
 use regex::Regex;
 use serenity::all::{CreateActionRow, CreateButton, CreateEmbed, CreateEmbedFooter, CreateInteractionResponse, CreateInteractionResponseMessage};
 
-use crate::{commands::voice_types::NumberOfEntries, types::Context};
+use crate::{commands::voice_types::NumberOfEntries, types::{Context, ContextExt, Error}};
 
 pub async fn paginate_search_stations(
     ctx: &Context<'_>,
     search_builder: &StationSearchBuilder,
     limit: NumberOfEntries
-) -> Result<(), serenity::Error> {
+) -> Result<(), Error> {
     // Define some unique identifiers for the navigation buttons
     let ctx_id = ctx.id();
     let prev_button_id = format!("{}prev", ctx_id);
     let next_button_id = format!("{}next", ctx_id);
-    
+
     let search_builder = search_builder;
-    
+
     let Ok(stations) = search_builder.clone().send().await else {
-        ctx.reply("Something went wrong, try searching again").await?;
+        ctx.reply_ephemeral("Something went wrong, try searching again").await?;
         return Ok(())
     };
-    
+
     let mut page = 0;
-    
+
     let embed = create_station_list_embed(&stations, page);
-    
+
     // Send the embed with the first page as content
     let reply = {
         let components = CreateActionRow::Buttons(vec![
             CreateButton::new(&prev_button_id).emoji('◀'),
             CreateButton::new(&next_button_id).emoji('▶'),
             ]);
-            
+
             CreateReply::default()
             .embed(embed)
             .components(vec![components])
         };
-        
+
         ctx.send(reply).await?;
-        
+
         // Loop through incoming interactions with the navigation buttons
         let mut offset = 0;
         let limit_int = limit as u32;
@@ -64,23 +66,23 @@ pub async fn paginate_search_stations(
         }
 
         let Ok(mut stations) = search_builder.clone().offset(offset.to_string()).send().await else {
-            ctx.reply("Something went wrong, try searching again").await?;
+            ctx.reply_ephemeral("Something went wrong, try searching again").await?;
             return Ok(())
         };
 
         if stations.is_empty() {
             offset = 0;
             page = 0;
-            
+
             let Ok(new_stations) = search_builder.clone().offset(offset.to_string()).send().await else {
-                ctx.reply("Something went wrong, try searching again").await?;
+                ctx.reply_ephemeral("Something went wrong, try searching again").await?;
                 return Ok(())
             };
             stations = new_stations;
         }
-        
+
         let embed = create_station_list_embed(&stations, page);
-        
+
         // Update the message with the new page contents
         press
         .create_response(
@@ -118,20 +120,16 @@ pub enum LinkString {
     String
 }
 
-pub fn link_or_string(haystack: &str) -> LinkString {
-    let Ok(re) = Regex::new(r"^https?://([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$") else {
-        panic!("Wrong regex expression!");
-    };
+static RE_URL: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^https?://([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$").unwrap());
 
-    return if re.is_match(haystack) { LinkString::Link } else { LinkString::String }
+pub fn link_or_string(haystack: &str) -> LinkString {
+    return if RE_URL.is_match(haystack) { LinkString::Link } else { LinkString::String }
 }
 
-pub fn parse_radio_autocomplete(haystack: &str) -> Option<(String, String, String)> {
-    let Ok(re) = Regex::new(r"^Name: (.*) Country: (.*) Language: (.*)") else {
-        panic!("Wrong regex expression!");
-    };
+static RE_AUTOCOMPLETE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^Name: (.*) Country: (.*) Language: (.*)").unwrap());
 
-    let Some(captures) = re.captures(haystack) else {
+pub fn parse_radio_autocomplete(haystack: &str) -> Option<(String, String, String)> {
+    let Some(captures) = RE_AUTOCOMPLETE.captures(haystack) else {
         return None
     };
 

src/commands/voice/voice_types.rs

@@ -35,7 +35,6 @@ pub struct GeneralInfo {
     pub duration: Option<String>
 }
 
-
 #[async_trait]
 impl GenerateEmbed for GeneralInfo {
     async fn generate_embed(&self) -> CreateEmbed {

src/commands/voice/voice_utils.rs

@@ -1,10 +1,14 @@
-use serenity::all::{ChannelId, GuildId};
+use std::sync::Arc;
+use std::time::Duration;
+
+use serenity::all::{CacheHttp, ChannelId, CreateMessage, GuildId};
 use serenity::async_trait;
 
 use songbird::events::{Event, EventContext, EventHandler as VoiceEventHandler};
-use songbird::TrackEvent;
+use songbird::{Songbird, TrackEvent};
+use tokio::time::sleep;
 
-use crate::{types::{Context, Error}, utils::utilities::get_channel_by_name};
+use crate::{types::Context, utils::utilities::get_channel_by_name};
 
 pub const MAX_ENTRIES: &str = "15";
 
@@ -30,18 +34,53 @@ async fn get_voice_channel(ctx: &Context<'_>, name: Option<String>) -> Result<Ch
     }
 }
 
-struct TrackErrorNotifier;
+struct TrackEventNotifier {
+    ctx: serenity::all::Context,
+    guild_id: GuildId,
+    channel_id: ChannelId
+}
+
+impl TrackEventNotifier {
+    fn new(ctx: serenity::all::Context,
+            guild_id: GuildId,
+            channel_id: ChannelId) -> TrackEventNotifier {
+        TrackEventNotifier {
+            ctx,
+            guild_id,
+            channel_id
+        }
+    }
+}
 
 #[async_trait]
-impl VoiceEventHandler for TrackErrorNotifier {
+impl VoiceEventHandler for TrackEventNotifier {
     async fn act(&self, ctx: &EventContext<'_>) -> Option<Event> {
         if let EventContext::Track(track_list) = ctx {
-            for (state, handle) in *track_list {
-                println!(
-                    "Track {:?} encountered an error: {:?}",
-                    handle.uuid(),
-                    state.playing
-                );
+            for (_, _) in *track_list {
+                sleep(Duration::from_secs(60)).await;     
+                let manager = songbird::get(&self.ctx)
+                    .await
+                    .expect("Songbird Voice client placed in at initialisation.")
+                    .clone();
+
+                if let Some(handler_lock) = manager.get(self.guild_id) {
+                    let handler = handler_lock.lock().await;
+                    if !handler.queue().is_empty() {
+                        return None
+                    }
+
+                    drop(handler);
+                    drop(handler_lock);
+                    match manager.remove(self.guild_id).await {
+                        Ok(_) => (),
+                        Err(e) => {
+                            dbg!(e);
+                            ()
+                        }
+                    }
+
+                    let _ = self.channel_id.say(self.ctx.http(), "Disconnected to save bandwidth!").await;
+                };
             }
         }
 
@@ -49,7 +88,50 @@ impl VoiceEventHandler for TrackErrorNotifier {
     }
 }
 
-pub async fn connect(ctx: &Context<'_>, guild_id: GuildId, channel: Option<String>) -> Result<(), Error> {
+
+struct TrackErrorNotifier {
+    ctx: serenity::all::Context,
+    channel_id: ChannelId
+}
+
+impl TrackErrorNotifier {
+    fn new(ctx: serenity::all::Context, channel_id: ChannelId) -> TrackErrorNotifier {
+        TrackErrorNotifier {
+            ctx,
+            channel_id
+        }
+    }
+}
+
+#[async_trait]
+impl VoiceEventHandler for TrackErrorNotifier {
+    async fn act(&self, ctx: &EventContext<'_>) -> Option<Event> {
+        if let EventContext::Track(track_list) = ctx {
+            for (_, _) in *track_list {
+                match self.channel_id.send_message(
+                    self.ctx.http(),
+                    CreateMessage::new().content("There was an error when playing a track!")
+                ).await {
+                    Ok(_) => (),
+                    Err(e) => println!("{}", e)
+                };
+            }
+        }
+
+        None
+    }
+}
+
+
+pub async fn connect(ctx: &Context<'_>, channel: Option<String>, events: Vec<TrackEvent>) -> Result<(Arc<Songbird>, GuildId), String> {
+    if ctx.guild().is_none() {
+        return Err("This command can be used only in guild".to_string())
+    }
+
+    let Some(guild_id) = ctx.guild_id() else {
+        return Err("Guild id not found".to_string())
+    };
+
     let voice_channel = get_voice_channel(&ctx, channel).await?;
 
     let manager = songbird::get(ctx.serenity_context())
@@ -59,10 +141,20 @@ pub async fn connect(ctx: &Context<'_>, guild_id: GuildId, channel: Option<Strin
 
     if let Ok(handler_lock) = manager.join(guild_id, voice_channel).await {
         let mut handler = handler_lock.lock().await;
-        handler.add_global_event(TrackEvent::Error.into(), TrackErrorNotifier);
+        handler.add_global_event(TrackEvent::Error.into(), TrackErrorNotifier::new(ctx.serenity_context().clone(), voice_channel));
+        for event in events {
+            handler.add_global_event(
+                event.into(),
+                TrackEventNotifier::new(
+                    ctx.serenity_context().clone(),
+                    guild_id,
+                    voice_channel
+                )
+            );
+        }
     }
 
-    Ok(())
+    Ok((manager, guild_id))
 }
 
 pub async fn autocomplete_channel(

src/commands/voice/yt/yt_player.rs

@@ -6,7 +6,6 @@ use songbird::input::YoutubeDl;
 use crate::commands::util::connect;
 use crate::util::poise_context_extension::ContextExt;
 use crate::types::{Context, Error};
-use crate::commands::voice::util::autocomplete_channel;
 
 // TODO: search, queue
 #[poise::command(
@@ -14,9 +13,9 @@ use crate::commands::voice::util::autocomplete_channel;
     description_localized("en-US", "Plays music from YouTube URL")
 )]
 pub async fn play_yt(ctx: Context<'_>,
-    #[autocomplete = "autocomplete_channel"]
     #[description = "Voice channel name: "]
-    channel: Option<String>,
+    #[channel_types("Voice")]
+    channel: Option<GuildChannel>,
     #[description = "Source URL: "]
     url: String,
 ) -> Result<(), Error> {

src/handlers.rs

@@ -0,0 +1,2 @@
+pub mod message_handler;
+pub mod voice_state_handler;

src/handlers/message_handler.rs

@@ -1,4 +1,5 @@
 use rand::random;
+use rand::seq::IndexedRandom;
 use serenity::http::CacheHttp;
 use serenity::{client::Context, http::Http};
 use serenity::model::channel::Message;
@@ -14,7 +15,7 @@ pub async fn handle(ctx: Context, msg: Message) {
     if msg.author.bot {
         return
     }
-    
+
     let lower_case_content = msg.content.to_lowercase();
 
     let bot_id = ctx.cache.current_user().id;
@@ -30,7 +31,7 @@ pub async fn handle(ctx: Context, msg: Message) {
             return
         }
     }
-    
+
     // X and IG not embedding correctly (IG fix does not work for now need to find different one)
     let link_fixes = HashMap::from([
         ("//x.com", "//fixvx.com")
@@ -80,8 +81,8 @@ async fn response(http: Arc<Http>, msg: Message) -> bool {
         "Hm?"
     ];
 
-    let num = random::<usize>() % RESPONSES.len();
-    match msg.reply(http.clone(), RESPONSES[num]).await {
+    let response = RESPONSES.choose(&mut rand::rng()).unwrap_or(&"?").to_string();
+    match msg.reply(http.clone(), response).await {
         Ok(_) => { return true }
         Err(e) => {
             let _ = send_error(http, e.to_string()).await;
@@ -93,10 +94,9 @@ async fn response(http: Arc<Http>, msg: Message) -> bool {
 async fn henlo(http: Arc<Http>, msg: Message) -> bool {
     const EMOJIS: [&str; 7] = ["🥰", "🐄", "🐮", "❤️", "👋", "🤠", "😊"];
 
-    let num = random::<usize>() % EMOJIS.len();
-    let response = format!("Henlooo {} {}", msg.author.name, EMOJIS[num]);
+    let emoji = EMOJIS.choose(&mut rand::rng()).unwrap_or(&"🐮");
+    let response = format!("Henlooo {} {}", msg.author.name, emoji);
 
-    
     match msg.reply(http.clone(), response).await {
         Ok(_) => { return true }
         Err(e) => {

src/handlers/voice_state_handler.rs

@@ -0,0 +1,110 @@
+use std::time::Duration;
+
+use serenity::all::{Context, CreateMessage, GuildChannel, VoiceState};
+use tokio::time::sleep;
+
+use crate::utils::{debug::send_error, voice_state_to_guild_channel};
+
+async fn get_channel_info(ctx: &Context, voice_state: &VoiceState) -> Option<GuildChannel> {
+    let voice_channel = voice_state_to_guild_channel(&ctx, &voice_state).await?;
+
+    let Ok(members) = voice_channel.members(&ctx.cache) else {
+        return None
+    };
+
+    let mut is_connected = false;
+    let mut users_connected: usize = 0;
+    for member in &members {
+        if member.user.id == ctx.cache.current_user().id {
+            is_connected = true
+        }
+        if ! member.user.bot {
+            users_connected += 1;
+        }
+    }
+
+    // Check if there is no real user in the voice channel
+    if ! is_connected || users_connected > 0 {
+        return None;
+    }
+
+    Some(voice_channel)
+}
+
+pub async fn handle_autodisconnect(ctx: Context, voice_state_old: VoiceState, voice_state: VoiceState) -> Option<()> {
+        // Logic is as follows:
+        // User connected -> voice_state_old is None (we handle this before this function)
+        // Bot was moved to different vc -> we check if the new voice_state has the bot's user id
+        // User moved to different VC or disconnected -> we check old channel instead (the bot could be still there)
+        let mut voice_channel: GuildChannel;
+        if voice_state.user_id == ctx.cache.current_user().id {
+            voice_channel = get_channel_info(&ctx, &voice_state).await?;
+        }
+        // Someone disconnected or moved channels
+        else {
+            voice_channel = get_channel_info(&ctx, &voice_state_old).await?;
+        }
+    
+        let manager = songbird::get(&ctx)
+            .await
+            .expect("Songbird Voice client placed in at initialisation.")
+            .clone();
+    
+        // bot is not connected to any channel via songbird, don't need to do anything
+        if manager.get(voice_channel.guild_id).is_none() {
+            return None;
+        }
+    
+        // There is a problem with this implementation
+        // if bot is left alone and users joins and disconnects while this counts down
+        // this is not a big problem since we want to disconnect anyway
+        sleep(Duration::from_secs(120)).await;
+    
+        if voice_state.user_id == ctx.cache.current_user().id {
+            voice_channel = get_channel_info(&ctx, &voice_state).await?;
+        }
+        else {
+            voice_channel = get_channel_info(&ctx, &voice_state_old).await?;
+        }
+    
+        // bot is not connected to any channel via songbird, don't need to do anything
+        // ? could have been removed while sleeping if the song stopped playing 
+        if manager.get(voice_channel.guild_id).is_none() {
+            return None;
+        }
+    
+        match manager.remove(voice_channel.guild_id).await {
+            Ok(()) => {
+                let _ = voice_channel.send_message(ctx.http,
+                    CreateMessage::new()
+                    .content("Disconnected to save bandwidth")
+                ).await;
+            }
+            Err(e) => {
+                let _ = send_error(ctx.http, e.to_string()).await;
+            }
+        }
+    
+        None
+}
+
+pub async fn handle_voice_update(ctx: Context, voice_state_old: VoiceState, voice_state: VoiceState) -> Option<()> {
+    // if the user was disconnected remove Songbird manager so it won't get stuck
+    // Actually this is not really a bug since we can handle disconnect and therefore saving the song queue for example
+    if voice_state.channel_id.is_none() && voice_state.user_id == ctx.cache.current_user().id {
+        let manager = songbird::get(&ctx)
+            .await
+            .expect("Songbird Voice client placed in at initialisation.")
+            .clone();
+    
+        let guild_id = voice_state_old.guild_id?;
+        // bot is not connected to any channel via songbird, don't need to do anything
+        if manager.get(guild_id).is_some() {
+            let _ = manager.remove(guild_id).await;
+            return None;
+        }
+    }
+
+    handle_autodisconnect(ctx, voice_state_old, voice_state).await?;
+    None
+}

src/main.rs

@@ -6,6 +6,7 @@ use std::time::Duration;
 use std::error;
 use std::env;
 
+use serenity::all::VoiceState;
 use serenity::async_trait;
 use serenity::futures::lock::Mutex;
 use serenity::prelude::GatewayIntents;
@@ -19,12 +20,14 @@ use reqwest::Client as HttpClient;
 use dotenv::dotenv;
 
 use songbird::SerenityInit;
+
 use tokio_cron_scheduler::{JobScheduler, Job};
 
 use radiobrowser::RadioBrowserAPI;
 
-mod message_handler;
-use message_handler::handle;
+mod handlers;
+use handlers::message_handler::handle;
+use handlers::voice_state_handler::handle_voice_update;
 
 mod commands;
 mod utils;
@@ -35,6 +38,7 @@ use other::notice;
 mod types;
 use types::{Data, Error};
 
+
 struct Handler;
 
 async fn on_error(error: poise::FrameworkError<'_, Data, Error>) {
@@ -53,6 +57,15 @@ async fn on_error(error: poise::FrameworkError<'_, Data, Error>) {
 
 #[async_trait]
 impl EventHandler for Handler {
+    async fn voice_state_update(&self, ctx: Context, old: Option<VoiceState>, new: VoiceState) {
+        // User was not connected to any channel and connected to VC
+        let Some(old_channel) = old else {
+            return
+        };
+
+        handle_voice_update(ctx, old_channel, new).await;
+    }
+
     async fn message(&self, ctx: Context, msg: Message) {
         handle(ctx, msg).await;
     }
@@ -113,11 +126,11 @@ async fn main() -> anyhow::Result<()> {
         ..Default::default()
     };
 
-    
+
     let framework = poise::Framework::builder()
     .setup(move |ctx, _ready, framework| {
         Box::pin(async move {
-            
+
             #[cfg(feature="GUILD_COMMAND")] {
                 use poise::samples::register_in_guild;
                 use serenity::all::GuildId;
@@ -125,7 +138,7 @@ async fn main() -> anyhow::Result<()> {
                 let debug_guild_id = env::var("DEBUG_GUILD_ID")
                     .context("DEBUG_GUILD_ID not found in env")?
                     .parse::<u64>().unwrap();
-            
+
                 register_in_guild(ctx, &framework.options().commands, GuildId::new(debug_guild_id)).await?;
             }
 
@@ -134,7 +147,7 @@ async fn main() -> anyhow::Result<()> {
                 register_globally(ctx, &framework.options().commands).await?;
             }
 
-            
+
             Ok(Data {
                 http_client: HttpClient::new(),
                 radio_browser: RadioBrowserAPI::new().await?,

src/other/notice.rs

@@ -26,13 +26,13 @@ pub async fn notice_wrapper(ctx: Context) {
 
 /// Send embed with event name and optional special message to guild's general channel
 async fn announce_event(guild_id: GuildId, name: &str, special_message: &str, http: Arc<Http>) -> anyhow::Result<()> {
-   
+
     let mut event_embed = CreateEmbed::new()
         .color(Colour::new(rand::random::<u32>() % 0xFFFFFF))
         .title("Today's event is:");
 
     let system_channel = utilities::get_system_channel(guild_id, &http).await?;
-    
+
     if special_message.contains("http") {
         event_embed = event_embed.description(name);
         system_channel.send_message(http.clone(),
@@ -58,7 +58,7 @@ async fn celebrate_birthday(guild_id: GuildId, user_id: UserId, nick: &str, http
         .locale("sk".to_string())
         .search("vsetko najlepsie").await?;
 
-    let index = rand::random::<usize>() % LIMIT as usize;
+    let index = (rand::random::<u8>() % LIMIT) as usize;
     let gif_url = match tenor::get_gif_url(MediaFilter::gif, tenor_response) {
         Ok(urls) => Some(urls),
         Err(e) => {

src/utils/debug.rs

@@ -4,13 +4,13 @@ use serenity::http::Http;
 
 pub async fn send_error(_http: Arc<Http>, msg: String) -> anyhow::Result<()> {
     println!("ERROR: {msg}");
-    
+
     #[cfg(feature="RELEASE")] {
         use serenity::all::ChannelId;
         use std::process::exit;
         use std::env;
         use anyhow::Context;
-        
+
         let channel_id: String = env::var("DEBUG_CHANNEL_ID").context("DEBUG_CHANNEL_ID not found in env file")?;
         match ChannelId::new(channel_id.parse::<u64>().unwrap())
             .say(_http, msg).await {
@@ -20,12 +20,13 @@ pub async fn send_error(_http: Arc<Http>, msg: String) -> anyhow::Result<()> {
     }
     Ok(())
 }
-    
+
 #[cfg(feature="RELEASE")]
 pub async fn hello(http: Arc<Http>) -> anyhow::Result<()> {
     use serenity::all::ChannelId;
     use anyhow::Context;
     use std::env;
+    use rand::seq::IndexedRandom;
 
     let messages = [
         "AAAAAAAAAAAAAAAAAAAA",
@@ -38,11 +39,11 @@ pub async fn hello(http: Arc<Http>) -> anyhow::Result<()> {
         "Whom'st have summoned the ancient one?",
     ];
 
-    let num = rand::random::<usize>() % messages.len();
-    
+    let message =  messages.choose(&mut rand::rng()).unwrap_or(&"Chello").to_string();
+
     let channel_id: String = env::var("DEBUG_CHANNEL_ID").context("DEBUG_CHANNEL_ID not found in env file")?;
     let channel = ChannelId::new(channel_id.parse::<u64>().unwrap());
-    if let Err(why) = channel.say(http, messages[num]).await {
+    if let Err(why) = channel.say(http, message).await {
         print!("Error sending message: {:?}", why);
     };
 

src/utils/gifs.rs

@@ -1,7 +1,7 @@
 use tenorv2::{tenor, tenor_types::{MediaFilter, TenorError}, JsonValue};
 
 pub async fn get_random_tenor_gif(tenor_response: JsonValue, limit: u8) -> Result<String, TenorError> {
-    let index = rand::random::<usize>() % limit as usize;
+    let index = (rand::random::<u8>() % limit) as usize;
     match tenor::get_gif_url(MediaFilter::gif, tenor_response) {
         Ok(urls) => Ok(urls[index].clone()),
         Err(e) => Err(e)

src/utils/utilities.rs

@@ -1,11 +1,6 @@
 use std::{fs, hash::{DefaultHasher, Hash, Hasher}, io, path::Path, sync::Arc, vec};
 
-use serenity::{all::{ChannelId, ChannelType, CreateMessage, GuildId, GuildRef, Message}, http::Http};
-
-use poise::CreateReply;
-use serenity::async_trait;
-
-use crate::types::Context;
+use serenity::{all::{ChannelId, ChannelType, Context, CreateMessage, GuildChannel, GuildId, GuildRef, Message, VoiceState}, http::Http};
 
 
 pub async fn get_system_channel(guild_id: GuildId, http: &Http) -> anyhow::Result<ChannelId> {
@@ -20,6 +15,16 @@ pub async fn replace_msg(http: Arc<Http>, msg: Message, content: String) -> Resu
     return ChannelId::new(msg.channel_id.get()).send_message(http.clone(), CreateMessage::new().content(content)).await;
 }
 
+pub async fn voice_state_to_guild_channel(ctx: &Context, voice_state: &VoiceState) -> Option<GuildChannel> {
+    let Ok(channel) = voice_state.channel_id?
+        .to_channel(&ctx.http)
+        .await else {
+            return None
+    };
+
+    Some(channel.guild()?)
+}
+
 pub fn get_vc_names(guild: GuildRef) -> Vec<String> {
 
     let mut result: Vec<String> = [].to_vec();