//! Compliance Integration Tests - Runtime Query Version
//!
//! This module provides comprehensive end-to-end integration tests for compliance
//! systems with live PostgreSQL database.

use chrono::{DateTime, Duration, Utc};
use sqlx::postgres::{PgPool, PgPoolOptions};
use sqlx::Row;
use uuid::Uuid;

/// Database connection pool for tests
async fn get_test_pool() -> PgPool {
    PgPoolOptions::new()
        .max_connections(10)
        .connect("postgresql://foxhunt:foxhunt_dev_password@localhost:5432/foxhunt")
        .await
        .expect("Failed to connect to test database")
}

// ============================================================================
// Audit Trail E2E Tests
// ============================================================================

#[tokio::test]
async fn test_audit_trail_insert_and_retrieve() {
    let pool = get_test_pool().await;
    let id = Uuid::new_v4();
    let event_id = Uuid::new_v4();

    // Insert
    sqlx::query(
        "INSERT INTO audit_trail (id, event_id, event_type, action, event_timestamp, metadata) 
         VALUES ($1, $2, $3, $4, $5, $6)"
    )
    .bind(&id)
    .bind(&event_id)
    .bind("TRADE_EXECUTION")
    .bind("EXECUTE")
    .bind(Utc::now())
    .bind(serde_json::json!({}))
    .execute(&pool)
    .await
    .expect("Failed to insert");

    // Retrieve
    let row = sqlx::query("SELECT event_type FROM audit_trail WHERE id = $1")
        .bind(&id)
        .fetch_one(&pool)
        .await
        .expect("Failed to retrieve");

    let event_type: String = row.try_get("event_type").expect("Failed to get event_type");
    assert_eq!(event_type, "TRADE_EXECUTION");
}

#[tokio::test]
async fn test_concurrent_audit_logging_100_events() {
    let pool = get_test_pool().await;
    let start_time = Utc::now();

    let mut handles = Vec::new();
    for i in 0..100 {
        let pool_clone = pool.clone();
        let handle = tokio::spawn(async move {
            sqlx::query(
                "INSERT INTO audit_trail (id, event_id, event_type, action, event_timestamp, metadata)
                 VALUES ($1, $2, $3, $4, $5, $6)"
            )
            .bind(Uuid::new_v4())
            .bind(Uuid::new_v4())
            .bind("CONCURRENT_TEST")
            .bind(format!("ACTION_{}", i))
            .bind(Utc::now())
            .bind(serde_json::json!({"iteration": i}))
            .execute(&pool_clone)
            .await
            .expect("Failed concurrent insert");
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.await.expect("Task failed");
    }

    let end_time = Utc::now();

    // Verify count
    let row = sqlx::query(
        "SELECT COUNT(*) as count FROM audit_trail 
         WHERE event_type = 'CONCURRENT_TEST' 
         AND event_timestamp >= $1 AND event_timestamp <= $2"
    )
    .bind(start_time)
    .bind(end_time)
    .fetch_one(&pool)
    .await
    .expect("Failed to count");

    let count: i64 = row.try_get("count").expect("Failed to get count");
    assert_eq!(count, 100);
}

// ============================================================================
// SOX Compliance Tests
// ============================================================================

#[tokio::test]
async fn test_sox_302_certification_workflow() {
    let pool = get_test_pool().await;
    let cert_id = Uuid::new_v4();

    // Create certification
    sqlx::query(
        "INSERT INTO audit_trail (id, event_id, event_type, action, user_id, username, user_role,
         target_type, target_id, event_timestamp, metadata, approval_required, approval_status, regulatory_impact)
         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)"
    )
    .bind(&cert_id)
    .bind(Uuid::new_v4())
    .bind("SOX_302_CERTIFICATION")
    .bind("CERTIFY")
    .bind("ceo_001")
    .bind("John CEO")
    .bind("CEO")
    .bind("financial_statement")
    .bind("Q4_2025")
    .bind(Utc::now())
    .bind(serde_json::json!({"section": "302"}))
    .bind(true)
    .bind("PENDING")
    .bind(true)
    .execute(&pool)
    .await
    .expect("Failed to insert");

    // Approve
    sqlx::query(
        "UPDATE audit_trail SET approval_status = $1, approved_by = $2, approval_timestamp = $3
         WHERE id = $4"
    )
    .bind("APPROVED")
    .bind("cfo_001")
    .bind(Utc::now())
    .bind(&cert_id)
    .execute(&pool)
    .await
    .expect("Failed to approve");

    // Verify
    let row = sqlx::query("SELECT approval_status, approved_by FROM audit_trail WHERE id = $1")
        .bind(&cert_id)
        .fetch_one(&pool)
        .await
        .expect("Failed to retrieve");

    let status: Option<String> = row.try_get("approval_status").ok();
    let approver: Option<String> = row.try_get("approved_by").ok();

    assert_eq!(status.as_deref(), Some("APPROVED"));
    assert_eq!(approver.as_deref(), Some("cfo_001"));
}

