2b-rs/src/messages/music.rs

use std::sync::Arc;

use serenity::builder::CreateEmbed;
use serenity::http::Http;
use serenity::model::prelude::ChannelId;
use songbird::input::Metadata;

use crate::commands::music::{get_queue_for_guild, get_voice_manager, is_dj};
use crate::utils::error::*;
use bot_serenityutils::core::MessageHandle;
use bot_serenityutils::error::SerenityUtilsResult;
use bot_serenityutils::menu::{Menu, MenuBuilder};
use serenity::builder::CreateMessage;
use serenity::client::Context;
use serenity::model::channel::Reaction;
use std::time::Duration;
use tokio::sync::RwLock;

static PAUSE_BUTTON: &str = "⏯️";
static SKIP_BUTTON: &str = "⏭️";
static STOP_BUTTON: &str = "⏹️";

/// Creates a new now playing message and returns the embed for that message
pub async fn create_now_playing_msg(
    ctx: &Context,
    channel_id: ChannelId,
    meta: &Metadata,
    paused: bool,
) -> BotResult<Arc<RwLock<MessageHandle>>> {
    log::debug!("Creating now playing message");
    let mut page = CreateMessage::default();
    page.embed(|e| create_now_playing_embed(meta, e, paused));

    let handle = MenuBuilder::default()
        .add_control(0, STOP_BUTTON, |c, m, r| {
            Box::pin(stop_button_action(c, m, r))
        })
        .add_control(1, PAUSE_BUTTON, |c, m, r| {
            Box::pin(play_pause_button_action(c, m, r))
        })
        .add_control(2, SKIP_BUTTON, |c, m, r| {
            Box::pin(skip_button_action(c, m, r))
        })
        .add_page(page)
        .sticky(true)
        .timeout(Duration::from_secs(60 * 60 * 24))
        .build(ctx, channel_id)
        .await?;

    Ok(handle)
}

/// Updates the now playing message with new content
pub async fn update_now_playing_msg(
    http: &Arc<Http>,
    handle: &Arc<RwLock<MessageHandle>>,
    meta: &Metadata,
    paused: bool,
) -> BotResult<()> {
    log::debug!("Updating now playing message");
    let handle = handle.read().await;
    let mut message = handle.get_message(http).await?;
    message
        .edit(http, |m| {
            m.embed(|e| create_now_playing_embed(meta, e, paused))
        })
        .await?;

    Ok(())
}

/// Creates the embed of the now playing message
fn create_now_playing_embed<'a>(
    meta: &Metadata,
    mut embed: &'a mut CreateEmbed,
    paused: bool,
) -> &'a mut CreateEmbed {
    embed = embed
        .title(if paused { "Paused" } else { "Playing" })
        .description(format!(
            "[{}]({}) by {}",
            meta.title.clone().unwrap(),
            meta.source_url.clone().unwrap(),
            meta.artist.clone().unwrap()
        ));

    if let Some(thumb) = meta.thumbnail.clone() {
        embed = embed.thumbnail(thumb);
    }

    embed
}

/// Toggled when the pause button is pressed
async fn play_pause_button_action(
    ctx: &Context,
    _: &mut Menu<'_>,
    reaction: Reaction,
) -> SerenityUtilsResult<()> {
    let guild_id = reaction.guild_id.unwrap();
    let user = reaction.user(&ctx).await?;

    if !is_dj(ctx, guild_id, &user).await? {
        return Ok(());
    }
    {
        let queue = get_queue_for_guild(ctx, &guild_id).await?;
        let mut queue = queue.lock().await;
        queue.pause();
        let message = queue.now_playing_msg.clone().unwrap();

        if let Some(current) = queue.current() {
            update_now_playing_msg(&ctx.http, &message, current.metadata(), queue.paused()).await?;
        }
    }

    Ok(())
}

/// Triggered when the skip button is pressed
async fn skip_button_action(
    ctx: &Context,
    _: &mut Menu<'_>,
    reaction: Reaction,
) -> SerenityUtilsResult<()> {
    let guild_id = reaction.guild_id.unwrap();
    let user = reaction.user(&ctx).await?;

    if !is_dj(ctx, guild_id, &user).await? {
        return Ok(());
    }
    {
        let queue = get_queue_for_guild(ctx, &guild_id).await?;
        let queue = queue.lock().await;

        if let Some(current) = queue.current() {
            let _ = current.stop();
        }
    }

    Ok(())
}

/// Triggered when the stop button is pressed
async fn stop_button_action(
    ctx: &Context,
    menu: &mut Menu<'_>,
    reaction: Reaction,
) -> SerenityUtilsResult<()> {
    let guild_id = reaction.guild_id.unwrap();
    let user = reaction.user(&ctx).await?;

    if !is_dj(ctx, guild_id, &user).await? {
        return Ok(());
    }
    {
        let manager = get_voice_manager(ctx).await;
        let queue = get_queue_for_guild(ctx, &guild_id).await?;
        let queue = queue.lock().await;

        let handler = manager.get(guild_id);

        if let Some(handler) = handler {
            let mut handler_lock = handler.lock().await;
            handler_lock.remove_all_global_events();
        }
        if let Some(current) = queue.current() {
            current.stop().map_err(BotError::from)?;
        }

        if manager.get(guild_id).is_some() {
            manager.remove(guild_id).await.map_err(BotError::from)?;
            log::debug!("Left the voice channel");
        } else {
            log::debug!("Not in a voice channel");
        }
    }
    {
        let handle = &menu.message;
        let handle = handle.read().await;
        ctx.http
            .delete_message(handle.channel_id, handle.message_id)
            .await?;
    }

    Ok(())
}