foxhunt/trading_engine/tests/compliance_automated_reporting_tests.rs

//! Comprehensive tests for automated reporting compliance module
//!
//! Tests cover:
//! - Scheduled report generation (daily, weekly, monthly, quarterly)
//! - Report delivery mechanisms (email, SFTP, API)
//! - Regulatory deadline tracking (MiFID II, EMIR)
//! - Report template processing
//! - Transaction aggregation and summary generation
//!
//! Total tests: 25
//! Target coverage: 70-75% of automated_reporting.rs

use chrono::{DateTime, Datelike, Duration, NaiveDate, TimeZone, Timelike, Utc};
use cron::Schedule;
use std::collections::HashMap;
use std::str::FromStr;

// Import types from automated_reporting module
use trading_engine::compliance::automated_reporting::{
    AlertCondition, AlertSettings, AuthoritySubmissionSettings, AutomatedReportingConfig,
    AutomatedReportingError, ComparisonOperator, CronJob, EscalationLevel, EscalationSettings,
    GeneratedReport, MonitoringSettings, NotificationChannel, NotificationLevel,
    NotificationSettings, PerformanceThresholds, QualityAssuranceSettings, QualityCheck,
    QualityCheckSeverity, QualityCheckType, ReportSchedule, ReportScheduler, ReportingMetrics,
    RetryPolicy, RetrySettings, ScheduledReportType, SubmissionMethod, SubmissionSettings,
    SubmissionStatus, SubmissionTask, TaskPriority, ValidationResult,
};

use trading_engine::compliance::transaction_reporting::{PeriodType, ReportingPeriod};

// ============================================================================
// SECTION 1: Scheduled Report Generation (9 tests)
// ============================================================================

#[test]
fn test_daily_schedule_cron_parsing() {
    // Test parsing of daily cron expression (6 PM UTC)
    // cron 0.12 uses 6-field format: second minute hour day month weekday
    let cron_expr = "0 0 18 * * *"; // Every day at 18:00:00
    let schedule = Schedule::from_str(cron_expr);

    assert!(
        schedule.is_ok(),
        "Daily cron expression should parse correctly"
    );

    let schedule = schedule.unwrap();
    let now = Utc::now();
    let next = schedule.after(&now).next();

    assert!(
        next.is_some(),
        "Should find next occurrence for daily schedule"
    );

    let next_dt = next.unwrap();
    assert!(next_dt > now, "Next run should be in the future");
    assert!(next_dt.hour() == 18, "Next run should be at 18:00 UTC");
}

#[test]
fn test_weekly_schedule_monday_9am() {
    // Test weekly schedule: Monday at 9 AM
    // cron 0.12 format: second minute hour day month weekday
    let cron_expr = "0 0 9 * * Mon"; // Monday at 09:00:00
    let schedule = Schedule::from_str(cron_expr);

    assert!(
        schedule.is_ok(),
        "Weekly cron expression should parse correctly"
    );

    let schedule = schedule.unwrap();
    let now = Utc::now();
    let next = schedule.after(&now).next();

    assert!(next.is_some(), "Should find next Monday occurrence");

    let next_dt = next.unwrap();
    assert_eq!(
        next_dt.weekday(),
        chrono::Weekday::Mon,
        "Next run should be Monday"
    );
    assert_eq!(next_dt.hour(), 9, "Next run should be at 9 AM");
    assert_eq!(next_dt.minute(), 0, "Minutes should be 0");
}

#[test]
fn test_monthly_schedule_first_day() {
    // Test monthly schedule: First day of month at 10 AM
    // cron 0.12 format: second minute hour day month weekday
    let cron_expr = "0 0 10 1 * *"; // First day of every month at 10:00:00
    let schedule = Schedule::from_str(cron_expr);

    assert!(
        schedule.is_ok(),
        "Monthly cron expression should parse correctly"
    );

    let schedule = schedule.unwrap();
    let now = Utc::now();
    let next = schedule.after(&now).next();

    assert!(next.is_some(), "Should find next first-of-month occurrence");

    let next_dt = next.unwrap();
    assert_eq!(next_dt.day(), 1, "Next run should be on day 1");
    assert_eq!(next_dt.hour(), 10, "Next run should be at 10 AM");
}

