// src/channels/traits.rs
#[async_trait]
pub trait Channel: Send + Sync + std::fmt::Debug {
    /// 渠道名称
    fn name(&self) -> &str;
    
    /// 发送消息
    async fn send(&self, message: OutgoingMessage) -> Result<(), ChannelError>;
    
    /// 开始监听消息
    async fn listen(&self, handler: MessageHandler) -> Result<(), ChannelError>;
    
    /// 健康检查
    async fn health_check(&self) -> HealthStatus;
    
    /// 发送"正在输入"状态（可选）
    async fn set_typing(&self, chat_id: &str) -> Result<(), ChannelError> {
        Ok(()) // 默认空实现
    }
}

/// 标准化消息格式
#[derive(Debug, Clone)]
pub struct IncomingMessage {
    pub id: String,
    pub text: String,
    pub sender: UserInfo,
    pub chat: ChatInfo,
    pub timestamp: DateTime<Utc>,
    pub attachments: Vec<Attachment>,
    pub reply_to: Option<String>,
    pub raw: serde_json::Value,  // 原始平台数据
}

pub struct OutgoingMessage {
    pub text: String,
    pub chat_id: String,
    pub reply_to: Option<String>,
    pub attachments: Vec<OutgoingAttachment>,
}

pub type MessageHandler = Box<dyn Fn(IncomingMessage) -> BoxFuture<'static, Result<()>> + Send + Sync>;

// src/channels/mod.rs
pub struct ChannelManager {
    channels: Arc<RwLock<HashMap<String, Box<dyn Channel>>>>,
    message_tx: mpsc::Sender<(String, IncomingMessage)>,
    config: ChannelsConfig,
}

impl ChannelManager {
    pub async fn register(&mut self, name: &str, channel: Box<dyn Channel>) {
        let mut channels = self.channels.write().await;
        
        // 启动监听
        let tx = self.message_tx.clone();
        let channel_name = name.to_string();
        
        tokio::spawn(async move {
            let handler = Box::new(move |msg: IncomingMessage| {
                let tx = tx.clone();
                let name = channel_name.clone();
                
                async move {
                    tx.send((name, msg)).await
                        .map_err(|e| Error::Channel(e.to_string()))
                }.boxed()
            }) as MessageHandler;
            
            if let Err(e) = channel.listen(handler).await {
                error!("Channel {} 监听出错: {}", name, e);
            }
        });
        
        channels.insert(name.to_string(), channel);
    }
    
    /// 发送消息到指定渠道
    pub async fn send(
        &self,
        channel_name: &str,
        message: OutgoingMessage,
    ) -> Result<()> {
        let channels = self.channels.read().await;
        
        let channel = channels.get(channel_name)
            .ok_or_else(|| Error::ChannelNotFound(channel_name.into()))?;
            
        channel.send(message).await
    }
    
    /// 广播消息到所有渠道
    pub async fn broadcast(&self, message: OutgoingMessage) {
        let channels = self.channels.read().await;
        
        for (name, channel) in channels.iter() {
            if let Err(e) = channel.send(message.clone()).await {
                error!("发送到 {} 失败: {}", name, e);
            }
        }
    }
}

// src/channels/router.rs
pub struct MessageRouter {
    worker_pool: Arc<Semaphore>,
    message_rx: mpsc::Receiver<(String, IncomingMessage)>,
    agent: Arc<Agent>,
}

impl MessageRouter {
    pub async fn run(mut self) {
        while let Some((channel_name, message)) = self.message_rx.recv().await {
            // 获取信号量许可，限制并发
            let permit = match self.worker_pool.clone().try_acquire_owned() {
                Ok(p) => p,
                Err(_) => {
                    // 资源不足，发送繁忙提示
                    warn!("工作池已满，拒绝新消息");
                    continue;
                }
            };
            
            let agent = self.agent.clone();
            
            tokio::spawn(async move {
                let _permit = permit;
                
                // 白名单检查
                if !Self::check_allowlist(&channel_name, &message).await {
                    return;
                }
                
                // 处理消息
                if let Err(e) = agent.process(message).await {
                    error!("消息处理失败: {}", e);
                }
            });
        }
    }
    
