foukoapi 0.1.1-alpha.1

//! Discord adapter built on top of [`serenity`].

use crate::{
    bot::Router,
    ctx::{ChatInfo, ChatInfoFn, Ctx, UrlFn},
    error::{Error, Result},
    keyboard::{ButtonKind, Embed as FkEmbed, Reply},
    platform::PlatformKind,
};
use async_trait::async_trait;
use serenity::{
    all::{
        ButtonStyle, ChannelId, Command, CommandInteraction, CommandOptionType,
        ComponentInteraction, CreateActionRow, CreateButton, CreateCommand, CreateCommandOption,
        CreateEmbed, CreateEmbedFooter, CreateInteractionResponse,
        CreateInteractionResponseFollowup, CreateInteractionResponseMessage, CreateMessage,
        EditInteractionResponse, GatewayIntents, GuildId, Interaction, Message, Ready, User,
        UserId,
    },
    client::{Context as SerenityContext, EventHandler},
    http::Http,
    model::guild::Guild,
    Client,
};
use std::sync::Arc;

/// Start the Discord adapter.
///
/// `commands` is the list of `(name, description)` pairs the bot has
/// registered. The adapter promotes each of them into a native Discord
/// slash command on startup so `/help`, `/menu`, etc. show up in the
/// client's autocomplete and can be invoked as real slash commands.
pub async fn run(
    token: String,
    router: Arc<Router>,
    commands: Vec<(String, Option<String>, bool)>,
    notifier: Option<crate::notifier::Notifier>,
) -> Result<()> {
    tracing::info!("starting discord adapter");

    let intents = GatewayIntents::GUILDS
        | GatewayIntents::GUILD_MESSAGES
        | GatewayIntents::DIRECT_MESSAGES
        | GatewayIntents::MESSAGE_CONTENT;

    let client = Client::builder(&token, intents)
        .event_handler(Handler {
            router,
            commands: Arc::new(commands),
            reply_index: Arc::new(std::sync::Mutex::new(ReplyIndex::default())),
            self_id: Arc::new(std::sync::atomic::AtomicU64::new(0)),
        })
        .await
        .map_err(|e| Error::platform("discord", e))?;

    // Install an outbound sender before the gateway loop takes over. The
    // HTTP handle works on its own, so background tasks can post to any
    // channel by id without an incoming interaction.
    if let Some(notifier) = &notifier {
        let http = client.http.clone();
        let send: crate::notifier::SendFn = Arc::new(move |chan_id: String, reply: Reply| {
            let http = http.clone();
            Box::pin(async move {
                let id: u64 = chan_id
                    .parse()
                    .map_err(|_| Error::platform("discord", format!("bad channel id {chan_id}")))?;
                let channel = ChannelId::new(id);
                for out in build_messages(&reply) {
                    channel
                        .send_message(&http, out)
                        .await
                        .map_err(|e| Error::platform("discord", e))?;
                }
                Ok(())
            })
        });
        notifier.register(PlatformKind::Discord, send).await;

        // DM sender: resolve the user's private channel first (create_dm
        // hits POST /users/@me/channels), cache the mapping so repeated
        // DMs to the same user skip the REST round-trip, then deliver
        // through the usual message-building path.
        let http = client.http.clone();
        let dm_cache = Arc::new(std::sync::Mutex::new(DmChannelCache::default()));
        let send_dm: crate::notifier::DmSendFn = Arc::new(move |user_id: String, reply: Reply| {
            let http = http.clone();
            let dm_cache = Arc::clone(&dm_cache);
            Box::pin(async move {
                let id: u64 = user_id
                    .parse()
                    .map_err(|_| Error::platform("discord", format!("bad user id {user_id}")))?;
                let cached = dm_cache.lock().ok().and_then(|c| c.get(id));
                let channel = match cached {
                    Some(chan) => ChannelId::new(chan),
                    None => {
                        let chan = UserId::new(id)
                            .create_dm_channel(&http)
                            .await
                            .map_err(|e| Error::platform("discord", e))?
                            .id;
                        if let Ok(mut cache) = dm_cache.lock() {
                            cache.record(id, chan.get());
                        }
                        chan
                    }
                };
                for out in build_messages(&reply) {
                    channel
                        .send_message(&http, out)
                        .await
                        .map_err(|e| Error::platform("discord", e))?;
                }
                Ok(())
            })
        });
        notifier.register_dm(PlatformKind::Discord, send_dm).await;

        // User lookup via GET /users/{id}. A 404 means no such user and
        // maps to Ok(None); other failures bubble up as errors.
        let http = client.http.clone();
        let lookup: crate::notifier::UserLookupFn = Arc::new(move |user_id: String| {
            let http = http.clone();
            Box::pin(async move {
                let id: u64 = user_id
                    .parse()
                    .map_err(|_| Error::platform("discord", format!("bad user id {user_id}")))?;
                match http.get_user(UserId::new(id)).await {
                    Ok(user) => Ok(Some(discord_display_name(&user))),
                    Err(e) if is_not_found(&e) => Ok(None),
                    Err(e) => Err(Error::platform("discord", e)),
                }
            })
        });
        notifier
            .register_user_lookup(PlatformKind::Discord, lookup)
            .await;
    }

    let mut client = client;
    client
        .start()
        .await
        .map_err(|e| Error::platform("discord", e))?;

    Ok(())
}