#[tokio::test]
async fn test_sox_404_internal_controls() {
    let pool = get_test_pool().await;
    let test_id = Uuid::new_v4();

    sqlx::query(
        "INSERT INTO audit_trail (id, event_id, event_type, action, user_id, username,
         target_type, target_id, event_timestamp, metadata, compliance_review_required, regulatory_impact)
         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)"
    )
    .bind(&test_id)
    .bind(Uuid::new_v4())
    .bind("SOX_404_CONTROL_TEST")
    .bind("TEST")
    .bind("auditor_001")
    .bind("Jane Auditor")
    .bind("internal_control")
    .bind("IC_001")
    .bind(Utc::now())
    .bind(serde_json::json!({"section": "404", "result": "PASS"}))
    .bind(true)
    .bind(true)
    .execute(&pool)
    .await
    .expect("Failed to insert");

    // Verify
    let row = sqlx::query("SELECT event_type, compliance_review_required FROM audit_trail WHERE id = $1")
        .bind(&test_id)
        .fetch_one(&pool)
        .await
        .expect("Failed to retrieve");

    let event_type: String = row.try_get("event_type").unwrap();
    let review_required: Option<bool> = row.try_get("compliance_review_required").ok();

    assert_eq!(event_type, "SOX_404_CONTROL_TEST");
    assert_eq!(review_required, Some(true));
}

#[tokio::test]
async fn test_sox_409_real_time_disclosure() {
    let pool = get_test_pool().await;
    let disclosure_id = Uuid::new_v4();

    sqlx::query(
        "INSERT INTO audit_trail (id, event_id, event_type, action, user_id,
         target_type, target_id, event_timestamp, effective_timestamp, metadata, regulatory_impact)
         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)"
    )
    .bind(&disclosure_id)
    .bind(Uuid::new_v4())
    .bind("SOX_409_DISCLOSURE")
    .bind("DISCLOSE")
    .bind("compliance_001")
    .bind("material_event")
    .bind("EVENT_001")
    .bind(Utc::now())
    .bind(Some(Utc::now()))
    .bind(serde_json::json!({"section": "409", "event": "material_change"}))
    .bind(true)
    .execute(&pool)
    .await
    .expect("Failed to insert");

    // Verify
    let row = sqlx::query("SELECT event_type, regulatory_impact FROM audit_trail WHERE id = $1")
        .bind(&disclosure_id)
        .fetch_one(&pool)
        .await
        .expect("Failed to retrieve");

    let event_type: String = row.try_get("event_type").unwrap();
    let regulatory: Option<bool> = row.try_get("regulatory_impact").ok();

    assert_eq!(event_type, "SOX_409_DISCLOSURE");
    assert_eq!(regulatory, Some(true));
}

