foxhunt/trading_engine/tests/compliance_transaction_reporting.rs

// Transaction Reporting Compliance Tests
// Tests MiFID II RTS 22 transaction reporting requirements

use chrono::{DateTime, Duration, Utc};
use rust_decimal::Decimal;
use trading_engine::compliance::transaction_reporting::{
    TransactionReporter, OrderExecution, TransactionReport,
    TradingCapacity, UnitOfMeasure, InstrumentClassification,
    DecisionMaker, TransmissionMethod, ReportStatus,
    ValidationStatus, SubmissionStatus,
};
use trading_engine::compliance::MiFIDConfig;


// Helper function to create default MiFID config
fn create_default_mifid_config() -> MiFIDConfig {
    MiFIDConfig {
        best_execution_enabled: true,
        transaction_reporting_endpoint: Some("https://api.esma.europa.eu/mifid/reports".to_string()),
        client_categorization_enabled: true,
        product_governance_enabled: true,
        position_limit_monitoring: true,
    }
}

// Helper function to create sample order execution
fn create_sample_order_execution() -> OrderExecution {
    OrderExecution {
        execution_id: "EXEC001".to_string(),
        order_id: "ORD001".to_string(),
        symbol: "AAPL".to_string(),
        isin: Some("US0378331005".to_string()),
        venue: "XNYS".to_string(),
        execution_time: Utc::now(),
        execution_price: Decimal::new(15025, 2), // 150.25
        filled_quantity: Decimal::new(1000, 0),
        currency: "USD".to_string(),
        order_type: "LIMIT".to_string(),
        side: "BUY".to_string(),
    }
}

#[tokio::test]
async fn test_generate_transaction_report() {
    let config = create_default_mifid_config();
    let reporter = TransactionReporter::new(&config);

    let execution = create_sample_order_execution();

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

    assert!(result.is_ok(), "Should generate transaction report successfully");
    
    let report = result.unwrap();
    assert!(!report.header.report_id.is_empty(), "Report should have ID");
    assert_eq!(report.transaction.quantity, Decimal::new(1000, 0), "Quantity should match");
    assert_eq!(report.transaction.price, Decimal::new(15025, 2), "Price should match");
}

#[tokio::test]
async fn test_validate_report_fields() {
    let config = create_default_mifid_config();
    let reporter = TransactionReporter::new(&config);

    let execution = create_sample_order_execution();
    let mut report = reporter.generate_transaction_report(&execution).await.unwrap();
    
    let result = reporter.validate_report(&mut report).await;
    assert!(result.is_ok(), "Valid report should pass validation");
    
    let validation_results = result.unwrap();
    assert!(
        validation_results.iter().all(|r| !matches!(r.status, ValidationStatus::Failed)),
        "No validation failures should occur"
    );
}

#[tokio::test]
async fn test_validate_missing_isin() {
    let config = create_default_mifid_config();
    let reporter = TransactionReporter::new(&config);

    let mut execution = create_sample_order_execution();
    execution.isin = None; // Missing ISIN
    
    let mut report = reporter.generate_transaction_report(&execution).await.unwrap();

    // Report is generated but may have warnings about missing ISIN
    let result = reporter.validate_report(&mut report).await;
    assert!(result.is_ok(), "Validation should complete");
    
    // Check if ISIN field is missing or empty
    assert!(
        report.instrument.isin.is_none() || report.instrument.isin.as_ref().unwrap().is_empty(),
        "ISIN should be missing or empty"
    );
}

#[tokio::test]
async fn test_validate_invalid_quantity() {
    let config = create_default_mifid_config();
    let reporter = TransactionReporter::new(&config);

    let mut execution = create_sample_order_execution();
    execution.filled_quantity = Decimal::ZERO;
    
    let mut report = reporter.generate_transaction_report(&execution).await.unwrap();

    let result = reporter.validate_report(&mut report).await;
    // Validation may warn about zero quantity but still succeed
    assert!(result.is_ok(), "Validation should complete");
    assert_eq!(report.transaction.quantity, Decimal::ZERO, "Quantity should be zero");
}

