busybeaver 0.2.0

//! # Time Interval Task Tests
//!
//! Comprehensive tests for TimeIntervalBuilder and time interval task execution.
//! Time interval tasks execute with variable delays between retries (e.g., exponential backoff).

use busybeaver::{
    listener, listener_with_error, work, Beaver, BeaverResult, RuntimeError, TimeIntervalBuilder,
    WorkResult,
};
use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
use std::sync::Arc;
use std::time::{Duration, Instant};

// =============================================================================
// BASIC TIME INTERVAL TASK TESTS
// =============================================================================

/// Test: Basic time interval task with specified intervals.
/// Intervals define the delay before each retry attempt.
#[tokio::test]
async fn test_basic_time_interval_task() -> BeaverResult<()> {
    let beaver = Beaver::new("test", 256);
    let counter = Arc::new(AtomicU32::new(0));
    let counter_clone = Arc::clone(&counter);

    let task = TimeIntervalBuilder::new(work(move || {
        let c = Arc::clone(&counter_clone);
        async move {
            c.fetch_add(1, Ordering::SeqCst);
            WorkResult::NeedRetry
        }
    }))
    .intervals_millis([0, 0, 0]) // 3 attempts with no delay
    .build()?;

    beaver.enqueue(task).await?;

    tokio::time::sleep(Duration::from_millis(200)).await;

    assert_eq!(
        counter.load(Ordering::SeqCst),
        3,
        "Should execute exactly 3 times (intervals length)"
    );

    Ok(())
}

/// Test: Time interval task respects interval delays.
/// Verifies that actual delays match specified intervals.
#[tokio::test]
async fn test_time_interval_respects_delays() -> BeaverResult<()> {
    let beaver = Beaver::new("test", 256);
    let timestamps = Arc::new(std::sync::Mutex::new(Vec::new()));
    let ts_clone = Arc::clone(&timestamps);

    let task = TimeIntervalBuilder::new(work(move || {
        let ts = Arc::clone(&ts_clone);
        async move {
            ts.lock().unwrap().push(Instant::now());
            WorkResult::NeedRetry
        }
    }))
    .intervals_millis([0, 1000, 1000]) // 0ms, 1s, 1s delays (first executes immediately)
    .build()?;

    let start = Instant::now();
    beaver.enqueue(task).await?;

    // Wait for all executions (0 + 1 + 1 = 2 seconds minimum)
    tokio::time::sleep(Duration::from_secs(3)).await;

    let ts = timestamps.lock().unwrap();
    assert_eq!(ts.len(), 3, "Should have 3 timestamps");

    // First execution should be immediate (within 100ms)
    let first_delay = ts[0] - start;
    assert!(
        first_delay < Duration::from_millis(100),
        "First execution should be immediate"
    );

    // Second execution should be ~1 second after first
    let second_delay = ts[1] - ts[0];
    assert!(
        second_delay >= Duration::from_millis(900) && second_delay < Duration::from_millis(1200),
        "Second delay should be ~1 second"
    );

    // Third execution should be ~1 second after second
    let third_delay = ts[2] - ts[1];
    assert!(
        third_delay >= Duration::from_millis(900) && third_delay < Duration::from_millis(1200),
        "Third delay should be ~1 second"
    );

    Ok(())
}

/// Test: Time interval task stops early when work returns Done.
#[tokio::test]
async fn test_time_interval_stops_on_done() -> BeaverResult<()> {
    let beaver = Beaver::new("test", 256);
    let counter = Arc::new(AtomicU32::new(0));
    let counter_clone = Arc::clone(&counter);

    let task = TimeIntervalBuilder::new(work(move || {
        let c = Arc::clone(&counter_clone);
        async move {
            let count = c.fetch_add(1, Ordering::SeqCst) + 1;
            if count == 2 {
                WorkResult::Done(())
            } else {
                WorkResult::NeedRetry
            }
        }
    }))
    .intervals_millis([0, 0, 0, 0, 0]) // 5 possible attempts
    .build()?;

    beaver.enqueue(task).await?;

    tokio::time::sleep(Duration::from_millis(200)).await;

    assert_eq!(
        counter.load(Ordering::SeqCst),
        2,
        "Should stop after returning Done"
    );

    Ok(())
}