struct Handler {
    router: Arc<Router>,
    /// Bot commands to expose as native Discord slash commands. Each
    /// item is `(name_with_slash, description)`.
    commands: Arc<Vec<(String, Option<String>, bool)>>,
    /// Maps a user's message id to the bot's reply ids in that channel, so
    /// when the user deletes their message we can clean up ours too.
    /// Bounded: oldest entries are evicted once the map grows past a cap.
    reply_index: Arc<std::sync::Mutex<ReplyIndex>>,
    /// Our own user id, learned at `ready`. Zero until then.
    self_id: Arc<std::sync::atomic::AtomicU64>,
}

/// Bookkeeping for "delete my reply when the trigger message is deleted".
#[derive(Default)]
struct ReplyIndex {
    /// trigger message id -> (channel, bot message id)s sent in response.
    map: std::collections::HashMap<u64, Vec<(u64, u64)>>,
    /// Insertion order for eviction. May hold ids already taken out of
    /// `map`; eviction skips those lazily.
    order: std::collections::VecDeque<u64>,
}

impl ReplyIndex {
    const CAP: usize = 5_000;

    fn record(&mut self, trigger: u64, channel: u64, bot_msg: u64) {
        let entry = self.map.entry(trigger).or_default();
        if entry.is_empty() {
            self.order.push_back(trigger);
        }
        entry.push((channel, bot_msg));
        // Evict oldest live entries; ids already removed by take() don't
        // count against the cap.
        while self.map.len() > Self::CAP {
            match self.order.pop_front() {
                Some(old) => {
                    self.map.remove(&old);
                }
                None => break,
            }
        }
    }

    fn take(&mut self, trigger: u64) -> Vec<(u64, u64)> {
        self.map.remove(&trigger).unwrap_or_default()
    }
}

/// Bounded user id -> DM channel id cache for `Notifier::send_dm`, so a
/// repeat DM to the same user skips the create-channel REST call. Same
/// eviction scheme as [`ReplyIndex`]: oldest entries go first.
#[derive(Default)]
struct DmChannelCache {
    map: std::collections::HashMap<u64, u64>,
    order: std::collections::VecDeque<u64>,
}

impl DmChannelCache {
    const CAP: usize = 1_000;

    fn get(&self, user: u64) -> Option<u64> {
        self.map.get(&user).copied()
    }

    fn record(&mut self, user: u64, channel: u64) {
        if self.map.insert(user, channel).is_none() {
            self.order.push_back(user);
        }
        while self.map.len() > Self::CAP {
            match self.order.pop_front() {
                Some(old) => {
                    self.map.remove(&old);
                }
                None => break,
            }
        }
    }
}

impl Handler {
    /// Build the native Discord slash-command set from the bot's command
    /// list. Names are lowercased and stripped of the leading `/`; ones
    /// Discord would reject (empty, starting with a digit like `8ball`,
    /// containing spaces) are skipped so the register call never fails
    /// on a single bad entry. Each command carries an optional `args`
    /// string field so the client shows a text box for `/weather Paris`,
    /// `/link CODE` and friends.
    fn build_commands(&self) -> Vec<CreateCommand> {
        let mut batch: Vec<CreateCommand> = Vec::new();
        for (name, desc, takes_user) in self.commands.iter() {
            let trimmed = name.trim_start_matches('/').to_ascii_lowercase();
            if trimmed.is_empty() || !is_valid_slash_name(&trimmed) {
                continue;
            }
            let description = desc
                .clone()
                .filter(|s| !s.is_empty())
                .unwrap_or_else(|| trimmed.clone());
            // Discord caps descriptions at 100 chars; truncate on a char
            // boundary so multi-byte codepoints never get sliced.
            let description = truncate_chars(&description, 100);
            let mut cmd = CreateCommand::new(trimmed).description(description);
            // Commands that target a person get a native USER option so
            // the Discord client offers its member picker instead of the
            // user typing an id by hand.
            if *takes_user {
                cmd = cmd.add_option(
                    CreateCommandOption::new(CommandOptionType::User, "user", "who to look at")
                        .required(false),
                );
            }
            cmd = cmd.add_option(
                CreateCommandOption::new(
                    CommandOptionType::String,
                    "args",
                    "arguments passed to the command (optional)",
                )
                .required(false),
            );
            batch.push(cmd);
        }
        batch
    }
}