#[tokio::test]
async fn test_sox_segregation_of_duties() {
    let pool = get_test_pool().await;
    let trade_id = format!("TRADE_{}", Uuid::new_v4());

    // Creator
    sqlx::query(
        "INSERT INTO audit_trail (id, event_id, event_type, action, user_id, username, user_role,
         target_type, target_id, event_timestamp, metadata)
         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)"
    )
    .bind(Uuid::new_v4())
    .bind(Uuid::new_v4())
    .bind("TRADE_CREATED")
    .bind("CREATE")
    .bind("trader_001")
    .bind("Trader One")
    .bind("TRADER")
    .bind("trade")
    .bind(&trade_id)
    .bind(Utc::now())
    .bind(serde_json::json!({"amount": 100000}))
    .execute(&pool)
    .await
    .expect("Failed to insert");

    // Approver (different user)
    sqlx::query(
        "INSERT INTO audit_trail (id, event_id, event_type, action, user_id, username, user_role,
         target_type, target_id, event_timestamp, metadata, approval_required, approval_status, approved_by)
         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)"
    )
    .bind(Uuid::new_v4())
    .bind(Uuid::new_v4())
    .bind("TRADE_APPROVED")
    .bind("APPROVE")
    .bind("manager_001")
    .bind("Manager One")
    .bind("MANAGER")
    .bind("trade")
    .bind(&trade_id)
    .bind(Utc::now())
    .bind(serde_json::json!({"approval_level": "MANAGER"}))
    .bind(true)
    .bind("APPROVED")
    .bind("manager_001")
    .execute(&pool)
    .await
    .expect("Failed to insert");

    // Verify SOD
    let rows = sqlx::query("SELECT DISTINCT user_id FROM audit_trail WHERE target_id = $1 ORDER BY user_id")
        .bind(&trade_id)
        .fetch_all(&pool)
        .await
        .expect("Failed to check SOD");

    assert_eq!(rows.len(), 2);
}

// ============================================================================
// MiFID II Transaction Reporting Tests
// ============================================================================

#[tokio::test]
async fn test_mifid_rts22_transaction_reporting() {
    let pool = get_test_pool().await;
    let report_id = Uuid::new_v4();

    sqlx::query(
        "INSERT INTO audit_trail (id, event_id, event_type, action, user_id,
         target_type, target_id, event_timestamp, metadata, regulatory_impact)
         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)"
    )
    .bind(&report_id)
    .bind(Uuid::new_v4())
    .bind("MIFID_RTS22_REPORT")
    .bind("SUBMIT")
    .bind("reporting_service")
    .bind("transaction_report")
    .bind("RTS22_001")
    .bind(Utc::now())
    .bind(serde_json::json!({
        "regulation": "RTS22",
        "authority": "ESMA",
        "instrument": "AAPL",
        "isin": "US0378331005"
    }))
    .bind(true)
    .execute(&pool)
    .await
    .expect("Failed to insert");

    // Verify
    let row = sqlx::query("SELECT event_type, regulatory_impact FROM audit_trail WHERE id = $1")
        .bind(&report_id)
        .fetch_one(&pool)
        .await
        .expect("Failed to retrieve");

    let event_type: String = row.try_get("event_type").unwrap();
    assert_eq!(event_type, "MIFID_RTS22_REPORT");
}

#[tokio::test]
async fn test_mifid_rts27_best_execution_monitoring() {
    let pool = get_test_pool().await;
    let monitoring_id = Uuid::new_v4();

    sqlx::query(
        "INSERT INTO audit_trail (id, event_id, event_type, action, user_id,
         target_type, target_id, event_timestamp, metadata, regulatory_impact)
         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)"
    )
    .bind(&monitoring_id)
    .bind(Uuid::new_v4())
    .bind("MIFID_RTS27_MONITORING")
    .bind("MONITOR")
    .bind("compliance_service")
    .bind("best_execution")
    .bind("BE_MONITOR_001")
    .bind(Utc::now())
    .bind(serde_json::json!({"regulation": "RTS27", "venue": "XNAS"}))
    .bind(true)
    .execute(&pool)
    .await
    .expect("Failed to insert");

    // Verify
    let row = sqlx::query("SELECT event_type FROM audit_trail WHERE id = $1")
        .bind(&monitoring_id)
        .fetch_one(&pool)
        .await
        .expect("Failed to retrieve");

    let event_type: String = row.try_get("event_type").unwrap();
    assert_eq!(event_type, "MIFID_RTS27_MONITORING");
}