#[test]
fn test_quarterly_schedule_first_day() {
    // Test quarterly schedule: First day of quarter (Jan, Apr, Jul, Oct) at 9 AM
    // cron 0.12 format: second minute hour day month weekday
    let cron_expr = "0 0 9 1 1,4,7,10 *"; // First day of Jan/Apr/Jul/Oct at 09:00:00
    let schedule = Schedule::from_str(cron_expr);

    assert!(
        schedule.is_ok(),
        "Quarterly cron expression should parse correctly"
    );

    let schedule = schedule.unwrap();
    let now = Utc::now();
    let next = schedule.after(&now).next();

    assert!(next.is_some(), "Should find next quarterly occurrence");

    let next_dt = next.unwrap();
    assert_eq!(next_dt.day(), 1, "Should be first day of quarter");
    assert!(
        [1, 4, 7, 10].contains(&next_dt.month()),
        "Should be in Jan, Apr, Jul, or Oct"
    );
}

#[tokio::test]
async fn test_schedule_initialization() {
    // Test scheduler initialization with multiple schedules
    let schedules = vec![
        ReportSchedule {
            schedule_id: "daily_test".to_string(),
            name: "Daily Test Report".to_string(),
            report_type: ScheduledReportType::MiFIDTransactionReports,
            cron_expression: "0 0 18 * * *".to_string(), // 6-field format
            timezone: "UTC".to_string(),
            enabled: true,
            target_authorities: vec!["ESMA".to_string()],
            parameters: HashMap::new(),
            quality_checks: vec![],
            notification_recipients: vec!["test@example.com".to_string()],
        },
        ReportSchedule {
            schedule_id: "weekly_test".to_string(),
            name: "Weekly Test Report".to_string(),
            report_type: ScheduledReportType::BestExecutionReports,
            cron_expression: "0 0 9 * * Mon".to_string(), // 6-field format
            timezone: "UTC".to_string(),
            enabled: true,
            target_authorities: vec!["FCA".to_string()],
            parameters: HashMap::new(),
            quality_checks: vec![],
            notification_recipients: vec!["test@example.com".to_string()],
        },
    ];

    let scheduler = ReportScheduler::new(&schedules);
    let result = scheduler.initialize_schedules().await;

    assert!(result.is_ok(), "Scheduler initialization should succeed");
}

#[tokio::test]
async fn test_add_schedule_validation() {
    // Test adding a new schedule with valid cron expression
    let schedules = vec![];
    let scheduler = ReportScheduler::new(&schedules);

    let new_schedule = ReportSchedule {
        schedule_id: "new_schedule".to_string(),
        name: "New Schedule".to_string(),
        report_type: ScheduledReportType::AuditTrailSummary,
        cron_expression: "0 0 12 * * *".to_string(), // 6-field format
        timezone: "UTC".to_string(),
        enabled: true,
        target_authorities: vec!["SEC".to_string()],
        parameters: HashMap::new(),
        quality_checks: vec![],
        notification_recipients: vec!["audit@example.com".to_string()],
    };

    let result = scheduler.add_schedule(new_schedule).await;
    assert!(result.is_ok(), "Adding valid schedule should succeed");
}

#[tokio::test]
async fn test_add_schedule_invalid_cron() {
    // Test adding schedule with invalid cron expression
    let schedules = vec![];
    let scheduler = ReportScheduler::new(&schedules);

    let invalid_schedule = ReportSchedule {
        schedule_id: "invalid_cron".to_string(),
        name: "Invalid Cron".to_string(),
        report_type: ScheduledReportType::RiskManagementReports,
        cron_expression: "invalid cron syntax".to_string(),
        timezone: "UTC".to_string(),
        enabled: true,
        target_authorities: vec!["SEC".to_string()],
        parameters: HashMap::new(),
        quality_checks: vec![],
        notification_recipients: vec![],
    };

    let result = scheduler.add_schedule(invalid_schedule).await;
    assert!(
        result.is_err(),
        "Adding invalid cron expression should fail"
    );

    if let Err(AutomatedReportingError::SchedulingError(msg)) = result {
        assert!(
            msg.contains("Invalid cron expression"),
            "Error should mention invalid cron"
        );
    } else {
        panic!("Expected SchedulingError, got different error type");
    }
}