#[tokio::test]
async fn test_validate_invalid_price() {
    let config = create_default_mifid_config();
    let reporter = TransactionReporter::new(&config);

    let mut execution = create_sample_order_execution();
    execution.execution_price = Decimal::ZERO;
    
    let mut report = reporter.generate_transaction_report(&execution).await.unwrap();

    let result = reporter.validate_report(&mut report).await;
    // Validation may warn about zero price but still succeed
    assert!(result.is_ok(), "Validation should complete");
    assert_eq!(report.transaction.price, Decimal::ZERO, "Price should be zero");
}

#[tokio::test]
async fn test_validate_business_logic() {
    let config = create_default_mifid_config();
    let reporter = TransactionReporter::new(&config);

    let execution = create_sample_order_execution();
    let mut report = reporter.generate_transaction_report(&execution).await.unwrap();
    
    let result = reporter.validate_report(&mut report).await;
    assert!(result.is_ok(), "Valid report should pass business logic validation");
}

#[tokio::test]
async fn test_validate_buyer_seller_same() {
    // This test is not applicable to the new structure as buyer/seller
    // are derived from side and counterparty information
    let config = create_default_mifid_config();
    let reporter = TransactionReporter::new(&config);

    let execution = create_sample_order_execution();
    let mut report = reporter.generate_transaction_report(&execution).await.unwrap();
    
    // Validate report - new structure doesn't have explicit buyer/seller fields
    let result = reporter.validate_report(&mut report).await;
    assert!(result.is_ok(), "Validation should complete");
}

#[tokio::test]
async fn test_validate_investment_decision_chain() {
    let config = create_default_mifid_config();
    let reporter = TransactionReporter::new(&config);

    let execution = create_sample_order_execution();
    let mut report = reporter.generate_transaction_report(&execution).await.unwrap();
    
    let result = reporter.validate_report(&mut report).await;
    assert!(
        result.is_ok(),
        "Valid decision chain should pass validation"
    );
    
    // Verify investment decision is set correctly
    match &report.investment_decision.decision_maker {
        DecisionMaker::Algorithm { algorithm_id, .. } => {
            assert!(!algorithm_id.is_empty(), "Algorithm ID should be set");
        }
        _ => panic!("Expected Algorithm decision maker"),
    }
}

#[tokio::test]
async fn test_submit_to_authority() {
    let config = create_default_mifid_config();
    let reporter = TransactionReporter::new(&config);

    let execution = create_sample_order_execution();
    let report = reporter.generate_transaction_report(&execution).await.unwrap();

    let result = reporter.submit_report(report, "ESMA").await;
    assert!(result.is_ok(), "Should submit report to authority successfully");
    
    let submission_attempt = result.unwrap();
    assert_eq!(submission_attempt.authority_id, "ESMA", "Should submit to ESMA");
    assert!(
        matches!(submission_attempt.status, SubmissionStatus::Submitted),
        "Submission status should be Submitted"
    );
}

#[tokio::test]
async fn test_retrieve_submission_status() {
    let config = create_default_mifid_config();
    let reporter = TransactionReporter::new(&config);

    let execution = create_sample_order_execution();
    let report = reporter.generate_transaction_report(&execution).await.unwrap();
    
    // Submit report and check status in metadata
    let submission_result = reporter.submit_report(report.clone(), "ESMA").await;
    assert!(submission_result.is_ok(), "Submission should succeed");
    
    let submission_attempt = submission_result.unwrap();
    assert!(
        matches!(
            submission_attempt.status,
            SubmissionStatus::Submitted | SubmissionStatus::Pending
        ),
        "Status should be Submitted or Pending"
    );
}

#[tokio::test]
async fn test_generate_transparency_report() {
    let config = create_default_mifid_config();
    let reporter = TransactionReporter::new(&config);

    // Use ReportingPeriod for transparency reports
    use trading_engine::compliance::transaction_reporting::{ReportingPeriod, PeriodType};
    
    let period = ReportingPeriod {
        start_date: Utc::now() - Duration::hours(1),
        end_date: Utc::now(),
        period_type: PeriodType::Daily,
    };

    let result = reporter.generate_transparency_reports(&period).await;

    assert!(result.is_ok(), "Should generate transparency report successfully");
    
    let reports = result.unwrap();
    assert!(reports.period.start_date <= reports.period.end_date, "Time range should be valid");
    assert!(reports.pre_trade_transparency.quotes_published >= 0, "Should have quote count");
    assert!(reports.post_trade_transparency.transactions_reported >= 0, "Should have transaction count");
}