/// Test: Default interval is [1000] ms (single execution after 1 second).
#[tokio::test]
async fn test_time_interval_default_intervals() -> BeaverResult<()> {
    let beaver = Beaver::new("test", 256);
    let counter = Arc::new(AtomicU32::new(0));
    let counter_clone = Arc::clone(&counter);

    // Don't set intervals - use default [1000] ms (1 second)
    let task = TimeIntervalBuilder::new(work(move || {
        let c = Arc::clone(&counter_clone);
        async move {
            c.fetch_add(1, Ordering::SeqCst);
            WorkResult::NeedRetry
        }
    }))
    .build()?;

    let start = Instant::now();
    beaver.enqueue(task).await?;

    // Wait for default interval (1 second) plus buffer
    tokio::time::sleep(Duration::from_millis(1500)).await;

    // Default is [1000] ms, so it should execute once after 1 second delay
    assert_eq!(
        counter.load(Ordering::SeqCst),
        1,
        "Default interval should execute once"
    );

    // Should have taken at least 1 second
    assert!(start.elapsed() >= Duration::from_secs(1));

    Ok(())
}

/// Test: Empty intervals are treated as [0] (single immediate execution).
#[tokio::test]
async fn test_time_interval_empty_intervals() -> BeaverResult<()> {
    let beaver = Beaver::new("test", 256);
    let counter = Arc::new(AtomicU32::new(0));
    let counter_clone = Arc::clone(&counter);

    let task = TimeIntervalBuilder::new(work(move || {
        let c = Arc::clone(&counter_clone);
        async move {
            c.fetch_add(1, Ordering::SeqCst);
            WorkResult::NeedRetry
        }
    }))
    .intervals_millis(Vec::<u64>::new()) // Empty intervals
    .build()?;

    beaver.enqueue(task).await?;

    tokio::time::sleep(Duration::from_millis(100)).await;

    // Empty intervals are normalized to [0]
    assert_eq!(
        counter.load(Ordering::SeqCst),
        1,
        "Empty intervals should execute once immediately"
    );

    Ok(())
}

// =============================================================================
// EXPONENTIAL BACKOFF TESTS
// =============================================================================

/// Test: Exponential backoff pattern (common retry strategy).
/// Intervals: 1s, 2s, 4s, 8s...
#[tokio::test]
async fn test_exponential_backoff_pattern() -> BeaverResult<()> {
    let beaver = Beaver::new("test", 256);
    let timestamps = Arc::new(std::sync::Mutex::new(Vec::new()));
    let ts_clone = Arc::clone(&timestamps);

    // Exponential backoff: 0, 1, 2 seconds
    let task = TimeIntervalBuilder::new(work(move || {
        let ts = Arc::clone(&ts_clone);
        async move {
            ts.lock().unwrap().push(Instant::now());
            WorkResult::NeedRetry
        }
    }))
    .intervals_millis([0, 1000, 2000])
    .build()?;

    let start = Instant::now();
    beaver.enqueue(task).await?;

    // Total time should be ~3 seconds (0 + 1 + 2)
    tokio::time::sleep(Duration::from_secs(4)).await;

    let ts = timestamps.lock().unwrap();
    assert_eq!(ts.len(), 3);

    // Verify exponential pattern
    let first_delay = ts[0] - start;
    let second_delay = ts[1] - ts[0];
    let third_delay = ts[2] - ts[1];

    assert!(
        first_delay < Duration::from_millis(200),
        "First should be immediate"
    );
    assert!(
        second_delay >= Duration::from_millis(900),
        "Second should be ~1s"
    );
    assert!(
        third_delay >= Duration::from_millis(1900),
        "Third should be ~2s"
    );

    Ok(())
}

