mur_chat/

discord.rs

//! Discord bot integration — Bot API, prefix commands, slash commands, reaction-based approval.

use crate::platform::{
    ApprovalRequest, ChatPlatform, OutgoingMessage, ProgressStatus, ProgressUpdate,
    WorkflowNotification,
};
use anyhow::{Context, Result};
use serde::Deserialize;
use std::collections::HashMap;

/// Discord bot configuration.
#[derive(Debug, Clone)]
pub struct DiscordConfig {
    /// Bot token from Discord Developer Portal.
    pub bot_token: String,
    /// Application ID for slash command registration.
    pub application_id: String,
    /// Default channel ID for notifications.
    pub default_channel_id: Option<String>,
    /// Command prefix for text commands (default: "!").
    pub command_prefix: String,
}

impl DiscordConfig {
    /// Create from environment variables.
    pub fn from_env() -> Result<Self> {
        let bot_token =
            std::env::var("DISCORD_BOT_TOKEN").context("DISCORD_BOT_TOKEN not set")?;
        let application_id =
            std::env::var("DISCORD_APPLICATION_ID").context("DISCORD_APPLICATION_ID not set")?;
        let default_channel_id = std::env::var("DISCORD_CHANNEL_ID").ok();
        let command_prefix = std::env::var("DISCORD_PREFIX").unwrap_or_else(|_| "!".to_string());

        Ok(Self {
            bot_token,
            application_id,
            default_channel_id,
            command_prefix,
        })
    }
}

/// Discord bot client.
pub struct DiscordBot {
    config: DiscordConfig,
    client: reqwest::Client,
}

/// Discord API response for message operations.
#[derive(Deserialize)]
struct DiscordMessage {
    id: String,
}

/// Parsed Discord command from user message.
///
/// NOTE: This enum is nearly identical to `TelegramCommand` and `ChatCommand`.
/// A shared command enum should be considered to reduce duplication.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DiscordCommand {
    /// !run <workflow> [--shadow] [--var key=value]
    Run {
        workflow: String,
        shadow: bool,
        variables: HashMap<String, String>,
    },
    /// !workflows — list available workflows
    Workflows,
    /// !audit [workflow_id] — show audit log
    Audit { workflow_id: Option<String> },
    /// !status — show daemon status
    Status,
    /// !help — show help text
    Help,
    /// Unknown command
    Unknown { text: String },
}

/// Slash command definition for registration.
#[derive(Debug, Clone, serde::Serialize)]
pub struct SlashCommand {
    pub name: String,
    pub description: String,
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub options: Vec<SlashCommandOption>,
}

/// Slash command option.
#[derive(Debug, Clone, serde::Serialize)]
pub struct SlashCommandOption {
    pub name: String,
    pub description: String,
    /// 3 = string, 5 = boolean
    #[serde(rename = "type")]
    pub option_type: u8,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub required: Option<bool>,
}

/// Reaction type for approval tracking.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ApprovalReaction {
    Approved,
    Denied,
    Unknown,
}

impl DiscordBot {
    pub fn new(config: DiscordConfig) -> Self {
        Self {
            config,
            client: reqwest::Client::builder().connect_timeout(std::time::Duration::from_secs(10)).timeout(std::time::Duration::from_secs(30)).build().unwrap_or_else(|_| reqwest::Client::new()),
        }
    }

    /// Base URL for Discord API.
    ///
    /// NOTE: The API version "v10" is hardcoded. Consider making it configurable
    /// or defining it as a constant for easier upgrades.
    fn api_url(path: &str) -> String {
        format!("https://discord.com/api/v10{}", path)
    }

    /// Make an authenticated request to the Discord API.
    async fn api_request(
        &self,
        method: reqwest::Method,
        path: &str,
        body: Option<serde_json::Value>,
    ) -> Result<serde_json::Value> {
        let url = Self::api_url(path);
        let mut request = self
            .client
            .request(method, &url)
            .header(
                "Authorization",
                format!("Bot {}", self.config.bot_token),
            )
            .header("Content-Type", "application/json");

        if let Some(body) = body {
            request = request.json(&body);
        }

        let response = request.send().await.context("Discord API request failed")?;

        let status = response.status();
        let text = response.text().await?;

        if !status.is_success() {
            anyhow::bail!("Discord API error ({}): {}", status, text);
        }

        // Some endpoints (like add_reaction) return 204 No Content
        if text.is_empty() {
            return Ok(serde_json::Value::Null);
        }

        serde_json::from_str(&text).context("Failed to parse Discord API response")
    }