#[async_trait]
impl EventHandler for Handler {
    async fn ready(&self, ctx: SerenityContext, ready: Ready) {
        tracing::info!(bot = %ready.user.name, "discord adapter ready");
        self.self_id
            .store(ready.user.id.get(), std::sync::atomic::Ordering::Relaxed);

        // Register every bot command as a native Discord slash command.
        // Global commands work everywhere (guilds and DMs) but Discord
        // can take up to an hour to roll them out to every guild the bot
        // sits in. To make commands show up on servers straight away we
        // *also* register them per-guild from `guild_create`, which is
        // near-instant. The two sets are identical, so Discord de-dupes
        // them in the client and users never see doubles.
        let batch = self.build_commands();
        match Command::set_global_commands(&ctx.http, batch).await {
            Ok(cmds) => {
                tracing::info!(
                    count = cmds.len(),
                    "discord: registered global slash commands"
                );
            }
            Err(e) => {
                tracing::warn!(error = %e, "discord: could not register slash commands");
            }
        }
    }

    async fn guild_create(&self, ctx: SerenityContext, guild: Guild, _is_new: Option<bool>) {
        // Push the command set straight into this guild so it's usable
        // immediately, without waiting for the global propagation delay.
        let batch = self.build_commands();
        match guild.id.set_commands(&ctx.http, batch).await {
            Ok(cmds) => {
                tracing::debug!(
                    guild = %guild.id,
                    count = cmds.len(),
                    "discord: registered guild slash commands"
                );
            }
            Err(e) => {
                tracing::warn!(
                    guild = %guild.id,
                    error = %e,
                    "discord: could not register guild slash commands"
                );
            }
        }
    }

    async fn message(&self, ctx: SerenityContext, msg: Message) {
        if msg.author.bot {
            return;
        }

        let router = Arc::clone(&self.router);
        let channel_id = msg.channel_id;
        let http = ctx.http.clone();

        // A guild message carries its guild id; a DM doesn't. Reading it
        // off the message is instant and never leaks private data into a
        // guild, unlike probing the channel over HTTP where a failed
        // lookup used to fall back to a guess.
        let is_dm = msg.guild_id.is_none();

        let trigger_id = msg.id.get();
        let reply_index = Arc::clone(&self.reply_index);
        let reply_fn: crate::ctx::ReplyFn = Box::new(move |reply: Reply| {
            let http = http.clone();
            let reply_index = Arc::clone(&reply_index);
            Box::pin(async move {
                for out in build_messages(&reply) {
                    let sent = channel_id
                        .send_message(&http, out)
                        .await
                        .map_err(|e| Error::platform("discord", e))?;
                    // Remember which message triggered this reply so a
                    // delete of the trigger can take the reply down too.
                    if let Ok(mut index) = reply_index.lock() {
                        index.record(trigger_id, channel_id.get(), sent.id.get());
                    }
                }
                Ok(())
            })
        });

        let fouko_ctx = Ctx::new_full(
            PlatformKind::Discord,
            channel_id.to_string(),
            msg.author.id.to_string(),
            msg.content.clone(),
            reply_fn,
            Some(is_dm),
            None,
        )
        .with_lookups(
            Some(avatar_lookup(msg.author.clone())),
            Some(banner_lookup(ctx.http.clone(), msg.author.id)),
            chatinfo_lookup(ctx.http.clone(), msg.guild_id, is_dm, channel_id),
        )
        .with_typing(typing_lookup(ctx.http.clone(), channel_id))
        .with_user_avatar(user_avatar_lookup(ctx.http.clone()))
        .with_user_name(Some(
            msg.author
                .global_name
                .clone()
                .unwrap_or_else(|| msg.author.name.clone()),
        ))
        .with_reply_to_bot(
            // The referenced (quoted) message was authored by this bot.
            msg.referenced_message
                .as_deref()
                .map(|r| {
                    r.author.id.get() == self.self_id.load(std::sync::atomic::Ordering::Relaxed)
                })
                .unwrap_or(false),
        )
        .with_temp_reply(temp_reply_lookup(ctx.http.clone(), channel_id));

        if let Err(e) = router.dispatch(fouko_ctx).await {
            tracing::warn!(error = %e, "discord handler error");
        }
    }

