disable arm target

Reviewed-on: #6

.gitea/workflows/ci.yml

@@ -2,7 +2,9 @@ name: tests
 
 on:
   push:
-  pull_request:
+
+paths-ignore:
+- 'README.md'
 
 env:
   CARGO_TERM_COLOR: always
@@ -36,6 +38,11 @@ jobs:
     - uses: actions/checkout@v4
     - run: sudo apt-get update
     - run: sudo apt-get install -y cmake
+    - uses: actions/setup-python@v5
+      with:
+        python-version: '3.12'
+    - name: Install yt-dlp
+      run: pip install yt-dlp
     - uses: actions-rust-lang/setup-rust-toolchain@v1
     - name: Run tests
       run: cargo test --verbose --all-features

.gitea/workflows/deploy.yaml

@@ -26,6 +26,6 @@ jobs:
         with:
           platforms: |
             linux/amd64
-            linux/arm64
+            # linux/arm64
           push: true
           tags: jheuel/ohrwurm:latest

.github/workflows/ci.yml

@@ -37,6 +37,11 @@ jobs:
     - uses: actions/checkout@v4
     - run: sudo apt-get update
     - run: sudo apt-get install -y cmake
+    - uses: actions/setup-python@v5
+      with:
+        python-version: '3.12'
+    - name: Install yt-dlp
+      run: pip install yt-dlp
     - uses: actions-rust-lang/setup-rust-toolchain@v1
     - name: Run tests
       run: cargo test --verbose --all-features

Cargo.toml

@@ -21,5 +21,10 @@ twilight-standby = "0.15"
 twilight-cache-inmemory = "0.15"
 twilight-util = { version = "0.15", features=["builder"] }
 dotenv = "0.15.0"
+serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 url = "2.5.0"
+anyhow = "1.0.86"
+dashmap = "5.5.3"
+async-trait = "0.1.80"
+uuid = "1.8.0"

src/colors.rs

@@ -0,0 +1,20 @@
+#[allow(dead_code)]
+pub(crate) const BLURPLE: u32 = 0x58_65_F2;
+#[allow(dead_code)]
+pub(crate) const YELLOW: u32 = 0xFE_E7_5C;
+#[allow(dead_code)]
+pub(crate) const WHITE: u32 = 0xFF_FF_FF;
+#[allow(dead_code)]
+pub(crate) const GREYPLE: u32 = 0x99_AA_B5;
+#[allow(dead_code)]
+pub(crate) const BLACK: u32 = 0x23_27_2A;
+#[allow(dead_code)]
+pub(crate) const DARK_BUT_NOT_BLACK: u32 = 0x2C_2F_33;
+#[allow(dead_code)]
+pub(crate) const NOT_QUITE_BLACK: u32 = 0x23_27_2A;
+#[allow(dead_code)]
+pub(crate) const GREEN: u32 = 0x57_F2_87;
+#[allow(dead_code)]
+pub(crate) const FUCHSIA: u32 = 0xEB_45_9E;
+#[allow(dead_code)]
+pub(crate) const RED: u32 = 0xED_42_45;

src/commands/delete.rs

@@ -9,14 +9,14 @@ pub(crate) async fn delete(
     state: State,
 ) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     let admin = env::var("ADMIN")?.parse::<u64>()?;