#[test]
fn test_timezone_handling() {
    // Test cron schedule with specific timezone context
    // Cron library works in UTC, but we validate timezone field exists
    let schedule = ReportSchedule {
        schedule_id: "tz_test".to_string(),
        name: "Timezone Test".to_string(),
        report_type: ScheduledReportType::SOXComplianceAssessment,
        cron_expression: "0 0 9 * * *".to_string(), // 6-field format
        timezone: "America/New_York".to_string(),   // Eastern Time
        enabled: true,
        target_authorities: vec![],
        parameters: HashMap::new(),
        quality_checks: vec![],
        notification_recipients: vec![],
    };

    // Validate timezone field is present
    assert_eq!(schedule.timezone, "America/New_York");
    assert!(Schedule::from_str(&schedule.cron_expression).is_ok());
}

#[test]
fn test_daylight_saving_transition() {
    // Test schedule behavior around DST transition
    // Note: cron library handles UTC, DST transitions are timezone-specific
    let cron_expr = "0 0 2 * * *"; // 2 AM daily (6-field format)
    let schedule = Schedule::from_str(cron_expr).unwrap();

    // Test around March DST transition (spring forward)
    // In UTC, this should work consistently
    let base_date = Utc.with_ymd_and_hms(2025, 3, 9, 0, 0, 0).unwrap(); // Before DST
    let next = schedule.after(&base_date).next().unwrap();

    assert_eq!(next.hour(), 2, "Should still find 2 AM UTC time");
    assert!(next > base_date, "Next run should be after base date");

    // Verify multiple iterations work correctly
    let next2 = schedule.after(&next).next().unwrap();
    assert_eq!(next2.hour(), 2, "Second iteration should also be 2 AM");

    let time_diff = next2 - next;
    assert_eq!(
        time_diff.num_hours(),
        24,
        "Should be exactly 24 hours apart in UTC"
    );
}

// ============================================================================
// SECTION 2: Report Delivery (7 tests)
// ============================================================================

#[test]
fn test_email_delivery_config() {
    // Test email delivery mechanism configuration
    let method = SubmissionMethod::Email {
        recipient: "regulator@authority.com".to_string(),
    };

    match method {
        SubmissionMethod::Email { recipient } => {
            assert_eq!(recipient, "regulator@authority.com");
            assert!(recipient.contains('@'), "Email should contain @ symbol");
            assert!(recipient.contains('.'), "Email should contain domain");
        },
        _ => panic!("Expected Email submission method"),
    }
}

#[test]
fn test_sftp_delivery_config() {
    // Test SFTP delivery mechanism configuration
    let method = SubmissionMethod::SFTP {
        host: "sftp.regulator.com".to_string(),
        path: "/reports/incoming".to_string(),
    };

    match method {
        SubmissionMethod::SFTP { host, path } => {
            assert_eq!(host, "sftp.regulator.com");
            assert_eq!(path, "/reports/incoming");
            assert!(!host.is_empty(), "Host should not be empty");
            assert!(path.starts_with('/'), "Path should be absolute");
        },
        _ => panic!("Expected SFTP submission method"),
    }
}

#[test]
fn test_api_delivery_config() {
    // Test REST API delivery mechanism configuration
    let method = SubmissionMethod::RestApi;

    match method {
        SubmissionMethod::RestApi => {
            // Configuration validated - REST API method
            assert!(true, "REST API submission method configured");
        },
        _ => panic!("Expected RestApi submission method"),
    }
}