    /// Parse a prefix-based command (!run, !workflows, etc.).
    pub fn parse_command(&self, text: &str) -> DiscordCommand {
        Self::parse_command_with_prefix(text, &self.config.command_prefix)
    }

    /// Parse a command with a given prefix.
    pub fn parse_command_with_prefix(text: &str, prefix: &str) -> DiscordCommand {
        let text = text.trim();

        if !text.starts_with(prefix) {
            return DiscordCommand::Unknown {
                text: text.to_string(),
            };
        }

        let without_prefix = &text[prefix.len()..];
        let parts: Vec<&str> = without_prefix.splitn(2, ' ').collect();
        let cmd = parts[0].to_lowercase();
        let args = parts.get(1).unwrap_or(&"").trim();

        match cmd.as_str() {
            "run" => {
                let mut workflow = String::new();
                let mut shadow = false;
                let mut variables = HashMap::new();

                // NOTE: Discord uses `--var=key=value` syntax (single token),
                // while command.rs uses `--var key=value` (two tokens). This
                // inconsistency should be unified in a future refactor.
                for token in args.split_whitespace() {
                    if token == "--shadow" {
                        shadow = true;
                    } else if let Some(var) = token.strip_prefix("--var=") {
                        if let Some((k, v)) = var.split_once('=') {
                            variables.insert(k.to_string(), v.to_string());
                        }
                    } else if workflow.is_empty() {
                        workflow = token.to_string();
                    }
                }

                if workflow.is_empty() {
                    DiscordCommand::Unknown {
                        text: text.to_string(),
                    }
                } else {
                    DiscordCommand::Run {
                        workflow,
                        shadow,
                        variables,
                    }
                }
            }
            "workflows" | "wf" => DiscordCommand::Workflows,
            "audit" => DiscordCommand::Audit {
                workflow_id: if args.is_empty() {
                    None
                } else {
                    Some(args.to_string())
                },
            },
            "status" => DiscordCommand::Status,
            "help" => DiscordCommand::Help,
            _ => DiscordCommand::Unknown {
                text: text.to_string(),
            },
        }
    }

    /// Build the list of slash commands for registration.
    pub fn slash_commands() -> Vec<SlashCommand> {
        vec![
            SlashCommand {
                name: "run".to_string(),
                description: "Run a MUR workflow".to_string(),
                options: vec![
                    SlashCommandOption {
                        name: "workflow".to_string(),
                        description: "Workflow name or ID to run".to_string(),
                        option_type: 3, // STRING
                        required: Some(true),
                    },
                    SlashCommandOption {
                        name: "shadow".to_string(),
                        description: "Dry-run mode (no real execution)".to_string(),
                        option_type: 5, // BOOLEAN
                        required: None,
                    },
                ],
            },
            SlashCommand {
                name: "workflows".to_string(),
                description: "List available MUR workflows".to_string(),
                options: vec![],
            },
        ]
    }

    /// Register slash commands with Discord for a guild (or globally).
    pub async fn register_slash_commands(&self, guild_id: Option<&str>) -> Result<()> {
        let commands = Self::slash_commands();

        let path = match guild_id {
            Some(gid) => format!(
                "/applications/{}/guilds/{}/commands",
                self.config.application_id, gid
            ),
            None => format!("/applications/{}/commands", self.config.application_id),
        };

        self.api_request(
            reqwest::Method::PUT,
            &path,
            Some(serde_json::to_value(&commands)?),
        )
        .await?;

        tracing::info!(
            "Registered {} slash commands (guild={:?})",
            commands.len(),
            guild_id
        );
        Ok(())
    }

