//! TDD tests for EtlMetrics functionality
//! These tests define expected behavior for metrics recording

use rtx_etl::dag::TaskType;
use rtx_etl::monitoring::EtlMetrics;
use std::sync::Arc;
use std::time::Duration;

#[tokio::test]
async fn test_record_task_execution() {
    // Test recording task execution metrics
    let metrics = Arc::new(EtlMetrics::new());

    // Should be able to record task execution
    metrics
        .record_task_execution(
            "task1",
            &TaskType::Extract,
            Duration::from_millis(500),
            true,
        )
        .await;

    // Metrics should be updated
    let stats = metrics.get_task_stats("task1").await;
    assert!(stats.is_some());

    let task_stats = stats.unwrap();
    assert_eq!(task_stats.total_executions, 1);
    assert_eq!(task_stats.successful_executions, 1);
    assert_eq!(task_stats.failed_executions, 0);
}

#[tokio::test]
async fn test_record_batch_processed() {
    // Test recording batch processing metrics
    let metrics = EtlMetrics::new();

    // Should be able to record batch processing
    metrics
        .record_batch_processed(100, Duration::from_millis(1000))
        .await;

    // Should be able to get batch metrics
    let batch_stats = metrics.get_batch_stats().await;
    assert_eq!(batch_stats.total_batches, 1);
    assert_eq!(batch_stats.total_records, 100);
    assert!(batch_stats.avg_processing_time.as_millis() > 0);
}

#[tokio::test]
async fn test_get_task_stats() {
    // Test retrieving task statistics
    let metrics = Arc::new(EtlMetrics::new());

    // Record some executions
    metrics
        .record_task_execution(
            "task1",
            &TaskType::Transform,
            Duration::from_millis(200),
            true,
        )
        .await;
    metrics
        .record_task_execution(
            "task1",
            &TaskType::Transform,
            Duration::from_millis(300),
            false,
        )
        .await;

    // Should get accurate stats
    let stats = metrics.get_task_stats("task1").await.unwrap();
    assert_eq!(stats.total_executions, 2);
    assert_eq!(stats.successful_executions, 1);
    assert_eq!(stats.failed_executions, 1);
    assert!(stats.avg_execution_time.as_millis() > 0);
}

#[tokio::test]
async fn test_metrics_thread_safety() {
    // Test that metrics can be safely accessed from multiple threads
    let metrics = Arc::new(EtlMetrics::new());
    let mut handles = vec![];

    for i in 0..10 {
        let metrics_clone = metrics.clone();
        let handle = tokio::spawn(async move {
            metrics_clone
                .record_task_execution(
                    &format!("task{}", i),
                    &TaskType::Load,
                    Duration::from_millis(100),
                    true,
                )
                .await;
        });
        handles.push(handle);
    }

    // Wait for all tasks to complete
    for handle in handles {
        handle.await.unwrap();
    }

    // Should have recorded all executions
    let total_stats = metrics.get_overall_stats().await;
    assert_eq!(total_stats.total_tasks_executed, 10);
}