#[tokio::test]
async fn test_mifid_timestamp_microsecond_precision() {
    let pool = get_test_pool().await;
    let trade_id = Uuid::new_v4();
    let precise_timestamp = Utc::now();

    sqlx::query(
        "INSERT INTO audit_trail (id, event_id, event_type, action, user_id,
         target_type, target_id, event_timestamp, metadata, regulatory_impact)
         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)"
    )
    .bind(&trade_id)
    .bind(Uuid::new_v4())
    .bind("MIFID_TRADE_EXECUTION")
    .bind("EXECUTE")
    .bind("trading_service")
    .bind("trade")
    .bind("TRADE_PRECISE_001")
    .bind(precise_timestamp)
    .bind(serde_json::json!({"timestamp_precision": "microsecond"}))
    .bind(true)
    .execute(&pool)
    .await
    .expect("Failed to insert");

    // Verify timestamp precision
    let row = sqlx::query("SELECT event_timestamp FROM audit_trail WHERE id = $1")
        .bind(&trade_id)
        .fetch_one(&pool)
        .await
        .expect("Failed to retrieve");

    let timestamp: DateTime<Utc> = row.try_get("event_timestamp").unwrap();
    let diff = (timestamp.timestamp_micros() - precise_timestamp.timestamp_micros()).abs();
    assert!(diff < 1000); // Within 1ms
}

#[tokio::test]
async fn test_mifid_client_lei_codes() {
    let pool = get_test_pool().await;
    let trade_id = Uuid::new_v4();

    sqlx::query(
        "INSERT INTO audit_trail (id, event_id, event_type, action, user_id,
         target_type, target_id, event_timestamp, metadata, regulatory_impact)
         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)"
    )
    .bind(&trade_id)
    .bind(Uuid::new_v4())
    .bind("MIFID_CLIENT_TRADE")
    .bind("EXECUTE")
    .bind("trading_service")
    .bind("client_trade")
    .bind("CLIENT_TRADE_001")
    .bind(Utc::now())
    .bind(serde_json::json!({"client_lei": "549300XXXXXXXXXXXXXXXXX"}))
    .bind(true)
    .execute(&pool)
    .await
    .expect("Failed to insert");

    // Verify LEI
    let row = sqlx::query("SELECT metadata FROM audit_trail WHERE id = $1")
        .bind(&trade_id)
        .fetch_one(&pool)
        .await
        .expect("Failed to retrieve");

    let metadata: Option<serde_json::Value> = row.try_get("metadata").ok();
    assert!(metadata.unwrap()["client_lei"].as_str().unwrap().starts_with("549300"));
}

#[tokio::test]
async fn test_mifid_instrument_isin_figi() {
    let pool = get_test_pool().await;
    let trade_id = Uuid::new_v4();

    sqlx::query(
        "INSERT INTO audit_trail (id, event_id, event_type, action, user_id,
         target_type, target_id, event_timestamp, metadata, regulatory_impact)
         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)"
    )
    .bind(&trade_id)
    .bind(Uuid::new_v4())
    .bind("MIFID_INSTRUMENT_TRADE")
    .bind("EXECUTE")
    .bind("trading_service")
    .bind("trade")
    .bind("INSTRUMENT_TRADE_001")
    .bind(Utc::now())
    .bind(serde_json::json!({"isin": "US0378331005", "figi": "BBG000B9XRY4"}))
    .bind(true)
    .execute(&pool)
    .await
    .expect("Failed to insert");

    // Verify identifiers
    let row = sqlx::query("SELECT metadata FROM audit_trail WHERE id = $1")
        .bind(&trade_id)
        .fetch_one(&pool)
        .await
        .expect("Failed to retrieve");

    let metadata: serde_json::Value = row.try_get("metadata").unwrap();
    assert_eq!(metadata["isin"].as_str().unwrap(), "US0378331005");
    assert_eq!(metadata["figi"].as_str().unwrap(), "BBG000B9XRY4");
}

