Add Future Carbs Alert

LoopFollow/Alarm/Alarm.swift

@@ -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/AlarmCondition/FutureCarbsCondition.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/AlarmEditing/AlarmEditor.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/Editors/FutureCarbsAlarmEditor.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/AlarmManager.swift

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

LoopFollow/Alarm/AlarmType/AlarmType+Snooze.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+canAcknowledge.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.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/DataStructs/PendingFutureCarb.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
+}

LoopFollow/Controllers/Nightscout/Treatments.swift

@@ -10,11 +10,11 @@ extension MainViewController {
         if !Storage.shared.downloadTreatments.value { return }
 
         let startTimeString = dateTimeUtils.getDateTimeString(addingDays: -1 * Storage.shared.downloadDays.value)
-        let currentTimeString = dateTimeUtils.getDateTimeString()
+        let endTimeString = dateTimeUtils.getDateTimeString(addingHours: 6)
         let estimatedCount = max(Storage.shared.downloadDays.value * 100, 5000)
         let parameters: [String: String] = [
             "find[created_at][$gte]": startTimeString,
-            "find[created_at][$lte]": currentTimeString,
+            "find[created_at][$lte]": endTimeString,
             "count": "\(estimatedCount)",
         ]
         NightscoutUtils.executeDynamicRequest(eventType: .treatments, parameters: parameters) { (result: Result<Any, Error>) in

LoopFollow/Helpers/DateTime.swift

@@ -69,16 +69,20 @@ class dateTimeUtils {
         return utcTime
     }
 
-    static func getDateTimeString(addingHours hours: Int? = nil, addingDays days: Int? = nil) -> String {
+    static func getDateTimeString(addingMinutes minutes: Int? = nil, addingHours hours: Int? = nil, addingDays days: Int? = nil) -> String {
         let currentDate = Date()
         var date = currentDate
 
+        if let minutesToAdd = minutes {
+            date = Calendar.current.date(byAdding: .minute, value: minutesToAdd, to: date)!
+        }
+
         if let hoursToAdd = hours {
-            date = Calendar.current.date(byAdding: .hour, value: hoursToAdd, to: currentDate)!
+            date = Calendar.current.date(byAdding: .hour, value: hoursToAdd, to: date)!
         }
 
         if let daysToAdd = days {
-            date = Calendar.current.date(byAdding: .day, value: daysToAdd, to: currentDate)!
+            date = Calendar.current.date(byAdding: .day, value: daysToAdd, to: date)!
         }
 
         let dateFormatter = DateFormatter()

LoopFollow/Settings/ImportExport/AlarmSelectionView.swift

@@ -213,6 +213,8 @@ struct AlarmSelectionRow: View {
             return "Not Looping Alert"
         case .missedBolus:
             return "Missed Bolus Alert"
+        case .futureCarbs:
+            return "Future Carbs Alert"
         case .sensorChange:
             return "Sensor Change Alert"
         case .pumpChange:

LoopFollow/Storage/Storage.swift

@@ -59,6 +59,7 @@ class Storage {
     var lastRecBolusNotified = StorageValue<Double?>(key: "lastRecBolusNotified", defaultValue: nil)
     var lastCOBNotified = StorageValue<Double?>(key: "lastCOBNotified", defaultValue: nil)
     var lastMissedBolusNotified = StorageValue<Date?>(key: "lastMissedBolusNotified", defaultValue: nil)
+    var pendingFutureCarbs = StorageValue<[PendingFutureCarb]>(key: "pendingFutureCarbs", defaultValue: [])
 
     // General Settings [BEGIN]
     var appBadge = StorageValue<Bool>(key: "appBadge", defaultValue: true)