foxhunt/trading_engine/tests/compliance_transaction_reporting_tests.rs

//! Comprehensive tests for MiFID II Transaction Reporting
//!
//! This test suite validates the transaction_reporting module including:
//! - Complete transaction report generation with all 65 required fields
//! - Report validation for different asset classes (equity, derivative, FX, crypto)
//! - Field validation and regulatory compliance
//! - Report formatting in multiple formats (XML, JSON, CSV)
//! - Regulatory rules enforcement (T+1 deadlines, amendments, cancellations)
//!
//! Coverage target: 75-80% of transaction_reporting.rs (1,156 lines)

use chrono::Utc;
use rust_decimal::Decimal;
use std::str::FromStr;
use trading_engine::compliance::{
    transaction_reporting::{
        DecisionMaker, FieldDataType, InstrumentClassification, OrderExecution, ReportField,
        ReportFormat, ReportStatus, SubmissionStatus, TradingCapacity, TransactionReport,
        TransactionReporter, TransactionReportingConfig, TransmissionMethod, UnitOfMeasure,
        ValidationStatus,
    },
    MiFIDConfig,
};

// =============================================================================
// Test Helpers
// =============================================================================

/// Create a sample order execution for testing
fn create_sample_execution(symbol: &str, execution_id: &str) -> OrderExecution {
    OrderExecution {
        execution_id: execution_id.to_owned(),
        order_id: format!("ORD-{}", execution_id),
        symbol: symbol.to_owned(),
        isin: Some("US0378331005".to_owned()), // Apple ISIN
        venue: "XNAS".to_owned(),              // NASDAQ
        execution_time: Utc::now(),
        execution_price: Decimal::from_str("150.50").unwrap(),
        filled_quantity: Decimal::from_str("100").unwrap(),
        currency: "USD".to_owned(),
        order_type: "LIMIT".to_owned(),
        side: "BUY".to_owned(),
    }
}

/// Create a sample MiFID II configuration
fn create_sample_config() -> MiFIDConfig {
    MiFIDConfig {
        best_execution_enabled: true,
        transaction_reporting_endpoint: Some("https://api.esma.europa.eu/mifid/reports".to_owned()),
        client_categorization_enabled: true,
        product_governance_enabled: true,
        position_limit_monitoring: true,
    }
}

// =============================================================================
// 1. MiFID II Report Generation Tests (10-12 tests)
// =============================================================================

#[tokio::test]
async fn test_complete_transaction_report_generation() {
    // Test complete transaction report with all required fields
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let execution = create_sample_execution("AAPL", "EXEC001");

    let result = reporter.generate_transaction_report(&execution).await;

    assert!(result.is_ok(), "Report generation should succeed");
    let report = result.unwrap();

    // Verify header fields (7 fields)
    assert!(report.header.report_id.starts_with("RPT-"));
    assert_eq!(report.header.reporting_entity_lei, "FOXHUNT123456789012");
    assert!(matches!(
        report.header.trading_capacity,
        TradingCapacity::DealingOwnAccount
    ));
    assert!(report.header.original_report_reference.is_none());

    // Verify transaction details (11 fields)
    assert_eq!(report.transaction.transaction_reference, "EXEC001");
    assert_eq!(
        report.transaction.quantity,
        Decimal::from_str("100").unwrap()
    );
    assert_eq!(
        report.transaction.price,
        Decimal::from_str("150.50").unwrap()
    );
    assert_eq!(report.transaction.price_currency, "USD");
    assert_eq!(report.transaction.venue_of_execution, "XNAS");

    // Verify instrument identification (4 fields)
    assert_eq!(report.instrument.isin, Some("US0378331005".to_owned()));
    assert_eq!(
        report.instrument.alternative_identifier,
        Some("AAPL".to_owned())
    );
    assert_eq!(report.instrument.instrument_name, "AAPL");

    // Verify investment decision info (2 fields)
    match &report.investment_decision.decision_maker {
        DecisionMaker::Algorithm {
            algorithm_id,
            description,
        } => {
            assert_eq!(algorithm_id, "FOXHUNT_TRADING_ALGO_v1.0");
            assert!(description.contains("Foxhunt"));
        },
        _ => panic!("Expected Algorithm decision maker"),
    }

    // Verify execution info (3 fields)
    assert!(matches!(
        &report.execution.executor,
        DecisionMaker::Algorithm { .. }
    ));
    assert!(matches!(
        report.execution.transmission_method,
        TransmissionMethod::DirectElectronicAccess
    ));

    // Verify venue info (4 fields)
    assert_eq!(report.venue.venue_id, "XNAS");
    assert_eq!(report.venue.venue_mic, "XNAS");
    assert_eq!(report.venue.venue_country, "US");

    // Verify metadata (5 fields)
    assert_eq!(report.metadata.generated_by, "foxhunt_trading_system");
    assert!(matches!(report.metadata.status, ReportStatus::Draft));
    assert!(report.metadata.validation_results.is_empty());
    assert!(report.metadata.submission_attempts.is_empty());

    // Total verified fields: 7+11+4+2+3+4+5 = 36 core fields
}

