postfix-log-parser 0.2.0

//! 重构组件示例
//!
//! 展示如何使用BaseLogEntry统一日志基础结构，实现组件间的公共字段复用

use postfix_log_parser::events::base_log::{BaseLogEntry, ExtendedLogEntry};
use postfix_log_parser::utils::queue_id::extract_queue_id;
use serde::{Deserialize, Serialize};

/// 重构后的SMTP事件类型
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum RefactoredSmtpEvent {
    /// 邮件发送成功事件
    /// 基础字段：queue_id, to_email, relay_info, delay_info, status_info 自动填充
    MessageSent {
        /// 基础日志信息（包含所有公共字段）
        base: BaseLogEntry,
        /// SMTP特定字段：响应代码和消息
        smtp_response: Option<String>,
        /// 是否为TLS连接
        is_tls: bool,
    },

    /// 邮件投递失败事件
    MessageBounced {
        base: BaseLogEntry,
        /// 错误代码
        error_code: Option<String>,
        /// 失败原因
        failure_reason: String,
        /// 是否为永久失败
        is_permanent: bool,
    },

    /// 邮件延迟投递事件
    MessageDeferred {
        base: BaseLogEntry,
        /// 延迟原因
        defer_reason: String,
        /// 下次重试时间
        next_retry: Option<String>,
    },
}

impl ExtendedLogEntry for RefactoredSmtpEvent {
    fn base_entry(&self) -> &BaseLogEntry {
        match self {
            RefactoredSmtpEvent::MessageSent { base, .. } => base,
            RefactoredSmtpEvent::MessageBounced { base, .. } => base,
            RefactoredSmtpEvent::MessageDeferred { base, .. } => base,
        }
    }

    fn component_type(&self) -> &'static str {
        "smtp"
    }

    fn event_type(&self) -> &'static str {
        match self {
            RefactoredSmtpEvent::MessageSent { .. } => "message_sent",
            RefactoredSmtpEvent::MessageBounced { .. } => "message_bounced",
            RefactoredSmtpEvent::MessageDeferred { .. } => "message_deferred",
        }
    }
}

/// 重构后的SMTP解析器
pub struct RefactoredSmtpParser;

impl RefactoredSmtpParser {
    pub fn new() -> Self {
        RefactoredSmtpParser
    }

    /// 解析SMTP日志消息
    /// 先使用BaseLogEntry解析公共字段，再解析组件特定字段
    pub fn parse(&self, message: &str) -> Option<RefactoredSmtpEvent> {
        // 第一步：提取队列ID
        let queue_id = extract_queue_id(message);

        // 第二步：创建基础日志条目（自动解析所有公共字段）
        let base = BaseLogEntry::from_message(message, queue_id);

        // 第三步：根据消息内容判断事件类型并解析特定字段
        if message.contains("status=sent") {
            self.parse_message_sent(base, message)
        } else if message.contains("status=bounced") {
            self.parse_message_bounced(base, message)
        } else if message.contains("status=deferred") {
            self.parse_message_deferred(base, message)
        } else {
            None
        }
    }

    /// 解析发送成功事件（只需解析SMTP特定字段）
    fn parse_message_sent(&self, base: BaseLogEntry, message: &str) -> Option<RefactoredSmtpEvent> {
        // 提取SMTP响应（如果有）
        let smtp_response = if let Some(start) = message.find('(') {
            if let Some(end) = message.rfind(')') {
                if end > start {
                    Some(message[start + 1..end].to_string())
                } else {
                    None
                }
            } else {
                None
            }
        } else {
            None
        };

        // 检查是否为TLS连接
        let is_tls = message.contains("TLS") || message.contains("SSL");

        Some(RefactoredSmtpEvent::MessageSent {
            base,
            smtp_response,
            is_tls,
        })
    }

    /// 解析投递失败事件
    fn parse_message_bounced(
        &self,
        base: BaseLogEntry,
        message: &str,
    ) -> Option<RefactoredSmtpEvent> {
        // 提取失败原因
        let failure_reason = if let Some(start) = message.find('(') {
            if let Some(end) = message.rfind(')') {
                if end > start {
                    message[start + 1..end].to_string()
                } else {
                    "Unknown bounce reason".to_string()
                }
            } else {
                "Unknown bounce reason".to_string()
            }
        } else {
            "Unknown bounce reason".to_string()
        };

        // 从DSN状态码判断是否为永久失败
        let is_permanent = base
            .status_info
            .as_ref()
            .and_then(|status| status.dsn.as_ref())
            .map(|dsn| dsn.starts_with('5'))
            .unwrap_or(false);

        // 提取错误代码
        let error_code = base
            .status_info
            .as_ref()
            .and_then(|status| status.dsn.clone());

        Some(RefactoredSmtpEvent::MessageBounced {
            base,
            error_code,
            failure_reason,
            is_permanent,
        })
    }

    /// 解析延迟投递事件
    fn parse_message_deferred(
        &self,
        base: BaseLogEntry,
        message: &str,
    ) -> Option<RefactoredSmtpEvent> {
        let defer_reason = if let Some(start) = message.find('(') {
            if let Some(end) = message.rfind(')') {
                if end > start {
                    message[start + 1..end].to_string()
                } else {
                    "Unknown defer reason".to_string()
                }
            } else {
                "Unknown defer reason".to_string()
            }
        } else {
            "Unknown defer reason".to_string()
        };

        // TODO: 解析下次重试时间（需要更复杂的逻辑）
        let next_retry = None;

        Some(RefactoredSmtpEvent::MessageDeferred {
            base,
            defer_reason,
            next_retry,
        })
    }
}