#[test]
fn test_delivery_retry_logic() {
    // Test retry policy configuration
    let retry_policy = RetryPolicy {
        max_attempts: 5,
        delay_seconds: 30,
        exponential_backoff: true,
    };

    assert_eq!(retry_policy.max_attempts, 5, "Should allow 5 attempts");
    assert_eq!(
        retry_policy.delay_seconds, 30,
        "Initial delay should be 30s"
    );
    assert!(
        retry_policy.exponential_backoff,
        "Should use exponential backoff"
    );

    // Calculate expected delays with exponential backoff
    let mut delay = retry_policy.delay_seconds as f64;
    let mut total_delay = 0.0;

    for attempt in 1..=retry_policy.max_attempts {
        total_delay += delay;
        if attempt < retry_policy.max_attempts {
            delay *= 2.0; // 2x backoff multiplier
        }
    }

    // Total delay: 30 + 60 + 120 + 240 + 480 = 930 seconds
    assert_eq!(
        total_delay, 930.0,
        "Total retry delay should be 930 seconds"
    );
}

#[test]
fn test_delivery_confirmation_tracking() {
    // Test submission task tracking
    let task = SubmissionTask {
        task_id: "task-001".to_string(),
        schedule_id: "daily_mifid".to_string(),
        report_data: create_test_report(),
        target_authority: "ESMA".to_string(),
        priority: TaskPriority::High,
        scheduled_time: Utc::now(),
        max_attempts: 3,
        current_attempts: 0,
    };

    assert_eq!(task.task_id, "task-001");
    assert_eq!(task.current_attempts, 0, "Initial attempts should be 0");
    assert_eq!(task.max_attempts, 3, "Max attempts configured");
    assert!(
        matches!(task.priority, TaskPriority::High),
        "Priority is High"
    );
}

#[test]
fn test_multiple_delivery_destinations() {
    // Test configuration for multiple authority destinations
    let mut authority_settings = HashMap::new();

    authority_settings.insert(
        "ESMA".to_string(),
        AuthoritySubmissionSettings {
            authority_id: "ESMA".to_string(),
            submission_method: SubmissionMethod::RestApi,
            rate_limit: 100,
            preferred_submission_time: Some("18:00".to_string()),
            retry_policy: None,
        },
    );

    authority_settings.insert(
        "FCA".to_string(),
        AuthoritySubmissionSettings {
            authority_id: "FCA".to_string(),
            submission_method: SubmissionMethod::SFTP {
                host: "fca.sftp.com".to_string(),
                path: "/reports".to_string(),
            },
            rate_limit: 50,
            preferred_submission_time: Some("17:00".to_string()),
            retry_policy: None,
        },
    );

    assert_eq!(
        authority_settings.len(),
        2,
        "Should have 2 authorities configured"
    );
    assert!(
        authority_settings.contains_key("ESMA"),
        "ESMA should be configured"
    );
    assert!(
        authority_settings.contains_key("FCA"),
        "FCA should be configured"
    );

    // Validate different settings per authority
    let esma_settings = &authority_settings["ESMA"];
    let fca_settings = &authority_settings["FCA"];

    assert_eq!(esma_settings.rate_limit, 100, "ESMA rate limit");
    assert_eq!(fca_settings.rate_limit, 50, "FCA rate limit");
    assert!(matches!(
        esma_settings.submission_method,
        SubmissionMethod::RestApi
    ));
    assert!(matches!(
        fca_settings.submission_method,
        SubmissionMethod::SFTP { .. }
    ));
}

#[test]
fn test_notification_channels() {
    // Test notification channel configuration
    let email_channel = NotificationChannel::Email {
        smtp_server: "smtp.example.com".to_string(),
        from_address: "reports@trading.com".to_string(),
    };

    let slack_channel = NotificationChannel::Slack {
        webhook_url: "https://hooks.slack.com/services/XXX".to_string(),
        channel: "#compliance".to_string(),
    };

    match email_channel {
        NotificationChannel::Email {
            smtp_server,
            from_address,
        } => {
            assert_eq!(smtp_server, "smtp.example.com");
            assert!(from_address.contains('@'));
        },
        _ => panic!("Expected Email channel"),
    }

    match slack_channel {
        NotificationChannel::Slack {
            webhook_url,
            channel,
        } => {
            assert!(webhook_url.starts_with("https://"));
            assert!(channel.starts_with('#'));
        },
        _ => panic!("Expected Slack channel"),
    }
}