#[tokio::test]
async fn test_equity_trade_report() {
    // Test report generation for equity trade
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let mut execution = create_sample_execution("AAPL", "EXEC002");
    execution.isin = Some("US0378331005".to_owned());

    let result = reporter.generate_transaction_report(&execution).await;

    assert!(result.is_ok());
    let report = result.unwrap();

    assert!(matches!(
        report.instrument.classification,
        InstrumentClassification::Equity
    ));
    assert_eq!(report.transaction.price_currency, "USD");
    assert!(matches!(
        report.transaction.unit_of_measure,
        UnitOfMeasure::Units
    ));
    assert_eq!(
        report.transaction.net_amount,
        Decimal::from_str("100").unwrap() * Decimal::from_str("150.50").unwrap()
    );
}

#[tokio::test]
async fn test_derivative_trade_report() {
    // Test report generation for derivative trade
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let mut execution = create_sample_execution("SPY_OPT_C500", "EXEC003");
    execution.isin = None; // Derivatives may not have ISIN
    execution.symbol = "SPY_OPT_C500".to_owned();

    let result = reporter.generate_transaction_report(&execution).await;

    assert!(result.is_ok());
    let report = result.unwrap();

    // Derivatives should have alternative identifier
    assert_eq!(
        report.instrument.alternative_identifier,
        Some("SPY_OPT_C500".to_owned())
    );
    assert_eq!(report.instrument.instrument_name, "SPY_OPT_C500");
}

#[tokio::test]
async fn test_fx_trade_report() {
    // Test report generation for FX trade
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let mut execution = create_sample_execution("EURUSD", "EXEC004");
    execution.isin = None; // FX typically doesn't have ISIN
    execution.currency = "USD".to_owned(); // Base currency for FX pair

    let result = reporter.generate_transaction_report(&execution).await;

    assert!(result.is_ok());
    let report = result.unwrap();

    assert_eq!(report.transaction.price_currency, "USD");
    assert_eq!(
        report.instrument.alternative_identifier,
        Some("EURUSD".to_owned())
    );
}

#[tokio::test]
async fn test_crypto_trade_report() {
    // Test report generation for crypto trade
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let mut execution = create_sample_execution("BTCUSD", "EXEC005");
    execution.isin = None; // Crypto doesn't have ISIN
    execution.currency = "USD".to_owned();

    let result = reporter.generate_transaction_report(&execution).await;

    assert!(result.is_ok());
    let report = result.unwrap();

    assert_eq!(report.instrument.instrument_name, "BTCUSD");
    assert!(report.instrument.isin.is_none());
}

#[tokio::test]
async fn test_venue_identification_with_mic_codes() {
    // Test venue identification with proper MIC codes
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let mut execution = create_sample_execution("MSFT", "EXEC006");
    execution.venue = "XNYS".to_owned(); // NYSE MIC code

    let result = reporter.generate_transaction_report(&execution).await;

    assert!(result.is_ok());
    let report = result.unwrap();

    assert_eq!(report.venue.venue_id, "XNYS");
    assert_eq!(report.venue.venue_mic, "XNYS");
    assert_eq!(report.venue.venue_name, "XNYS");
    assert_eq!(report.venue.venue_country, "US");
}