fn main() {
    println!("🔄 重构组件示例 - 使用BaseLogEntry统一架构");
    println!("{}", "=".repeat(60));

    let parser = RefactoredSmtpParser::new();

    // 测试数据
    let test_messages = vec![
        "4bG4VR5z: to=<recipient@example.com>, relay=mx.example.com[1.2.3.4]:25, delay=0.5, delays=0.1/0/0.3/0.1, dsn=2.0.0, status=sent (250 2.0.0 OK)",
        "4bG4VR6a: to=<bad@example.com>, relay=mx.example.com[1.2.3.4]:25, delay=1.2, delays=0.1/0/1.0/0.1, dsn=5.1.1, status=bounced (550 5.1.1 User unknown)",
        "4bG4VR7b: to=<temp@example.com>, relay=mx.example.com[1.2.3.4]:25, delay=30, delays=0.1/0/29.8/0.1, dsn=4.4.1, status=deferred (Connection timed out)",
    ];

    for (i, message) in test_messages.iter().enumerate() {
        println!("\n📧 测试消息 {}: {}", i + 1, message);

        if let Some(event) = parser.parse(message) {
            println!("✅ 解析成功:");
            println!("   组件类型: {}", event.component_type());
            println!("   事件类型: {}", event.event_type());

            let base = event.base_entry();
            println!("   队列ID: {:?}", base.queue_id);
            println!("   收件人: {}", base.formatted_to());
            println!("   中继: {}", base.formatted_relay());

            if let Some(delay) = &base.delay_info {
                println!("   总延迟: {:.1}s", delay.total);
                if let Some(breakdown) = delay.breakdown {
                    println!(
                        "   延迟分解: qmgr={:.1}s, conn={:.1}s, net={:.1}s, data={:.1}s",
                        breakdown[0], breakdown[1], breakdown[2], breakdown[3]
                    );
                }
            }

            if let Some(status) = &base.status_info {
                println!("   状态: {} (DSN: {:?})", status.status, status.dsn);
            }

            // 组件特定信息
            match &event {
                RefactoredSmtpEvent::MessageSent {
                    smtp_response,
                    is_tls,
                    ..
                } => {
                    println!("   SMTP响应: {:?}", smtp_response);
                    println!("   TLS连接: {}", is_tls);
                }
                RefactoredSmtpEvent::MessageBounced {
                    error_code,
                    failure_reason,
                    is_permanent,
                    ..
                } => {
                    println!("   错误代码: {:?}", error_code);
                    println!("   失败原因: {}", failure_reason);
                    println!("   永久失败: {}", is_permanent);
                }
                RefactoredSmtpEvent::MessageDeferred {
                    defer_reason,
                    next_retry,
                    ..
                } => {
                    println!("   延迟原因: {}", defer_reason);
                    println!("   下次重试: {:?}", next_retry);
                }
            }
        } else {
            println!("❌ 解析失败");
        }
    }

    // 性能对比示例
    println!("\n🚀 性能优势展示:");
    println!("传统方式：每个组件重复解析 from=<>, to=<>, relay=, delay= 等公共字段");
    println!("重构方式：BaseLogEntry一次解析，所有组件共享，避免重复正则匹配");

    // 代码简化展示
    println!("\n📝 代码简化效果:");
    println!("原SMTP组件: ~150行 (包含重复的字段解析正则)");
    println!("重构SMTP组件: ~80行 (专注于SMTP特定逻辑)");
    println!("代码减少: 47% ⬇️");
}

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

    #[test]
    fn test_refactored_smtp_parsing() {
        let parser = RefactoredSmtpParser::new();

        let sent_message = "4bG4VR5z: to=<recipient@example.com>, relay=mx.example.com[1.2.3.4]:25, delay=0.5, status=sent (250 2.0.0 OK)";
        if let Some(event) = parser.parse(sent_message) {
            assert_eq!(event.component_type(), "smtp");
            assert_eq!(event.event_type(), "message_sent");
            assert_eq!(event.base_entry().queue_id, Some("4bG4VR5z".to_string()));
            assert_eq!(event.base_entry().formatted_to(), "<recipient@example.com>");
        } else {
            panic!("Failed to parse sent message");
        }
    }

    #[test]
    fn test_base_log_entry_reuse() {
        let message = "4bG4VR5z: from=<sender@example.com>, to=<recipient@example.com>, relay=mx.example.com[1.2.3.4]:25, delay=0.5, status=sent";
        let base = BaseLogEntry::from_message(message, None);

        // 基础字段应该正确解析
        assert!(base.from_email.is_some());
        assert!(base.to_email.is_some());
        assert!(base.relay_info.is_some());
        assert!(base.delay_info.is_some());

        // 所有组件都可以复用这个基础解析结果
        assert_eq!(base.formatted_from(), "<sender@example.com>");
        assert_eq!(base.formatted_to(), "<recipient@example.com>");
        assert_eq!(base.formatted_relay(), "mx.example.com[1.2.3.4]:25");
    }
}