tiny-counter 0.1.0

//! Edge cases for last_seen calculations.
//!
//! Tests the logic for estimating last_seen across different interval
//! configurations and with events at various time positions.

use chrono::{DateTime, Duration, Local, TimeZone, Utc};
use std::sync::Arc;
use tiny_counter::{EventStore, TestClock};

// ============================================================================
// Test Helpers
// ============================================================================

/// Get the local timezone offset in hours for a given UTC timestamp.
/// This is used to calculate timezone-adjusted expected values in calendar tests.
/// Returns a float to handle fractional timezone offsets (e.g., UTC+5:30).
///
/// Note: Calendar tests use ±1h tolerance because:
/// 1. Tests may span DST transitions (e.g., looking back 18 months crosses multiple DST changes)
/// 2. Calendar boundaries (midnight, Monday, 1st of month) shift by 1 hour in UTC terms when DST changes
/// 3. The linear approximation (base_hours - offset * 1.0) doesn't account for historical DST transitions
fn local_offset_hours(utc_time: DateTime<Utc>) -> f64 {
    let offset_seconds = Local
        .timestamp_opt(utc_time.timestamp(), 0)
        .unwrap()
        .offset()
        .local_minus_utc();
    offset_seconds as f64 / 3600.0
}

// ============================================================================
// Last Seen - Basic Scenarios
// ============================================================================

#[test]
fn last_seen_very_recent_event() {
    let fixed_time = Utc.with_ymd_and_hms(2025, 3, 1, 12, 0, 0).unwrap();
    let clock = TestClock::build_for_testing_at(fixed_time);

    let store = EventStore::builder()
        .track_seconds(60)
        .track_minutes(60)
        .with_clock(Arc::new(clock.clone()))
        .build()
        .unwrap();

    store.record("event");

    let last = store.query("event").last_seen();
    assert!(last.is_some());

    // Should be in current bucket (very recent)
    let duration = last.unwrap();
    assert!(duration.num_seconds() < 60);
}

#[test]
fn last_seen_uses_finest_granularity() {
    let fixed_time = Utc.with_ymd_and_hms(2025, 3, 1, 12, 0, 0).unwrap();
    let clock = TestClock::build_for_testing_at(fixed_time);

    let store = EventStore::builder()
        .track_minutes(60)
        .track_hours(24)
        .track_days(7)
        .with_clock(Arc::new(clock.clone()))
        .build()
        .unwrap();

    // Event 5 minutes ago
    store.record_ago("event", Duration::minutes(5));

    let last = store.query("event").last_seen();
    assert!(last.is_some());

    // Event at 5 minutes falls into minute bucket
    // Midpoint: 5 + 0.5 = 5.5 minutes = 330 seconds
    let expected = Duration::seconds(330);

    assert_eq!(
        last,
        Some(expected),
        "Should return exact minute bucket midpoint"
    );
}

#[test]
fn last_seen_with_multiple_events_returns_most_recent() {
    let fixed_time = Utc.with_ymd_and_hms(2025, 3, 1, 12, 0, 0).unwrap();
    let clock = TestClock::build_for_testing_at(fixed_time);

    let store = EventStore::builder()
        .track_hours(48)
        .track_days(7)
        .with_clock(Arc::new(clock.clone()))
        .build()
        .unwrap();

    // Old event
    store.record_ago("event", Duration::days(3));

    // More recent event
    store.record_ago("event", Duration::hours(2));

    // Most recent event
    store.record_ago("event", Duration::minutes(30));

    let last = store.query("event").last_seen();
    assert!(last.is_some());

    let duration = last.unwrap();
    // Should reflect the most recent event (~30 minutes, but with bucket midpoint can be longer)
    assert!(duration.num_hours() <= 2);
}

// ============================================================================
// Last Seen - Interval Selection
// ============================================================================