#[tokio::test]
async fn test_pre_trade_transparency() {
    let config = create_default_mifid_config();
    let reporter = TransactionReporter::new(&config);

    use trading_engine::compliance::transaction_reporting::{ReportingPeriod, PeriodType};
    
    let period = ReportingPeriod {
        start_date: Utc::now() - Duration::hours(1),
        end_date: Utc::now(),
        period_type: PeriodType::Daily,
    };

    let result = reporter.generate_transparency_reports(&period).await;
    assert!(result.is_ok(), "Should retrieve pre-trade transparency data");
    
    let reports = result.unwrap();
    assert!(reports.pre_trade_transparency.quotes_published >= 0, "Should have quotes");
    assert!(reports.pre_trade_transparency.quote_availability >= 0.0, "Should have availability metric");
}

#[tokio::test]
async fn test_post_trade_transparency() {
    let config = create_default_mifid_config();
    let reporter = TransactionReporter::new(&config);

    use trading_engine::compliance::transaction_reporting::{ReportingPeriod, PeriodType};
    
    let period = ReportingPeriod {
        start_date: Utc::now() - Duration::hours(1),
        end_date: Utc::now(),
        period_type: PeriodType::Daily,
    };

    let result = reporter.generate_transparency_reports(&period).await;
    assert!(result.is_ok(), "Should retrieve post-trade transparency data");
    
    let reports = result.unwrap();
    assert!(reports.post_trade_transparency.transactions_reported >= 0, "Should have transactions");
    assert!(reports.post_trade_transparency.reporting_completeness >= 0.0, "Should have completeness metric");
}

#[tokio::test]
async fn test_report_amendment() {
    let config = create_default_mifid_config();
    let reporter = TransactionReporter::new(&config);

    let execution = create_sample_order_execution();
    let original_report = reporter.generate_transaction_report(&execution).await.unwrap();
    let original_report_id = original_report.header.report_id.clone();
    
    let submit_result = reporter.submit_report(original_report, "ESMA").await;
    assert!(submit_result.is_ok(), "Original submission should succeed");

    // Create amended report with corrected price
    let mut amended_execution = create_sample_order_execution();
    amended_execution.execution_price = Decimal::new(15050, 2); // 150.50
    let mut amended_report = reporter.generate_transaction_report(&amended_execution).await.unwrap();
    amended_report.header.original_report_reference = Some(original_report_id);
    
    let amend_result = reporter.submit_report(amended_report, "ESMA").await;
    assert!(amend_result.is_ok(), "Report amendment should succeed");
}

#[tokio::test]
async fn test_report_cancellation() {
    let config = create_default_mifid_config();
    let reporter = TransactionReporter::new(&config);

    let execution = create_sample_order_execution();
    let mut report = reporter.generate_transaction_report(&execution).await.unwrap();
    
    let submit_result = reporter.submit_report(report.clone(), "ESMA").await;
    assert!(submit_result.is_ok(), "Submission should succeed");

    // Mark report as cancelled in metadata
    report.metadata.status = ReportStatus::Cancelled;
    
    assert!(
        matches!(report.metadata.status, ReportStatus::Cancelled),
        "Report should be marked as cancelled"
    );
}

#[tokio::test]
async fn test_batch_report_submission() {
    let config = create_default_mifid_config();
    let reporter = TransactionReporter::new(&config);

    let mut submission_ids = Vec::new();
    for i in 0..10 {
        let mut execution = create_sample_order_execution();
        execution.execution_id = format!("EXEC{:03}", i);
        execution.order_id = format!("ORD{:03}", i);
        
        let report = reporter.generate_transaction_report(&execution).await.unwrap();
        let submission = reporter.submit_report(report, "ESMA").await;
        
        assert!(submission.is_ok(), "Submission {} should succeed", i);
        submission_ids.push(submission.unwrap().authority_id);
    }

    assert_eq!(submission_ids.len(), 10, "Should return 10 submission IDs");
}