    /// Interpret a reaction emoji as an approval decision.
    pub fn parse_approval_reaction(emoji: &str) -> ApprovalReaction {
        match emoji {
            "\u{1f44d}" | "thumbsup" => ApprovalReaction::Approved,
            "\u{1f44e}" | "thumbsdown" => ApprovalReaction::Denied,
            "white_check_mark" | "\u{2705}" => ApprovalReaction::Approved,
            "x" | "\u{274c}" => ApprovalReaction::Denied,
            _ => ApprovalReaction::Unknown,
        }
    }

    /// Build a Discord embed for an approval request.
    fn approval_embed(request: &ApprovalRequest) -> serde_json::Value {
        serde_json::json!({
            "embeds": [{
                "title": "⚠️ Approval Required",
                "color": 16753920,  // Orange
                "fields": [
                    {
                        "name": "Step",
                        "value": format!("`{}`", request.step_name),
                        "inline": true
                    },
                    {
                        "name": "Execution",
                        "value": format!("`{}`", request.execution_id),
                        "inline": true
                    },
                    {
                        "name": "Description",
                        "value": &request.description,
                        "inline": false
                    },
                    {
                        "name": "Command",
                        "value": format!("`{}`", request.action),
                        "inline": false
                    }
                ],
                "footer": {
                    "text": "React with 👍 to approve or 👎 to deny"
                }
            }]
        })
    }
}

impl ChatPlatform for DiscordBot {
    async fn send_message(&self, msg: &OutgoingMessage) -> Result<String> {
        let mut body = serde_json::json!({
            "content": msg.text,
        });

        if let Some(ref blocks) = msg.blocks {
            if let Some(embeds) = blocks.get("embeds") {
                body["embeds"] = embeds.clone();
            }
        }

        // If thread_id is set, post to the thread channel instead
        let channel_id = msg.thread_id.as_deref().unwrap_or(&msg.channel_id);
        let path = format!("/channels/{}/messages", channel_id);
        let response = self
            .api_request(reqwest::Method::POST, &path, Some(body))
            .await?;

        let msg_response: DiscordMessage =
            serde_json::from_value(response).context("Failed to parse message response")?;

        Ok(msg_response.id)
    }

    async fn send_approval(&self, channel_id: &str, request: &ApprovalRequest) -> Result<String> {
        let embed = Self::approval_embed(request);

        let msg = OutgoingMessage {
            channel_id: channel_id.to_string(),
            text: format!(
                "**Approval Required** for step `{}` — react 👍 to approve, 👎 to deny",
                request.step_name
            ),
            thread_id: None,
            blocks: Some(embed),
        };

        let message_id = self.send_message(&msg).await?;

        // Pre-add reaction emojis to make it easy for users
        let _ = self
            .add_reaction(channel_id, &message_id, "👍")
            .await;
        let _ = self
            .add_reaction(channel_id, &message_id, "👎")
            .await;

        Ok(message_id)
    }

    async fn update_message(&self, channel_id: &str, message_id: &str, text: &str) -> Result<()> {
        let path = format!("/channels/{}/messages/{}", channel_id, message_id);
        self.api_request(
            reqwest::Method::PATCH,
            &path,
            Some(serde_json::json!({ "content": text })),
        )
        .await?;
        Ok(())
    }

    async fn add_reaction(&self, channel_id: &str, message_id: &str, emoji: &str) -> Result<()> {
        // URL-encode the emoji for the API path
        let encoded_emoji = urlencoding::encode(emoji);
        let path = format!(
            "/channels/{}/messages/{}/reactions/{}/@me",
            channel_id, message_id, encoded_emoji
        );
        self.api_request(reqwest::Method::PUT, &path, None).await?;
        Ok(())
    }