#[test]
fn last_seen_falls_back_to_coarser_interval() {
    let fixed_time = Utc.with_ymd_and_hms(2025, 3, 1, 12, 0, 0).unwrap();
    let clock = TestClock::build_for_testing_at(fixed_time);

    // Minutes: 60 buckets (1 hour)
    // Hours: 48 buckets (2 days)
    let store = EventStore::builder()
        .track_minutes(60)
        .track_hours(48)
        .with_clock(Arc::new(clock.clone()))
        .build()
        .unwrap();

    // Event 2 hours ago (outside minutes window, in hours)
    store.record_ago("event", Duration::hours(2));

    let last = store.query("event").last_seen();
    assert!(last.is_some());

    // Event at 2 hours falls into hour bucket (minutes only cover 1 hour)
    // Midpoint: 2 + 0.5 = 2.5 hours = 9000 seconds
    let expected = Duration::seconds(9000);

    assert_eq!(
        last,
        Some(expected),
        "Should return exact hour bucket midpoint"
    );
}

#[test]
#[cfg(not(feature = "calendar"))]
fn last_seen_in_coarsest_interval_only() {
    // 2025/01/01 Wednesday, so weeks start on Wednesday
    // 2025/03/01 Saturday, at midday that's exactly halfway through the week.
    let fixed_time = Utc.with_ymd_and_hms(2025, 3, 1, 12, 0, 0).unwrap();
    let clock = TestClock::build_for_testing_at(fixed_time);

    let store = EventStore::builder()
        .track_days(30)
        .track_weeks(52)
        .track_months(24)
        .with_clock(Arc::new(clock.clone()))
        .build()
        .unwrap();

    // Event 60 days ago (in months interval, not days or weeks)
    // Event time = 2025-03-01 12:00:00 - 60 days = 2024-12-31 12:00:00
    store.record_ago("event", Duration::days(60));
    let event_time = fixed_time - Duration::days(60);

    let last = store.query("event").last_seen();
    assert!(last.is_some());

    let duration = last.unwrap();
    let days = duration.num_days();
    let hours = duration.num_hours();
    let seconds = duration.num_seconds();

    // For now, just verify it's exactly 9 weeks
    assert_eq!(
        seconds, 5443200,
        "Should be exactly 5443200 seconds (63 days)"
    );
    assert_eq!(days, 63, "Uniform buckets return 63 days (9 weeks exactly)");
}

#[test]
#[cfg(feature = "calendar")]
fn last_seen_in_coarsest_interval_only_calendar() {
    let fixed_time = Utc.with_ymd_and_hms(2025, 3, 1, 12, 0, 0).unwrap();
    let clock = TestClock::build_for_testing_at(fixed_time);

    let store = EventStore::builder()
        .track_days(30)
        .track_weeks(52)
        .track_months(24)
        .with_clock(Arc::new(clock.clone()))
        .build()
        .unwrap();

    // Event 60 days ago (in months interval, not days or weeks)
    // Event time = 2025-03-01 12:00:00 - 60 days = 2024-12-31 12:00:00
    store.record_ago("event", Duration::days(60));

    let last = store.query("event").last_seen();
    assert!(last.is_some());

    // Calculate expected value based on local timezone offset
    let offset = local_offset_hours(fixed_time);

    let duration = last.unwrap();
    let hours = duration.num_hours();

    // Calendar buckets align to Monday boundaries, not interval_start
    // Base value at UTC+0: 1560 hours (empirically observed)
    // Event 60 days ago crosses DST transitions in many timezones
    let expected_hours = 1560.0 - offset * 1.0;

    assert!(
        ((expected_hours - 1.0) as i64..=(expected_hours + 1.0) as i64).contains(&hours),
        "Expected ~{:.0} hours (±1h) based on UTC{:+.1} offset, got {} hours",
        expected_hours,
        offset,
        hours
    );
}

// ============================================================================
// Last Seen - Gap Detection
// ============================================================================