    async fn check_allowlist(channel: &str, message: &IncomingMessage) -> bool {
        // 检查用户是否在白名单中
        // 具体实现...
        true
    }
}

// src/channels/telegram.rs
pub struct TelegramChannel {
    bot: Bot,
    config: TelegramConfig,
}

#[async_trait]
impl Channel for TelegramChannel {
    fn name(&self) -> &str {
        "telegram"
    }
    
    async fn listen(&self, handler: MessageHandler) -> Result<(), ChannelError> {
        let mut stream = self.bot.get_updates().await;
        
        while let Some(update) = stream.next().await {
            if let Some(message) = update.message {
                // 转换为标准格式
                let standard_msg = self.convert_message(message).await?;
                
                // 调用处理器
                if let Err(e) = handler(standard_msg).await {
                    error!("处理 Telegram 消息失败: {}", e);
                }
            }
        }
        
        Ok(())
    }
    
    async fn send(&self, message: OutgoingMessage) -> Result<(), ChannelError> {
        // 解析媒体标记
        let (text, media) = self.parse_media_tags(&message.text);
        
        match media {
            Some(Media::Photo(path)) => {
                self.bot.send_photo(
                    ChatId(message.chat_id.parse::<i64>()?),
                    InputFile::file(path),
                ).caption(text).await?;
            }
            Some(Media::Document(path)) => {
                self.bot.send_document(
                    ChatId(message.chat_id.parse::<i64>()?),
                    InputFile::file(path),
                ).caption(text).await?;
            }
            None => {
                self.bot.send_message(
                    ChatId(message.chat_id.parse::<i64>()?),
                    text,
                ).await?;
            }
        }
        
        Ok(())
    }
}

impl TelegramChannel {
    async fn convert_message(&self, msg: Message) -> Result<IncomingMessage> {
        Ok(IncomingMessage {
            id: msg.id.to_string(),
            text: msg.text().unwrap_or("").to_string(),
            sender: UserInfo {
                id: msg.from.as_ref().map(|u| u.id.to_string()).unwrap_or_default(),
                name: msg.from.as_ref().map(|u| u.username.clone()).flatten(),
            },
            chat: ChatInfo {
                id: msg.chat.id.to_string(),
                type_: match msg.chat.kind {
                    ChatKind::Public(_) => ChatType::Group,
                    ChatKind::Private(_) => ChatType::Private,
                },
            },
            timestamp: msg.date,
            attachments: vec![],
            reply_to: msg.reply_to_message.map(|m| m.id.to_string()),
            raw: serde_json::to_value(msg)?,
        })
    }
    
    /// 解析媒体标记，如 [IMAGE:/path/to/img.png]
    fn parse_media_tags(&self, text: &str) -> (String, Option<Media>) {
        let re = regex::Regex::new(r"\[(IMAGE|DOCUMENT|VIDEO):([^\]]+)\]").unwrap();
        
        let mut clean_text = text.to_string();
        let mut media = None;
        
        for cap in re.captures_iter(text) {
            let media_type = &cap[1];
            let path = &cap[2];
            
            media = Some(match media_type {
                "IMAGE" => Media::Photo(path.into()),
                "DOCUMENT" => Media::Document(path.into()),
                "VIDEO" => Media::Video(path.into()),
                _ => continue,
            });
            
            // 从文本中移除标记
            clean_text = clean_text.replace(&cap[0], "");
        }
        
        (clean_text.trim().to_string(), media)
    }
}