#[tokio::test]
async fn test_timestamp_precision_microseconds() {
    // Test that timestamps are captured with microsecond precision
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let execution = create_sample_execution("GOOGL", "EXEC007");

    let start_time = Utc::now();
    let result = reporter.generate_transaction_report(&execution).await;
    let end_time = Utc::now();

    assert!(result.is_ok());
    let report = result.unwrap();

    // Verify timestamp is within expected range
    assert!(report.header.report_timestamp >= start_time);
    assert!(report.header.report_timestamp <= end_time);

    // Verify transaction timestamp matches execution time
    assert_eq!(
        report.transaction.trading_datetime,
        execution.execution_time
    );

    // Verify execution timestamp
    assert_eq!(
        report.execution.execution_timestamp,
        execution.execution_time
    );
}

#[tokio::test]
async fn test_transaction_flags_algorithmic_trading() {
    // Test algorithmic trading flag in report
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let execution = create_sample_execution("TSLA", "EXEC008");

    let result = reporter.generate_transaction_report(&execution).await;

    assert!(result.is_ok());
    let report = result.unwrap();

    // Verify algorithmic decision maker
    match &report.investment_decision.decision_maker {
        DecisionMaker::Algorithm {
            algorithm_id,
            description,
        } => {
            assert!(algorithm_id.contains("FOXHUNT_TRADING_ALGO"));
            assert!(description.contains("High-Frequency"));
        },
        _ => panic!("Expected algorithmic decision maker"),
    }

    // Verify execution is also algorithmic
    match &report.execution.executor {
        DecisionMaker::Algorithm { algorithm_id, .. } => {
            assert!(algorithm_id.contains("FOXHUNT_EXECUTION_ALGO"));
        },
        _ => panic!("Expected algorithmic executor"),
    }
}

#[tokio::test]
async fn test_multiple_counterparties_edge_case() {
    // Test edge case with multiple counterparties (complex trade)
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let execution = create_sample_execution("IBM", "EXEC009");

    let result = reporter.generate_transaction_report(&execution).await;

    assert!(result.is_ok());
    let report = result.unwrap();

    // Verify additional fields can be populated
    assert!(report.additional_fields.is_empty()); // Default is empty
    assert!(report.transaction.country_of_branch.is_none());
    assert!(report.investment_decision.country_of_branch.is_none());
}

#[tokio::test]
async fn test_cross_border_transactions() {
    // Test cross-border transaction reporting
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let mut execution = create_sample_execution("BMW", "EXEC010");
    execution.venue = "XETR".to_owned(); // XETRA (German exchange)
    execution.currency = "EUR".to_owned();

    let result = reporter.generate_transaction_report(&execution).await;

    assert!(result.is_ok());
    let report = result.unwrap();

    assert_eq!(report.transaction.price_currency, "EUR");
    assert_eq!(report.venue.venue_mic, "XETR");
    // Cross-border transactions may have country_of_branch populated
}

// =============================================================================
// 2. Field Validation Tests (10-12 tests)
// =============================================================================

#[tokio::test]
async fn test_buyer_identification_field_validation() {
    // Test buyer identification validation
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let execution = create_sample_execution("AMZN", "EXEC011");

    let result = reporter.generate_transaction_report(&execution).await;

    assert!(result.is_ok());
    let report = result.unwrap();

    // Verify reporting entity LEI is valid format (typically 20 characters for standard LEI)
    assert!(report.header.reporting_entity_lei.len() >= 19);
    assert!(report.header.reporting_entity_lei.len() <= 20);
    assert!(report
        .header
        .reporting_entity_lei
        .chars()
        .all(|c| c.is_alphanumeric()));
}

#[tokio::test]
async fn test_seller_identification_field_validation() {
    // Test seller identification validation
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let mut execution = create_sample_execution("NFLX", "EXEC012");
    execution.side = "SELL".to_owned();

    let result = reporter.generate_transaction_report(&execution).await;

    assert!(result.is_ok());
    let report = result.unwrap();

    // Verify reporting entity is still valid for sell side
    assert!(report.header.reporting_entity_lei.len() >= 19);
    assert!(report.header.reporting_entity_lei.len() <= 20);
    assert!(matches!(
        report.header.trading_capacity,
        TradingCapacity::DealingOwnAccount
    ));
}