// ============================================================================
// SECTION 3: Regulatory Deadlines (6 tests)
// ============================================================================

#[test]
fn test_mifid_t_plus_1_deadline() {
    // MiFID II requires T+1 submission (by end of next business day)
    let trade_date = Utc.with_ymd_and_hms(2025, 10, 6, 15, 30, 0).unwrap(); // Monday trade
    let deadline = trade_date + Duration::days(1); // T+1 = Tuesday

    assert!(deadline > trade_date, "Deadline should be after trade date");

    let hours_difference = deadline.signed_duration_since(trade_date).num_hours();
    assert_eq!(
        hours_difference, 24,
        "T+1 should be 24 hours for standard case"
    );
}

#[test]
fn test_emir_t_plus_1_deadline() {
    // EMIR also requires T+1 submission
    let transaction_date = Utc.with_ymd_and_hms(2025, 10, 6, 10, 0, 0).unwrap();
    let deadline = transaction_date + Duration::days(1);

    assert!(
        deadline > transaction_date,
        "EMIR deadline should be after transaction"
    );
    assert_eq!(
        deadline.date_naive(),
        (transaction_date + Duration::days(1)).date_naive(),
        "Should be next calendar day"
    );
}

#[test]
fn test_deadline_warning_notification() {
    // Test deadline warning (e.g., 2 hours before deadline)
    let deadline = Utc.with_ymd_and_hms(2025, 10, 7, 18, 0, 0).unwrap(); // 6 PM deadline
    let warning_threshold = Duration::hours(2);
    let warning_time = deadline - warning_threshold;

    assert_eq!(warning_time.hour(), 16, "Warning should trigger at 4 PM");

    let now = Utc.with_ymd_and_hms(2025, 10, 7, 17, 0, 0).unwrap(); // 5 PM
    let should_warn = now >= warning_time && now < deadline;

    assert!(
        should_warn,
        "Should trigger warning at 5 PM (1 hour before deadline)"
    );
}

#[test]
fn test_overdue_report_alert() {
    // Test overdue report detection
    let deadline = Utc.with_ymd_and_hms(2025, 10, 7, 18, 0, 0).unwrap();
    let current_time = Utc.with_ymd_and_hms(2025, 10, 7, 19, 30, 0).unwrap(); // 1.5 hours late

    let is_overdue = current_time > deadline;
    assert!(is_overdue, "Report should be marked overdue");

    let overdue_duration = current_time.signed_duration_since(deadline);
    assert_eq!(
        overdue_duration.num_minutes(),
        90,
        "Should be 90 minutes overdue"
    );
}

#[test]
fn test_holiday_calendar_integration() {
    // Test holiday calendar consideration for deadlines
    // If trade on Friday, T+1 could be Saturday (skip to Monday)
    let friday_trade = Utc.with_ymd_and_hms(2025, 10, 10, 14, 0, 0).unwrap(); // Friday

    assert_eq!(
        friday_trade.weekday(),
        chrono::Weekday::Fri,
        "Should be Friday"
    );

    // Calculate business day deadline (skip weekend)
    let mut deadline = friday_trade + Duration::days(1); // Saturday

    // Skip Saturday and Sunday
    while deadline.weekday() == chrono::Weekday::Sat || deadline.weekday() == chrono::Weekday::Sun {
        deadline = deadline + Duration::days(1);
    }

    assert_eq!(
        deadline.weekday(),
        chrono::Weekday::Mon,
        "Deadline should be Monday"
    );

    let days_diff = deadline.signed_duration_since(friday_trade).num_days();
    assert_eq!(days_diff, 3, "Should be 3 calendar days (Fri -> Mon)");
}

