Fix max lookahead sliding window bug

Carbs originally outside the lookahead window could drift into it over
time and fire incorrectly. Now all future carbs are tracked from first
observation, and only fire if their original distance (carbDate minus
observedAt) was within the max lookahead. Stale cleanup also preserves
entries whose carb still exists to prevent re-observation with a fresh
timestamp.

Author: bjorkert

LoopFollow/Alarm/AlarmCondition/FutureCarbsCondition.swift

@@ -6,13 +6,15 @@ import Foundation
 /// Fires once when a future-dated carb entry's scheduled time arrives.
 ///
 /// **How it works:**
-/// 1. Each alarm tick scans `recentCarbs` for entries whose `date` is in the future
-///    (within a configurable max lookahead window). New ones are added to a persistent
-///    "pending" list.
+/// 1. Each alarm tick scans `recentCarbs` for entries whose `date` is in the future.
+///    New ones are added to a persistent "pending" list regardless of lookahead distance,
+///    capturing the moment they were first observed (`observedAt`).
 /// 2. When a pending entry's `carbDate` passes (i.e. `carbDate <= now`), verify the
-///    carb still exists in `recentCarbs`. If so, fire the alarm. If the carb was
-///    deleted, silently remove it.
-/// 3. Stale entries (observed > 2 hours ago) are cleaned up automatically.
+///    carb still exists in `recentCarbs` **and** that the original distance
+///    (`carbDate − observedAt`) was within the max lookahead window. If both hold,
+///    fire the alarm. Otherwise silently remove the entry.
+/// 3. Stale entries (observed > 2 hours ago) whose carb no longer exists in
+///    `recentCarbs` are cleaned up automatically.
 struct FutureCarbsCondition: AlarmCondition {
     static let type: AlarmType = .futureCarbs
     init() {}
@@ -36,9 +38,11 @@ struct FutureCarbsCondition: AlarmCondition {
         for carb in data.recentCarbs {
             let carbTI = carb.date.timeIntervalSince1970
 
-            // Must be in the future and within the lookahead window
+            // Must be in the future and meet the minimum grams threshold.
+            // We track ALL future carbs (not just those within the lookahead
+            // window) so that carbs originally outside the window cannot
+            // drift in later with a fresh observedAt.
             guard carbTI > nowTI,
-                  carbTI - nowTI <= maxLookaheadSec,
                   carb.grams >= minGrams
             else { continue }
 
@@ -61,27 +65,30 @@ struct FutureCarbsCondition: AlarmCondition {
         var fired = false
 
         pending.removeAll { entry in
-            // Cleanup stale entries (observed > 2 hours ago)
-            if nowTI - entry.observedAt > 7200 {
+            let stillExists = data.recentCarbs.contains { carb in
+                abs(carb.date.timeIntervalSince1970 - entry.carbDate) < tolerance
+                    && carb.grams == entry.grams
+            }
+
+            // Cleanup stale entries (observed > 2 hours ago) only if
+            // the carb no longer exists — prevents eviction and
+            // re-observation with a fresh observedAt.
+            if nowTI - entry.observedAt > 7200, !stillExists {
                 return true
             }
 
             // Not yet due
             guard entry.carbDate <= nowTI else { return false }
 
-            // Due — verify carb still exists in recentCarbs
-            let stillExists = data.recentCarbs.contains { carb in
-                abs(carb.date.timeIntervalSince1970 - entry.carbDate) < tolerance
-                    && carb.grams == entry.grams
-            }
+            // Carb was deleted — remove silently
+            if !stillExists { return true }
 
-            if stillExists, !fired {
-                fired = true
-                return true // remove from pending after firing
-            }
+            // Carb was originally outside the lookahead window — remove without firing
+            if entry.carbDate - entry.observedAt > maxLookaheadSec { return true }
 
-            // Carb was deleted or we already fired this tick — remove silently
-            if !stillExists {
+            // Fire (one per tick)
+            if !fired {
+                fired = true
                 return true
             }
 

Tests/AlarmConditions/FutureCarbsConditionTests.swift

@@ -74,10 +74,10 @@ struct FutureCarbsConditionTests {
         #expect(Storage.shared.pendingFutureCarbs.value.isEmpty)
     }
 
-    // MARK: - 4. Beyond lookahead — carb ignored
+    // MARK: - 4. Beyond lookahead — tracked but does not fire
 
-    @Test("#beyond lookahead — carb ignored")
-    func beyondLookaheadIgnored() {
+    @Test("#beyond lookahead — tracked but does not fire")
+    func beyondLookaheadTrackedButNoFire() {
         resetPending()
         let now = Date()
         let alarm = Alarm.futureCarbs(threshold: 45)
@@ -86,7 +86,9 @@ struct FutureCarbsConditionTests {
         let result = cond.evaluate(alarm: alarm, data: data, now: now)
 
         #expect(!result)
-        #expect(Storage.shared.pendingFutureCarbs.value.isEmpty)
+        // Carb is tracked (to prevent re-observation with fresh observedAt)
+        // but will never fire because original distance > lookahead
+        #expect(Storage.shared.pendingFutureCarbs.value.count == 1)
     }
 
     // MARK: - 5. Below min grams — carb ignored
@@ -212,4 +214,87 @@ struct FutureCarbsConditionTests {
         _ = cond.evaluate(alarm: alarm, data: data, now: now)
         #expect(Storage.shared.pendingFutureCarbs.value.count == 1)
     }
+
+    // MARK: - 11. Sliding window — carb outside lookahead never fires
+
+    @Test("#sliding window — carb outside lookahead never fires")
+    func slidingWindowNeverFires() {
+        resetPending()
+        let t0 = Date()
+        let alarm = Alarm.futureCarbs(threshold: 10) // 10-minute lookahead
+        let carbDate = t0.addingTimeInterval(15 * 60) // 15 min in future
+        let carbSample = CarbSample(grams: 20, date: carbDate)
+
+        // Tick at T+0: carb is 15 min away, outside 10-min window but tracked
+        let data = AlarmData.withCarbs([carbSample])
+        let r0 = cond.evaluate(alarm: alarm, data: data, now: t0)
+        #expect(!r0)
+        #expect(Storage.shared.pendingFutureCarbs.value.count == 1)
+
+        // Tick at T+5min: carb is now 10 min away (inside window), but
+        // original distance was 15 min — must NOT fire
+        let t1 = t0.addingTimeInterval(5 * 60)
+        let r1 = cond.evaluate(alarm: alarm, data: data, now: t1)
+        #expect(!r1)
+
+        // Tick at T+15min: carb is due — still must NOT fire
+        let t2 = t0.addingTimeInterval(15 * 60)
+        let r2 = cond.evaluate(alarm: alarm, data: data, now: t2)
+        #expect(!r2)
+        // Entry should be removed (due, outside original window)
+        #expect(Storage.shared.pendingFutureCarbs.value.isEmpty)
+    }
+
+    // MARK: - 12. Due entry outside original window removed without firing
+
+    @Test("#due entry outside original window removed without firing")
+    func dueOutsideWindowRemovedNoFire() {
+        resetPending()
+        let now = Date()
+        let pastDate = now.addingTimeInterval(-60) // 1 min ago
+
+        // Entry was observed 20 min before its carb date (outside 10-min window)
+        Storage.shared.pendingFutureCarbs.value = [
+            PendingFutureCarb(
+                carbDate: pastDate.timeIntervalSince1970,
+                grams: 20,
+                observedAt: pastDate.timeIntervalSince1970 - 20 * 60
+            ),
+        ]
+
+        let alarm = Alarm.futureCarbs(threshold: 10)
+        let data = AlarmData.withCarbs([CarbSample(grams: 20, date: pastDate)])
+
+        let result = cond.evaluate(alarm: alarm, data: data, now: now)
+
+        #expect(!result)
+        #expect(Storage.shared.pendingFutureCarbs.value.isEmpty)
+    }
+
+    // MARK: - 13. Stale entry with existing carb is not evicted
+
+    @Test("#stale entry with existing carb is not evicted")
+    func staleWithExistingCarbNotEvicted() {
+        resetPending()
+        let now = Date()
+        let futureDate = now.addingTimeInterval(300) // 5 min in the future
+
+        // Entry observed 3 hours ago, but carb still exists in recentCarbs
+        Storage.shared.pendingFutureCarbs.value = [
+            PendingFutureCarb(
+                carbDate: futureDate.timeIntervalSince1970,
+                grams: 20,
+                observedAt: now.addingTimeInterval(-3 * 3600).timeIntervalSince1970
+            ),
+        ]
+
+        let alarm = Alarm.futureCarbs()
+        let data = AlarmData.withCarbs([CarbSample(grams: 20, date: futureDate)])
+
+        let result = cond.evaluate(alarm: alarm, data: data, now: now)
+
+        #expect(!result)
+        // Entry must survive — carb still exists, don't evict
+        #expect(Storage.shared.pendingFutureCarbs.value.count == 1)
+    }
 }