    async fn interaction_create(&self, ctx: SerenityContext, interaction: Interaction) {
        match interaction {
            Interaction::Component(component) => {
                handle_component(&ctx, &self.router, component).await;
            }
            Interaction::Command(command) => {
                handle_command(&ctx, &self.router, command).await;
            }
            _ => {}
        }
    }

    async fn message_delete(
        &self,
        ctx: SerenityContext,
        _channel_id: ChannelId,
        deleted: serenity::all::MessageId,
        _guild_id: Option<GuildId>,
    ) {
        // If the deleted message was one we replied to, take our replies
        // down as well - nobody wants an orphaned bot answer quoting a
        // message that no longer exists.
        let replies = match self.reply_index.lock() {
            Ok(mut index) => index.take(deleted.get()),
            Err(_) => return,
        };
        for (chan, msg_id) in replies {
            let _ = ChannelId::new(chan)
                .delete_message(&ctx.http, serenity::all::MessageId::new(msg_id))
                .await;
        }
    }
}

/// Treat a Discord slash-command invocation as if the user had typed
/// `/<name> <args>` into the chat, then forward it to the router.
async fn handle_command(ctx: &SerenityContext, router: &Router, command: CommandInteraction) {
    let channel_id = command.channel_id;
    let user_id = command.user.id.to_string();
    // A slash command carries its guild id inline: `None` means it came
    // from a DM. That's far more reliable (and free) than probing the
    // channel over HTTP, and it's what makes `/link`'s DM-only guard
    // behave correctly on servers.
    let is_dm = command.guild_id.is_none();

    // Stitch `/<name> <arg1> <arg2> ...` back together so the dispatch
    // layer sees what it would see from a real text message. Options are
    // picked by name, not position: the native USER option (the member
    // picker) becomes an id token placed before the free-form args.
    let mut text = format!("/{}", command.data.name);
    if let Some(opt) = command.data.options.iter().find(|o| o.name == "user") {
        if let Some(user_id) = opt.value.as_user_id() {
            text.push(' ');
            text.push_str(&user_id.to_string());
        }
    }
    if let Some(opt) = command.data.options.iter().find(|o| o.name == "args") {
        if let Some(v) = opt.value.as_str() {
            text.push(' ');
            text.push_str(v);
        }
    }

    // Defer the interaction so Discord knows we're working on it.
    // The first reply the handler sends replaces the "…" placeholder,
    // every next one comes through as a followup. That way buttons
    // that live on an embed stay attached to the same message as the
    // slash-command answer itself, and secondary messages (like a
    // "linked!" confirmation after /link CODE) still show up.
    let defer = CreateInteractionResponse::Defer(CreateInteractionResponseMessage::new());
    // When the defer fails the interaction token is unusable: every
    // edit_response/followup would fail too and the user would get
    // nothing. Fall back to plain channel sends in that case.
    let use_interaction = match command.create_response(&ctx.http, defer).await {
        Ok(()) => true,
        Err(e) => {
            tracing::debug!(error = %e, "discord slash-cmd defer failed; falling back to channel sends");
            false
        }
    };

    let http = ctx.http.clone();
    let cmd_clone = command.clone();
    let first_call = Arc::new(std::sync::atomic::AtomicBool::new(true));
    // Shared with the reply closure: stays `true` until the first reply
    // flips it, so after dispatch we can tell whether anything answered.
    let awaiting_reply = first_call.clone();
    let reply_fn: crate::ctx::ReplyFn = Box::new(move |reply: Reply| {
        let http = http.clone();
        let command = cmd_clone.clone();
        let first = first_call.clone();
        Box::pin(async move {
            if !use_interaction {
                // Defer failed: the token is dead, post straight to the
                // channel instead so the user still gets an answer.
                first.store(false, std::sync::atomic::Ordering::SeqCst);
                for out in build_messages(&reply) {
                    command
                        .channel_id
                        .send_message(&http, out)
                        .await
                        .map_err(|e| Error::platform("discord", e))?;
                }
                return Ok(());
            }
            // First reply: edit the defered message so the slash-command
            // "bot is thinking…" placeholder turns into the real answer.
            // Every subsequent reply becomes a followup. Long text is
            // split at Discord's 2000-char cap: the first chunk edits,
            // the rest go out as followups.
            let is_first = first
                .compare_exchange(
                    true,
                    false,
                    std::sync::atomic::Ordering::SeqCst,
                    std::sync::atomic::Ordering::SeqCst,
                )
                .is_ok();
            let chunks = split_text(reply.get_text());
            let last = chunks.len().saturating_sub(1);
            if is_first {
                let mut edit = EditInteractionResponse::new();
                if let Some(first_chunk) = chunks.first() {
                    edit = edit.content(first_chunk.clone());
                }
                if last == 0 {
                    if let Some(em) = reply.get_embed() {
                        edit = edit.embed(to_discord_embed(em));
                    }
                    if let Some(kb) = reply.get_keyboard() {
                        edit = edit.components(build_rows(kb));
                    }
                }
                command
                    .edit_response(&http, edit)
                    .await
                    .map_err(|e| Error::platform("discord", e))?;
                // Remaining chunks (and the embed/keyboard, attached to
                // the final one) follow up.
                for (i, chunk) in chunks.iter().enumerate().skip(1) {
                    let mut follow =
                        CreateInteractionResponseFollowup::new().content(chunk.clone());
                    if i == last {
                        if let Some(em) = reply.get_embed() {
                            follow = follow.add_embed(to_discord_embed(em));
                        }
                        if let Some(kb) = reply.get_keyboard() {
                            follow = follow.components(build_rows(kb));
                        }
                    }
                    command
                        .create_followup(&http, follow)
                        .await
                        .map_err(|e| Error::platform("discord", e))?;
                }
            } else {
                for follow in build_followups(&reply) {
                    command
                        .create_followup(&http, follow)
                        .await
                        .map_err(|e| Error::platform("discord", e))?;
                }
            }
            Ok(())
        })
    });

    let fouko_ctx = Ctx::new_full(
        PlatformKind::Discord,
        channel_id.to_string(),
        user_id,
        text,
        reply_fn,
        Some(is_dm),
        None,
    )
    .with_lookups(
        Some(avatar_lookup(command.user.clone())),
        Some(banner_lookup(ctx.http.clone(), command.user.id)),
        chatinfo_lookup(ctx.http.clone(), command.guild_id, is_dm, channel_id),
    )
    .with_typing(typing_lookup(ctx.http.clone(), channel_id))
    .with_temp_reply(temp_reply_lookup(ctx.http.clone(), channel_id))
    .with_user_avatar(user_avatar_lookup(ctx.http.clone()))
    .with_user_name(Some(
        command
            .user
            .global_name
            .clone()
            .unwrap_or_else(|| command.user.name.clone()),
    ));

    let dispatch_result = router.dispatch(fouko_ctx).await;
    if let Err(e) = &dispatch_result {
        tracing::warn!(error = %e, "discord slash-cmd handler error");
    }

    // If nothing ever answered (a command gated to another platform, or
    // one that silently bailed), the "bot is thinking…" placeholder would
    // hang forever. Clear it with a short acknowledgement - a check when
    // the handler ran fine, a warning marker when it errored - so the
    // client doesn't sit on a dead spinner or fake a success.
    if use_interaction && awaiting_reply.load(std::sync::atomic::Ordering::SeqCst) {
        let marker = if dispatch_result.is_ok() {
            "\u{2705}"
        } else {
            "\u{26A0}\u{FE0F}"
        };
        let edit = EditInteractionResponse::new().content(marker);
        if let Err(e) = command.edit_response(&ctx.http, edit).await {
            tracing::debug!(error = %e, "discord slash-cmd cleanup edit failed");
        }
    }
}