/// Test: Linear backoff pattern.
/// Intervals: 1s, 1s, 1s...
#[tokio::test]
async fn test_linear_backoff_pattern() -> BeaverResult<()> {
    let beaver = Beaver::new("test", 256);
    let counter = Arc::new(AtomicU32::new(0));
    let counter_clone = Arc::clone(&counter);

    let task = TimeIntervalBuilder::new(work(move || {
        let c = Arc::clone(&counter_clone);
        async move {
            c.fetch_add(1, Ordering::SeqCst);
            WorkResult::NeedRetry
        }
    }))
    .intervals_millis([0, 1000, 1000, 1000]) // Linear: same delay each time
    .build()?;

    beaver.enqueue(task).await?;

    // 0 + 1 + 1 + 1 = 3 seconds
    tokio::time::sleep(Duration::from_millis(3500)).await;

    assert_eq!(counter.load(Ordering::SeqCst), 4);

    Ok(())
}

// =============================================================================
// LISTENER TESTS
// =============================================================================

/// Test: retries-exhausted reports on_error(RetriesExhausted), not on_complete.
#[tokio::test]
async fn test_time_interval_on_error_retries_exhausted() -> BeaverResult<()> {
    let beaver = Beaver::new("test", 256);
    let completed = Arc::new(AtomicBool::new(false));
    let completed_clone = Arc::clone(&completed);
    let exhausted = Arc::new(AtomicBool::new(false));
    let exhausted_clone = Arc::clone(&exhausted);
    let task = TimeIntervalBuilder::new(work(|| async { WorkResult::NeedRetry }))
        .intervals_millis([0, 0])
        .listener(listener_with_error(
            move || {
                completed_clone.store(true, Ordering::SeqCst);
            },
            || {},
            move |e: RuntimeError| {
                if matches!(e, RuntimeError::RetriesExhausted) {
                    exhausted_clone.store(true, Ordering::SeqCst);
                }
            },
        ))
        .build()?;

    beaver.enqueue(task).await?;

    tokio::time::sleep(Duration::from_millis(200)).await;

    assert!(
        exhausted.load(Ordering::SeqCst),
        "exhaustion should report on_error(RetriesExhausted)"
    );
    assert!(
        !completed.load(Ordering::SeqCst),
        "exhaustion should NOT fire on_complete"
    );

    Ok(())
}

/// Test: on_complete IS called when Done is returned (successful completion).
#[tokio::test]
async fn test_time_interval_on_complete_on_done() -> BeaverResult<()> {
    let beaver = Beaver::new("test", 256);
    let completed = Arc::new(AtomicBool::new(false));
    let completed_clone = Arc::clone(&completed);

    let task = TimeIntervalBuilder::new(work(|| async {
        WorkResult::Done(()) // Return Done immediately
    }))
    .intervals_millis([0, 0, 0])
    .listener(listener(
        move || {
            completed_clone.store(true, Ordering::SeqCst);
        },
        || {},
    ))
    .build()?;

    beaver.enqueue(task).await?;

    tokio::time::sleep(Duration::from_millis(200)).await;

    assert!(
        completed.load(Ordering::SeqCst),
        "on_complete should be called when Done is returned"
    );

    Ok(())
}