    async fn send_progress(
        &self,
        channel_id: &str,
        thread_id: &str,
        progress: &ProgressUpdate,
    ) -> Result<String> {
        let icon = match progress.status {
            ProgressStatus::Started => "🚀",
            ProgressStatus::StepRunning => "⏳",
            ProgressStatus::StepDone => "✅",
            ProgressStatus::StepFailed => "❌",
            ProgressStatus::Completed => "🎉",
            ProgressStatus::Failed => "💥",
        };

        let duration = progress
            .duration_ms
            .map(|ms| format!(" ({}ms)", ms))
            .unwrap_or_default();

        let text = format!(
            "{} [{}/{}] `{}`{}",
            icon,
            progress.step_index + 1,
            progress.total_steps,
            progress.step_name,
            duration
        );

        let msg = OutgoingMessage {
            channel_id: channel_id.to_string(),
            text,
            thread_id: Some(thread_id.to_string()),
            blocks: None,
        };

        self.send_message(&msg).await
    }

    async fn send_notification(
        &self,
        channel_id: &str,
        thread_id: Option<&str>,
        notification: &WorkflowNotification,
    ) -> Result<String> {
        let (emoji, title) = if notification.success {
            ("✅", "Workflow Completed")
        } else {
            ("❌", "Workflow Failed")
        };

        let error_line = notification
            .error
            .as_ref()
            .map(|e| format!("\nError: `{}`", e))
            .unwrap_or_default();

        let text = format!(
            "{} **{}**\nWorkflow: `{}`\nSteps: {}/{}\nDuration: {}ms{}",
            emoji,
            title,
            notification.workflow_id,
            notification.steps_completed,
            notification.total_steps,
            notification.duration_ms,
            error_line,
        );

        let embed = serde_json::json!({
            "embeds": [{
                "title": format!("{} {}", emoji, title),
                "color": if notification.success { 5763719 } else { 15548997 },
                "description": format!(
                    "Workflow: `{}`\nSteps: {}/{}\nDuration: {}ms{}",
                    notification.workflow_id,
                    notification.steps_completed,
                    notification.total_steps,
                    notification.duration_ms,
                    error_line,
                )
            }]
        });

        let msg = OutgoingMessage {
            channel_id: channel_id.to_string(),
            text,
            thread_id: thread_id.map(String::from),
            blocks: Some(embed),
        };

        self.send_message(&msg).await
    }

