queue system improved

.gitmodules

@@ -7,3 +7,6 @@
 [submodule "libs/poise"]
 	path = libs/poise
 	url = git@github.com:eRgo35/poise.git
+[submodule "libs/spotify-parser"]
+	path = libs/spotify-parser
+	url = git@github.com:eRgo35/spotify-parser.git

Cargo.lock

@@ -1349,7 +1349,7 @@ dependencies = [
 
 [[package]]
 name = "lyra"
-version = "0.9.1"
+version = "0.10.0"
 dependencies = [
  "dotenv",
  "fancy-regex",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lyra"
-version = "0.9.1"
+version = "0.10.0"
 authors = ["Michał Czyż <mike@c2yz.com>"]
 edition = "2021"
 description = "A featureful Discord bot written in Rust."

libs/spotify-parser/Cargo.toml

@@ -1,12 +0,0 @@
-[package]
-name = "lib-spotify-parser"
-version = "1.0.0"
-edition = "2021"
-
-[dependencies]
-regex = "1.10.6"
-reqwest = { version = "0.12.5", features = ["blocking", "rustls-tls"] }
-scraper = "0.19.1"
-serde = "1.0.204"
-serde_json = "1.0.122"
-tokio = { version = "1.39.2", features = ["macros"] }

libs/spotify-parser/src/error.rs

@@ -1,14 +0,0 @@
-use std::fmt;
-
-#[derive(Debug)]
-pub enum ParseError {
-    InvalidUrl,
-}
-
-impl fmt::Display for ParseError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Invalid URL")
-    }
-}
-
-impl std::error::Error for ParseError {}

libs/spotify-parser/src/lib.rs