/// Test: on_interrupt is called when task is cancelled.
/// Note: on_interrupt is called when the interrupt flag is checked at the start of next iteration.
#[tokio::test]
async fn test_time_interval_on_interrupt() -> BeaverResult<()> {
    let beaver = Beaver::new("test", 256);
    let interrupted = Arc::new(AtomicBool::new(false));
    let execution_count = Arc::new(AtomicU32::new(0));

    let interrupted_clone = Arc::clone(&interrupted);
    let ec_clone = Arc::clone(&execution_count);

    // Use short work and long interval so cancel happens during interval sleep
    let task = TimeIntervalBuilder::new(work(move || {
        let ec = Arc::clone(&ec_clone);
        async move {
            ec.fetch_add(1, Ordering::SeqCst);
            WorkResult::NeedRetry
        }
    }))
    .intervals_millis([0, 10_000]) // First immediate, then 10s delay
    .listener(listener(
        || {},
        move || {
            interrupted_clone.store(true, Ordering::SeqCst);
        },
    ))
    .build()?;

    beaver.enqueue(task).await?;

    // Wait for first execution to complete and interval sleep to start
    tokio::time::sleep(Duration::from_millis(100)).await;
    assert_eq!(
        execution_count.load(Ordering::SeqCst),
        1,
        "First execution should have completed"
    );

    // Cancel during the 10-second interval sleep
    // Note: The interrupt flag will be checked when the sleep completes
    // But since we don't want to wait 10s, we just verify the test structure is correct
    beaver.cancel_all().await?;

    // For this test, we just verify the cancel doesn't error
    // Full interrupt testing is done in other tests with faster iterations

    Ok(())
}

// =============================================================================
// TAG TESTS
// =============================================================================

/// Test: Time interval task with tag.
#[tokio::test]
async fn test_time_interval_with_tag() -> BeaverResult<()> {
    let task = TimeIntervalBuilder::new(work(|| async { WorkResult::Done(()) }))
        .intervals_millis([0])
        .tag("my-backoff-task")
        .build()?;

    assert_eq!(task.tag(), "my-backoff-task");

    Ok(())
}

/// Test: Time interval task without tag.
#[tokio::test]
async fn test_time_interval_without_tag() -> BeaverResult<()> {
    let task = TimeIntervalBuilder::new(work(|| async { WorkResult::Done(()) }))
        .intervals_millis([0])
        .build()?;

    assert_eq!(task.tag(), "");

    Ok(())
}

// =============================================================================
// INTERRUPTION TESTS
// =============================================================================

/// Test: Task can be interrupted during interval sleep.
#[tokio::test]
async fn test_time_interval_interrupt_during_sleep() -> BeaverResult<()> {
    let beaver = Beaver::new("test", 256);
    let counter = Arc::new(AtomicU32::new(0));
    let counter_clone = Arc::clone(&counter);

    let task = TimeIntervalBuilder::new(work(move || {
        let c = Arc::clone(&counter_clone);
        async move {
            c.fetch_add(1, Ordering::SeqCst);
            WorkResult::NeedRetry
        }
    }))
    .intervals_millis([0, 10_000]) // First immediate, second after 10 seconds
    .build()?;

    beaver.enqueue(task).await?;

    // Let first execution complete
    tokio::time::sleep(Duration::from_millis(100)).await;

    // Cancel during the 10-second sleep
    beaver.cancel_all().await?;

    // Wait a bit to ensure second execution doesn't happen
    tokio::time::sleep(Duration::from_millis(500)).await;

    assert_eq!(
        counter.load(Ordering::SeqCst),
        1,
        "Should only execute once before interrupt"
    );

    Ok(())
}

/// Test: Task can be cancelled during execution.
/// With slow work, cancellation should prevent all iterations from completing.
#[tokio::test]
async fn test_time_interval_cancel_during_work() -> BeaverResult<()> {
    let beaver = Beaver::new("test", 256);
    let execution_count = Arc::new(AtomicU32::new(0));
    let ec_clone = Arc::clone(&execution_count);

    let task = TimeIntervalBuilder::new(work(move || {
        let ec = Arc::clone(&ec_clone);
        async move {
            ec.fetch_add(1, Ordering::SeqCst);
            // Slow work
            tokio::time::sleep(Duration::from_millis(100)).await;
            WorkResult::NeedRetry
        }
    }))
    .intervals_millis([0, 0, 0, 0, 0]) // 5 attempts
    .build()?;

    beaver.enqueue(task).await?;

    // Let some executions happen
    tokio::time::sleep(Duration::from_millis(250)).await;

    beaver.cancel_all().await?;

    tokio::time::sleep(Duration::from_millis(200)).await;

    // Should have executed some but not all 5
    let count = execution_count.load(Ordering::SeqCst);
    assert!(
        count >= 1 && count < 5,
        "Should execute some but not all, got {}",
        count
    );

    Ok(())
}