-    if msg.author.id != Id::from(NonZeroU64::new(admin).unwrap()) {
+    if msg.author.id != Id::from(NonZeroU64::new(admin).expect("Could not get author id")) {
         return Ok(());
     }
     let n = msg
         .content
         .split(' ')
         .last()
-        .unwrap()
+        .unwrap_or("1")
         .parse::<u16>()
         .unwrap_or(1);
     if n > 100 {

src/commands/join.rs

@@ -2,8 +2,8 @@ use crate::state::State;
 use std::error::Error;
 use tracing::debug;
 use twilight_model::{
-    application::interaction::Interaction,
     channel::message::MessageFlags,
+    gateway::payload::incoming::InteractionCreate,
     http::interaction::{InteractionResponse, InteractionResponseType},
     id::{
         marker::{GuildMarker, UserMarker},
@@ -42,7 +42,7 @@ pub(crate) async fn join_channel(
 }
 
 pub(crate) async fn join(
-    interaction: Interaction,
+    interaction: Box<InteractionCreate>,
     state: State,
 ) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     debug!(

src/commands/leave.rs

@@ -1,9 +1,9 @@
 use crate::state::State;
 use std::error::Error;
-use twilight_model::application::interaction::Interaction;
+use twilight_model::gateway::payload::incoming::InteractionCreate;
 
 pub(crate) async fn leave(
-    interaction: Interaction,
+    interaction: Box<InteractionCreate>,
     state: State,
 ) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     tracing::debug!(

src/commands/loop_queue.rs

@@ -0,0 +1,129 @@
+use crate::metadata::MetadataMap;
+use crate::state::{Settings, State, StateRef};
+use async_trait::async_trait;
+use songbird::{Event, EventContext, EventHandler, TrackEvent};
+use std::ops::Sub;
+use std::time::Duration;
+use std::{error::Error, sync::Arc};
+use twilight_model::{
+    gateway::payload::incoming::InteractionCreate,
+    http::interaction::{InteractionResponse, InteractionResponseType},
+    id::{marker::GuildMarker, Id},
+};
+use twilight_util::builder::InteractionResponseDataBuilder;
+
+pub(crate) async fn loop_queue(
+    interaction: Box<InteractionCreate>,
+    state: State,
+) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
+    tracing::debug!(
+        "loop command in guild {:?} in channel {:?} by {:?}",
+        interaction.guild_id,
+        interaction.channel,
+        interaction.author(),
+    );
+
+    let guild_id: Id<GuildMarker> = if let Some(guild_id) = interaction.guild_id {
+        guild_id
+    } else {
+        return Ok(());
+    };
+
+    state
+        .guild_settings
+        .entry(guild_id)
+        .or_insert_with(|| Settings { loop_queue: false });
+
+    state.guild_settings.entry(guild_id).and_modify(|settings| {
+        settings.loop_queue = !settings.loop_queue;
+        println!("loop_queue: {}", settings.loop_queue);
+    });
+
+    let looping = state
+        .guild_settings
+        .get(&guild_id)
+        .expect("Cannot get loop state")
+        .loop_queue;
+
+    if let Some(call_lock) = state.songbird.get(guild_id) {
+        let mut call = call_lock.lock().await;
+        call.add_global_event(
+            Event::Track(TrackEvent::End),
+            TrackEndNotifier {
+                guild_id,
+                state: Arc::clone(&state),
+            },
+        );
+    }
+
+    let message = if looping {
+        "I'm now looping the current queue!".to_string()
+    } else {
+        "I'm not looping anymore!".to_string()
+    };
+
+    let interaction_response_data = InteractionResponseDataBuilder::new()
+        .content(message)
+        .build();
+
+    let response = InteractionResponse {
+        kind: InteractionResponseType::ChannelMessageWithSource,
+        data: Some(interaction_response_data),
+    };
+
+    state
+        .http
+        .interaction(interaction.application_id)
+        .create_response(interaction.id, &interaction.token, &response)
+        .await?;
+
+    Ok(())
+}
+
+struct TrackEndNotifier {
+    guild_id: Id<GuildMarker>,
+    state: Arc<StateRef>,
+}
+
+#[async_trait]
+impl EventHandler for TrackEndNotifier {
+    async fn act(&self, ctx: &EventContext<'_>) -> Option<Event> {
+        if !self
+            .state
+            .guild_settings
+            .get(&self.guild_id)
+            .unwrap()
+            .loop_queue
+        {
+            return None;
+        }
+        let EventContext::Track(track_list) = ctx else {
+            return None;
+        };
+        let (_, track_handle) = track_list.first()?;
+        if let Some(call_lock) = self.state.songbird.get(self.guild_id) {
+            let mut call = call_lock.lock().await;
+
+            // get metadata from finished track
+            let old_typemap_lock = track_handle.typemap().read().await;
+            let old_metadata = old_typemap_lock.get::<MetadataMap>().unwrap();
+
+            // enqueue track
+            let handle = call.enqueue_with_preload(
+                old_metadata.src.clone().into(),
+                old_metadata.duration.map(|duration| -> Duration {
+                    if duration.as_secs() > 5 {
+                        duration.sub(Duration::from_secs(5))
+                    } else {
+                        duration
+                    }
+                }),
+            );
+
+            // insert metadata into new track
+            let mut new_typemap = handle.typemap().write().await;
+            new_typemap.insert::<MetadataMap>(old_metadata.clone());
+        }
+        None
+    }
+}

src/commands/mod.rs

@@ -7,10 +7,16 @@ pub(crate) use leave::leave;
 mod pause;
 pub(crate) use pause::pause;
 
+mod skip;
+pub(crate) use skip::skip;
+
+mod loop_queue;
+pub(crate) use loop_queue::loop_queue;
+
 mod play;
 pub(crate) use play::play;
 
-mod queue;
+pub(crate) mod queue;
 pub(crate) use queue::queue;
 
 mod resume;
@@ -29,12 +35,14 @@ pub(crate) fn get_chat_commands() -> Vec<twilight_model::application::command::C
     vec![
         CommandBuilder::new("join", "Join the channel", CommandType::ChatInput).build(),
         CommandBuilder::new("leave", "Leave the channel", CommandType::ChatInput).build(),
+        CommandBuilder::new("loop", "Loop queue", CommandType::ChatInput).build(),
+        CommandBuilder::new("skip", "Skip track", CommandType::ChatInput).build(),
+        CommandBuilder::new("queue", "Print track queue", CommandType::ChatInput).build(),
+        CommandBuilder::new("stop", "Stop playing", CommandType::ChatInput).build(),
         CommandBuilder::new("pause", "Pause playing", CommandType::ChatInput).build(),
+        CommandBuilder::new("resume", "Resume playing", CommandType::ChatInput).build(),
         CommandBuilder::new("play", "Add a song to the queue", CommandType::ChatInput)
             .option(StringBuilder::new("query", "URL of a song").required(true))
             .build(),
-        CommandBuilder::new("queue", "Print track queue", CommandType::ChatInput).build(),
-        CommandBuilder::new("resume", "Resume playing", CommandType::ChatInput).build(),
-        CommandBuilder::new("stop", "Stop playing", CommandType::ChatInput).build(),
     ]
 }

src/commands/pause.rs

@@ -1,14 +1,14 @@
 use crate::state::State;
 use std::error::Error;
 use twilight_model::{
-    application::interaction::Interaction,
     channel::message::MessageFlags,
+    gateway::payload::incoming::InteractionCreate,
     http::interaction::{InteractionResponse, InteractionResponseType},
 };
 use twilight_util::builder::InteractionResponseDataBuilder;
 
 pub(crate) async fn pause(
-    interaction: Interaction,
+    interaction: Box<InteractionCreate>,
     state: State,
 ) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     tracing::debug!(

src/commands/play.rs

@@ -1,20 +1,70 @@
+use crate::colors;
 use crate::commands::join::join_channel;
 use crate::metadata::{Metadata, MetadataMap};
 use crate::state::State;
-use serde_json::Value;
+
+use serde::{Deserialize, Serialize};
 use songbird::input::{Compose, YoutubeDl};
+use songbird::tracks::Track;
 use std::io::{BufRead, BufReader};
-use std::{error::Error, ops::Sub, time::Duration};
+use std::ops::Sub;
+use std::{error::Error, time::Duration};
 use tokio::process::Command;
 use tracing::debug;
-use twilight_model::application::interaction::Interaction;
+use twilight_model::channel::message::MessageFlags;
+use twilight_model::gateway::payload::incoming::InteractionCreate;
 use twilight_model::http::interaction::{InteractionResponse, InteractionResponseType};
 use twilight_util::builder::embed::EmbedBuilder;
 use twilight_util::builder::InteractionResponseDataBuilder;
 use url::Url;
 
+#[derive(Debug, Serialize, Deserialize)]
+struct YouTubeTrack {
+    url: Option<String>,
+    original_url: Option<String>,
+    title: String,
+    channel: String,
+    playlist: Option<String>,
+    playlist_id: Option<String>,
+    duration_string: String,
+}
+
+fn build_playlist_url(playlist_id: &str) -> String {
+    format!("https://www.youtube.com/playlist?list={}", playlist_id)
+}
+
+async fn get_tracks(
+    url: String,
+) -> Result<Vec<YouTubeTrack>, Box<dyn Error + Send + Sync + 'static>> {
+    let output = Command::new("yt-dlp")
+        .args(vec![&url, "--flat-playlist", "-j"])
+        .output()
+        .await?;
+
+    let reader = BufReader::new(output.stdout.as_slice());
+    let tracks: Vec<YouTubeTrack> = reader
+        .lines()
+        .map_while(Result::ok)
+        .flat_map(|line| serde_json::from_str(&line))
+        .collect();
+
+    if tracks.is_empty() {
+        if let Ok(stderr) = String::from_utf8(output.stderr) {
+            if stderr.contains("This video is only available to Music Premium members") {
+                return Err("This video is only available to Music Premium members".into());
+            }
+            if stderr.contains("YouTube said: The playlist does not exist.") {
+                return Err("YouTube said: The playlist does not exist.".into());
+            }
+        }
+        return Err("No tracks found".into());
+    }
+    tracing::debug!("tracks: {:?}", tracks);
+    Ok(tracks)
+}
+
 pub(crate) async fn play(
-    interaction: Interaction,
+    interaction: Box<InteractionCreate>,
     state: State,
     query: String,
 ) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
@@ -25,14 +75,16 @@ pub(crate) async fn play(
     );
 
     let content = format!("Adding track(s) to the queue: {}", query);
-    let yellow = 0xFE_E7_5C;
     let embeds = vec![EmbedBuilder::new()
         .description(content)
-        .color(yellow)
+        .color(colors::YELLOW)
         .build()];
-    let interaction_response_data = InteractionResponseDataBuilder::new().embeds(embeds).build();
+    let interaction_response_data = InteractionResponseDataBuilder::new()
+        .flags(MessageFlags::LOADING)
+        .embeds(embeds)
+        .build();
     let response = InteractionResponse {
-        kind: InteractionResponseType::ChannelMessageWithSource,
+        kind: InteractionResponseType::DeferredChannelMessageWithSource,
         data: Some(interaction_response_data),
     };
     state
@@ -59,7 +111,50 @@ pub(crate) async fn play(
 
     debug!("query: {:?}", query);
 
-    let urls = get_playlist_urls(query).await?;
+    let tracks = match get_tracks(query).await {
+        Err(e) => {
+            let content = format!("{}", e);
+            let embeds = vec![EmbedBuilder::new()
+                .description(content)
+                .color(colors::RED)
+                .build()];
+            state
+                .http
+                .interaction(interaction.application_id)
+                .update_response(&interaction.token)
+                .embeds(Some(&embeds))?
+                .await?;
+            return Ok(());
+        }
+        Ok(tracks) => tracks,
+    };
+
+    if tracks.len() > 1 {
+        let first_track = tracks.first().unwrap();
+        let content = format!(
+            "Adding playlist [{}]({})",
+            first_track
+                .playlist
+                .clone()
+                .unwrap_or("Unknown".to_string()),
+            build_playlist_url(
+                &first_track
+                    .playlist_id
+                    .clone()
+                    .unwrap_or("Unknown".to_string())
+            )
+        );
+        let embeds = vec![EmbedBuilder::new()
+            .description(content)
+            .color(colors::BLURPLE)
+            .build()];
+        state
+            .http
+            .interaction(interaction.application_id)
+            .update_response(&interaction.token)
+            .embeds(Some(&embeds))?
+            .await?;
+    }
 
     if let Some(call_lock) = state.songbird.get(guild_id) {
         let call = call_lock.lock().await;
@@ -67,8 +162,13 @@ pub(crate) async fn play(
     }
 
     let mut tracks_added = vec![];
-    for url in urls {
-        let mut src = YoutubeDl::new(reqwest::Client::new(), url.to_string());
+    for track in &tracks {
+        tracing::debug!("track: {:?}", track);
+        let url = track.url.clone().or(track.original_url.clone()).ok_or("")?;
+        let mut src = YoutubeDl::new(reqwest::Client::new(), url.clone());
+        let src_copy = src.clone();
+        let track: Track = src_copy.into();
+
         if let Ok(metadata) = src.aux_metadata().await {
             debug!("metadata: {:?}", metadata);
             tracks_added.push((url.clone(), metadata.title.clone()));
@@ -76,7 +176,7 @@ pub(crate) async fn play(
             if let Some(call_lock) = state.songbird.get(guild_id) {
                 let mut call = call_lock.lock().await;
                 let handle = call.enqueue_with_preload(
-                    src.into(),
+                    track,
                     metadata.duration.map(|duration| -> Duration {
                         if duration.as_secs() > 5 {
                             duration.sub(Duration::from_secs(5))
@@ -90,6 +190,7 @@ pub(crate) async fn play(
                     title: metadata.title,
                     duration: metadata.duration,
                     url,
+                    src,
                 });
             }
         }
@@ -99,59 +200,96 @@ pub(crate) async fn play(
     match num_tracks_added {
         0 => {}
         1 => {
-            let track = tracks_added.first().unwrap().clone();
-            let title = track.1.unwrap();
-            let url = track.0;
+            let (title, url) = if let Some(track) = tracks_added.first() {
+                let track = track.clone();
+                (track.1.unwrap_or("Unknown".to_string()), track.0)
+            } else {
+                ("Unknown".to_string(), "".to_string())
+            };
             content = format!("Added [{}]({}) to the queue", title, url);
         }
         _ => {
-            content = format!("Added {} tracks to the queue:\n", num_tracks_added);
-            for track in tracks_added.into_iter().take(num_tracks_added.min(3)) {
-                let title = track.1.unwrap();
-                let url = track.0;
-                content.push_str(&format!("  \"[{}]({})\"\n", title, url));
-            }
+            let first_track = tracks.first().unwrap();
+            content.push_str(&format!(
+                "Adding playlist: [{}]({})\n",
+                &first_track
+                    .playlist
+                    .clone()
+                    .unwrap_or("Unknown".to_string()),
+                build_playlist_url(
+                    &first_track
+                        .playlist_id
+                        .clone()
+                        .unwrap_or("Unknown".to_string())
+                )
+            ));
+            content.push_str(&format!(
+                "Added {} tracks to the queue:\n",
+                num_tracks_added
+            ));
         }
     }
 
-    let blurple = 0x58_65_F2;
     let embeds = vec![EmbedBuilder::new()
         .description(content)
-        .color(blurple)
+        .color(colors::BLURPLE)
         .build()];
     state
         .http
         .interaction(interaction.application_id)
         .update_response(&interaction.token)
-        .embeds(Some(&embeds))
-        .unwrap()
+        .embeds(Some(&embeds))?
         .await?;
 
     Ok(())
 }
 
-async fn get_playlist_urls(
-    url: String,
-) -> Result<Vec<String>, Box<dyn Error + Send + Sync + 'static>> {
-    let output = Command::new("yt-dlp")
-        .args(vec![&url, "--flat-playlist", "-j"])
-        .output()
-        .await?;
+#[cfg(test)]
+mod tests {
+    use super::*;
 
-    let reader = BufReader::new(output.stdout.as_slice());
-    let urls = reader
-        .lines()
-        .map_while(Result::ok)
-        .map(|line| {
-            let entry: Value = serde_json::from_str(&line).unwrap();
-            entry
-                .get("webpage_url")
-                .unwrap()
-                .as_str()
+    #[tokio::test]
+    async fn test_get_tracks() {
+        let urls = [
+            "https://www.youtube.com/playlist?list=PLFxxhcEeloYa1OlnWD6UgxlVQKJH5i_0p",
+            "https://music.youtube.com/watch?v=RO75ZzqUOJw",
+            "https://www.youtube.com/watch?v=qVHyl0P_P-M",
+            "https://www.youtube.com/watch?v=34CZjsEI1yU",
+        ];
+        for url in urls.iter() {
+            println!("url: {:?}", url);
+            let tracks = get_tracks(url.to_string()).await.unwrap();
+            assert!(!tracks.is_empty());
+        }
+    }
+
+    #[tokio::test]
+    async fn test_premium_tracks() {
+        let urls = ["https://www.youtube.com/watch?v=QgMZRmxQ0Dc"];
+        for url in urls.iter() {
+            println!("url: {:?}", url);
+            let tracks = get_tracks(url.to_string()).await;
+            assert!(tracks.is_err());
+            assert!(tracks
+                .err()
                 .unwrap()
                 .to_string()
-        })
-        .collect();
+                .contains("This video is only available to Music Premium members"));
+        }
+    }
 
-    Ok(urls)
+    #[tokio::test]
+    async fn test_playlist_does_not_exist_tracks() {
+        let urls = ["https://www.youtube.com/playlist?list=PLox0oG0uy8Lc1IaIfGyrvtuRItuEyJiyG"];
+        for url in urls.iter() {
+            println!("url: {:?}", url);
+            let tracks = get_tracks(url.to_string()).await;
+            assert!(tracks.is_err());
+            assert!(tracks
+                .err()
+                .unwrap()
+                .to_string()
+                .contains("YouTube said: The playlist does not exist."));
+        }
+    }
 }

src/commands/queue.rs

@@ -1,16 +1,106 @@
+use songbird::tracks::TrackHandle;
+use twilight_model::channel::message::component::{ActionRow, Button, ButtonStyle};
+use twilight_model::channel::message::{Component, Embed, MessageFlags, ReactionType};
+use twilight_model::gateway::payload::incoming::InteractionCreate;
+use twilight_model::http::interaction::InteractionResponse;
 use twilight_model::http::interaction::InteractionResponseType;
-use twilight_model::{
-    application::interaction::Interaction, channel::message::MessageFlags,
-    http::interaction::InteractionResponse,
-};
 use twilight_util::builder::embed::EmbedBuilder;
 use twilight_util::builder::InteractionResponseDataBuilder;
 
+use crate::colors;
 use crate::{metadata::MetadataMap, state::State};
 use std::error::Error;
 
+pub(crate) const TRACKS_PER_PAGE: usize = 5;
+
+fn format_duration(duration: std::time::Duration) -> String {
+    let res = duration.as_secs();
+    let hours = res / (60 * 60);
+    let res = res - hours * 60 * 60;
+    let minutes = res / 60;
+    let res = res - minutes * 60;
+    let seconds = res;
+    let mut s = String::new();
+    if hours > 0 {
+        s.push_str(format!("{:02}:", hours).as_str());
+    }
+    s.push_str(format!("{:02}:{:02}", minutes, seconds).as_str());
+    s
+}
+
+pub(crate) async fn build_queue_embeds(queue: &[TrackHandle], page: usize) -> Vec<Embed> {
+    let mut message = String::new();
+    if queue.is_empty() {
+        message.push_str("There are no tracks in the queue.\n");
+    }
+    for track in queue
+        .iter()
+        .skip(TRACKS_PER_PAGE * page)
+        .take(TRACKS_PER_PAGE)
+    {
+        let map = track.typemap().read().await;
+        let metadata = map
+            .get::<MetadataMap>()
+            .expect("Could not get metadata map");
+        message.push_str(
+            format!(
+                "* [{}]({})",
+                metadata.title.clone().unwrap_or("Unknown".to_string()),
+                metadata.url,
+            )
+            .as_str(),
+        );
+        if let Some(duration) = metadata.duration {
+            message.push_str(" (");
+            message.push_str(&format_duration(duration));
+            message.push(')');
+        }
+        message.push('\n');
+    }
+    message.push('\n');
+
+    let max_pages = queue.len() / TRACKS_PER_PAGE;
+    if max_pages > 0 {
+        message.push_str(&format!("page {}/{}", 1 + page, 1 + max_pages));
+    }
+    vec![EmbedBuilder::new()
+        .description(&message)
+        .color(colors::BLURPLE)
+        .build()]
+}
+
+pub(crate) fn build_action_row(page: usize, max_pages: usize) -> Vec<Component> {
+    if max_pages == 0 {
+        return Vec::new();
+    }
+    vec![Component::ActionRow(ActionRow {
+        components: vec![
+            Component::Button(Button {
+                custom_id: Some(format!("page:{}", page as i32 - 1)),
+                style: ButtonStyle::Primary,
+                label: Some("Previous page".to_string()),
+                emoji: Some(ReactionType::Unicode {
+                    name: "⬅️".to_string(),
+                }),
+                url: None,
+                disabled: page == 0,
+            }),
+            Component::Button(Button {
+                custom_id: Some(format!("page:{}", page + 1)),
+                style: ButtonStyle::Primary,
+                label: Some("Next page".to_string()),
+                emoji: Some(ReactionType::Unicode {
+                    name: "➡️".to_string(),
+                }),
+                url: None,
+                disabled: page >= max_pages,
+            }),
+        ],
+    })]
+}
+
 pub(crate) async fn queue(
-    interaction: Interaction,
+    interaction: Box<InteractionCreate>,
     state: State,
 ) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     tracing::debug!(
@@ -22,59 +112,42 @@ pub(crate) async fn queue(
     let Some(guild_id) = interaction.guild_id else {
         return Ok(());
     };
+
+    let content = "Fetching queue".to_string();
+    let embeds = vec![EmbedBuilder::new()
+        .description(content)
+        .color(colors::YELLOW)
+        .build()];
+    let interaction_response_data = InteractionResponseDataBuilder::new()
+        .embeds(embeds)
+        .flags(MessageFlags::LOADING)
+        .build();
+    let response = InteractionResponse {
+        kind: InteractionResponseType::DeferredChannelMessageWithSource,
+        data: Some(interaction_response_data),
+    };
+    state
+        .http
+        .interaction(interaction.application_id)
+        .create_response(interaction.id, &interaction.token, &response)
+        .await?;
+
+    let mut queue = Vec::new();
     if let Some(call_lock) = state.songbird.get(guild_id) {
         let call = call_lock.lock().await;
-        let queue = call.queue().current_queue();
-        let mut message = String::new();
-        if queue.is_empty() {
-            message.push_str("There are no tracks in the queue.\n");
-        } else {
-            message.push_str("Next songs are:\n");
-        }
-        for track in queue.iter().take(5) {
-            let map = track.typemap().read().await;
-            let metadata = map.get::<MetadataMap>().unwrap();
-            message.push_str(
-                format!(
-                    "* [{}]({})",
-                    metadata.title.clone().unwrap_or("Unknown".to_string()),
-                    metadata.url,
-                )
-                .as_str(),
-            );
-            if let Some(duration) = metadata.duration {
-                let res = duration.as_secs();
-                let hours = res / (60 * 60);
-                let res = res - hours * 60 * 60;
-                let minutes = res / 60;
-                let res = res - minutes * 60;
-                let seconds = res;
-                message.push_str(" (");
-                if hours > 0 {
-                    message.push_str(format!("{:02}:", hours).as_str());
-                }
-                message.push_str(format!("{:02}:{:02}", minutes, seconds).as_str());
-                message.push(')');
-            }
-            message.push('\n');
-        }
-
-        let embeds = vec![EmbedBuilder::new().description(&message).build()];
-        let interaction_response_data = InteractionResponseDataBuilder::new()
-            .flags(MessageFlags::EPHEMERAL)
-            .embeds(embeds)
-            .build();
-
-        let response = InteractionResponse {
-            kind: InteractionResponseType::ChannelMessageWithSource,
-            data: Some(interaction_response_data),
-        };
-
-        state
-            .http
-            .interaction(interaction.application_id)
-            .create_response(interaction.id, &interaction.token, &response)
-            .await?;
+        queue = call.queue().current_queue();
     }
+
+    let embeds = build_queue_embeds(&queue, 0).await;
+    let action_row = build_action_row(0, queue.len() / TRACKS_PER_PAGE);
+
+    state
+        .http
+        .interaction(interaction.application_id)
+        .update_response(&interaction.token)
+        .embeds(Some(&embeds))?
+        .components(Some(&action_row))?
+        .await?;
+
     Ok(())
 }

src/commands/resume.rs

@@ -1,14 +1,14 @@
 use crate::state::State;
 use std::error::Error;
 use twilight_model::{
-    application::interaction::Interaction,
     channel::message::MessageFlags,
+    gateway::payload::incoming::InteractionCreate,
     http::interaction::{InteractionResponse, InteractionResponseType},
 };
 use twilight_util::builder::InteractionResponseDataBuilder;
 
 pub(crate) async fn resume(
-    interaction: Interaction,
+    interaction: Box<InteractionCreate>,
     state: State,
 ) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     tracing::debug!(

src/commands/skip.rs

@@ -0,0 +1,45 @@
+use crate::state::State;
+use std::error::Error;
+use twilight_model::{
+    gateway::payload::incoming::InteractionCreate,
+    http::interaction::{InteractionResponse, InteractionResponseType},
+};
+use twilight_util::builder::InteractionResponseDataBuilder;
+
+pub(crate) async fn skip(
+    interaction: Box<InteractionCreate>,
+    state: State,
+) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
+    tracing::debug!(
+        "skip command in guild {:?} in channel {:?} by {:?}",
+        interaction.guild_id,
+        interaction.channel,
+        interaction.author(),
+    );
+
+    let Some(guild_id) = interaction.guild_id else {
+        return Ok(());
+    };
+
+    if let Some(call_lock) = state.songbird.get(guild_id) {
+        let call = call_lock.lock().await;
+        call.queue().skip()?;
+    }
+
+    let interaction_response_data = InteractionResponseDataBuilder::new()
+        .content("Skipped a track")
+        .build();
+
+    let response = InteractionResponse {
+        kind: InteractionResponseType::ChannelMessageWithSource,
+        data: Some(interaction_response_data),
+    };
+
+    state
+        .http
+        .interaction(interaction.application_id)
+        .create_response(interaction.id, &interaction.token, &response)
+        .await?;
+
+    Ok(())
+}

src/commands/stop.rs

@@ -1,6 +1,6 @@
 use twilight_model::{
-    application::interaction::Interaction,
     channel::message::MessageFlags,
+    gateway::payload::incoming::InteractionCreate,
     http::interaction::{InteractionResponse, InteractionResponseType},
 };
 use twilight_util::builder::InteractionResponseDataBuilder;
@@ -9,7 +9,7 @@ use crate::state::State;
 use std::error::Error;
 
 pub(crate) async fn stop(
-    interaction: Interaction,
+    interaction: Box<InteractionCreate>,
     state: State,
 ) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     tracing::debug!(

src/handler.rs

@@ -1,23 +1,30 @@
-use crate::commands::{delete, join, leave, pause, play, queue, resume, stop};
+use crate::commands::queue::{build_action_row, build_queue_embeds, TRACKS_PER_PAGE};
+use crate::commands::{delete, join, leave, loop_queue, pause, play, queue, resume, skip, stop};
 use crate::state::State;
 use futures::Future;
 use std::error::Error;
 use std::sync::Arc;
 use tracing::debug;
 use twilight_gateway::Event;
-use twilight_model::application::interaction::application_command::CommandOptionValue;
-use twilight_model::application::interaction::{Interaction, InteractionData};
+use twilight_model::application::interaction::application_command::{
+    CommandData, CommandOptionValue,
+};
+use twilight_model::application::interaction::InteractionData;
 use twilight_model::gateway::payload::incoming::VoiceStateUpdate;
+use twilight_model::http::interaction::{InteractionResponse, InteractionResponseType};
+use twilight_util::builder::InteractionResponseDataBuilder;
 
 #[derive(Debug)]
 enum InteractionCommand {
-    Play(Interaction, String),
-    Stop(Interaction),
-    Pause(Interaction),
-    Resume(Interaction),
-    Leave(Interaction),
-    Join(Interaction),
-    Queue(Interaction),
+    Play(String),
+    Stop,
+    Pause,
+    Skip,
+    Loop,
+    Resume,
+    Leave,
+    Join,
+    Queue,
     NotImplemented,
 }
 
@@ -75,80 +82,129 @@ impl Handler {
     pub(crate) fn new(state: State) -> Self {
         Self { state }
     }
-    pub(crate) async fn act(&self, event: Event) {
-        match &event {
+    pub(crate) async fn act(&self, event: Event) -> anyhow::Result<()> {
+        match event {
             Event::MessageCreate(message) if message.content.starts_with('!') => {
                 if message.content.contains("!delete") {
                     spawn(delete(message.0.clone(), Arc::clone(&self.state)));
                 }
+                Ok(())
             }
             Event::VoiceStateUpdate(update) => {
-                spawn(leave_if_alone(*update.clone(), Arc::clone(&self.state)))
+                spawn(leave_if_alone(*update.clone(), Arc::clone(&self.state)));
+                Ok(())
             }
-            _ => {}
-        }
-
-        let interaction_command = match event {
             Event::InteractionCreate(interaction) => {
-                debug!("interaction: {:?}", &interaction);
+                tracing::info!("interaction: {:?}", &interaction);
                 match &interaction.data {
                     Some(InteractionData::ApplicationCommand(command)) => {
-                        debug!("command: {:?}", command);
-                        match command.name.as_str() {
-                            "play" => {
-                                if let Some(query_option) =
-                                    command.options.iter().find(|opt| opt.name == "query")
-                                {
-                                    if let CommandOptionValue::String(query) = &query_option.value {
-                                        InteractionCommand::Play(
-                                            interaction.0.clone(),
-                                            query.clone(),
-                                        )
-                                    } else {
-                                        InteractionCommand::NotImplemented
-                                    }
-                                } else {
-                                    InteractionCommand::NotImplemented
-                                }
+                        let interaction_command = parse_interaction_command(command);
+                        debug!("{:?}", interaction_command);
+                        match interaction_command {
+                            InteractionCommand::Play(query) => {
+                                spawn(play(interaction, Arc::clone(&self.state), query))
                             }
-                            "stop" => InteractionCommand::Stop(interaction.0.clone()),
-                            "pause" => InteractionCommand::Pause(interaction.0.clone()),
-                            "resume" => InteractionCommand::Resume(interaction.0.clone()),
-                            "leave" => InteractionCommand::Leave(interaction.0.clone()),
-                            "join" => InteractionCommand::Join(interaction.0.clone()),
-                            "queue" => InteractionCommand::Queue(interaction.0.clone()),
-                            _ => InteractionCommand::NotImplemented,
+                            InteractionCommand::Stop => {
+                                spawn(stop(interaction, Arc::clone(&self.state)))
+                            }
+                            InteractionCommand::Pause => {
+                                spawn(pause(interaction, Arc::clone(&self.state)))
+                            }
+                            InteractionCommand::Skip => {
+                                spawn(skip(interaction, Arc::clone(&self.state)))
+                            }
+                            InteractionCommand::Loop => {
+                                spawn(loop_queue(interaction, Arc::clone(&self.state)))
+                            }
+                            InteractionCommand::Resume => {
+                                spawn(resume(interaction, Arc::clone(&self.state)))
+                            }
+                            InteractionCommand::Leave => {
+                                spawn(leave(interaction, Arc::clone(&self.state)))
+                            }
+                            InteractionCommand::Join => {
+                                spawn(join(interaction, Arc::clone(&self.state)))
+                            }
+                            InteractionCommand::Queue => {
+                                spawn(queue(interaction, Arc::clone(&self.state)))
+                            }
+                            _ => {}
+                        }
+                        Ok(())
+                    }
+                    Some(InteractionData::MessageComponent(data)) => {
+                        tracing::info!("message component: {:?}", data);
+
+                        if !data.custom_id.starts_with("page:") {
+                            return Ok(());
+                        }
+                        let page = data
+                            .custom_id
+                            .trim_start_matches("page:")
+                            .parse::<usize>()
+                            .unwrap_or(0);
+                        tracing::info!("page: {:?}", page);
+
+                        if let Some(guild_id) = interaction.guild_id {
+                            let mut queue = Vec::new();
+                            if let Some(call_lock) = self.state.songbird.get(guild_id) {
+                                let call = call_lock.lock().await;
+                                queue = call.queue().current_queue();
+                            }
+                            let embeds = build_queue_embeds(&queue, page).await;
+                            let action_row = build_action_row(page, queue.len() / TRACKS_PER_PAGE);
+
+                            let interaction_response_data = InteractionResponseDataBuilder::new()
+                                .embeds(embeds)
+                                .components(action_row)
+                                .build();
+                            let response = InteractionResponse {
+                                kind: InteractionResponseType::UpdateMessage,
+                                data: Some(interaction_response_data),
+                            };
+                            self.state
+                                .http
+                                .interaction(interaction.application_id)
+                                .create_response(interaction.id, &interaction.token, &response)
+                                .await?;
+                            Ok(())
+                        } else {
+                            Ok(())
                         }
                     }
-                    _ => InteractionCommand::NotImplemented,
+                    _ => Ok(()),
                 }
             }
-            _ => InteractionCommand::NotImplemented,
-        };
-        debug!("{:?}", interaction_command);
-        match interaction_command {
-            InteractionCommand::Play(interaction, query) => {
-                spawn(play(interaction, Arc::clone(&self.state), query))
+            event => {
+                tracing::info!("unhandled event: {:?}", event);
+                Ok(())
             }
-            InteractionCommand::Stop(interaction) => {
-                spawn(stop(interaction, Arc::clone(&self.state)))
-            }
-            InteractionCommand::Pause(interaction) => {
-                spawn(pause(interaction, Arc::clone(&self.state)))
-            }
-            InteractionCommand::Resume(interaction) => {
-                spawn(resume(interaction, Arc::clone(&self.state)))
-            }
-            InteractionCommand::Leave(interaction) => {
-                spawn(leave(interaction, Arc::clone(&self.state)))
-            }
-            InteractionCommand::Join(interaction) => {
-                spawn(join(interaction, Arc::clone(&self.state)))
-            }
-            InteractionCommand::Queue(interaction) => {
-                spawn(queue(interaction, Arc::clone(&self.state)))
-            }
-            _ => {}
-        };
+        }
+    }
+}
+
+fn parse_interaction_command(command: &CommandData) -> InteractionCommand {
+    debug!("command: {:?}", command);
+    match command.name.as_str() {
+        "play" => {
+            if let Some(query_option) = command.options.iter().find(|opt| opt.name == "query") {
+                if let CommandOptionValue::String(query) = &query_option.value {
+                    InteractionCommand::Play(query.clone())
+                } else {
+                    InteractionCommand::NotImplemented
+                }
+            } else {
+                InteractionCommand::NotImplemented
+            }
+        }
+        "stop" => InteractionCommand::Stop,
+        "pause" => InteractionCommand::Pause,
+        "skip" => InteractionCommand::Skip,
+        "loop" => InteractionCommand::Loop,
+        "resume" => InteractionCommand::Resume,
+        "leave" => InteractionCommand::Leave,
+        "join" => InteractionCommand::Join,
+        "queue" => InteractionCommand::Queue,
+        _ => InteractionCommand::NotImplemented,
     }
 }

src/main.rs

@@ -1,9 +1,11 @@
 mod handler;
 use handler::Handler;
+mod colors;
 mod commands;
 mod metadata;
 mod signal;
 mod state;
+
 use crate::commands::get_chat_commands;
 use dotenv::dotenv;
 use futures::StreamExt;
@@ -75,6 +77,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
                 cache,
                 songbird,
                 standby: Standby::new(),
+                guild_settings: Default::default(),
             }),
         )
     };
@@ -118,7 +121,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
                 state.standby.process(&event);
                 state.songbird.process(&event).await;
 
-                handler.act(event).await;
+                handler.act(event).await?;
             }
         }
     }

src/metadata.rs

@@ -1,10 +1,12 @@
-use songbird::typemap::TypeMapKey;
+use songbird::{input::YoutubeDl, typemap::TypeMapKey};
 use std::time::Duration;
 
+#[derive(Clone)]
 pub(crate) struct Metadata {
     pub(crate) title: Option<String>,
     pub(crate) duration: Option<Duration>,
     pub(crate) url: String,
+    pub(crate) src: YoutubeDl,
 }
 
 pub(crate) struct MetadataMap;

src/state.rs

@@ -1,15 +1,23 @@
+use dashmap::DashMap;
 use songbird::Songbird;
 use std::sync::Arc;
 use twilight_cache_inmemory::InMemoryCache;
 use twilight_http::Client as HttpClient;
+use twilight_model::id::{marker::GuildMarker, Id};
 use twilight_standby::Standby;
 
 pub(crate) type State = Arc<StateRef>;
 
+#[derive(Debug)]
+pub(crate) struct Settings {
+    pub(crate) loop_queue: bool,
+}
+
 #[derive(Debug)]
 pub(crate) struct StateRef {
     pub(crate) http: HttpClient,
     pub(crate) cache: InMemoryCache,
     pub(crate) songbird: Songbird,
     pub(crate) standby: Standby,
+    pub(crate) guild_settings: DashMap<Id<GuildMarker>, Settings>,
 }