#[test]
fn test_quarterly_reporting_cycle() {
    // Test quarterly reporting deadlines (SOX example)
    let q1_end = NaiveDate::from_ymd_opt(2025, 3, 31).unwrap();
    let q2_end = NaiveDate::from_ymd_opt(2025, 6, 30).unwrap();
    let q3_end = NaiveDate::from_ymd_opt(2025, 9, 30).unwrap();
    let q4_end = NaiveDate::from_ymd_opt(2025, 12, 31).unwrap();

    // Verify quarter-end dates
    assert_eq!(q1_end.month(), 3, "Q1 ends in March");
    assert_eq!(q2_end.month(), 6, "Q2 ends in June");
    assert_eq!(q3_end.month(), 9, "Q3 ends in September");
    assert_eq!(q4_end.month(), 12, "Q4 ends in December");

    // SOX reports typically due 45 days after quarter end
    let q1_sox_deadline = q1_end + Duration::days(45);
    assert!(
        q1_sox_deadline.month() == 5,
        "Q1 SOX deadline should be in May"
    );
}

// ============================================================================
// SECTION 4: Report Templates (4 tests)
// ============================================================================

#[test]
fn test_template_loading() {
    // Test report template configuration
    let custom_template = ScheduledReportType::Custom {
        report_template: "quarterly_sox_template.json".to_string(),
    };

    match custom_template {
        ScheduledReportType::Custom { report_template } => {
            assert_eq!(report_template, "quarterly_sox_template.json");
            assert!(
                report_template.ends_with(".json"),
                "Template should be JSON format"
            );
        },
        _ => panic!("Expected Custom report type"),
    }
}

#[test]
fn test_template_variable_substitution() {
    // Test template variables in parameters
    let mut parameters = HashMap::new();
    parameters.insert("period".to_string(), serde_json::json!("Q1-2025"));
    parameters.insert("entity".to_string(), serde_json::json!("Foxhunt Trading"));
    parameters.insert(
        "prepared_by".to_string(),
        serde_json::json!("compliance@foxhunt.com"),
    );

    assert_eq!(parameters.len(), 3, "Should have 3 template variables");
    assert!(parameters.contains_key("period"));
    assert!(parameters.contains_key("entity"));
    assert!(parameters.contains_key("prepared_by"));

    // Validate variable values
    assert_eq!(parameters["period"], serde_json::json!("Q1-2025"));
}

#[test]
fn test_conditional_template_sections() {
    // Test conditional sections in report based on parameters
    let mut parameters = HashMap::new();
    parameters.insert("include_details".to_string(), serde_json::json!(true));
    parameters.insert("include_charts".to_string(), serde_json::json!(false));

    let include_details = parameters
        .get("include_details")
        .and_then(|v| v.as_bool())
        .unwrap_or(false);

    let include_charts = parameters
        .get("include_charts")
        .and_then(|v| v.as_bool())
        .unwrap_or(false);

    assert!(include_details, "Details section should be included");
    assert!(!include_charts, "Charts section should be excluded");
}

#[test]
fn test_template_validation() {
    // Test quality checks as template validation
    let quality_check = QualityCheck {
        check_id: "template_001".to_string(),
        name: "Template Completeness".to_string(),
        check_type: QualityCheckType::DataCompleteness,
        parameters: HashMap::new(),
        severity: QualityCheckSeverity::Critical,
        blocking: true,
    };

    assert_eq!(quality_check.check_id, "template_001");
    assert!(matches!(
        quality_check.check_type,
        QualityCheckType::DataCompleteness
    ));
    assert!(matches!(
        quality_check.severity,
        QualityCheckSeverity::Critical
    ));
    assert!(quality_check.blocking, "Should block submission on failure");
}

// ============================================================================
// SECTION 5: Aggregation (4 tests)
// ============================================================================