impl TelegramChannel {
    async fn check_allowlist(&self, user_id: &str) -> Result<bool> {
        let allowed = &self.config.allowed_users;
        
        // 空列表 = 拒绝所有
        if allowed.is_empty() {
            return Ok(false);
        }
        
        // 通配符 = 允许所有
        if allowed.contains(&"*".to_string()) {
            return Ok(true);
        }
        
        Ok(allowed.contains(&user_id.to_string()))
    }
    
    async fn send_unauthorized_message(&self, chat_id: ChatId, user_id: &str) {
        let msg = format!(
            "⚠️ 未授权访问\n\n\
            您的用户 ID: {}\n\
            请联系管理员将此 ID 添加到白名单。\n\n\
            管理员可以运行：\n\
            zeroclaw channel bind-telegram {}",
            user_id, user_id
        );
        
        let _ = self.bot.send_message(chat_id, msg).await;
    }
}

// src/channels/discord.rs
use serenity::{Client, model::gateway::Ready, prelude::*};

pub struct DiscordChannel {
    client: Client,
    config: DiscordConfig,
}

#[async_trait]
impl EventHandler for DiscordHandler {
    async fn message(&self, ctx: Context, msg: Message) {
        // 忽略机器人自己的消息
        if msg.author.bot {
            return;
        }
        
        // 检查是否需要响应
        if !self.should_respond(&msg) {
            return;
        }
        
        // 转换为标准格式
        let standard_msg = self.convert_message(msg).await;
        
        // 设置 typing 状态
        let _ = msg.channel_id.broadcast_typing(&ctx.http).await;
        
        // 调用处理器（通过 channel 发送）
        if let Some(ref tx) = self.message_tx {
            let _ = tx.send(("discord".into(), standard_msg)).await;
        }
    }
    
    async fn ready(&self, _: Context, ready: Ready) {
        info!("Discord 连接就绪: {}", ready.user.name);
    }
}

impl DiscordChannel {
    fn should_respond(&self, msg: &Message) -> bool {
        // 1. 私信总是响应
        if msg.guild_id.is_none() {
            return true;
        }
        
        // 2. @提及响应
        if msg.mentions.iter().any(|u| u.id == self.bot_id) {
            return true;
        }
        
        // 3. 命令前缀响应
        if let Some(ref prefix) = self.config.command_prefix {
            if msg.content.starts_with(prefix) {
                return true;
            }
        }
        
        false
    }
}

use serenity::builder::CreateApplicationCommand;

pub fn register_commands(
    commands: &mut CreateApplicationCommand,
) -> &mut CreateApplicationCommand {
    commands
        .name("ask")
        .description("向 AI 提问")
        .create_option(|option| {
            option
                .name("question")
                .description("你的问题")
                .kind(CommandOptionType::String)
                .required(true)
        })
}

async fn handle_slash_command(
    ctx: &Context,
    command: &ApplicationCommandInteraction,
) {
    match command.data.name.as_str() {
        "ask" => {
            let question = command
                .data.options
                .get(0)
                .and_then(|opt| opt.value.as_ref())
                .and_then(|v| v.as_str())
                .unwrap_or("");
                
            // 先响应"正在思考"
            command
                .create_interaction_response(&ctx.http, |response| {
                    response
                        .kind(InteractionResponseType::DeferredChannelMessageWithSource)
                })
                .await
                .unwrap();
                
            // 调用 AI（异步）
            let answer = call_ai(question).await;
            
            // 编辑响应
            command
                .edit_original_interaction_response(&ctx.http, |response| {
                    response.content(answer)
                })
                .await
                .unwrap();
        }
        _ => {}
    }
}

// src/channels/slack.rs
pub struct SlackChannel {
    client: SlackClient,
    config: SlackConfig,
}

#[async_trait]
impl Channel for SlackChannel {
    async fn listen(&self, handler: MessageHandler) -> Result<(), ChannelError> {
        // Slack 使用 HTTP Webhook，不需要长连接
        // 消息通过 Gateway 接收
        Ok(())
    }
}

