Add Future Carbs Alert (#571)

* Add Future Carbs Alert

Notify when a future-dated carb entry's scheduled time arrives, serving
as a reminder to start eating in pre-bolus scenarios. Tracks future carb
entries across alarm ticks using persistent storage, with configurable
max lookahead window (default 45 min) to filter out fat/protein entries
and minimum carb threshold (default 5g).

* Add FutureCarbsCondition unit tests

10 test cases covering tracking, firing, deletion, lookahead bounds,
min grams filter, past carbs, stale cleanup, multi-carb per-tick
behavior, and duplicate prevention. Also fix Tests target missing
FRAMEWORK_SEARCH_PATHS for CocoaPods dependencies and add missing
latestPumpBattery field in withBattery test helper.

* Fix future-dated treatments not being downloaded from Nightscout

Trio sets created_at to the scheduled future time, but the Nightscout
query had an upper bound of "now", excluding any future-dated entries.
Extend the query window by predictionToLoad minutes so treatments
within the graph lookahead are fetched. Also add addingMinutes
parameter to getDateTimeString for precise minute-level offsets.

* Default Future Carbs Alert to acknowledge instead of snooze

* Download treatments 6 hours into the future

Replace the prediction-based lookahead with a fixed 6-hour window and
rename currentTimeString to endTimeString for clarity.

* 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.xcodeproj/project.pbxproj

@@ -309,6 +309,12 @@ struct Alarm: Identifiable, Codable, Equatable {
             predictiveMinutes = 15
             delta = 0.1
             threshold = 4
+        case .futureCarbs:
+            soundFile = .alertToneRingtone1
+            threshold = 45 // max lookahead minutes
+            delta = 5 // min grams
+            snoozeDuration = 0
+            repeatSoundOption = .never
         case .sensorChange:
             soundFile = .wakeUpWillYou
             threshold = 12
@@ -364,7 +370,7 @@ extension AlarmType {
         switch self {
         case .low, .high, .fastDrop, .fastRise, .missedReading, .temporary:
             return .glucose
-        case .iob, .cob, .missedBolus, .recBolus:
+        case .iob, .cob, .missedBolus, .futureCarbs, .recBolus:
             return .insulin
         case .battery, .batteryDrop, .pump, .pumpBattery, .pumpChange,
              .sensorChange, .notLooping, .buildExpire:
@@ -384,6 +390,7 @@ extension AlarmType {
         case .iob: return "syringe"
         case .cob: return "fork.knife"
         case .missedBolus: return "exclamationmark.arrow.triangle.2.circlepath"
+        case .futureCarbs: return "clock.arrow.circlepath"
         case .recBolus: return "bolt.horizontal"
         case .battery: return "battery.25"
         case .batteryDrop: return "battery.100.bolt"
@@ -411,6 +418,7 @@ extension AlarmType {
         case .iob: return "High insulin-on-board."
         case .cob: return "High carbs-on-board."
         case .missedBolus: return "Carbs without bolus."
+        case .futureCarbs: return "Reminder when future carbs are due."
         case .recBolus: return "Recommended bolus issued."
         case .battery: return "Phone battery low."
         case .batteryDrop: return "Battery drops quickly."

LoopFollow/Alarm/Alarm.swift

@@ -0,0 +1,104 @@
+// LoopFollow
+// FutureCarbsCondition.swift
+
+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.
+///    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` **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() {}
+
+    func evaluate(alarm: Alarm, data: AlarmData, now: Date) -> Bool {
+        // ────────────────────────────────
+        // 0. Pull settings
+        // ────────────────────────────────
+        let maxLookaheadMin = alarm.threshold ?? 45 // max lookahead in minutes
+        let minGrams = alarm.delta ?? 5 // ignore carbs below this
+
+        let nowTI = now.timeIntervalSince1970
+        let maxLookaheadSec = maxLookaheadMin * 60
+
+        var pending = Storage.shared.pendingFutureCarbs.value
+        let tolerance: TimeInterval = 5 // seconds, for matching carb entries
+
+        // ────────────────────────────────
+        // 1. Scan for new future carbs
+        // ────────────────────────────────
+        for carb in data.recentCarbs {
+            let carbTI = carb.date.timeIntervalSince1970
+
+            // 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,
+                  carb.grams >= minGrams
+            else { continue }
+
+            // Already tracked?
+            let alreadyTracked = pending.contains { entry in
+                abs(entry.carbDate - carbTI) < tolerance && entry.grams == carb.grams
+            }
+            if !alreadyTracked {
+                pending.append(PendingFutureCarb(
+                    carbDate: carbTI,
+                    grams: carb.grams,
+                    observedAt: nowTI
+                ))
+            }
+        }
+
+        // ────────────────────────────────
+        // 2. Check if any pending entry is due
+        // ────────────────────────────────
+        var fired = false
+
+        pending.removeAll { entry in
+            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 }
+
+            // Carb was deleted — remove silently
+            if !stillExists { return true }
+
+            // Carb was originally outside the lookahead window — remove without firing
+            if entry.carbDate - entry.observedAt > maxLookaheadSec { return true }
+
+            // Fire (one per tick)
+            if !fired {
+                fired = true
+                return true
+            }
+
+            return false
+        }
+
+        // ────────────────────────────────
+        // 3. Persist and return
+        // ────────────────────────────────
+        Storage.shared.pendingFutureCarbs.value = pending
+        return fired
+    }
+}

LoopFollow/Alarm/AlarmCondition/FutureCarbsCondition.swift

@@ -82,6 +82,7 @@ struct AlarmEditor: View {
         case .battery: PhoneBatteryAlarmEditor(alarm: $alarm)
         case .batteryDrop: BatteryDropAlarmEditor(alarm: $alarm)
         case .missedBolus: MissedBolusAlarmEditor(alarm: $alarm)
+        case .futureCarbs: FutureCarbsAlarmEditor(alarm: $alarm)
         }
     }
 }

LoopFollow/Alarm/AlarmEditing/AlarmEditor.swift

@@ -0,0 +1,46 @@
+// LoopFollow
+// FutureCarbsAlarmEditor.swift
+
+import SwiftUI
+
+struct FutureCarbsAlarmEditor: View {
+    @Binding var alarm: Alarm
+
+    var body: some View {
+        Group {
+            InfoBanner(
+                text: "Alerts when a future-dated carb entry's scheduled time arrives — " +
+                    "a reminder to start eating. Use the max lookahead to ignore " +
+                    "fat/protein entries that are typically scheduled further ahead.",
+                alarmType: alarm.type
+            )
+
+            AlarmGeneralSection(alarm: $alarm)
+
+            AlarmStepperSection(
+                header: "Max Lookahead",
+                footer: "Only track carb entries scheduled up to this many minutes " +
+                    "in the future. Entries beyond this window are ignored.",
+                title: "Lookahead",
+                range: 5 ... 120,
+                step: 5,
+                unitLabel: "min",
+                value: $alarm.threshold
+            )
+
+            AlarmStepperSection(
+                header: "Minimum Carbs",
+                footer: "Ignore carb entries below this amount.",
+                title: "At or Above",
+                range: 0 ... 50,
+                step: 1,
+                unitLabel: "g",
+                value: $alarm.delta
+            )
+
+            AlarmActiveSection(alarm: $alarm)
+            AlarmAudioSection(alarm: $alarm)
+            AlarmSnoozeSection(alarm: $alarm)
+        }
+    }
+}

LoopFollow/Alarm/AlarmEditing/Editors/FutureCarbsAlarmEditor.swift

@@ -33,6 +33,7 @@ class AlarmManager {
             IOBCondition.self,
             BatteryCondition.self,
             BatteryDropCondition.self,
+            FutureCarbsCondition.self,
         ]
     ) {
         var dict = [AlarmType: AlarmCondition]()

LoopFollow/Alarm/AlarmManager.swift

@@ -11,7 +11,7 @@ extension AlarmType {
             return .day
         case .low, .high, .fastDrop, .fastRise,
              .missedReading, .notLooping, .missedBolus,
-             .recBolus,
+             .futureCarbs, .recBolus,
              .overrideStart, .overrideEnd, .tempTargetStart,
              .tempTargetEnd:
             return .minute

LoopFollow/Alarm/AlarmType/AlarmType+Snooze.swift

@@ -8,7 +8,7 @@ extension AlarmType {
     var canAcknowledge: Bool {
         switch self {
         // These are alarms that typically has a "memory", they will only alarm once and acknowledge them is fine
-        case .low, .high, .fastDrop, .fastRise, .temporary, .cob, .missedBolus, .recBolus, .overrideStart, .overrideEnd, .tempTargetStart, .tempTargetEnd:
+        case .low, .high, .fastDrop, .fastRise, .temporary, .cob, .missedBolus, .futureCarbs, .recBolus, .overrideStart, .overrideEnd, .tempTargetStart, .tempTargetEnd:
             return true
         // These are alarms without memory, if they only are acknowledged - they would alarm again immediately
         case

LoopFollow/Alarm/AlarmType/AlarmType+canAcknowledge.swift

@@ -16,6 +16,7 @@ enum AlarmType: String, CaseIterable, Codable {
     case missedReading = "Missed Reading Alert"
     case notLooping = "Not Looping Alert"
     case missedBolus = "Missed Bolus Alert"
+    case futureCarbs = "Future Carbs Alert"
     case sensorChange = "Sensor Change Alert"
     case pumpChange = "Pump Change Alert"
     case pump = "Pump Insulin Alert"

LoopFollow/Alarm/AlarmType/AlarmType.swift

@@ -0,0 +1,17 @@
+// LoopFollow
+// PendingFutureCarb.swift
+
+import Foundation
+
+/// Tracks a future-dated carb entry that has been observed but whose scheduled time
+/// has not yet arrived. Used by `FutureCarbsCondition` to fire a reminder when it's time to eat.
+struct PendingFutureCarb: Codable, Equatable {
+    /// Scheduled eating time (`timeIntervalSince1970`)
+    let carbDate: TimeInterval
+
+    /// Grams of carbs (used together with `carbDate` to identify unique entries)
+    let grams: Double
+
+    /// When the entry was first observed (`timeIntervalSince1970`, for staleness cleanup)
+    let observedAt: TimeInterval
+}