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::{
    DecisionMaker, InstrumentClassification, OrderExecution, ReportStatus, SubmissionStatus,
    TradingCapacity, TransactionReport, TransactionReporter, TransmissionMethod, UnitOfMeasure,
    ValidationStatus,
};
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::{PeriodType, ReportingPeriod};

    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::{PeriodType, ReportingPeriod};

    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::{PeriodType, ReportingPeriod};

    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");
}