#[tokio::test]
async fn test_mifid_venue_mic_codes() {
    let pool = get_test_pool().await;
    let trade_id = Uuid::new_v4();

    sqlx::query(
        "INSERT INTO audit_trail (id, event_id, event_type, action, user_id,
         target_type, target_id, event_timestamp, metadata, regulatory_impact)
         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)"
    )
    .bind(&trade_id)
    .bind(Uuid::new_v4())
    .bind("MIFID_VENUE_TRADE")
    .bind("EXECUTE")
    .bind("trading_service")
    .bind("trade")
    .bind("VENUE_TRADE_001")
    .bind(Utc::now())
    .bind(serde_json::json!({"execution_venue_mic": "XNAS", "venue_name": "NASDAQ"}))
    .bind(true)
    .execute(&pool)
    .await
    .expect("Failed to insert");

    // Verify MIC
    let row = sqlx::query("SELECT metadata FROM audit_trail WHERE id = $1")
        .bind(&trade_id)
        .fetch_one(&pool)
        .await
        .expect("Failed to retrieve");

    let metadata: serde_json::Value = row.try_get("metadata").unwrap();
    assert_eq!(metadata["execution_venue_mic"].as_str().unwrap(), "XNAS");
}

#[tokio::test]
async fn test_mifid_multi_jurisdiction_reporting() {
    let pool = get_test_pool().await;
    let trade_id = Uuid::new_v4().to_string();

    // EU
    sqlx::query(
        "INSERT INTO audit_trail (id, event_id, event_type, action, user_id,
         target_type, target_id, event_timestamp, metadata, regulatory_impact)
         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)"
    )
    .bind(Uuid::new_v4())
    .bind(Uuid::new_v4())
    .bind("MIFID_EU_REPORT")
    .bind("SUBMIT")
    .bind("reporting_service")
    .bind("transaction_report")
    .bind(&trade_id)
    .bind(Utc::now())
    .bind(serde_json::json!({"jurisdiction": "EU", "authority": "ESMA"}))
    .bind(true)
    .execute(&pool)
    .await
    .expect("Failed to insert EU");

    // UK
    sqlx::query(
        "INSERT INTO audit_trail (id, event_id, event_type, action, user_id,
         target_type, target_id, event_timestamp, metadata, regulatory_impact)
         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)"
    )
    .bind(Uuid::new_v4())
    .bind(Uuid::new_v4())
    .bind("MIFID_UK_REPORT")
    .bind("SUBMIT")
    .bind("reporting_service")
    .bind("transaction_report")
    .bind(&trade_id)
    .bind(Utc::now())
    .bind(serde_json::json!({"jurisdiction": "UK", "authority": "FCA"}))
    .bind(true)
    .execute(&pool)
    .await
    .expect("Failed to insert UK");

    // US
    sqlx::query(
        "INSERT INTO audit_trail (id, event_id, event_type, action, user_id,
         target_type, target_id, event_timestamp, metadata, regulatory_impact)
         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)"
    )
    .bind(Uuid::new_v4())
    .bind(Uuid::new_v4())
    .bind("SEC_TRADE_REPORT")
    .bind("SUBMIT")
    .bind("reporting_service")
    .bind("transaction_report")
    .bind(&trade_id)
    .bind(Utc::now())
    .bind(serde_json::json!({"jurisdiction": "US", "authority": "SEC"}))
    .bind(true)
    .execute(&pool)
    .await
    .expect("Failed to insert US");

    // Verify
    let rows = sqlx::query("SELECT event_type FROM audit_trail WHERE target_id = $1")
        .bind(&trade_id)
        .fetch_all(&pool)
        .await
        .expect("Failed to retrieve");

    assert_eq!(rows.len(), 3);
}

// ============================================================================
// Regulatory API Integration Tests
// ============================================================================

#[tokio::test]
async fn test_sec_form_13f_submission() {
    let pool = get_test_pool().await;
    let submission_id = Uuid::new_v4();

    sqlx::query(
        "INSERT INTO audit_trail (id, event_id, event_type, action, user_id,
         target_type, target_id, event_timestamp, metadata, regulatory_impact, compliance_review_required)
         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)"
    )
    .bind(&submission_id)
    .bind(Uuid::new_v4())
    .bind("SEC_FORM_13F")
    .bind("SUBMIT")
    .bind("reporting_service")
    .bind("sec_filing")
    .bind("13F_Q4_2025")
    .bind(Utc::now())
    .bind(serde_json::json!({"form_type": "13F-HR", "period_end": "2025-12-31"}))
    .bind(true)
    .bind(true)
    .execute(&pool)
    .await
    .expect("Failed to insert");

    // Verify
    let row = sqlx::query("SELECT event_type FROM audit_trail WHERE id = $1")
        .bind(&submission_id)
        .fetch_one(&pool)
        .await
        .expect("Failed to retrieve");

    let event_type: String = row.try_get("event_type").unwrap();
    assert_eq!(event_type, "SEC_FORM_13F");
}