/// Slack 事件处理器（在 Gateway 中调用）
pub async fn handle_slack_event(
    State(state): State<AppState>,
    headers: HeaderMap,
    Json(body): Json<SlackEvent>,
) -> Result<impl IntoResponse, StatusCode> {
    // 1. 验证签名
    if !verify_slack_signature(&headers, &body, &state.config.signing_secret) {
        return Err(StatusCode::UNAUTHORIZED);
    }
    
    match body {
        SlackEvent::UrlVerification { challenge } => {
            // 配置验证
            Ok((StatusCode::OK, challenge).into_response())
        }
        
        SlackEvent::EventCallback { event } => {
            match event {
                SlackInnerEvent::AppMention { text, user, channel } => {
                    let msg = IncomingMessage {
                        id: uuid::Uuid::new_v4().to_string(),
                        text,
                        sender: UserInfo { id: user, name: None },
                        chat: ChatInfo { id: channel, type_: ChatType::Group },
                        timestamp: Utc::now(),
                        attachments: vec![],
                        reply_to: None,
                        raw: serde_json::to_value(&event).unwrap(),
                    };
                    
                    // 发送到处理器
                    state.channel_tx.send(("slack".into(), msg)).await
                        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
                }
                
                SlackInnerEvent::Message { text, user, channel, .. } => {
                    // 处理私信
                    // ...
                }
                
                _ => {}
            }
            
            Ok(StatusCode::OK.into_response())
        }
        
        _ => Ok(StatusCode::OK.into_response()),
    }
}

fn verify_slack_signature(
    headers: &HeaderMap,
    body: &str,
    signing_secret: &str,
) -> bool {
    let timestamp = headers
        .get("x-slack-request-timestamp")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("");
        
    let signature = headers
        .get("x-slack-signature")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("");
        
    // 检查时间戳（5分钟内）
    let now = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_secs();
        
    if let Ok(ts) = timestamp.parse::<u64>() {
        if now - ts > 300 {
            return false;
        }
    }
    
    // 计算签名
    let base_string = format!("v0:{}:{}", timestamp, body);
    let mut mac = HmacSha256::new_from_slice(signing_secret.as_bytes()).unwrap();
    mac.update(base_string.as_bytes());
    let computed = format!("v0={}", hex::encode(mac.finalize().into_bytes()));
    
    // 比较签名
    signature == computed
}

# Telegram 配置
[channels_config.telegram]
bot_token = "${TELEGRAM_BOT_TOKEN}"
allowed_users = ["your_telegram_user_id"]
polling_interval = 30

# Discord 配置
[channels_config.discord]
bot_token = "${DISCORD_BOT_TOKEN}"
allowed_users = ["your_discord_user_id"]
command_prefix = "!ai"

# Slack 配置
[channels_config.slack]
bot_token = "xoxb-your-bot-token"
app_token = "xapp-your-app-token"
signing_secret = "your-signing-secret"
allowed_users = ["U12345678"]

# WhatsApp 配置
[channels_config.whatsapp]
access_token = "EAAB..."
phone_number_id = "123456789012345"
verify_token = "your-verify-token"
allowed_numbers = ["+1234567890"]

# Matrix 配置
[channels_config.matrix]
homeserver = "https://matrix.org"
username = "@bot:matrix.org"
password = "${MATRIX_PASSWORD}"
allowed_users = ["@you:matrix.org"]

// 运行时添加新渠道
async fn add_channel(
    manager: &mut ChannelManager,
    config: ChannelConfig,
) -> Result<()> {
    match config.type_.as_str() {
        "telegram" => {
            let channel = TelegramChannel::new(config).await?;
            manager.register("telegram", Box::new(channel)).await;
        }
        "discord" => {
            let channel = DiscordChannel::new(config).await?;
            manager.register("discord", Box::new(channel)).await;
        }
        // ...
        _ => bail!("未知渠道类型"),
    }
    
    Ok(())
}