/// Handle a button / select press the same way we handle messages,
/// routing the custom-id back through the router as `callback_data`.
///
/// The incoming `component` interaction is deferred (so Discord stops
/// the spinner) and then the handler is free to either:
///
/// - send followups against the interaction token (`ctx.reply`), which
///   post fresh messages in the same channel, or
/// - edit the **original** message that carried the pressed button
///   (`ctx.edit_reply`), wiping or replacing its text/keyboard.
async fn handle_component(ctx: &SerenityContext, router: &Router, component: ComponentInteraction) {
    let channel_id = component.channel_id;
    let http = ctx.http.clone();
    let data = component.data.custom_id.clone();
    let user_id = component.user.id.to_string();
    // Same trick as slash commands: the interaction knows its own guild,
    // so a missing guild id means we're in a DM.
    let is_dm = component.guild_id.is_none();

    // Defer the component update so Discord stops the "thinking" spinner
    // on the button. DeferredUpdateMessage keeps the original message
    // intact - we can still edit it via edit_response.
    let defer = CreateInteractionResponse::Acknowledge;
    if let Err(e) = component.create_response(&http, defer).await {
        tracing::debug!(error = %e, "discord component defer failed");
    }

    let http_for_reply = http.clone();
    let comp_for_reply = component.clone();
    let reply_fn: crate::ctx::ReplyFn = Box::new(move |reply: Reply| {
        let http = http_for_reply.clone();
        let comp = comp_for_reply.clone();
        Box::pin(async move {
            // Send as a followup so the reply belongs to the same
            // interaction. That's how buttons "produce" new messages
            // in Discord; plain channel_id.send_message would work but
            // would show the bot posting out of the blue instead of
            // being tied to the user's click.
            for follow in build_followups(&reply) {
                comp.create_followup(&http, follow)
                    .await
                    .map_err(|e| Error::platform("discord", e))?;
            }
            Ok(())
        })
    });

    // Edit callback: rewrite the message that carried the button. Overlong
    // text is edited in with the first chunk; the rest follow up.
    let http_for_edit = http.clone();
    let comp_for_edit = component.clone();
    let edit_fn: crate::ctx::EditFn = Arc::new(move |reply: Reply| {
        let http = http_for_edit.clone();
        let comp = comp_for_edit.clone();
        Box::pin(async move {
            let chunks = split_text(reply.get_text());
            let mut edit = serenity::all::EditMessage::new();
            // Always clear embeds/components first so stale ones don't
            // linger when the new reply doesn't include them.
            edit = edit.content(chunks.first().cloned().unwrap_or_default());
            let mut embeds = Vec::new();
            if let Some(em) = reply.get_embed() {
                embeds.push(to_discord_embed(em));
            }
            edit = edit.embeds(embeds);
            let components = match reply.get_keyboard() {
                Some(kb) => build_rows(kb),
                None => Vec::new(),
            };
            edit = edit.components(components);
            let mut msg = comp.message.clone();
            msg.edit(&http, edit)
                .await
                .map_err(|e| Error::platform("discord", e))?;
            for chunk in chunks.iter().skip(1) {
                let follow = CreateInteractionResponseFollowup::new().content(chunk.clone());
                comp.create_followup(&http, follow)
                    .await
                    .map_err(|e| Error::platform("discord", e))?;
            }
            Ok(())
        })
    });

    let fouko_ctx = Ctx::new_with_edit(
        PlatformKind::Discord,
        channel_id.to_string(),
        user_id,
        data.clone(),
        reply_fn,
        Some(is_dm),
        Some(data),
        Some(edit_fn),
    )
    .with_lookups(
        Some(avatar_lookup(component.user.clone())),
        Some(banner_lookup(ctx.http.clone(), component.user.id)),
        chatinfo_lookup(ctx.http.clone(), component.guild_id, is_dm, channel_id),
    )
    .with_typing(typing_lookup(ctx.http.clone(), channel_id))
    .with_user_avatar(user_avatar_lookup(ctx.http.clone()))
    .with_user_name(Some(
        component
            .user
            .global_name
            .clone()
            .unwrap_or_else(|| component.user.name.clone()),
    ))
    .with_temp_reply(temp_reply_lookup(ctx.http.clone(), channel_id));

    if let Err(e) = router.dispatch(fouko_ctx).await {
        tracing::warn!(error = %e, "discord interaction handler error");
    }
}