#[tokio::test]
async fn test_finra_trace_reporting() {
    let pool = get_test_pool().await;
    let report_id = Uuid::new_v4();

    sqlx::query(
        "INSERT INTO audit_trail (id, event_id, event_type, action, user_id,
         target_type, target_id, event_timestamp, metadata, regulatory_impact)
         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)"
    )
    .bind(&report_id)
    .bind(Uuid::new_v4())
    .bind("FINRA_TRACE_REPORT")
    .bind("SUBMIT")
    .bind("reporting_service")
    .bind("finra_report")
    .bind("TRACE_001")
    .bind(Utc::now())
    .bind(serde_json::json!({"report_type": "TRACE", "security_type": "CORPORATE_BOND"}))
    .bind(true)
    .execute(&pool)
    .await
    .expect("Failed to insert");

    // Verify
    let row = sqlx::query("SELECT event_type FROM audit_trail WHERE id = $1")
        .bind(&report_id)
        .fetch_one(&pool)
        .await
        .expect("Failed to retrieve");

    let event_type: String = row.try_get("event_type").unwrap();
    assert_eq!(event_type, "FINRA_TRACE_REPORT");
}

#[tokio::test]
async fn test_fca_uk_transaction_submission() {
    let pool = get_test_pool().await;
    let report_id = Uuid::new_v4();

    sqlx::query(
        "INSERT INTO audit_trail (id, event_id, event_type, action, user_id,
         target_type, target_id, event_timestamp, metadata, regulatory_impact)
         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)"
    )
    .bind(&report_id)
    .bind(Uuid::new_v4())
    .bind("FCA_TRANSACTION_REPORT")
    .bind("SUBMIT")
    .bind("reporting_service")
    .bind("fca_report")
    .bind("FCA_TXN_001")
    .bind(Utc::now())
    .bind(serde_json::json!({"authority": "FCA", "jurisdiction": "UK"}))
    .bind(true)
    .execute(&pool)
    .await
    .expect("Failed to insert");

    // Verify
    let row = sqlx::query("SELECT event_type FROM audit_trail WHERE id = $1")
        .bind(&report_id)
        .fetch_one(&pool)
        .await
        .expect("Failed to retrieve");

    let event_type: String = row.try_get("event_type").unwrap();
    assert_eq!(event_type, "FCA_TRANSACTION_REPORT");
}

#[tokio::test]
async fn test_esma_eu_transaction_submission() {
    let pool = get_test_pool().await;
    let report_id = Uuid::new_v4();

    sqlx::query(
        "INSERT INTO audit_trail (id, event_id, event_type, action, user_id,
         target_type, target_id, event_timestamp, metadata, regulatory_impact)
         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)"
    )
    .bind(&report_id)
    .bind(Uuid::new_v4())
    .bind("ESMA_TRANSACTION_REPORT")
    .bind("SUBMIT")
    .bind("reporting_service")
    .bind("esma_report")
    .bind("ESMA_TXN_001")
    .bind(Utc::now())
    .bind(serde_json::json!({"authority": "ESMA", "jurisdiction": "EU"}))
    .bind(true)
    .execute(&pool)
    .await
    .expect("Failed to insert");

    // Verify
    let row = sqlx::query("SELECT event_type FROM audit_trail WHERE id = $1")
        .bind(&report_id)
        .fetch_one(&pool)
        .await
        .expect("Failed to retrieve");

    let event_type: String = row.try_get("event_type").unwrap();
    assert_eq!(event_type, "ESMA_TRANSACTION_REPORT");
}

// ============================================================================
// Database Integration Tests
// ============================================================================