#[test]
#[cfg(not(feature = "calendar"))]
fn last_seen_gap_between_intervals() {
    let fixed_time = Utc.with_ymd_and_hms(2025, 3, 1, 12, 0, 0).unwrap();
    let clock = TestClock::build_for_testing_at(fixed_time);

    // Minutes: 60 buckets = 1 hour
    // Days: 7 buckets = 7 days
    // Gap exists between 1 hour and 7 days
    let store = EventStore::builder()
        .track_minutes(60)
        .track_days(7)
        .with_clock(Arc::new(clock.clone()))
        .build()
        .unwrap();

    // Event 12 hours ago - in the gap
    store.record_ago("event", Duration::hours(12));

    let last = store.query("event").last_seen();
    assert!(last.is_some());

    // Event at 12 hours in gap between minutes(60) and days(7)
    // Falls into day bucket with gap detection: 12.5 hours = 45000 seconds
    let expected = Duration::seconds(45000);

    assert_eq!(
        last,
        Some(expected),
        "Should return exact calculated midpoint with gap detection"
    );
}

#[test]
#[cfg(feature = "calendar")]
fn last_seen_gap_between_intervals_calendar() {
    // Test with calendar-aligned days (midnight at local time)
    let fixed_time = Utc.with_ymd_and_hms(2025, 3, 1, 12, 0, 0).unwrap();
    let clock = TestClock::build_for_testing_at(fixed_time);

    // Minutes: 60 buckets = 1 hour
    // Days: 7 buckets = 7 days
    // Gap exists between 1 hour and 7 days
    let store = EventStore::builder()
        .track_minutes(60)
        .track_days(7)
        .with_clock(Arc::new(clock.clone()))
        .build()
        .unwrap();

    // Event 12 hours ago - in the gap
    store.record_ago("event", Duration::hours(12));

    let last = store.query("event").last_seen();
    assert!(last.is_some());

    // With calendar feature, days align at midnight in local time
    // Calculate expected value based on local timezone offset
    let offset = local_offset_hours(fixed_time);

    // Event at 12 hours ago falls into a day bucket
    // Base value at UTC+0: 18 hours (empirically observed)
    // Timezone offset shifts day boundaries by approximately 1 hour per timezone hour
    let expected_hours = 18.0 - offset * 1.0;

    let duration = last.unwrap();
    let hours = duration.num_hours();

    assert!(
        ((expected_hours - 1.0) as i64..=(expected_hours + 1.0) as i64).contains(&hours),
        "Expected ~{:.0} hours (±1h) based on UTC{:+.1} offset, got {} hours",
        expected_hours,
        offset,
        hours
    );
}

#[test]
#[cfg(not(feature = "calendar"))]
fn last_seen_at_exact_interval_boundary() {
    let fixed_time = Utc.with_ymd_and_hms(2025, 3, 1, 12, 0, 0).unwrap();
    let clock = TestClock::build_for_testing_at(fixed_time);

    let store = EventStore::builder()
        .track_hours(24)
        .track_days(7)
        .with_clock(Arc::new(clock.clone()))
        .build()
        .unwrap();

    // Event exactly 24 hours ago (at boundary)
    store.record_ago("event", Duration::hours(24));

    let last = store.query("event").last_seen();
    assert!(last.is_some());

    // Event at 24 hours (boundary)
    // Falls into day bucket midpoint: 24 + 12 = 36 hours = 129600 seconds
    let expected = Duration::seconds(129600);

    assert_eq!(
        last,
        Some(expected),
        "Should return exact boundary midpoint"
    );
}