/// Discord caps message content at 2000 chars.
const DISCORD_LIMIT: usize = 2000;

/// Split reply text at Discord's content cap. Empty text yields no chunks.
fn split_text(text: &str) -> Vec<String> {
    crate::util::split_chunks(text, DISCORD_LIMIT)
}

/// Render a [`Reply`] into one or more channel messages, splitting long
/// text at Discord's cap. The embed and keyboard ride on the last message
/// so buttons sit under the final chunk.
fn build_messages(reply: &Reply) -> Vec<CreateMessage> {
    let chunks = split_text(reply.get_text());
    let mut out = Vec::new();
    let last = chunks.len().saturating_sub(1);
    if chunks.is_empty() {
        let mut msg = CreateMessage::new();
        if let Some(em) = reply.get_embed() {
            msg = msg.add_embed(to_discord_embed(em));
        }
        if let Some(kb) = reply.get_keyboard() {
            msg = msg.components(build_rows(kb));
        }
        out.push(msg);
        return out;
    }
    for (i, chunk) in chunks.iter().enumerate() {
        let mut msg = CreateMessage::new().content(chunk.clone());
        if i == last {
            if let Some(em) = reply.get_embed() {
                msg = msg.add_embed(to_discord_embed(em));
            }
            if let Some(kb) = reply.get_keyboard() {
                msg = msg.components(build_rows(kb));
            }
        }
        out.push(msg);
    }
    out
}