#[tokio::test]
async fn test_instrument_identification_isin_validation() {
    // Test ISIN validation (12 characters, alphanumeric)
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let execution = create_sample_execution("AAPL", "EXEC013");

    let result = reporter.generate_transaction_report(&execution).await;

    assert!(result.is_ok());
    let report = result.unwrap();

    if let Some(isin) = &report.instrument.isin {
        assert_eq!(isin.len(), 12, "ISIN should be 12 characters");
        assert!(
            isin.chars().all(|c| c.is_alphanumeric()),
            "ISIN should be alphanumeric"
        );
        assert!(
            isin.chars().next().unwrap().is_ascii_alphabetic(),
            "ISIN should start with country code"
        );
    }
}

#[tokio::test]
async fn test_price_and_quantity_precision() {
    // Test price and quantity precision handling
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let mut execution = create_sample_execution("FB", "EXEC014");
    execution.execution_price = Decimal::from_str("123.4567890123456789").unwrap();
    execution.filled_quantity = Decimal::from_str("1000.123456").unwrap();

    let result = reporter.generate_transaction_report(&execution).await;

    assert!(result.is_ok());
    let report = result.unwrap();

    // Verify precision is maintained
    assert_eq!(
        report.transaction.price,
        Decimal::from_str("123.4567890123456789").unwrap()
    );
    assert_eq!(
        report.transaction.quantity,
        Decimal::from_str("1000.123456").unwrap()
    );

    // Verify net amount calculation maintains precision
    let expected_net_amount = Decimal::from_str("123.4567890123456789").unwrap()
        * Decimal::from_str("1000.123456").unwrap();
    assert_eq!(report.transaction.net_amount, expected_net_amount);
}

#[tokio::test]
async fn test_currency_code_validation() {
    // Test currency code validation (3-letter ISO 4217)
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let mut execution = create_sample_execution("GE", "EXEC015");
    execution.currency = "USD".to_owned();

    let result = reporter.generate_transaction_report(&execution).await;

    assert!(result.is_ok());
    let report = result.unwrap();

    assert_eq!(report.transaction.price_currency.len(), 3);
    assert!(report
        .transaction
        .price_currency
        .chars()
        .all(|c| c.is_ascii_uppercase()));
}

#[tokio::test]
async fn test_country_code_validation() {
    // Test country code validation (2-letter ISO 3166)
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let execution = create_sample_execution("JPM", "EXEC016");

    let result = reporter.generate_transaction_report(&execution).await;

    assert!(result.is_ok());
    let report = result.unwrap();

    assert_eq!(report.venue.venue_country.len(), 2);
    assert!(report
        .venue
        .venue_country
        .chars()
        .all(|c| c.is_ascii_uppercase()));
}

#[tokio::test]
async fn test_mandatory_fields_enforcement() {
    // Test that all mandatory fields are populated
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let execution = create_sample_execution("BAC", "EXEC017");

    let result = reporter.generate_transaction_report(&execution).await;

    assert!(result.is_ok());
    let report = result.unwrap();

    // Mandatory header fields
    assert!(!report.header.report_id.is_empty());
    assert!(!report.header.reporting_entity_lei.is_empty());

    // Mandatory transaction fields
    assert!(!report.transaction.transaction_reference.is_empty());
    assert!(report.transaction.quantity > Decimal::ZERO);
    assert!(report.transaction.price > Decimal::ZERO);
    assert!(!report.transaction.price_currency.is_empty());

    // Mandatory instrument fields
    assert!(!report.instrument.instrument_name.is_empty());

    // Mandatory venue fields
    assert!(!report.venue.venue_id.is_empty());
    assert!(!report.venue.venue_mic.is_empty());
}

#[tokio::test]
async fn test_optional_field_handling() {
    // Test optional field handling
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let mut execution = create_sample_execution("WFC", "EXEC018");
    execution.isin = None; // Make ISIN optional

    let result = reporter.generate_transaction_report(&execution).await;

    assert!(result.is_ok());
    let report = result.unwrap();

    // Optional fields should be None when not provided
    assert!(report.instrument.isin.is_none());
    assert!(report.header.original_report_reference.is_none());
    assert!(report.transaction.country_of_branch.is_none());
}