    async fn start_thread(
        &self,
        channel_id: &str,
        execution_id: &str,
        workflow_id: &str,
        total_steps: usize,
        shadow: bool,
    ) -> Result<String> {
        let mode = if shadow { "Shadow" } else { "Live" };

        // First send a message to get a message ID
        let msg = OutgoingMessage {
            channel_id: channel_id.to_string(),
            text: format!(
                "{} Running: `{}` ({} steps)\nExecution: `{}`",
                if shadow { "\u{1f47b}" } else { "\u{25b6}\u{fe0f}" },
                workflow_id,
                total_steps,
                execution_id
            ),
            thread_id: None,
            blocks: None,
        };
        let message_id = self.send_message(&msg).await?;

        // Create a thread from the message
        let path = format!("/channels/{}/messages/{}/threads", channel_id, message_id);
        let thread_body = serde_json::json!({
            "name": format!("{} {} ({})", mode, workflow_id, &execution_id[..8.min(execution_id.len())]),
            "auto_archive_duration": 1440,
        });

        let response = self
            .api_request(reqwest::Method::POST, &path, Some(thread_body))
            .await?;
        let thread_id = response
            .get("id")
            .and_then(|v| v.as_str())
            .unwrap_or(&message_id)
            .to_string();

        Ok(thread_id)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_discord_config_fields() {
        let config = DiscordConfig {
            bot_token: "test-token".into(),
            application_id: "123456".into(),
            default_channel_id: Some("789".into()),
            command_prefix: "!".into(),
        };
        assert_eq!(config.bot_token, "test-token");
        assert_eq!(config.application_id, "123456");
    }

    #[test]
    fn test_parse_run_command() {
        let cmd = DiscordBot::parse_command_with_prefix("!run deploy --shadow", "!");
        assert_eq!(
            cmd,
            DiscordCommand::Run {
                workflow: "deploy".into(),
                shadow: true,
                variables: HashMap::new(),
            }
        );
    }

    #[test]
    fn test_parse_run_with_vars() {
        let cmd = DiscordBot::parse_command_with_prefix("!run deploy --var=env=prod", "!");
        match cmd {
            DiscordCommand::Run {
                workflow,
                shadow,
                variables,
            } => {
                assert_eq!(workflow, "deploy");
                assert!(!shadow);
                assert_eq!(variables.get("env").unwrap(), "prod");
            }
            _ => panic!("Expected Run command"),
        }
    }

    #[test]
    fn test_parse_workflows_command() {
        assert_eq!(
            DiscordBot::parse_command_with_prefix("!workflows", "!"),
            DiscordCommand::Workflows
        );
        assert_eq!(
            DiscordBot::parse_command_with_prefix("!wf", "!"),
            DiscordCommand::Workflows
        );
    }

    #[test]
    fn test_parse_audit_command() {
        assert_eq!(
            DiscordBot::parse_command_with_prefix("!audit", "!"),
            DiscordCommand::Audit { workflow_id: None }
        );
        assert_eq!(
            DiscordBot::parse_command_with_prefix("!audit my-workflow", "!"),
            DiscordCommand::Audit {
                workflow_id: Some("my-workflow".into())
            }
        );
    }

    #[test]
    fn test_parse_status_command() {
        assert_eq!(
            DiscordBot::parse_command_with_prefix("!status", "!"),
            DiscordCommand::Status
        );
    }

    #[test]
    fn test_parse_help_command() {
        assert_eq!(
            DiscordBot::parse_command_with_prefix("!help", "!"),
            DiscordCommand::Help
        );
    }

    #[test]
    fn test_parse_unknown_command() {
        let cmd = DiscordBot::parse_command_with_prefix("!foobar", "!");
        assert!(matches!(cmd, DiscordCommand::Unknown { .. }));
    }

    #[test]
    fn test_parse_no_prefix() {
        let cmd = DiscordBot::parse_command_with_prefix("hello world", "!");
        assert!(matches!(cmd, DiscordCommand::Unknown { .. }));
    }

    #[test]
    fn test_parse_custom_prefix() {
        let cmd = DiscordBot::parse_command_with_prefix("$run deploy", "$");
        assert_eq!(
            cmd,
            DiscordCommand::Run {
                workflow: "deploy".into(),
                shadow: false,
                variables: HashMap::new(),
            }
        );
    }

    #[test]
    fn test_approval_reaction_parsing() {
        assert_eq!(
            DiscordBot::parse_approval_reaction("👍"),
            ApprovalReaction::Approved
        );
        assert_eq!(
            DiscordBot::parse_approval_reaction("thumbsup"),
            ApprovalReaction::Approved
        );
        assert_eq!(
            DiscordBot::parse_approval_reaction("👎"),
            ApprovalReaction::Denied
        );
        assert_eq!(
            DiscordBot::parse_approval_reaction("thumbsdown"),
            ApprovalReaction::Denied
        );
        assert_eq!(
            DiscordBot::parse_approval_reaction("✅"),
            ApprovalReaction::Approved
        );
        assert_eq!(
            DiscordBot::parse_approval_reaction("❌"),
            ApprovalReaction::Denied
        );
        assert_eq!(
            DiscordBot::parse_approval_reaction("fire"),
            ApprovalReaction::Unknown
        );
    }

    #[test]
    fn test_slash_commands() {
        let commands = DiscordBot::slash_commands();
        assert_eq!(commands.len(), 2);
        assert_eq!(commands[0].name, "run");
        assert_eq!(commands[1].name, "workflows");
        assert_eq!(commands[0].options.len(), 2);
        assert_eq!(commands[0].options[0].name, "workflow");
    }

    #[test]
    fn test_approval_embed() {
        let request = ApprovalRequest {
            execution_id: "exec-123".into(),
            step_name: "deploy".into(),
            description: "Deploy to production".into(),
            action: "docker compose up -d".into(),
            allowed_approvers: Vec::new(),
        };
        let embed = DiscordBot::approval_embed(&request);
        let embeds = embed["embeds"].as_array().unwrap();
        assert_eq!(embeds.len(), 1);
        assert_eq!(embeds[0]["title"], "⚠️ Approval Required");
        assert_eq!(embeds[0]["fields"].as_array().unwrap().len(), 4);
    }
}