#[tokio::test]
async fn test_rts22_field_coverage() {
    let config = create_default_mifid_config();
    let reporter = TransactionReporter::new(&config);

    let execution = create_sample_order_execution();
    let report = reporter.generate_transaction_report(&execution).await.unwrap();
    
    // Validate that all RTS 22 required fields are present in nested structure
    assert!(!report.header.report_id.is_empty(), "report_id should be present");
    assert!(!report.transaction.transaction_reference.is_empty(), "transaction_reference should be present");
    assert!(!report.instrument.instrument_name.is_empty(), "instrument should be present");
    assert!(report.instrument.isin.is_some(), "isin should be present");
    assert!(!report.transaction.price_currency.is_empty(), "currency should be present");
    assert!(report.transaction.quantity > Decimal::ZERO, "quantity should be positive");
    assert!(report.transaction.price > Decimal::ZERO, "price should be positive");
    assert!(!report.venue.venue_id.is_empty(), "venue should be present");
}

#[tokio::test]
async fn test_venue_type_validation() {
    let config = create_default_mifid_config();
    let reporter = TransactionReporter::new(&config);

    let venue_ids = vec![
        "XNYS", // NYSE
        "XNAS", // NASDAQ
        "XLON", // London Stock Exchange
        "XPAR", // Euronext Paris
    ];

    for venue_id in venue_ids {
        let mut execution = create_sample_order_execution();
        execution.venue = venue_id.to_string();
        
        let mut report = reporter.generate_transaction_report(&execution).await.unwrap();
        let result = reporter.validate_report(&mut report).await;
        assert!(
            result.is_ok(),
            "Venue {} should be valid",
            venue_id
        );
    }
}

#[tokio::test]
async fn test_liquidity_provision_validation() {
    // Liquidity provision is not explicitly tracked in the new structure
    // This would be part of additional_fields or venue-specific data
    let config = create_default_mifid_config();
    let reporter = TransactionReporter::new(&config);

    let execution = create_sample_order_execution();
    let mut report = reporter.generate_transaction_report(&execution).await.unwrap();
    
    // Add liquidity provision info to additional fields
    report.additional_fields.insert("liquidity_provision".to_string(), "added".to_string());
    
    let result = reporter.validate_report(&mut report).await;
    assert!(result.is_ok(), "Report with liquidity provision should be valid");
}

#[tokio::test]
async fn test_transaction_reporting_latency() {
    let config = create_default_mifid_config();
    let reporter = TransactionReporter::new(&config);

    let start = std::time::Instant::now();
    
    let execution = create_sample_order_execution();
    let result = reporter.generate_transaction_report(&execution).await;

    let duration = start.elapsed();
    
    assert!(result.is_ok(), "Report generation should succeed");
    assert!(
        duration.as_millis() < 100,
        "Report generation should complete within 100ms (actual: {}ms)",
        duration.as_millis()
    );
}

#[tokio::test]
async fn test_hft_batch_reporting_performance() {
    let config = create_default_mifid_config();
    let reporter = TransactionReporter::new(&config);

    let start = std::time::Instant::now();
    let mut submission_count = 0;
    
    for i in 0..1000 {
        let mut execution = create_sample_order_execution();
        execution.execution_id = format!("EXEC{:04}", i);
        
        let report = reporter.generate_transaction_report(&execution).await;
        if report.is_ok() {
            submission_count += 1;
        }
    }

    let duration = start.elapsed();
    
    assert_eq!(submission_count, 1000, "Should generate 1000 reports");
    assert!(
        duration.as_secs() < 5,
        "Batch submission of 1000 reports should complete within 5 seconds (actual: {}s)",
        duration.as_secs()
    );
}

#[tokio::test]
async fn test_waiver_indicator_handling() {
    let config = create_default_mifid_config();
    let reporter = TransactionReporter::new(&config);

    let execution = create_sample_order_execution();
    let mut report = reporter.generate_transaction_report(&execution).await.unwrap();
    report.additional_fields.insert("waiver_indicator".to_string(), "RFPT".to_string()); // Reference Price Transparency waiver
    
    let result = reporter.validate_report(&mut report).await;
    assert!(result.is_ok(), "Waiver indicator should be valid");
}

#[tokio::test]
async fn test_transmission_indicator() {
    let config = create_default_mifid_config();
    let reporter = TransactionReporter::new(&config);

    let execution = create_sample_order_execution();
    let mut report = reporter.generate_transaction_report(&execution).await.unwrap();
    report.additional_fields.insert("transmission_indicator".to_string(), "true".to_string()); // Order transmitted to another entity
    
    let result = reporter.validate_report(&mut report).await;
    assert!(result.is_ok(), "Transmission indicator should be valid");
}