add: initial commit

src/commands/buzzer.rs

@@ -0,0 +1,153 @@
+use serenity::all::{
+    ComponentInteraction, Context, CreateInteractionResponse, CreateInteractionResponseMessage,
+    EditInteractionResponse,
+};
+
+use super::controls::{self, ControlAction};
+use crate::app::buzzer::{
+    BUZZER_CUSTOM_ID, BuzzerSessionKey, LOCK_CUSTOM_ID, RESET_CUSTOM_ID, UNLOCK_CUSTOM_ID,
+    buzzer_sound, session_components,
+};
+
+pub async fn run(ctx: &Context, interaction: &ComponentInteraction) {
+    match interaction.data.custom_id.as_str() {
+        BUZZER_CUSTOM_ID => press(ctx, interaction).await,
+        RESET_CUSTOM_ID => run_control(ctx, interaction, ControlAction::Reset).await,
+        LOCK_CUSTOM_ID => run_control(ctx, interaction, ControlAction::Lock).await,
+        UNLOCK_CUSTOM_ID => run_control(ctx, interaction, ControlAction::Unlock).await,
+        _ => {}
+    }
+}
+
+async fn press(ctx: &Context, interaction: &ComponentInteraction) {
+    let session = {
+        let data = ctx.data.read().await;
+        data.get::<BuzzerSessionKey>().cloned()
+    };
+
+    let Some(session) = session else {
+        respond_ephemeral(ctx, interaction, "The buzzer session is unavailable.").await;
+        return;
+    };
+
+    let mut session = session.lock().await;
+    let Some(active_session) = session.as_mut() else {
+        respond_ephemeral(ctx, interaction, "There is no active buzzer session.").await;
+        return;
+    };
+
+    let belongs_to_session = interaction.guild_id == Some(active_session.guild_id)
+        && interaction.message.id == active_session.button_message_id;
+    if !belongs_to_session {
+        respond_ephemeral(ctx, interaction, "That buzzer is no longer active.").await;
+        return;
+    }
+
+    let user_voice_channel = ctx.cache.guild(active_session.guild_id).and_then(|guild| {
+        guild
+            .voice_states
+            .get(&interaction.user.id)
+            .and_then(|state| state.channel_id)
+    });
+    if user_voice_channel != Some(active_session.voice_channel_id) {
+        respond_ephemeral(
+            ctx,
+            interaction,
+            "Join the buzzer session's voice channel before buzzing.",
+        )
+        .await;
+        return;
+    }
+
+    if !active_session.is_open {
+        let content = match active_session.buzzed_user {
+            Some(user_id) => format!("The buzzer is locked; <@{user_id}> buzzed first."),
+            None => "The buzzer is locked.".to_string(),
+        };
+        respond_ephemeral(ctx, interaction, &content).await;
+        return;
+    }
+
+    active_session.is_open = false;
+    active_session.buzzed_user = Some(interaction.user.id);
+
+    let message = CreateInteractionResponseMessage::new()
+        .content(format!("<@{}> buzzed first!", interaction.user.id))
+        .components(session_components(false));
+
+    if let Err(error) = interaction
+        .create_response(&ctx.http, CreateInteractionResponse::UpdateMessage(message))
+        .await
+    {
+        // Keep the state open if Discord could not disable the actual button.
+        active_session.is_open = true;
+        active_session.buzzed_user = None;
+        tracing::error!(?error, "failed to lock buzzer message");
+        return;
+    }
+
+    let guild_id = active_session.guild_id;
+    drop(session);
+
+    let Some(manager) = songbird::get(ctx).await else {
+        tracing::error!("voice manager unavailable while playing buzzer");
+        return;
+    };
+    let Some(call) = manager.get(guild_id) else {
+        tracing::error!(%guild_id, "bot is not connected to voice for active buzzer");
+        return;
+    };
+
+    call.lock().await.play_only_input(buzzer_sound());
+}
+
+async fn run_control(ctx: &Context, interaction: &ComponentInteraction, action: ControlAction) {
+    let deferred =
+        CreateInteractionResponse::Defer(CreateInteractionResponseMessage::new().ephemeral(true));
+    if let Err(error) = interaction.create_response(&ctx.http, deferred).await {
+        tracing::error!(
+            ?error,
+            ?action,
+            "failed to defer buzzer control interaction"
+        );
+        return;
+    }
+
+    let content = match interaction.guild_id {
+        Some(guild_id) => {
+            controls::apply(
+                ctx,
+                guild_id,
+                interaction.user.id,
+                Some(interaction.message.id),
+                action,
+            )
+            .await
+        }
+        None => "Buzzer controls can only be used in a server.".to_string(),
+    };
+
+    if let Err(error) = interaction
+        .edit_response(&ctx.http, EditInteractionResponse::new().content(content))
+        .await
+    {
+        tracing::error!(
+            ?error,
+            ?action,
+            "failed to respond to buzzer control interaction"
+        );
+    }
+}
+
+async fn respond_ephemeral(ctx: &Context, interaction: &ComponentInteraction, content: &str) {
+    let message = CreateInteractionResponseMessage::new()
+        .content(content)
+        .ephemeral(true);
+
+    if let Err(error) = interaction
+        .create_response(&ctx.http, CreateInteractionResponse::Message(message))
+        .await
+    {
+        tracing::error!(?error, "failed to respond to buzzer interaction");
+    }
+}