#[test]
fn test_aggregation_by_venue() {
    // Test transaction aggregation by trading venue
    let mut venue_counts = HashMap::new();
    venue_counts.insert("NYSE".to_string(), 150);
    venue_counts.insert("NASDAQ".to_string(), 230);
    venue_counts.insert("BATS".to_string(), 85);

    assert_eq!(venue_counts.len(), 3, "Should have 3 venues");

    let total_transactions: i32 = venue_counts.values().sum();
    assert_eq!(total_transactions, 465, "Total should be 465 transactions");

    // Find venue with most transactions
    let max_venue = venue_counts
        .iter()
        .max_by_key(|(_, &count)| count)
        .map(|(venue, _)| venue);

    assert_eq!(
        max_venue,
        Some(&"NASDAQ".to_string()),
        "NASDAQ should have most transactions"
    );
}

#[test]
fn test_aggregation_by_instrument() {
    // Test transaction aggregation by instrument type
    let mut instrument_volumes = HashMap::new();
    instrument_volumes.insert("Equities".to_string(), 1_250_000.0);
    instrument_volumes.insert("Futures".to_string(), 875_000.0);
    instrument_volumes.insert("Options".to_string(), 450_000.0);

    assert_eq!(
        instrument_volumes.len(),
        3,
        "Should have 3 instrument types"
    );

    let total_volume: f64 = instrument_volumes.values().sum();
    assert!(
        (total_volume - 2_575_000.0).abs() < 0.01,
        "Total volume should be ~2.575M"
    );

    // Calculate percentage by instrument
    let equities_pct = (instrument_volumes["Equities"] / total_volume) * 100.0;
    assert!(
        (equities_pct - 48.54).abs() < 0.1,
        "Equities should be ~48.54%"
    );
}

#[test]
fn test_summary_statistics_generation() {
    // Test generation of summary statistics for report
    let metrics = ReportingMetrics {
        total_reports_generated: 150,
        total_reports_submitted: 145,
        total_submission_failures: 5,
        average_generation_time_ms: 1250.5,
        average_submission_time_ms: 3420.8,
        success_rate_percentage: 96.67,
        last_updated: Utc::now(),
        detailed_metrics: HashMap::new(),
    };

    assert_eq!(metrics.total_reports_generated, 150);
    assert_eq!(metrics.total_reports_submitted, 145);
    assert_eq!(metrics.total_submission_failures, 5);

    // Validate success rate calculation
    let calculated_success_rate = (metrics.total_reports_submitted as f64
        / (metrics.total_reports_submitted + metrics.total_submission_failures) as f64)
        * 100.0;

    assert!(
        (metrics.success_rate_percentage - calculated_success_rate).abs() < 0.1,
        "Success rate should match calculation"
    );
}

#[test]
fn test_multi_day_aggregation() {
    // Test aggregation across multiple days
    let period = ReportingPeriod {
        start_date: Utc.with_ymd_and_hms(2025, 10, 1, 0, 0, 0).unwrap(),
        end_date: Utc.with_ymd_and_hms(2025, 10, 7, 23, 59, 59).unwrap(),
        period_type: PeriodType::Weekly,
    };

    assert!(matches!(period.period_type, PeriodType::Weekly));

    let duration = period.end_date.signed_duration_since(period.start_date);
    let days = duration.num_days();

    assert!(days >= 6 && days <= 7, "Weekly period should span ~7 days");

    // Verify period boundaries
    assert_eq!(period.start_date.day(), 1, "Should start on day 1");
    assert_eq!(period.end_date.day(), 7, "Should end on day 7");
}

// ============================================================================
// SECTION 6: Performance Monitoring (3 tests)
// ============================================================================

#[test]
fn test_performance_threshold_configuration() {
    // Test performance threshold settings
    let thresholds = PerformanceThresholds {
        max_generation_time_seconds: 300, // 5 minutes
        max_submission_time_seconds: 600, // 10 minutes
        max_queue_time_seconds: 1800,     // 30 minutes
        min_success_rate_percentage: 95.0,
    };

    assert_eq!(thresholds.max_generation_time_seconds, 300);
    assert_eq!(thresholds.max_submission_time_seconds, 600);
    assert_eq!(thresholds.max_queue_time_seconds, 1800);
    assert_eq!(thresholds.min_success_rate_percentage, 95.0);

    // Validate threshold relationships
    assert!(
        thresholds.max_submission_time_seconds > thresholds.max_generation_time_seconds,
        "Submission should allow more time than generation"
    );
}