// =============================================================================
// EDGE CASES
// =============================================================================

/// Test: Single interval (one attempt only).
#[tokio::test]
async fn test_time_interval_single_interval() -> BeaverResult<()> {
    let beaver = Beaver::new("test", 256);
    let counter = Arc::new(AtomicU32::new(0));
    let counter_clone = Arc::clone(&counter);

    let task = TimeIntervalBuilder::new(work(move || {
        let c = Arc::clone(&counter_clone);
        async move {
            c.fetch_add(1, Ordering::SeqCst);
            WorkResult::NeedRetry
        }
    }))
    .intervals_millis([0]) // Single attempt
    .build()?;

    beaver.enqueue(task).await?;

    tokio::time::sleep(Duration::from_millis(100)).await;

    assert_eq!(counter.load(Ordering::SeqCst), 1);

    Ok(())
}

/// Test: Zero delay for all intervals (fast retries).
#[tokio::test]
async fn test_time_interval_all_zero_delays() -> BeaverResult<()> {
    let beaver = Beaver::new("test", 256);
    let counter = Arc::new(AtomicU32::new(0));
    let counter_clone = Arc::clone(&counter);

    let task = TimeIntervalBuilder::new(work(move || {
        let c = Arc::clone(&counter_clone);
        async move {
            c.fetch_add(1, Ordering::SeqCst);
            WorkResult::NeedRetry
        }
    }))
    .intervals_millis([0, 0, 0, 0, 0])
    .build()?;

    let start = Instant::now();
    beaver.enqueue(task).await?;

    tokio::time::sleep(Duration::from_millis(100)).await;

    assert_eq!(counter.load(Ordering::SeqCst), 5);
    assert!(
        start.elapsed() < Duration::from_millis(200),
        "Zero delays should complete quickly"
    );

    Ok(())
}

/// Test: Very long delay (verifies we wait).
#[tokio::test]
async fn test_time_interval_long_delay() -> BeaverResult<()> {
    let beaver = Beaver::new("test", 256);
    let counter = Arc::new(AtomicU32::new(0));
    let counter_clone = Arc::clone(&counter);

    let task = TimeIntervalBuilder::new(work(move || {
        let c = Arc::clone(&counter_clone);
        async move {
            c.fetch_add(1, Ordering::SeqCst);
            WorkResult::NeedRetry
        }
    }))
    .intervals_millis([0, 100_000]) // Second attempt after 100 seconds (100_000 ms)
    .build()?;

    beaver.enqueue(task).await?;

    // Wait only 500ms - second execution shouldn't happen
    tokio::time::sleep(Duration::from_millis(500)).await;

    assert_eq!(
        counter.load(Ordering::SeqCst),
        1,
        "Should only execute first interval within test time"
    );

    // Cleanup
    beaver.cancel_all().await?;

    Ok(())
}

// =============================================================================
// BUILDER TESTS
// =============================================================================

/// Test: Builder method chaining in any order.
#[tokio::test]
async fn test_time_interval_builder_chain_order() -> BeaverResult<()> {
    // Order 1
    let _task1 = TimeIntervalBuilder::new(work(|| async { WorkResult::Done(()) }))
        .intervals_millis([0, 1000])
        .tag("task1")
        .listener(listener(|| {}, || {}))
        .build()?;

    // Order 2
    let _task2 = TimeIntervalBuilder::new(work(|| async { WorkResult::Done(()) }))
        .listener(listener(|| {}, || {}))
        .tag("task2")
        .intervals_millis([0, 1000])
        .build()?;

    Ok(())
}