#[test]
#[cfg(feature = "calendar")]
fn last_seen_at_exact_interval_boundary_calendar() {
    // Test with calendar-aligned days (midnight at local time)
    let fixed_time = Utc.with_ymd_and_hms(2025, 3, 1, 12, 0, 0).unwrap();
    let clock = TestClock::build_for_testing_at(fixed_time);

    let store = EventStore::builder()
        .track_hours(24)
        .track_days(7)
        .with_clock(Arc::new(clock.clone()))
        .build()
        .unwrap();

    // Event exactly 24 hours ago (at boundary)
    store.record_ago("event", Duration::hours(24));

    let last = store.query("event").last_seen();
    assert!(last.is_some());

    // With calendar feature, days align at midnight in local time
    // Calculate expected value based on local timezone offset
    let offset = local_offset_hours(fixed_time);

    // Base value at UTC+0: 42 hours (empirically observed)
    // Timezone offset shifts day boundaries by approximately 1 hour per timezone hour
    let expected_hours = 42.0 - offset * 1.0;

    let duration = last.unwrap();
    let hours = duration.num_hours();

    assert!(
        ((expected_hours - 1.0) as i64..=(expected_hours + 1.0) as i64).contains(&hours),
        "Expected ~{:.0} hours (±1h) based on UTC{:+.1} offset, got {} hours",
        expected_hours,
        offset,
        hours
    );
}

// ============================================================================
// Last Seen - Empty and Missing Cases
// ============================================================================

#[test]
fn last_seen_for_nonexistent_event() {
    let store = EventStore::new();

    let last = store.query("nonexistent").last_seen();
    assert_eq!(last, None);
}

#[test]
fn last_seen_after_event_rotates_out() {
    let fixed_time = Utc.with_ymd_and_hms(2025, 3, 1, 12, 0, 0).unwrap();
    let clock = TestClock::build_for_testing_at(fixed_time);

    let store = EventStore::builder()
        .track_hours(24)
        .with_clock(Arc::new(clock.clone()))
        .build()
        .unwrap();

    store.record("event");

    // Advance clock way past retention
    clock.advance(Duration::hours(48));

    // Trigger rotation by recording another event
    store.record("trigger");

    let last = store.query("event").last_seen();
    // Event should have rotated out
    assert_eq!(last, None);
}

// ============================================================================
// Last Seen - Consistency with First Seen
// ============================================================================

#[test]
fn last_seen_equals_first_seen_for_single_event() {
    let fixed_time = Utc.with_ymd_and_hms(2025, 3, 1, 12, 0, 0).unwrap();
    let clock = TestClock::build_for_testing_at(fixed_time);

    let store = EventStore::builder()
        .track_minutes(60)
        .track_hours(24)
        .with_clock(Arc::new(clock.clone()))
        .build()
        .unwrap();

    store.record_ago("event", Duration::minutes(15));

    let first = store.query("event").first_seen();
    let last = store.query("event").last_seen();

    assert!(first.is_some());
    assert!(last.is_some());

    // For single event, first and last must be identical
    // Event at 15 minutes: midpoint = 15 + 0.5 = 15.5 minutes = 930 seconds
    let expected = Duration::seconds(930);

    assert_eq!(first, Some(expected), "first_seen should be exact");
    assert_eq!(last, Some(expected), "last_seen should be exact");
    assert_eq!(
        first, last,
        "For single event, first and last must be identical"
    );
}

#[test]
#[cfg(not(feature = "calendar"))]
fn last_seen_more_recent_than_first_seen() {
    let fixed_time = Utc.with_ymd_and_hms(2025, 3, 1, 12, 0, 0).unwrap();
    let clock = TestClock::build_for_testing_at(fixed_time);

    let store = EventStore::builder()
        .track_hours(48)
        .track_days(7)
        .with_clock(Arc::new(clock.clone()))
        .build()
        .unwrap();

    // Old event
    store.record_ago("event", Duration::days(3));
    // Recent event
    store.record_ago("event", Duration::hours(2));

    let first = store.query("event").first_seen();
    let last = store.query("event").last_seen();

    // Old event at 3 days: midpoint = 54 hours = 194400 seconds
    let expected_first = Duration::seconds(194400);
    // Recent event at 2 hours: midpoint = 2.5 hours = 9000 seconds
    let expected_last = Duration::seconds(9000);

    assert_eq!(first, Some(expected_first), "first_seen should be exact");
    assert_eq!(last, Some(expected_last), "last_seen should be exact");
    assert!(
        last.unwrap() < first.unwrap(),
        "Last must be more recent than first"
    );
}