/// Same as [`build_messages`] but for interaction followups.
fn build_followups(reply: &Reply) -> Vec<CreateInteractionResponseFollowup> {
    let chunks = split_text(reply.get_text());
    let mut out = Vec::new();
    let last = chunks.len().saturating_sub(1);
    if chunks.is_empty() {
        let mut follow = CreateInteractionResponseFollowup::new();
        if let Some(em) = reply.get_embed() {
            follow = follow.add_embed(to_discord_embed(em));
        }
        if let Some(kb) = reply.get_keyboard() {
            follow = follow.components(build_rows(kb));
        }
        out.push(follow);
        return out;
    }
    for (i, chunk) in chunks.iter().enumerate() {
        let mut follow = CreateInteractionResponseFollowup::new().content(chunk.clone());
        if i == last {
            if let Some(em) = reply.get_embed() {
                follow = follow.add_embed(to_discord_embed(em));
            }
            if let Some(kb) = reply.get_keyboard() {
                follow = follow.components(build_rows(kb));
            }
        }
        out.push(follow);
    }
    out
}

fn build_rows(kb: &crate::keyboard::Keyboard) -> Vec<CreateActionRow> {
    kb.rows()
        .iter()
        .map(|row| {
            let buttons: Vec<CreateButton> = row
                .iter()
                .map(|b| match &b.kind {
                    ButtonKind::Callback(id) => CreateButton::new(id.clone())
                        .label(b.label())
                        .style(ButtonStyle::Primary),
                    ButtonKind::Url(u) => CreateButton::new_link(u.clone()).label(b.label()),
                })
                .collect();
            CreateActionRow::Buttons(buttons)
        })
        .collect()
}

/// Discord requires slash-command names to start with a letter and only
/// contain `[a-z0-9_-]`. Everything else (starting with a digit like
/// `8ball`, containing spaces, etc.) is rejected server-side, so we
/// filter out non-conforming names before the register call.
fn is_valid_slash_name(s: &str) -> bool {
    let mut chars = s.chars();
    let Some(first) = chars.next() else {
        return false;
    };
    if !first.is_ascii_lowercase() {
        return false;
    }
    chars.all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '_' || c == '-')
        && s.len() <= 32
}

/// Truncate `s` to at most `max_chars` Unicode characters without
/// slicing in the middle of a multi-byte codepoint.
fn truncate_chars(s: &str, max_chars: usize) -> String {
    let mut out = String::new();
    for (i, ch) in s.chars().enumerate() {
        if i >= max_chars {
            break;
        }
        out.push(ch);
    }
    out
}

/// Translate a cross-platform [`FkEmbed`] into a [`CreateEmbed`] that
/// serenity knows how to send.
fn to_discord_embed(src: &FkEmbed) -> CreateEmbed {
    let mut em = CreateEmbed::new();
    if let Some(t) = src.get_title() {
        em = em.title(t);
    }
    if let Some(u) = src.get_url() {
        em = em.url(u);
    }
    if let Some(d) = src.get_description() {
        em = em.description(d);
    }
    if let Some(c) = src.get_color() {
        em = em.colour(c);
    }
    for f in src.get_fields() {
        em = em.field(f.name(), f.value(), f.is_inline());
    }
    if let Some(url) = src.get_image() {
        em = em.image(url);
    }
    if let Some(url) = src.get_thumbnail() {
        em = em.thumbnail(url);
    }
    if let Some(foot) = src.get_footer() {
        em = em.footer(CreateEmbedFooter::new(foot));
    }
    em
}