/// Test: Intervals can be passed as various types.
#[tokio::test]
async fn test_time_interval_intervals_type_flexibility() -> BeaverResult<()> {
    // Array
    let _task1 = TimeIntervalBuilder::new(work(|| async { WorkResult::Done(()) }))
        .intervals_millis([1000, 2000, 3000])
        .build()?;

    // Vec
    let _task2 = TimeIntervalBuilder::new(work(|| async { WorkResult::Done(()) }))
        .intervals_millis(vec![1000, 2000, 3000])
        .build()?;

    // Slice via into()
    let intervals: Vec<u64> = vec![1000, 2000, 3000];
    let _task3 = TimeIntervalBuilder::new(work(|| async { WorkResult::Done(()) }))
        .intervals_millis(intervals)
        .build()?;

    Ok(())
}

/// Test: Each build creates unique task ID.
#[tokio::test]
async fn test_time_interval_unique_task_id() -> BeaverResult<()> {
    let task1 = TimeIntervalBuilder::new(work(|| async { WorkResult::Done(()) }))
        .intervals_millis([0])
        .build()?;

    let task2 = TimeIntervalBuilder::new(work(|| async { WorkResult::Done(()) }))
        .intervals_millis([0])
        .build()?;

    assert_ne!(task1.id(), task2.id());

    Ok(())
}

// =============================================================================
// REAL-WORLD SCENARIOS
// =============================================================================

/// Test: HTTP retry with exponential backoff simulation.
/// Common pattern for API calls that may fail temporarily.
#[tokio::test]
async fn test_http_retry_simulation() -> BeaverResult<()> {
    let beaver = Beaver::new("test", 256);
    let attempt = Arc::new(AtomicU32::new(0));
    let success = Arc::new(AtomicBool::new(false));

    let att = Arc::clone(&attempt);
    let suc = Arc::clone(&success);

    // Simulate: HTTP server returns 503 twice, then 200
    let task = TimeIntervalBuilder::new(work(move || {
        let a = Arc::clone(&att);
        let s = Arc::clone(&suc);
        async move {
            let current = a.fetch_add(1, Ordering::SeqCst) + 1;

            // Simulate HTTP response
            let status = if current < 3 { 503 } else { 200 };

            if status == 200 {
                s.store(true, Ordering::SeqCst);
                WorkResult::Done(())
            } else {
                WorkResult::NeedRetry
            }
        }
    }))
    .intervals_millis([0, 1000, 2000, 4000]) // Exponential backoff: immediate, 1s, 2s, 4s
    .tag("http-retry")
    .build()?;

    beaver.enqueue(task).await?;

    tokio::time::sleep(Duration::from_secs(5)).await;

    assert_eq!(attempt.load(Ordering::SeqCst), 3, "Should retry 3 times");
    assert!(success.load(Ordering::SeqCst), "Should eventually succeed");

    Ok(())
}

/// Test: Database reconnection pattern.
/// Tries to reconnect with increasing delays.
#[tokio::test]
async fn test_db_reconnection_pattern() -> BeaverResult<()> {
    let beaver = Beaver::new("test", 256);
    let connected = Arc::new(AtomicBool::new(false));
    let connection_attempts = Arc::new(AtomicU32::new(0));

    let conn = Arc::clone(&connected);
    let attempts = Arc::clone(&connection_attempts);

    let task = TimeIntervalBuilder::new(work(move || {
        let c = Arc::clone(&conn);
        let a = Arc::clone(&attempts);
        async move {
            let attempt = a.fetch_add(1, Ordering::SeqCst) + 1;

            // Simulate DB connection - succeeds on 4th attempt
            if attempt >= 4 {
                c.store(true, Ordering::SeqCst);
                WorkResult::Done(())
            } else {
                WorkResult::NeedRetry
            }
        }
    }))
    .intervals_millis([0, 1000, 1000, 2000, 2000, 4000]) // Gradually increasing delays
    .tag("db-reconnect")
    .listener(listener(
        || println!("DB connected!"),
        || println!("Reconnection aborted"),
    ))
    .build()?;

    beaver.enqueue(task).await?;

    tokio::time::sleep(Duration::from_secs(6)).await;

    assert!(connected.load(Ordering::SeqCst), "Should reconnect");
    assert_eq!(connection_attempts.load(Ordering::SeqCst), 4);

    Ok(())
}