#[test]
fn test_alert_condition_evaluation() {
    // Test alert condition configuration
    let alert = AlertCondition {
        name: "High Failure Rate".to_string(),
        metric: "success_rate_percentage".to_string(),
        threshold: 90.0,
        operator: ComparisonOperator::LessThan,
        time_window_minutes: 60,
    };

    assert_eq!(alert.name, "High Failure Rate");
    assert!(matches!(alert.operator, ComparisonOperator::LessThan));

    // Test condition evaluation
    let current_success_rate = 88.5;
    let should_alert = match alert.operator {
        ComparisonOperator::LessThan => current_success_rate < alert.threshold,
        ComparisonOperator::GreaterThan => current_success_rate > alert.threshold,
        ComparisonOperator::EqualTo => (current_success_rate - alert.threshold).abs() < 0.01,
        ComparisonOperator::NotEqualTo => (current_success_rate - alert.threshold).abs() >= 0.01,
    };

    assert!(
        should_alert,
        "Should alert when success rate (88.5%) < threshold (90%)"
    );
}

#[test]
fn test_escalation_levels() {
    // Test escalation configuration
    let escalation_levels = vec![
        EscalationLevel {
            level: 1,
            recipients: vec!["team-lead@example.com".to_string()],
            delay_minutes: 15,
            channels: vec![NotificationChannel::Email {
                smtp_server: "smtp.example.com".to_string(),
                from_address: "alerts@trading.com".to_string(),
            }],
        },
        EscalationLevel {
            level: 2,
            recipients: vec!["manager@example.com".to_string()],
            delay_minutes: 30,
            channels: vec![
                NotificationChannel::Email {
                    smtp_server: "smtp.example.com".to_string(),
                    from_address: "alerts@trading.com".to_string(),
                },
                NotificationChannel::SMS {
                    provider: "twilio".to_string(),
                    api_key: "test-key".to_string(),
                },
            ],
        },
    ];

    assert_eq!(
        escalation_levels.len(),
        2,
        "Should have 2 escalation levels"
    );

    let level1 = &escalation_levels[0];
    let level2 = &escalation_levels[1];

    assert_eq!(level1.level, 1);
    assert_eq!(level1.delay_minutes, 15);
    assert_eq!(level1.channels.len(), 1, "Level 1 uses email only");

    assert_eq!(level2.level, 2);
    assert_eq!(level2.delay_minutes, 30);
    assert_eq!(level2.channels.len(), 2, "Level 2 uses email + SMS");

    assert!(
        level2.delay_minutes > level1.delay_minutes,
        "Higher level should have longer delay"
    );
}

// ============================================================================
// Helper Functions
// ============================================================================

/// Create a test generated report for use in tests
fn create_test_report() -> GeneratedReport {
    let now = Utc::now();

    GeneratedReport {
        report_id: format!("TEST-RPT-{}", now.timestamp()),
        report_type: ScheduledReportType::MiFIDTransactionReports,
        generated_at: now,
        period: ReportingPeriod {
            start_date: now - Duration::days(1),
            end_date: now,
            period_type: PeriodType::Daily,
        },
        data: serde_json::json!({
            "transactions_count": 1000,
            "total_volume": 5_000_000.0,
            "status": "generated"
        }),
        quality_scores: {
            let mut scores = HashMap::new();
            scores.insert("completeness".to_string(), 98.5);
            scores.insert("accuracy".to_string(), 99.2);
            scores
        },
        validation_results: vec![ValidationResult {
            check_id: "check_001".to_string(),
            check_name: "Data Completeness".to_string(),
            passed: true,
            score: 98.5,
            messages: vec!["All required fields present".to_string()],
            severity: QualityCheckSeverity::Medium,
        }],
    }
}