mur_chat/

telegram.rs

//! Telegram bot integration — Bot API, command handling, inline keyboards.

use crate::platform::{
    ApprovalRequest, ChatPlatform, OutgoingMessage, ProgressStatus, ProgressUpdate,
    WorkflowNotification,
};
use anyhow::{Context, Result};
use serde::Deserialize;
use tracing::warn;

/// Telegram bot configuration.
#[derive(Debug, Clone)]
pub struct TelegramConfig {
    /// Bot token from @BotFather.
    pub bot_token: String,
    /// Default chat ID for notifications.
    pub default_chat_id: Option<String>,
}

impl TelegramConfig {
    /// Create from environment variables.
    pub fn from_env() -> Result<Self> {
        let bot_token =
            std::env::var("TELEGRAM_BOT_TOKEN").context("TELEGRAM_BOT_TOKEN not set")?;
        let default_chat_id = std::env::var("TELEGRAM_CHAT_ID").ok();

        Ok(Self {
            bot_token,
            default_chat_id,
        })
    }
}

/// Telegram bot client.
pub struct TelegramBot {
    config: TelegramConfig,
    client: reqwest::Client,
}

/// Telegram API response wrapper.
#[derive(Deserialize)]
struct TelegramResponse {
    ok: bool,
    #[serde(default)]
    description: Option<String>,
    result: Option<serde_json::Value>,
}

/// Parsed Telegram command from user message.
///
/// NOTE: This enum is nearly identical to `DiscordCommand` and `ChatCommand`.
/// A shared command enum should be considered to reduce duplication.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TelegramCommand {
    /// /run <workflow> [--shadow] [--var key=value]
    Run {
        workflow: String,
        shadow: bool,
        variables: std::collections::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 },
}