/// Avatar lookup: Discord builds the CDN URL locally from the user's id
/// and avatar hash, so no network call is needed. `face()` always yields a
/// URL, falling back to the default avatar.
fn avatar_lookup(user: User) -> UrlFn {
    Arc::new(move || {
        let user = user.clone();
        Box::pin(async move { Ok(Some(user.face())) })
    })
}

/// Banner lookup: the banner hash isn't in gateway events, so we fetch the
/// full user over REST and read its banner URL. Returns `None` if the user
/// has no banner.
fn banner_lookup(http: Arc<Http>, user_id: UserId) -> UrlFn {
    Arc::new(move || {
        let http = http.clone();
        Box::pin(async move {
            match user_id.to_user(&http).await {
                Ok(user) => Ok(user.banner_url()),
                Err(e) => Err(Error::platform("discord", e)),
            }
        })
    })
}

/// Chat-info lookup: for a guild command, fetch member counts and icon via
/// REST; for a DM there's no server, so report a minimal private ChatInfo.
fn chatinfo_lookup(
    http: Arc<Http>,
    guild_id: Option<GuildId>,
    is_dm: bool,
    channel_id: ChannelId,
) -> Option<ChatInfoFn> {
    Some(Arc::new(move || {
        let http = http.clone();
        Box::pin(async move {
            match guild_id {
                Some(gid) => match gid.to_partial_guild_with_counts(&http).await {
                    Ok(g) => Ok(ChatInfo {
                        id: gid.to_string(),
                        title: Some(g.name.clone()),
                        member_count: g.approximate_member_count,
                        icon_url: g.icon_url(),
                        description: g.description.clone(),
                        is_private: false,
                    }),
                    Err(e) => Err(Error::platform("discord", e)),
                },
                None => Ok(ChatInfo {
                    id: channel_id.to_string(),
                    is_private: is_dm,
                    ..Default::default()
                }),
            }
        })
    }))
}

/// Typing indicator for a Discord channel. Lasts ~10s or until the bot
/// posts, which comfortably covers most command work.
fn typing_lookup(http: Arc<Http>, channel_id: ChannelId) -> Option<crate::ctx::TypingFn> {
    Some(Arc::new(move || {
        let http = http.clone();
        Box::pin(async move {
            channel_id
                .broadcast_typing(&http)
                .await
                .map_err(|e| Error::platform("discord", e))?;
            Ok(())
        })
    }))
}

/// Send a message to a channel and delete it after a delay - for transient
/// notices that shouldn't clutter the chat.
fn temp_reply_lookup(http: Arc<Http>, channel_id: ChannelId) -> Option<crate::ctx::TempReplyFn> {
    Some(Arc::new(move |reply: Reply, secs: u64| {
        let http = http.clone();
        Box::pin(async move {
            let mut sent_ids = Vec::new();
            for msg in build_messages(&reply) {
                let sent = channel_id
                    .send_message(&http, msg)
                    .await
                    .map_err(|e| Error::platform("discord", e))?;
                sent_ids.push(sent.id);
            }
            tokio::spawn(async move {
                tokio::time::sleep(std::time::Duration::from_secs(secs)).await;
                for id in sent_ids {
                    let _ = channel_id.delete_message(&http, id).await;
                }
            });
            Ok(())
        })
    }))
}

/// Avatar lookup for an arbitrary user id, via REST. Backs commands like
/// "/avatar @someone" where the target isn't the interaction's author.
fn user_avatar_lookup(http: Arc<Http>) -> Option<crate::ctx::UserUrlFn> {
    Some(Arc::new(move |raw_id: String| {
        let http = http.clone();
        Box::pin(async move {
            let Ok(id) = raw_id.parse::<u64>() else {
                return Ok(None);
            };
            match UserId::new(id).to_user(&http).await {
                Ok(user) => Ok(Some(user.face())),
                Err(_) => Ok(None),
            }
        })
    }))
}

/// Pretty name for a user: display name first, plus the unique handle in
/// brackets when it differs, e.g. "Vall (@vall_)".
fn discord_display_name(user: &User) -> String {
    let display = user
        .global_name
        .clone()
        .unwrap_or_else(|| user.name.clone());
    if display == user.name {
        display
    } else {
        format!("{display} (@{})", user.name)
    }
}

/// `true` when a serenity error is an HTTP 404 from the REST API.
fn is_not_found(e: &serenity::Error) -> bool {
    matches!(
        e,
        serenity::Error::Http(http) if http.status_code() == Some(serenity::http::StatusCode::NOT_FOUND)
    )
}