#[test]
#[cfg(feature = "calendar")]
fn last_seen_more_recent_than_first_seen_calendar() {
    // Test with calendar-aligned days (midnight at local time)
    let fixed_time = Utc.with_ymd_and_hms(2025, 3, 1, 12, 0, 0).unwrap();
    let clock = TestClock::build_for_testing_at(fixed_time);

    let store = EventStore::builder()
        .track_hours(48)
        .track_days(7)
        .with_clock(Arc::new(clock.clone()))
        .build()
        .unwrap();

    // Old event
    store.record_ago("event", Duration::days(3));
    // Recent event
    store.record_ago("event", Duration::hours(2));

    let first = store.query("event").first_seen();
    let last = store.query("event").last_seen();

    assert!(first.is_some(), "first_seen should exist");
    assert!(last.is_some(), "last_seen should exist");

    // With calendar feature, days align at midnight
    // Old event ~3 days ago, recent event ~2 hours ago
    assert!(
        last.unwrap() < first.unwrap(),
        "Last must be more recent than first"
    );

    // Verify reasonable ranges
    let offset = local_offset_hours(fixed_time);

    let first_hours = first.unwrap().num_hours();
    let last_hours = last.unwrap().num_hours();

    // Base value at UTC+0: 66 hours for 3 days with calendar alignment
    // (Varies by test date/time - this test uses March 20, 2025 at 15:00 UTC)
    // Timezone offset shifts day boundaries by approximately 1 hour per timezone hour
    let expected_first_hours = 66.0 - offset * 1.0;

    assert!(
        ((expected_first_hours - 1.0) as i64..=(expected_first_hours + 1.0) as i64)
            .contains(&first_hours),
        "Expected first_seen ~{:.0} hours (±1h) based on UTC{:+.1} offset, got {} hours",
        expected_first_hours,
        offset,
        first_hours
    );
    assert!(
        (1..=4).contains(&last_hours),
        "Expected last_seen ~2 hours (stable, in hours bucket), got {} hours",
        last_hours
    );
}

// ============================================================================
// Last Seen - Clock Advancement
// ============================================================================

#[test]
fn last_seen_updates_as_time_advances() {
    let fixed_time = Utc.with_ymd_and_hms(2025, 3, 1, 12, 0, 0).unwrap();
    let clock = TestClock::build_for_testing_at(fixed_time);

    let store = EventStore::builder()
        .track_minutes(60)
        .with_clock(Arc::new(clock.clone()))
        .build()
        .unwrap();

    store.record("event");

    let last1 = store.query("event").last_seen();

    // Advance clock
    clock.advance(Duration::minutes(10));

    let last2 = store.query("event").last_seen();

    assert!(last1.is_some());
    assert!(last2.is_some());

    // Duration should increase as time advances
    assert!(last2.unwrap() > last1.unwrap());
    let diff = last2.unwrap().num_minutes() - last1.unwrap().num_minutes();
    assert!((8..=12).contains(&diff)); // ~10 minutes
}

#[test]
fn last_seen_bucket_midpoint_estimation() {
    let fixed_time = Utc.with_ymd_and_hms(2025, 3, 1, 12, 0, 0).unwrap();
    let clock = TestClock::build_for_testing_at(fixed_time);

    let store = EventStore::builder()
        .track_hours(24)
        .with_clock(Arc::new(clock.clone()))
        .build()
        .unwrap();

    // Record at start of bucket
    store.record("event");

    // Advance to middle of next bucket
    clock.advance(Duration::minutes(90)); // 1.5 hours

    let last = store.query("event").last_seen();
    assert!(last.is_some());

    // Event recorded at start of bucket, then clock advanced 90 minutes
    // Last_seen returns age from current time to estimated event time
    // Bucket midpoint: approximately 90 + 30 = 120 minutes = 7200 seconds
    let expected = Duration::seconds(7200);

    assert_eq!(
        last,
        Some(expected),
        "Should return exact bucket midpoint estimation"
    );
}