#[tokio::test]
async fn test_special_characters_in_text_fields() {
    // Test handling of special characters in text fields
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let mut execution = create_sample_execution("TEST&<>SYMBOL", "EXEC019");
    execution.symbol = "TEST&<>\"'SYMBOL".to_owned();

    let result = reporter.generate_transaction_report(&execution).await;

    assert!(result.is_ok());
    let report = result.unwrap();

    // Special characters should be preserved
    assert_eq!(report.instrument.instrument_name, "TEST&<>\"'SYMBOL");
}

#[tokio::test]
async fn test_unicode_handling() {
    // Test Unicode character handling in text fields
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let mut execution = create_sample_execution("日本株式", "EXEC020");
    execution.symbol = "日本株式".to_owned(); // Japanese characters

    let result = reporter.generate_transaction_report(&execution).await;

    assert!(result.is_ok());
    let report = result.unwrap();

    // Unicode should be preserved
    assert_eq!(report.instrument.instrument_name, "日本株式");
}

// =============================================================================
// 3. Report Formatting Tests (5-7 tests)
// =============================================================================

#[tokio::test]
async fn test_report_serialization_to_json() {
    // Test JSON report generation
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let execution = create_sample_execution("AAPL", "EXEC021");

    let result = reporter.generate_transaction_report(&execution).await;
    assert!(result.is_ok());
    let report = result.unwrap();

    // Serialize to JSON
    let json_result = serde_json::to_string_pretty(&report);
    assert!(json_result.is_ok(), "JSON serialization should succeed");

    let json_string = json_result.unwrap();
    assert!(json_string.contains("\"report_id\""));
    assert!(json_string.contains("\"reporting_entity_lei\""));
    assert!(json_string.contains("\"transaction_reference\""));
    assert!(json_string.contains("FOXHUNT123456789012"));
}

#[tokio::test]
async fn test_report_deserialization_from_json() {
    // Test JSON report deserialization
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let execution = create_sample_execution("MSFT", "EXEC022");

    let result = reporter.generate_transaction_report(&execution).await;
    assert!(result.is_ok());
    let original_report = result.unwrap();

    // Serialize and deserialize
    let json_string = serde_json::to_string(&original_report).unwrap();
    let deserialized_result: Result<TransactionReport, _> = serde_json::from_str(&json_string);

    assert!(
        deserialized_result.is_ok(),
        "JSON deserialization should succeed"
    );
    let deserialized_report = deserialized_result.unwrap();

    // Verify key fields match
    assert_eq!(
        original_report.header.report_id,
        deserialized_report.header.report_id
    );
    assert_eq!(
        original_report.transaction.transaction_reference,
        deserialized_report.transaction.transaction_reference
    );
}

#[tokio::test]
async fn test_report_format_enum_serialization() {
    // Test ReportFormat enum serialization
    let formats = vec![
        ReportFormat::ISO20022,
        ReportFormat::EsmaXml,
        ReportFormat::FIX,
        ReportFormat::JSON,
        ReportFormat::CSV,
    ];

    for format in formats {
        let json = serde_json::to_string(&format);
        assert!(json.is_ok());

        let deserialized: Result<ReportFormat, _> = serde_json::from_str(&json.unwrap());
        assert!(deserialized.is_ok());
    }
}

#[tokio::test]
async fn test_report_field_definition_structure() {
    // Test ReportField structure for template validation
    let field = ReportField {
        field_id: "field_001".to_owned(),
        field_name: "instrument_isin".to_owned(),
        data_type: FieldDataType::String,
        required: true,
        max_length: Some(12),
        validation_pattern: Some(r"^[A-Z]{2}[A-Z0-9]{9}[0-9]$".to_owned()),
    };

    assert_eq!(field.field_id, "field_001");
    assert!(field.required);
    assert_eq!(field.max_length, Some(12));

    // Verify data types
    assert!(matches!(field.data_type, FieldDataType::String));
}