@@ -1,154 +0,0 @@
-mod error;
-mod parser;
-mod retriever;
-
-use error::ParseError;
-use parser::{parse_list, parse_single, USER_AGENT};
-use regex::Regex;
-use reqwest;
-use retriever::{retrieve_async_track, retrieve_async_tracks, retrieve_track, retrieve_tracks};
-
-pub fn retrieve_url(url: &str) -> Result<Vec<String>, ParseError> {
-    let spotify_regex: Regex = Regex::new(r"https?:\/\/(?:embed\.|open\.)spotify\.com\/(track|album|playlist)\/([a-zA-Z0-9]+)(?:\?si=[\w-]+)?").unwrap();
-
-    if let Some(captures) = spotify_regex.captures(url) {
-        let category = captures.get(1).unwrap().as_str();
-        let id = captures.get(2).unwrap().as_str();
-
-        match category {
-            "track" => {
-                let track = retrieve_track(category, id).unwrap();
-                Ok(vec![track])
-            }
-            "playlist" | "album" => {
-                let tracks = retrieve_tracks(category, id).unwrap();
-                Ok(tracks)
-            }
-            _ => Err(ParseError::InvalidUrl),
-        }
-    } else {
-        Err(ParseError::InvalidUrl)
-    }
-}
-
-pub async fn retrieve_async_url(url: &str) -> Result<Vec<String>, ParseError> {
-    let spotify_regex: Regex = Regex::new(r"https?:\/\/(?:embed\.|open\.)spotify\.com\/(track|album|playlist)\/([a-zA-Z0-9]+)(?:\?si=[\w-]+)?").unwrap();
-
-    if let Some(captures) = spotify_regex.captures(url) {
-        let category = captures.get(1).unwrap().as_str();
-        let id = captures.get(2).unwrap().as_str();
-
-        match category {
-            "track" => {
-                let track = retrieve_async_track(category, id).await.unwrap();
-                Ok(vec![track])
-            }
-            "playlist" | "album" => {
-                let tracks = retrieve_async_tracks(category, id).await.unwrap();
-                Ok(tracks)
-            }
-            _ => Err(ParseError::InvalidUrl),
-        }
-    } else {
-        Err(ParseError::InvalidUrl)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    const TRACK: &str = "https://open.spotify.com/track/4PTG3Z6ehGkBFwjybzWkR8?si=e0a8c8ada8284e43";
-    const MULTIPLE_ARTISTS_TRACK: &str =
-        "https://open.spotify.com/track/1O0SdrryPeGp6eSSUibdgo?si=4ae58febe9e74eae";
-    const PLAYLIST: &str =
-        "https://open.spotify.com/playlist/37i9dQZF1DZ06evO05tE88?si=e0c6f44d176f44e6";
-    const ALBUM: &str =
-        "https://open.spotify.com/album/6eUW0wxWtzkFdaEFsTJto6?si=_grLtlNySNyfJTZr8tP44Q";
-
-    #[test]
-    fn check_track() {
-        let track: Vec<&str> = vec!["Rick Astley - Never Gonna Give You Up"];
-        assert_eq!(retrieve_url(TRACK).unwrap(), track);
-    }
-
-    #[test]
-    fn check_multiple_artists_track() {
-        let track: Vec<&str> = vec!["Will o' the wisp, Rick Astley - Blood on My Tie"];
-        assert_eq!(retrieve_url(MULTIPLE_ARTISTS_TRACK).unwrap(), track);
-    }
-
-    #[test]
-    fn check_playlist() {
-        let playlist: Vec<&str> = vec![
-            "Rick Astley - Never Gonna Give You Up",
-            "Rick Astley - Take Me to Your Heart (2023 Remaster)",
-            "Rick Astley - Cry for Help - Single Edit",
-            "Rick Astley - Never Gonna Stop",
-            "Rick Astley - Together Forever",
-            "Rick Astley - Hold Me in Your Arms (7\" Version)",
-            "Rick Astley - Angels on My Side",
-            "New Kids On The Block, Salt-N-Pepa, Rick Astley, En Vogue - Bring Back The Time",
-            "Rick Astley - Whenever You Need Somebody",
-            "Rick Astley - She Wants to Dance with Me (2023 Remaster)",
-            "Rick Astley - Dippin My Feet",
-            "Rick Astley - My Arms Keep Missing You",
-            "Rick Astley - Don't Say Goodbye",
-            "Rick Astley - Dance",
-            "Rick Astley - Giving Up On Love (7'' Pop Version)",
-            "Rick Astley - Never Gonna Give You Up (Cake Mix)",
-            "Rick Astley - It Would Take a Strong Strong Man",
-            "Rick Astley - Driving Me Crazy",
-            "Rick Astley - Beautiful Life",
-            "Rick Astley - I Don't Want to Lose Her",
-            "Rick Astley - Keep Singing",
-            "Rick Astley - Forever and More",
-            "Rick Astley - Hopelessly",
-            "Rick Astley - When I Fall in Love",
-            "Rick Astley - Every One of Us",
-            "Rick Astley - High Enough",
-            "Rick Astley - Ain't Too Proud to Beg (2023 Remaster)",
-            "Rick Astley - I'll Never Let You Down",
-            "Trevor Horn, Rick Astley - Owner Of A Lonely Heart",
-            "Rick Astley - Letting Go",
-            "Rick Astley - Never Knew Love",
-            "Rick Astley - Lights Out - Radio Edit",
-            "Rick Astley - Try",
-            "Rick Astley - Dial My Number (2023 Remaster)",
-            "Rick Astley - Wish Away",
-            "Rick Astley - Giant",
-            "Rick Astley - Move Right Out",
-            "Rick Astley - Till Then (Time Stands Still) (2023 Remaster)",
-            "Rick Astley - Pray with Me",
-            "Rick Astley - I Don't Want to Be Your Lover",
-            "Will o' the wisp, Rick Astley - Blood on My Tie",
-            "Rick Astley - Can't Help Falling in Love",
-            "Rick Astley - I Like the Sun",
-            "Rick Astley - She Makes Me",
-            "Rick Astley - Body and Soul",
-            "Rick Astley - (They Long to Be) Close to You",
-            "Rick Astley - Unwanted (Official Song from the Podcast)",
-            "Rick Astley - Last Night on Earth",
-            "Rick Astley - Everlong - Acoustic Version",
-            "Rick Astley - Superman",
-        ];
-        assert_eq!(retrieve_url(PLAYLIST).unwrap(), playlist);
-    }
-
-    #[test]
-    fn check_album() {
-        let album: Vec<&str> = vec![
-            "Rick Astley - Never Gonna Give You Up",
-            "Rick Astley - Whenever You Need Somebody",
-            "Rick Astley - Together Forever",
-            "Rick Astley - It Would Take a Strong Strong Man",
-            "Rick Astley - The Love Has Gone",
-            "Rick Astley - Don't Say Goodbye",
-            "Rick Astley - Slipping Away",
-            "Rick Astley - No More Looking for Love",
-            "Rick Astley - You Move Me",
-            "Rick Astley - When I Fall in Love",
-        ];
-        assert_eq!(retrieve_url(ALBUM).unwrap(), album);
-    }
-}

libs/spotify-parser/src/parser.rs

@@ -1,70 +0,0 @@
-use scraper::{Html, Selector};
-use serde_json::Value;
-use std::error::Error;
-
-#[derive(Debug, Clone)]
-pub(crate) struct SpotifyTrack {
-    pub title: String,
-    pub artist: String,
-}
-
-pub(crate) const USER_AGENT: &str = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36";
-
-pub(crate) fn parse_single(content: String) -> Result<SpotifyTrack, Box<dyn Error>> {
-    let document = Html::parse_document(&content);
-    let selector = Selector::parse("#__NEXT_DATA__").unwrap();
-
-    if let Some(script_element) = document.select(&selector).next() {
-        let json_str = script_element.inner_html();
-        let json_value: Value = serde_json::from_str(&json_str)?;
-        let metadata = &json_value["props"]["pageProps"]["state"]["data"]["entity"];
-
-        // println!("{metadata:?}");
-
-        let title = metadata["title"].as_str().unwrap().to_string();
-
-        let artists = metadata["artists"].as_array().unwrap();
-        let artists_list: Vec<String> = artists
-            .iter()
-            .map(|artist| artist["name"].as_str().unwrap().to_string())
-            .collect();
-        let artist: String = artists_list.join(", ").to_string();
-
-        let track = SpotifyTrack { title, artist };
-
-        Ok(track)
-    } else {
-        Err("Could not find element".into())
-    }
-}
-
-pub(crate) fn parse_list(content: String) -> Result<Vec<SpotifyTrack>, Box<dyn Error>> {
-    let document = Html::parse_document(&content);
-    let selector = Selector::parse("#__NEXT_DATA__").unwrap();
-
-    if let Some(script_element) = document.select(&selector).next() {
-        let json_str = script_element.inner_html();
-        let json_value: Value = serde_json::from_str(&json_str)?;
-        let metadata = &json_value["props"]["pageProps"]["state"]["data"]["entity"]["trackList"]
-            .as_array()
-            .unwrap();
-
-        // println!("{metadata:?}");
-
-        let tracks: Vec<SpotifyTrack> = metadata
-            .iter()
-            .map(|track| {
-                let title = track["title"].as_str().unwrap().to_string();
-                let artist = track["subtitle"].as_str().unwrap().to_string();
-
-                SpotifyTrack { title, artist }
-            })
-            .collect();
-
-        // println!("{tracks:?}");
-
-        Ok(tracks)
-    } else {
-        Err("Could not find element".into())
-    }
-}

libs/spotify-parser/src/retriever.rs

@@ -1,85 +0,0 @@
-use crate::*;
-
-pub fn retrieve_track(category: &str, id: &str) -> Result<String, String> {
-    let embed_url = format!("https://embed.spotify.com/?uri=spotify:{}:{}", category, id);
-
-    let client = reqwest::blocking::Client::builder()
-        .use_rustls_tls()
-        .user_agent(USER_AGENT)
-        .build()
-        .unwrap();
-
-    let response = client.get(&embed_url).send().unwrap();
-    let content = response.text().unwrap();
-
-    let parsed_content = parse_single(content).unwrap();
-
-    Ok(format!(
-        "{} - {}",
-        parsed_content.artist, parsed_content.title
-    ))
-}
-
-pub fn retrieve_tracks(category: &str, id: &str) -> Result<Vec<String>, String> {
-    let embed_url = format!("https://embed.spotify.com/?uri=spotify:{}:{}", category, id);
-
-    let client = reqwest::blocking::Client::builder()
-        .use_rustls_tls()
-        .user_agent(USER_AGENT)
-        .build()
-        .unwrap();
-
-    let response = client.get(&embed_url).send().unwrap();
-    let content = response.text().unwrap();
-
-    let parsed_content = parse_list(content).unwrap();
-
-    let tracks: Vec<String> = parsed_content
-        .iter()
-        .map(|track| format!("{} - {}", track.artist, track.title))
-        .collect();
-
-    Ok(tracks)
-}
-
-pub async fn retrieve_async_track(category: &str, id: &str) -> Result<String, String> {
-    let embed_url = format!("https://embed.spotify.com/?uri=spotify:{}:{}", category, id);
-
-    let client = reqwest::Client::builder()
-        .use_rustls_tls()
-        .user_agent(USER_AGENT)
-        .build()
-        .unwrap();
-
-    let response = client.get(&embed_url).send().await.unwrap();
-    let content = response.text().await.unwrap();
-
-    let parsed_content = parse_single(content).unwrap();
-
-    Ok(format!(
-        "{} - {}",
-        parsed_content.artist, parsed_content.title
-    ))
-}
-
-pub async fn retrieve_async_tracks(category: &str, id: &str) -> Result<Vec<String>, String> {
-    let embed_url = format!("https://embed.spotify.com/?uri=spotify:{}:{}", category, id);
-
-    let client = reqwest::Client::builder()
-        .use_rustls_tls()
-        .user_agent(USER_AGENT)
-        .build()
-        .unwrap();
-
-    let response = client.get(&embed_url).send().await.unwrap();
-    let content = response.text().await.unwrap();
-
-    let parsed_content = parse_list(content).unwrap();
-
-    let tracks: Vec<String> = parsed_content
-        .iter()
-        .map(|track| format!("{} - {}", track.artist, track.title))
-        .collect();
-
-    Ok(tracks)
-}

src/commands.rs

@@ -1,4 +1,3 @@
 pub mod embeds;
-pub mod kashi;
 pub mod music;
 pub mod tools;

src/commands/kashi.rs

@@ -1,3 +0,0 @@
-pub mod kashi;
-
-pub use kashi::kashi;

src/commands/kashi/kashi.rs

@@ -1,17 +0,0 @@
-use crate::{Context, Error};
-
-/// Kashi integration platform (WIP)
-#[poise::command(
-    prefix_command, 
-    slash_command,
-    category = "Kashi"
-)]
-pub async fn kashi(
-    ctx: Context<'_>
-) -> Result<(), Error> {
-    
-    let response = format!("Kashi platform is currently under construction!");
-    ctx.say(response).await?;
-
-    Ok(())
-}