impl TelegramBot {
    pub fn new(config: TelegramConfig) -> 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()),
        }
    }

    /// Build the API URL for a given method.
    ///
    /// SECURITY: The bot token is embedded in the URL path. This is required by
    /// the Telegram Bot API design. Tracing/logging MUST NEVER log the full URL
    /// returned by this method, as it would expose the bot token.
    fn api_url(&self, method: &str) -> String {
        format!(
            "https://api.telegram.org/bot{}/{}",
            self.config.bot_token, method
        )
    }

    /// Call a Telegram Bot API method.
    async fn api_call(
        &self,
        method: &str,
        body: serde_json::Value,
    ) -> Result<TelegramResponse> {
        let url = self.api_url(method);
        let response = self
            .client
            .post(&url)
            .json(&body)
            .send()
            .await
            .context("Telegram API request failed")?;

        let api_response: TelegramResponse = response.json().await?;
        if !api_response.ok {
            anyhow::bail!(
                "Telegram API error: {}",
                api_response.description.unwrap_or_default()
            );
        }
        Ok(api_response)
    }

    /// Parse a Telegram command from message text.
    pub fn parse_command(text: &str) -> TelegramCommand {
        let text = text.trim();

        // Strip @bot_name suffix from commands (e.g. /run@mybot)
        let parts: Vec<&str> = text.splitn(2, ' ').collect();
        let cmd = parts[0].split('@').next().unwrap_or(parts[0]);
        let args = parts.get(1).unwrap_or(&"").trim();

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

                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() {
                    TelegramCommand::Unknown {
                        text: text.to_string(),
                    }
                } else {
                    TelegramCommand::Run {
                        workflow,
                        shadow,
                        variables,
                    }
                }
            }
            "/workflows" | "/wf" => TelegramCommand::Workflows,
            "/audit" => TelegramCommand::Audit {
                workflow_id: if args.is_empty() {
                    None
                } else {
                    Some(args.to_string())
                },
            },
            "/status" => TelegramCommand::Status,
            "/help" | "/start" => TelegramCommand::Help,
            _ => TelegramCommand::Unknown {
                text: text.to_string(),
            },
        }
    }

    /// Build inline keyboard markup JSON for approval buttons.
    fn approval_keyboard(execution_id: &str) -> serde_json::Value {
        serde_json::json!({
            "inline_keyboard": [[
                {
                    "text": "Approve",
                    "callback_data": format!("approve:{}", execution_id)
                },
                {
                    "text": "Deny",
                    "callback_data": format!("deny:{}", execution_id)
                }
            ]]
        })
    }
}

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

        if let Some(ref thread) = msg.thread_id {
            if let Ok(msg_id) = thread.parse::<i64>() {
                body["reply_to_message_id"] = serde_json::json!(msg_id);
            }
        }

        if let Some(ref blocks) = msg.blocks {
            // Use blocks as reply_markup (inline keyboards)
            body["reply_markup"] = blocks.clone();
        }

        let response = self.api_call("sendMessage", body).await?;

        // Extract message_id from result
        let message_id = response
            .result
            .as_ref()
            .and_then(|r| r.get("message_id"))
            .and_then(|id| id.as_i64())
            .map(|id| id.to_string())
            .unwrap_or_default();

        Ok(message_id)
    }

    async fn send_approval(&self, channel_id: &str, request: &ApprovalRequest) -> Result<String> {
        let text = format!(
            "*Approval Required*\n\nStep: `{}`\n{}\n\nCommand: `{}`",
            request.step_name, request.description, request.action
        );

        let keyboard = Self::approval_keyboard(&request.execution_id);

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

        self.send_message(&msg).await
    }

    async fn update_message(&self, channel_id: &str, message_id: &str, text: &str) -> Result<()> {
        let parsed_msg_id = message_id.parse::<i64>().unwrap_or_else(|e| {
            warn!(
                message_id = message_id,
                error = %e,
                "Failed to parse Telegram message_id as i64, defaulting to 0"
            );
            0
        });
        self.api_call(
            "editMessageText",
            serde_json::json!({
                "chat_id": channel_id,
                "message_id": parsed_msg_id,
                "text": text,
                "parse_mode": "Markdown",
            }),
        )
        .await?;
        Ok(())
    }

    async fn add_reaction(&self, channel_id: &str, message_id: &str, emoji: &str) -> Result<()> {
        let parsed_msg_id = message_id.parse::<i64>().unwrap_or_else(|e| {
            warn!(
                message_id = message_id,
                error = %e,
                "Failed to parse Telegram message_id as i64, defaulting to 0"
            );
            0
        });
        // Telegram uses setMessageReaction API
        self.api_call(
            "setMessageReaction",
            serde_json::json!({
                "chat_id": channel_id,
                "message_id": parsed_msg_id,
                "reaction": [{
                    "type": "emoji",
                    "emoji": emoji
                }]
            }),
        )
        .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 msg = OutgoingMessage {
            channel_id: channel_id.to_string(),
            text,
            thread_id: thread_id.map(String::from),
            blocks: None,
        };

        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" };
        let text = format!(
            "{} Running: `{}` ({} steps)\nExecution: `{}`",
            mode, workflow_id, total_steps, execution_id
        );

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

        self.send_message(&msg).await
    }
}

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

    #[test]
    fn test_telegram_config_fields() {
        let config = TelegramConfig {
            bot_token: "123456:ABC-DEF".into(),
            default_chat_id: Some("12345".into()),
        };
        assert_eq!(config.bot_token, "123456:ABC-DEF");
    }

    #[test]
    fn test_parse_run_command() {
        let cmd = TelegramBot::parse_command("/run deploy --shadow");
        assert_eq!(
            cmd,
            TelegramCommand::Run {
                workflow: "deploy".into(),
                shadow: true,
                variables: std::collections::HashMap::new(),
            }
        );
    }

    #[test]
    fn test_parse_run_with_vars() {
        let cmd = TelegramBot::parse_command("/run deploy --var=env=prod");
        match cmd {
            TelegramCommand::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!(
            TelegramBot::parse_command("/workflows"),
            TelegramCommand::Workflows
        );
        assert_eq!(
            TelegramBot::parse_command("/wf"),
            TelegramCommand::Workflows
        );
    }

    #[test]
    fn test_parse_audit_command() {
        assert_eq!(
            TelegramBot::parse_command("/audit"),
            TelegramCommand::Audit { workflow_id: None }
        );
        assert_eq!(
            TelegramBot::parse_command("/audit my-workflow"),
            TelegramCommand::Audit {
                workflow_id: Some("my-workflow".into())
            }
        );
    }

    #[test]
    fn test_parse_status_command() {
        assert_eq!(
            TelegramBot::parse_command("/status"),
            TelegramCommand::Status
        );
    }

    #[test]
    fn test_parse_help_command() {
        assert_eq!(TelegramBot::parse_command("/help"), TelegramCommand::Help);
        assert_eq!(TelegramBot::parse_command("/start"), TelegramCommand::Help);
    }

    #[test]
    fn test_parse_unknown_command() {
        let cmd = TelegramBot::parse_command("/unknown");
        assert!(matches!(cmd, TelegramCommand::Unknown { .. }));
    }

    #[test]
    fn test_parse_command_with_bot_name() {
        let cmd = TelegramBot::parse_command("/run@mybot deploy");
        assert_eq!(
            cmd,
            TelegramCommand::Run {
                workflow: "deploy".into(),
                shadow: false,
                variables: std::collections::HashMap::new(),
            }
        );
    }

    #[test]
    fn test_approval_keyboard() {
        let keyboard = TelegramBot::approval_keyboard("exec-123");
        let buttons = keyboard["inline_keyboard"][0].as_array().unwrap();
        assert_eq!(buttons.len(), 2);
        assert_eq!(buttons[0]["text"], "Approve");
        assert_eq!(buttons[0]["callback_data"], "approve:exec-123");
        assert_eq!(buttons[1]["text"], "Deny");
        assert_eq!(buttons[1]["callback_data"], "deny:exec-123");
    }
}