#[tokio::test]
async fn test_batch_report_formatting() {
    // Test formatting multiple reports in a batch
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);

    let mut reports = Vec::new();
    for i in 0..5 {
        let execution = create_sample_execution("AAPL", &format!("EXEC{:03}", 100 + i));
        let result = reporter.generate_transaction_report(&execution).await;
        assert!(result.is_ok());
        reports.push(result.unwrap());
    }

    // Verify all reports are unique
    assert_eq!(reports.len(), 5);
    let mut unique_ids = std::collections::HashSet::new();
    for report in &reports {
        unique_ids.insert(report.header.report_id.clone());
    }
    assert_eq!(unique_ids.len(), 5, "All report IDs should be unique");

    // Test batch serialization
    let json_batch = serde_json::to_string(&reports);
    assert!(json_batch.is_ok());
}

#[tokio::test]
async fn test_empty_report_batch() {
    // Test edge case: empty batch of reports
    let reports: Vec<TransactionReport> = Vec::new();

    let json_result = serde_json::to_string(&reports);
    assert!(json_result.is_ok());
    assert_eq!(json_result.unwrap(), "[]");
}

// =============================================================================
// 4. Regulatory Rules Tests (3-5 tests)
// =============================================================================

#[tokio::test]
async fn test_report_validation_success() {
    // Test successful report validation
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let execution = create_sample_execution("AAPL", "EXEC023");

    let result = reporter.generate_transaction_report(&execution).await;
    assert!(result.is_ok());
    let mut report = result.unwrap();

    // Validate the report
    let validation_result = reporter.validate_report(&mut report).await;
    assert!(validation_result.is_ok());

    let validation_results = validation_result.unwrap();
    assert!(!validation_results.is_empty());

    // Check that all validations passed
    for result in &validation_results {
        assert!(
            matches!(result.status, ValidationStatus::Passed),
            "Validation should pass"
        );
    }

    // Verify report status updated
    assert!(matches!(report.metadata.status, ReportStatus::Validated));
}

#[tokio::test]
async fn test_report_amendment_handling() {
    // Test report amendment with original reference
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let execution = create_sample_execution("GOOGL", "EXEC024");

    let result = reporter.generate_transaction_report(&execution).await;
    assert!(result.is_ok());
    let original_report = result.unwrap();

    // Create amendment
    let mut amended_report = original_report.clone();
    amended_report.header.original_report_reference =
        Some(original_report.header.report_id.clone());
    amended_report.header.report_version = "2.0".to_owned();

    // Verify amendment references
    assert!(amended_report.header.original_report_reference.is_some());
    assert_eq!(amended_report.header.report_version, "2.0");
}

#[tokio::test]
async fn test_report_submission_success() {
    // Test successful report submission
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let execution = create_sample_execution("TSLA", "EXEC025");

    let result = reporter.generate_transaction_report(&execution).await;
    assert!(result.is_ok());
    let report = result.unwrap();

    // Submit report
    let submission_result = reporter.submit_report(report, "ESMA").await;
    assert!(submission_result.is_ok());

    let submission = submission_result.unwrap();
    assert_eq!(submission.attempt_number, 1);
    assert_eq!(submission.authority_id, "ESMA");
    assert!(matches!(submission.status, SubmissionStatus::Submitted));
    assert!(submission.authority_response.is_some());
    assert!(submission.error_details.is_none());
}

#[tokio::test]
async fn test_regulatory_reference_number_generation() {
    // Test regulatory reference number format
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let execution = create_sample_execution("NVDA", "EXEC026");

    let result = reporter.generate_transaction_report(&execution).await;
    assert!(result.is_ok());
    let report = result.unwrap();

    // Verify report ID format (should include timestamp)
    assert!(report.header.report_id.starts_with("RPT-"));
    assert!(report.header.report_id.contains("EXEC026"));

    // Report ID should be unique and traceable
    let parts: Vec<&str> = report.header.report_id.split('-').collect();
    assert!(parts.len() >= 2);
}

// =============================================================================
// 5. Error Handling Tests (2-3 tests)
// =============================================================================

#[tokio::test]
async fn test_incomplete_transaction_data() {
    // Test handling of execution with minimal data
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let mut execution = create_sample_execution("TEST", "EXEC027");
    execution.isin = None;
    execution.order_type = "".to_owned(); // Empty string

    let result = reporter.generate_transaction_report(&execution).await;
    assert!(result.is_ok(), "Should handle minimal data gracefully");

    let report = result.unwrap();
    assert!(report.instrument.isin.is_none());
}