src/commands/music/deafen.rs

@@ -15,7 +15,7 @@ use poise::CreateReply;
 pub async fn deafen(ctx: Context<'_>) -> Result<(), Error> {
     let guild_id = ctx.guild_id().unwrap();
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird client placed at init")
         .clone();

src/commands/music/join.rs

@@ -27,7 +27,7 @@ pub async fn join(ctx: Context<'_>) -> Result<(), Error> {
         }
     };
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird client placed at init")
         .clone();

src/commands/music/leave.rs

@@ -15,12 +15,12 @@ use poise::CreateReply;
 pub async fn leave(ctx: Context<'_>) -> Result<(), Error> {
     let guild_id = ctx.guild_id().unwrap();
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird client placed at init")
         .clone();
 
-    if !manager.get(guild_id).is_some() {
+    if manager.get(guild_id).is_none() {
         let msg = "I am not in a voice channel!";
         ctx.send(CreateReply::default().embed(error_embed(ctx, msg).await.unwrap()))
             .await?;

src/commands/music/mute.rs

@@ -15,7 +15,7 @@ use poise::CreateReply;
 pub async fn mute(ctx: Context<'_>) -> Result<(), Error> {
     let guild_id = ctx.guild_id().unwrap();
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird client placed at init")
         .clone();

src/commands/music/pause.rs

@@ -9,7 +9,7 @@ use poise::CreateReply;
 pub async fn pause(ctx: Context<'_>) -> Result<(), Error> {
     let guild_id = ctx.guild_id().unwrap();
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird client placed at init")
         .clone();

src/commands/music/play.rs

@@ -1,23 +1,24 @@
 use crate::commands::music::metadata::Metadata;
+use crate::commands::music::notifier::TrackErrorNotifier;
 use crate::{commands::embeds::error_embed, Context, Error};
 
-use fancy_regex::Regex;
 use lib_spotify_parser;
 use poise::serenity_prelude::{
     Color, CreateEmbed, CreateEmbedAuthor, CreateEmbedFooter, Timestamp,
 };
 use poise::CreateReply;
 use regex::Regex as Regex_Classic;
+use reqwest::Client;
+use serenity::all::GuildId;
 use songbird::events::TrackEvent;
 use songbird::input::AuxMetadata;
 use songbird::input::{Compose, YoutubeDl};
-use songbird::tracks::{TrackHandle, TrackQueue};
+use songbird::tracks::TrackQueue;
+use songbird::Call;
+use std::collections::VecDeque;
 use std::process::Command;
 use std::time::Duration;
 
-use crate::commands::music::notifier::TrackErrorNotifier;
-use crate::http::HttpKey;
-
 /// Plays a song; \
 /// you can search by query or paste an url; \
 /// aliases: play, p, enqueue
@@ -31,25 +32,15 @@ pub async fn play(
     ctx: Context<'_>,
     #[description = "Provide a query or an url"]
     #[rest]
-    mut song: String,
+    song: String,
 ) -> Result<(), Error> {
-    let regex_spotify = Regex::new(r"https?:\/\/(?:embed\.|open\.)(?:spotify\.com\/)(?:track\/|\?uri=spotify:track:)((\w|-)+)(?:(?=\?)(?:[?&]foo=(\d*)(?=[&#]|$)|(?![?&]foo=)[^#])+)?(?=#|$)").unwrap();
-    let regex_youtube =
-        Regex_Classic::new(r#""url": "(https://www.youtube.com/watch\?v=[A-Za-z0-9]{11})""#)
-            .unwrap();
-    let regex_youtube_playlist = Regex::new(
-        r"^((?:https?:)\/\/)?((?:www|m)\.)?((?:youtube\.com)).*(youtu.be\/|list=)([^#&?]*).*",
-    )
-    .unwrap();
-    let regex_spotify_playlist = Regex::new(r"https?:\/\/(?:embed\.|open\.)(?:spotify\.com\/)(?:(album|playlist)\/|\?uri=spotify:playlist:)((\w|-)+)(?:(?=\?)(?:[?&]foo=(\d*)(?=[&#]|$)|(?![?&]foo=)[^#])+)?(?=#|$)").unwrap();
-
-    let is_playlist = regex_youtube_playlist.is_match(&song).unwrap()
-        || regex_spotify_playlist.is_match(&song).unwrap();
-    let is_spotify =
-        regex_spotify.is_match(&song).unwrap() || regex_spotify_playlist.is_match(&song).unwrap();
-    let is_query = !song.starts_with("http");
-
     let guild_id = ctx.guild_id().unwrap();
+    let http_client = ctx.data().http_client.clone();
+    let manager = songbird::get(ctx.serenity_context()).await.unwrap().clone();
+
+    let mut rest_playlist: VecDeque<String> = VecDeque::new();
+
+    if manager.get(guild_id).is_none() {
         let channel_id = ctx
             .guild()
             .unwrap()
@@ -63,125 +54,131 @@ pub async fn play(
                 let msg = "I am not in a voice channel!";
                 ctx.send(CreateReply::default().embed(error_embed(ctx, msg).await.unwrap()))
                     .await?;
-
                 return Ok(());
             }
         };
 
-    let http_client = {
-        let data = ctx.serenity_context().data.read().await;
-        data.get::<HttpKey>()
-            .cloned()
-            .expect("Guaranteed to exist in the typemap.")
-    };
-
-    let manager = songbird::get(&ctx.serenity_context())
-        .await
-        .expect("Songbird Voice placed at init")
-        .clone();
-
         if let Ok(handler_lock) = manager.join(guild_id, connect_to).await {
             let mut handler = handler_lock.lock().await;
-
             handler.add_global_event(TrackEvent::Error.into(), TrackErrorNotifier);
 
-        if is_playlist && is_spotify {
+            rest_playlist = handle_play(ctx, song, handler, http_client.clone())
-            let tracks: Vec<String> = lib_spotify_parser::retrieve_async_url(&song).await.unwrap();
+                .await
-
+                .unwrap();
-            for (index, url) in tracks.clone().iter().enumerate() {
+        } else {
-                if url.is_empty() {
+            let msg = "Failed to join the voice channel!";
-                    break;
+            ctx.send(CreateReply::default().embed(error_embed(ctx, msg).await.unwrap()))
+                .await?;
         }
-                let src = YoutubeDl::new_ytdl_like(
+    } else {
-                    "yt-dlp",
+        let handler = manager.get(guild_id).unwrap();
-                    http_client.clone(),
+        let mut handler = handler.lock().await;
-                    format!("ytsearch:{}", url.to_string()),
+        handler.add_global_event(TrackEvent::Error.into(), TrackErrorNotifier);
-                );
+        rest_playlist = handle_play(ctx, song, handler, http_client.clone())
+            .await
+            .unwrap();
+    }
+
+    handle_playlist(rest_playlist, manager, guild_id, http_client)
+        .await
+        .unwrap();
+
+    Ok(())
+}
+
+async fn handle_play<'a>(
+    ctx: Context<'a>,
+    song: String,
+    mut handler: tokio::sync::MutexGuard<'a, Call>,
+    http_client: Client,
+) -> Result<VecDeque<String>, Error> {
+    let mut results = parse_data(song).await;
+
+    let src: YoutubeDl =
+        YoutubeDl::new_ytdl_like("yt-dlp", http_client, results.pop_front().unwrap());
+
+    ctx.send(
+        CreateReply::default().embed(
+            generate_embed(ctx, src.clone(), handler.queue(), results.clone())
+                .await
+                .unwrap(),
+        ),
+    )
+    .await?;
+
     let aux_metadata = src.clone().aux_metadata().await.unwrap();
-                let track = handler.enqueue_input(src.clone().into()).await;
+
-                let _ = track
+    handler
+        .enqueue_input(src.clone().into())
+        .await
         .typemap()
         .write()
         .await
         .insert::<Metadata>(aux_metadata);
 
-                if index == 0 {
+    Ok(results)
-                    let embed = generate_playlist_embed(ctx, track, tracks.len()).await;
+}
-                    let response = CreateReply::default().embed(embed.unwrap());
-                    ctx.send(response).await?;
-                }
-            }
 
-            return Ok(());
+async fn parse_data(data: String) -> VecDeque<String> {
-        }
+    let tracks = lib_spotify_parser::retrieve_async_url(&data)
+        .await
+        .unwrap_or(vec![data])
+        .iter()
+        .flat_map(|track| {
+            if track.contains("?list=") {
+                let regex_youtube = Regex_Classic::new(
+                    r#""url": "(https://www.youtube.com/watch\?v=[A-Za-z0-9]{11})""#,
+                )
+                .unwrap();
 
-        if is_playlist {
+                let list = Command::new("yt-dlp")
-            let raw_list = Command::new("yt-dlp")
+                    .args(["-j", "--flat-playlist", track])
-                .args(["-j", "--flat-playlist", &song])
                     .output()
-                .expect("failed to execute process")
+                    .expect("Failed to execute process")
                     .stdout;
+                let list = String::from_utf8(list).unwrap();
 
-            let list = String::from_utf8(raw_list.clone()).expect("Invalid UTF-8");
+                regex_youtube
-
-            let urls: Vec<String> = regex_youtube
                     .captures_iter(&list)
-                .map(|capture| capture[1].to_string())
+                    .map(|capture| capture.get(1).unwrap().as_str().to_string())
+                    .collect::<Vec<String>>()
+            } else if track.starts_with("http") {
+                vec![track.clone()]
+            } else {
+                vec![format!("ytsearch:{}", track)]
+            }
+        })
         .collect();
 
-            for (index, url) in urls.clone().iter().enumerate() {
+    tracks
-                if url.is_empty() {
+}
-                    break;
+
-                }
+async fn handle_playlist(
-                let src = YoutubeDl::new_ytdl_like("yt-dlp", http_client.clone(), url.to_string());
+    playlist: VecDeque<String>,
+    manager: std::sync::Arc<songbird::Songbird>,
+    guild_id: GuildId,
+    http_client: Client,
+) -> Result<(), Error> {
+    for song in playlist {
+        if manager.get(guild_id).is_some() {
+            let handler = manager.get(guild_id).unwrap();
+            let mut handler = handler.lock().await;
+
+            let src: YoutubeDl =
+                YoutubeDl::new_ytdl_like("yt-dlp", http_client.clone(), song.clone());
+
             let aux_metadata = src.clone().aux_metadata().await.unwrap();
-                let track = handler.enqueue_input(src.clone().into()).await;
+
-                let _ = track
+            handler
+                .enqueue_input(src.clone().into())
+                .await
                 .typemap()
                 .write()
                 .await
                 .insert::<Metadata>(aux_metadata);
-
-                if index == 0 {
-                    let embed = generate_playlist_embed(ctx, track, urls.len()).await;
-                    let response = CreateReply::default().embed(embed.unwrap());
-                    ctx.send(response).await?;
         }
     }
 
-            return Ok(());
-        }
-
-        if is_spotify {
-            song = format!(
-                "ytsearch:{}",
-                lib_spotify_parser::retrieve_async_url(&song)
-                    .await
-                    .unwrap()
-                    .first()
-                    .unwrap()
-            );
-        }
-
-        if is_query {
-            song = format!("ytsearch:{}", song);
-        }
-
-        let src = YoutubeDl::new_ytdl_like("yt-dlp", http_client, song);
-        let embed = generate_embed(ctx, src.clone(), handler.queue()).await;
-        let response = CreateReply::default().embed(embed.unwrap());
-        ctx.send(response).await?;
-
-        let aux_metadata = src.clone().aux_metadata().await.unwrap();
-
-        let track = handler.enqueue_input(src.clone().into()).await;
-        let _ = track
-            .typemap()
-            .write()
-            .await
-            .insert::<Metadata>(aux_metadata);
-    }
-
     Ok(())
 }
 
@@ -189,6 +186,7 @@ async fn generate_embed(
     ctx: Context<'_>,
     src: YoutubeDl,
     queue: &TrackQueue,
+    results: VecDeque<String>,
 ) -> Result<CreateEmbed, Error> {
     let metadata = src.clone().aux_metadata().await.unwrap();
     let AuxMetadata {
@@ -199,17 +197,21 @@ async fn generate_embed(
         duration,
         ..
     } = metadata;
-    let timestamp = Timestamp::now();
     let duration_minutes = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() / 60;
     let duration_seconds = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() % 60;
-    let mut description = format!("Song added to queue @ {}", queue.len() + 1);
+    let mut description = format!("Enqueued @ {}", queue.len() + 1);
+    let mut tracks = "Tracks enqueued";
 
-    if queue.len() == 0 {
+    if results.len() == 1 {
-        description = format!("Playing now!");
+        tracks = "Track enqueued";
+    }
+
+    if queue.is_empty() {
+        description = "Playing now!".to_string();
     }
 
     let embed = CreateEmbed::default()
-        .author(CreateEmbedAuthor::new("Track enqueued").icon_url(ctx.author().clone().face()))
+        .author(CreateEmbedAuthor::new(tracks).icon_url(ctx.author().clone().face()))
         .colour(Color::from_rgb(255, 58, 97))
         .title(title.unwrap())
         .url(source_url.unwrap())
@@ -226,59 +228,7 @@ async fn generate_embed(
         )
         .field("DJ", ctx.author().name.clone(), true)
         .description(description)
-        .timestamp(timestamp)
+        .timestamp(Timestamp::now())
-        .footer(
-            CreateEmbedFooter::new(ctx.cache().current_user().name.to_string())
-                .icon_url(ctx.cache().current_user().face()),
-        );
-
-    Ok(embed)
-}
-
-async fn generate_playlist_embed(
-    ctx: Context<'_>,
-    track: TrackHandle,
-    queue_length: usize,
-) -> Result<CreateEmbed, Error> {
-    let meta_typemap = track.typemap().read().await;
-    let metadata = meta_typemap.get::<Metadata>().unwrap();
-    let AuxMetadata {
-        title,
-        thumbnail,
-        source_url,
-        artist,
-        duration,
-        ..
-    } = metadata;
-    let timestamp = Timestamp::now();
-    let duration_minutes = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() / 60;
-    let duration_seconds = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() % 60;
-
-    let description = format!("Enqueued tracks: {}", queue_length - 1);
-
-    let embed = CreateEmbed::default()
-        .author(CreateEmbedAuthor::new("Playlist enqueued").icon_url(ctx.author().clone().face()))
-        .colour(Color::from_rgb(255, 58, 97))
-        .title(title.as_ref().unwrap())
-        .url(source_url.as_ref().unwrap())
-        .thumbnail(
-            thumbnail
-                .as_ref()
-                .unwrap_or(&ctx.cache().current_user().face()),
-        )
-        .field(
-            "Artist",
-            artist.as_ref().unwrap_or(&"Unknown Artist".to_string()),
-            true,
-        )
-        .field(
-            "Duration",
-            format!("{:02}:{:02}", duration_minutes, duration_seconds),
-            true,
-        )
-        .field("DJ", ctx.author().name.clone(), true)
-        .description(description)
-        .timestamp(timestamp)
         .footer(
             CreateEmbedFooter::new(ctx.cache().current_user().name.to_string())
                 .icon_url(ctx.cache().current_user().face()),

src/commands/music/queue.rs

@@ -16,7 +16,7 @@ const QUEUE_DISPLAY_LENGTH: usize = 10;
 pub async fn queue(ctx: Context<'_>) -> Result<(), Error> {
     let guild_id = ctx.guild_id().unwrap();
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird client placed at init")
         .clone();

src/commands/music/repeat.rs

@@ -21,7 +21,7 @@ pub async fn repeat(
 ) -> Result<(), Error> {
     let guild_id = ctx.guild_id().unwrap();
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird client placed at init")
         .clone();

src/commands/music/resume.rs

@@ -9,7 +9,7 @@ use poise::CreateReply;
 pub async fn resume(ctx: Context<'_>) -> Result<(), Error> {
     let guild_id = ctx.guild_id().unwrap();
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird client placed at init")
         .clone();

src/commands/music/seek.rs

@@ -14,7 +14,7 @@ pub async fn seek(
 ) -> Result<(), Error> {
     let guild_id = ctx.guild_id().unwrap();
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird client placed at init")
         .clone();

src/commands/music/skip.rs

@@ -17,7 +17,7 @@ use songbird::{input::AuxMetadata, tracks::TrackHandle};
 pub async fn skip(ctx: Context<'_>) -> Result<(), Error> {
     let guild_id = ctx.guild_id().unwrap();
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird client placed at init")
         .clone();
@@ -30,23 +30,18 @@ pub async fn skip(ctx: Context<'_>) -> Result<(), Error> {
         let track = track_raw.get(1);
         let queue_length = queue.len() - 1;
 
-        let response;
+        let mut response = CreateReply::default().embed(
+            embed(ctx, "Skipped!", "The queue is empty!", "")
+                .await
+                .unwrap(),
+        );
 
-        match track {
+        if let Some(track) = track {
-            Some(track) => {
             response = CreateReply::default().embed(
                 generate_embed(ctx, track.clone(), queue_length)
                     .await
                     .unwrap(),
             );
-            }
-            None => {
-                response = CreateReply::default().embed(
-                    embed(ctx, "Skipped!", "The queue is empty!", "")
-                        .await
-                        .unwrap(),
-                );
-            }
         };
 
         ctx.send(response).await?;

src/commands/music/soundboard/effect.rs

@@ -34,7 +34,7 @@ pub async fn effect(
             .expect("Guaranteed to exist in the typemap.")
     };
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird Voice placed at init")
         .clone();
@@ -85,7 +85,7 @@ async fn generate_embed(ctx: Context<'_>, src: YoutubeDl) -> Result<CreateEmbed,
     let duration_minutes = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() / 60;
     let duration_seconds = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() % 60;
 
-    let description = format!("Playing now!");
+    let description = "Playing now!";
 
     let embed = CreateEmbed::default()
         .author(CreateEmbedAuthor::new("Playing an effect!").icon_url(ctx.author().clone().face()))

src/commands/music/soundboard/stream.rs

@@ -41,7 +41,7 @@ pub async fn stream(
             .expect("Guaranteed to exist in the typemap.")
     };
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird Voice placed at init")
         .clone();
@@ -92,7 +92,7 @@ async fn generate_embed(ctx: Context<'_>, src: YoutubeDl) -> Result<CreateEmbed,
     let duration_minutes = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() / 60;
     let duration_seconds = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() % 60;
 
-    let description = format!("Playing now!");
+    let description = "Playing now!";
 
     let embed = CreateEmbed::default()
         .author(

src/commands/music/stop.rs

@@ -10,7 +10,7 @@ use poise::CreateReply;
 pub async fn stop(ctx: Context<'_>) -> Result<(), Error> {
     let guild_id = ctx.guild_id().unwrap();
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird client placed at init")
         .clone();

src/commands/music/volume.rs

@@ -9,7 +9,7 @@ use poise::CreateReply;
 pub async fn volume(ctx: Context<'_>, #[description = "Volume"] volume: f32) -> Result<(), Error> {
     let guild_id = ctx.guild_id().unwrap();
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird client placed at init")
         .clone();

src/commands/tools/ai.rs

@@ -15,7 +15,7 @@ pub async fn ai(
     #[rest]
     prompt: String,
 ) -> Result<(), Error> {
-    let iamsorry = vec![
+    let iamsorry = &[
         "I'm sorry, but as an AI language model, I must follow ethical guidelines, and I cannot engage in harmful, malicious, or offensive behavior.",
         "I'm sorry, but as an AI language model, I may not always be perfect and can make mistakes or provide inaccurate information. Please verify important details from reliable sources.",
         "I'm sorry, but as an AI language model, I can't engage in real-time conversations or remember previous interactions with users.",
@@ -27,19 +27,17 @@ pub async fn ai(
 
     println!("Funny prompts: {}", prompt);
 
-    let response;
+    let response = {
-
-    let _ = {
         let mut rng = rand::thread_rng();
 
-        response = rng.gen_range(0..iamsorry.len());
+        rng.gen_range(0..iamsorry.len())
     };
 
     sleep(Duration::from_secs(1));
 
     ctx.send(
         CreateReply::default().embed(
-            embed(ctx, "AI Response:", "", &format!("{}", iamsorry[response]))
+            embed(ctx, "AI Response:", "", iamsorry[response])
                 .await
                 .unwrap(),
         ),

src/commands/tools/dice.rs

@@ -7,12 +7,9 @@ use crate::{commands::embeds::embed, Context, Error};
 /// Rolls a dice
 #[poise::command(prefix_command, slash_command, category = "Tools")]
 pub async fn dice(ctx: Context<'_>) -> Result<(), Error> {
-    let dice;
+    let dice = {
-
-    let _ = {
         let mut rng = rand::thread_rng();
-
+        rng.gen_range(1..=6)
-        dice = rng.gen_range(1..7);
     };
 
     ctx.send(

src/main.rs

@@ -9,7 +9,6 @@ use tracing::{error, info, warn};
 mod commands;
 mod http;
 
-use crate::commands::kashi;
 use crate::commands::music;
 use crate::commands::tools;
 use crate::http::HttpKey;
@@ -17,7 +16,9 @@ use crate::http::HttpKey;
 type Error = Box<dyn std::error::Error + Send + Sync>;
 type Context<'a> = poise::Context<'a, Data, Error>;
 
-pub struct Data;
+pub struct Data {
+    pub http_client: HttpClient,
+}
 
 async fn on_error(error: poise::FrameworkError<'_, Data, Error>) {
     match error {
@@ -45,7 +46,6 @@ async fn main() {
     let prefix = std::env::var("PREFIX").expect("Environment variable `PREFIX` not found!");
 
     let commands = vec![
-        kashi::kashi(),
         music::deafen(),
         music::join(),
         music::leave(),
@@ -141,7 +141,9 @@ async fn main() {
                 )
                 .await?;
 
-                Ok(Data {})
+                Ok(Data {
+                    http_client: HttpClient::new(),
+                })
             })
         })
         .options(options)