#[tokio::test]
async fn test_acid_transaction_atomicity() {
    let pool = get_test_pool().await;
    let mut tx = pool.begin().await.expect("Failed to start tx");

    let id1 = Uuid::new_v4();
    let id2 = Uuid::new_v4();

    sqlx::query(
        "INSERT INTO audit_trail (id, event_id, event_type, action, event_timestamp, metadata)
         VALUES ($1, $2, 'TEST_ATOMIC', 'INSERT', $3, $4)"
    )
    .bind(&id1)
    .bind(Uuid::new_v4())
    .bind(Utc::now())
    .bind(serde_json::json!({}))
    .execute(&mut *tx)
    .await
    .expect("Failed to insert 1");

    sqlx::query(
        "INSERT INTO audit_trail (id, event_id, event_type, action, event_timestamp, metadata)
         VALUES ($1, $2, 'TEST_ATOMIC', 'INSERT', $3, $4)"
    )
    .bind(&id2)
    .bind(Uuid::new_v4())
    .bind(Utc::now())
    .bind(serde_json::json!({}))
    .execute(&mut *tx)
    .await
    .expect("Failed to insert 2");

    tx.rollback().await.expect("Failed to rollback");

    // Verify events don't exist
    let row = sqlx::query(
        "SELECT COUNT(*) as count FROM audit_trail WHERE id = $1 OR id = $2"
    )
    .bind(&id1)
    .bind(&id2)
    .fetch_one(&pool)
    .await
    .expect("Failed to count");

    let count: i64 = row.try_get("count").unwrap();
    assert_eq!(count, 0);
}

#[tokio::test]
async fn test_acid_transaction_isolation() {
    let pool = get_test_pool().await;
    let mut tx1 = pool.begin().await.expect("Failed to start tx1");
    let id = Uuid::new_v4();

    sqlx::query(
        "INSERT INTO audit_trail (id, event_id, event_type, action, event_timestamp, metadata)
         VALUES ($1, $2, 'TEST_ISOLATION', 'INSERT', $3, $4)"
    )
    .bind(&id)
    .bind(Uuid::new_v4())
    .bind(Utc::now())
    .bind(serde_json::json!({}))
    .execute(&mut *tx1)
    .await
    .expect("Failed to insert");

    // tx2 shouldn't see uncommitted data
    let row = sqlx::query("SELECT COUNT(*) as count FROM audit_trail WHERE id = $1")
        .bind(&id)
        .fetch_one(&pool)
        .await
        .expect("Failed to count");

    let count: i64 = row.try_get("count").unwrap();
    assert_eq!(count, 0); // Isolation

    tx1.commit().await.expect("Failed to commit");

    // Now visible
    let row = sqlx::query("SELECT COUNT(*) as count FROM audit_trail WHERE id = $1")
        .bind(&id)
        .fetch_one(&pool)
        .await
        .expect("Failed to count after commit");

    let count: i64 = row.try_get("count").unwrap();
    assert_eq!(count, 1);
}

#[tokio::test]
async fn test_acid_transaction_durability() {
    let pool = get_test_pool().await;
    let id = Uuid::new_v4();

    let mut tx = pool.begin().await.expect("Failed to start tx");

    sqlx::query(
        "INSERT INTO audit_trail (id, event_id, event_type, action, event_timestamp, metadata)
         VALUES ($1, $2, 'TEST_DURABILITY', 'INSERT', $3, $4)"
    )
    .bind(&id)
    .bind(Uuid::new_v4())
    .bind(Utc::now())
    .bind(serde_json::json!({"durable": true}))
    .execute(&mut *tx)
    .await
    .expect("Failed to insert");

    tx.commit().await.expect("Failed to commit");

    // Reconnect and verify
    drop(pool);
    let new_pool = get_test_pool().await;

    let row = sqlx::query("SELECT metadata FROM audit_trail WHERE id = $1")
        .bind(&id)
        .fetch_one(&new_pool)
        .await
        .expect("Failed to retrieve");

    let metadata: serde_json::Value = row.try_get("metadata").unwrap();
    assert_eq!(metadata["durable"].as_bool().unwrap(), true);
}