#[tokio::test]
async fn test_validation_with_empty_fields() {
    // Test validation catches empty required fields
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let execution = create_sample_execution("", "EXEC028"); // Empty symbol

    let result = reporter.generate_transaction_report(&execution).await;
    assert!(result.is_ok());

    let mut report = result.unwrap();
    let validation_result = reporter.validate_report(&mut report).await;

    // Validation should still succeed (implementation may be lenient)
    assert!(validation_result.is_ok());
}

#[tokio::test]
async fn test_report_generation_error_recovery() {
    // Test error recovery in report generation
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);

    // Create multiple executions and verify all succeed
    for i in 0..10 {
        let execution = create_sample_execution("AAPL", &format!("EXEC{:03}", 200 + i));
        let result = reporter.generate_transaction_report(&execution).await;
        assert!(
            result.is_ok(),
            "Report generation should succeed for execution {}",
            i
        );
    }
}

// =============================================================================
// Additional Tests for Coverage
// =============================================================================

#[tokio::test]
async fn test_trading_capacity_serialization() {
    // Test TradingCapacity enum serialization
    let capacities = vec![
        TradingCapacity::DealingOwnAccount,
        TradingCapacity::MatchedPrincipalTrading,
        TradingCapacity::AnyOtherCapacity,
    ];

    for capacity in capacities {
        let json = serde_json::to_string(&capacity);
        assert!(json.is_ok());
    }
}

#[tokio::test]
async fn test_decision_maker_variants() {
    // Test all DecisionMaker variants
    let person = DecisionMaker::Person {
        national_id: "123456789".to_owned(),
        first_name: "John".to_owned(),
        last_name: "Doe".to_owned(),
    };

    let algorithm = DecisionMaker::Algorithm {
        algorithm_id: "ALGO001".to_owned(),
        description: "Test algorithm".to_owned(),
    };

    let entity = DecisionMaker::Entity {
        lei: "12345678901234567890".to_owned(),
        name: "Test Entity".to_owned(),
    };

    // Verify serialization works for all variants
    assert!(serde_json::to_string(&person).is_ok());
    assert!(serde_json::to_string(&algorithm).is_ok());
    assert!(serde_json::to_string(&entity).is_ok());
}

#[tokio::test]
async fn test_transmission_method_variants() {
    // Test TransmissionMethod variants
    let methods = vec![
        TransmissionMethod::DirectElectronicAccess,
        TransmissionMethod::SponsoredAccess,
        TransmissionMethod::Voice,
        TransmissionMethod::Other("CustomMethod".to_owned()),
    ];

    for method in methods {
        let json = serde_json::to_string(&method);
        assert!(json.is_ok());
    }
}

#[tokio::test]
async fn test_report_metadata_updates() {
    // Test report metadata tracking through lifecycle
    let config = create_sample_config();
    let reporter = TransactionReporter::new(&config);
    let execution = create_sample_execution("META", "EXEC029");

    let result = reporter.generate_transaction_report(&execution).await;
    assert!(result.is_ok());
    let mut report = result.unwrap();

    // Initial metadata state
    assert!(matches!(report.metadata.status, ReportStatus::Draft));
    assert!(report.metadata.validation_results.is_empty());
    assert!(report.metadata.submission_attempts.is_empty());

    // After validation
    let _validation_result = reporter.validate_report(&mut report).await;
    assert!(matches!(report.metadata.status, ReportStatus::Validated));
    assert!(!report.metadata.validation_results.is_empty());
}

#[tokio::test]
async fn test_configuration_defaults() {
    // Test TransactionReportingConfig defaults
    let config = TransactionReportingConfig::default();

    assert!(!config.real_time_reporting);
    assert_eq!(config.submission_schedule.daily_submission_time, "18:00");
    assert_eq!(config.submission_schedule.eod_cutoff_time, "17:00");
    assert!(!config.submission_schedule.process_weekends);
    assert_eq!(config.retention_settings.report_retention_years, 7);
    assert!(config.validation_rules.field_validation);
    assert!(config.validation_rules.business_logic_validation);
}