Merge pull request #691 from tidepool-org/noah/LOOP-4953/favorite-food-insights

[LOOP-4953] Favorite Food Insights

Author: SwiftlyNoah

Loop.xcodeproj/project.pbxproj

@@ -0,0 +1,15 @@
+//
+//  Character+IsEmoji.swift
+//  Loop
+//
+//  Created by Noah Brauner on 8/6/24.
+//  Copyright © 2024 LoopKit Authors. All rights reserved.
+//
+
+import Foundation
+
+extension Character {
+    public var isEmoji: Bool {
+        unicodeScalars.contains(where: { $0.properties.isEmoji })
+    }
+}

Loop/Extensions/Character+IsEmoji.swift

@@ -166,8 +166,8 @@ final class AnalyticsServicesManager {
         logEvent("CGM Added", withProperties: ["identifier" : identifier])
     }
 
-    func didAddCarbs(source: String, amount: Double, inSession: Bool = false) {
-        logEvent("Carb entry created", withProperties: ["source" : source, "amount": "\(amount)"], outOfSession: inSession)
+    func didAddCarbs(source: String, amount: Double, isFavoriteFood: Bool = false, inSession: Bool = false) {
+        logEvent("Carb entry created", withProperties: ["source" : source, "amount": "\(amount)", "isFavoriteFood": isFavoriteFood], outOfSession: inSession)
     }
 
     func didRetryBolus() {

Loop/Managers/AnalyticsServicesManager.swift

@@ -1127,12 +1127,111 @@ extension LoopDataManager: CarbEntryViewModelDelegate {
     var defaultAbsorptionTimes: DefaultAbsorptionTimes {
         LoopCoreConstants.defaultCarbAbsorptionTimes
     }
-
     func getGlucoseSamples(start: Date?, end: Date?) async throws -> [StoredGlucoseSample] {
         try await glucoseStore.getGlucoseSamples(start: start, end: end)
     }
 }
 
+extension LoopDataManager: FavoriteFoodInsightsViewModelDelegate {
+    func selectedFavoriteFoodLastEaten(_ favoriteFood: StoredFavoriteFood) async throws -> Date? {
+        try await carbStore.getCarbEntries(start: nil, end: nil, dateAscending: false, fetchLimit: 1, with: favoriteFood.id).first?.startDate
+    }
+
+    
+    func getFavoriteFoodCarbEntries(_ favoriteFood: StoredFavoriteFood) async throws -> [LoopKit.StoredCarbEntry] {
+        try await carbStore.getCarbEntries(start: nil, end: nil, dateAscending: false, fetchLimit: nil, with: favoriteFood.id)
+    }
+    
+    func getHistoricalChartsData(start: Date, end: Date) async throws -> HistoricalChartsData {
+        // Need to get insulin data from any active doses that might affect this time range
+        var dosesStart = start.addingTimeInterval(-InsulinMath.defaultInsulinActivityDuration)
+        let doses = try await doseStore.getNormalizedDoseEntries(
+            start: dosesStart,
+            end: end
+        ).map { $0.simpleDose(with: insulinModel(for: $0.insulinType)) }
+
+        dosesStart = doses.map { $0.startDate }.min() ?? dosesStart
+
+        let basal = try await settingsProvider.getBasalHistory(startDate: dosesStart, endDate: end)
+
+        let carbEntries = try await carbStore.getCarbEntries(start: start, end: end)
+
+        let carbRatio = try await settingsProvider.getCarbRatioHistory(startDate: start, endDate: end)
+
+        let glucose = try await glucoseStore.getGlucoseSamples(start: start, end: end)
+
+        let sensitivityStart = min(start, dosesStart)
+
+        let sensitivity = try await settingsProvider.getInsulinSensitivityHistory(startDate: sensitivityStart, endDate: end)
+
+        let overrides = temporaryPresetsManager.overrideHistory.getOverrideHistory(startDate: sensitivityStart, endDate: end)
+
+        guard !sensitivity.isEmpty else {
+            throw LoopError.configurationError(.insulinSensitivitySchedule)
+        }
+
+        let sensitivityWithOverrides = overrides.applySensitivity(over: sensitivity)
+
+        guard !basal.isEmpty else {
+            throw LoopError.configurationError(.basalRateSchedule)
+        }
+        let basalWithOverrides = overrides.applyBasal(over: basal)
+
+        guard !carbRatio.isEmpty else {
+            throw LoopError.configurationError(.carbRatioSchedule)
+        }
+        let carbRatioWithOverrides = overrides.applyCarbRatio(over: carbRatio)
+
+        let carbModel: CarbAbsorptionModel = FeatureFlags.nonlinearCarbModelEnabled ? .piecewiseLinear : .linear
+
+        // Overlay basal history on basal doses, splitting doses to get amount delivered relative to basal
+        let annotatedDoses = doses.annotated(with: basalWithOverrides)
+
+        let insulinEffects = annotatedDoses.glucoseEffects(
+            insulinSensitivityHistory: sensitivityWithOverrides,
+            from: start.addingTimeInterval(-CarbMath.maximumAbsorptionTimeInterval).dateFlooredToTimeInterval(GlucoseMath.defaultDelta),
+            to: nil)
+
+        // ICE
+        let insulinCounteractionEffects = glucose.counteractionEffects(to: insulinEffects)
+
+        // Carb Effects
+        let carbStatus = carbEntries.map(
+            to: insulinCounteractionEffects,
+            carbRatio: carbRatioWithOverrides,
+            insulinSensitivity: sensitivityWithOverrides
+        )
+
+        let carbEffects = carbStatus.dynamicGlucoseEffects(
+            from: end,
+            to: end.addingTimeInterval(InsulinMath.defaultInsulinActivityDuration),
+            carbRatios: carbRatioWithOverrides,
+            insulinSensitivities: sensitivityWithOverrides,
+            absorptionModel: carbModel.model
+        )
+        
+        let carbAbsorptionReview = CarbAbsorptionReview(
+            carbEntries: carbEntries,
+            carbStatuses: carbStatus,
+            effectsVelocities: insulinCounteractionEffects,
+            carbEffects: carbEffects
+        )
+        
+        let trimmedDoses = annotatedDoses.filterDateRange(start, end)
+        let trimmedIOBValues = annotatedDoses.insulinOnBoardTimeline().filterDateRange(start, end)
+        
+        let historicalChartsData = HistoricalChartsData(
+            glucoseValues: glucose,
+            carbEntries: carbEntries,
+            doses: trimmedDoses,
+            iobValues: trimmedIOBValues,
+            carbAbsorptionReview: carbAbsorptionReview
+        )
+
+        return historicalChartsData
+    }
+}
+
 extension LoopDataManager: ManualDoseViewModelDelegate {
     var pumpInsulinType: InsulinType? {
         deliveryDelegate?.pumpInsulinType

Loop/Managers/LoopDataManager.swift

@@ -11,7 +11,7 @@ import HealthKit
 
 protocol CarbStoreProtocol: AnyObject {
 
-    func getCarbEntries(start: Date?, end: Date?, dateAscending: Bool, with favoriteFoodID: String?) async throws -> [StoredCarbEntry]
+    func getCarbEntries(start: Date?, end: Date?, dateAscending: Bool, fetchLimit: Int?, with favoriteFoodID: String?) async throws -> [StoredCarbEntry]
 
     func replaceCarbEntry(_ oldEntry: StoredCarbEntry, withEntry newEntry: NewCarbEntry) async throws -> StoredCarbEntry
 
@@ -23,7 +23,7 @@ protocol CarbStoreProtocol: AnyObject {
 
 extension CarbStoreProtocol {
     func getCarbEntries(start: Date?, end: Date?) async throws -> [StoredCarbEntry] {
-        try await getCarbEntries(start: start, end: end, dateAscending: true, with: nil)
+        try await getCarbEntries(start: start, end: end, dateAscending: true, fetchLimit: nil, with: nil)
     }
 }
 

Loop/Managers/Store Protocols/CarbStoreProtocol.swift

@@ -1623,6 +1623,7 @@ final class StatusTableViewController: LoopChartsTableViewController {
                                           therapySettingsViewModelDelegate: deviceManager,
                                           delegate: self
         )
+        viewModel.favoriteFoodInsightsDelegate = loopManager
         let hostingController = DismissibleHostingController(
             rootView: SettingsView(viewModel: viewModel, localizedAppNameAndVersion: supportManager.localizedAppNameAndVersion)
                 .environmentObject(deviceManager.displayGlucosePreference)

Loop/View Controllers/StatusTableViewController.swift

@@ -382,7 +382,7 @@ final class BolusEntryViewModel: ObservableObject {
             }
             if let storedCarbEntry = await saveCarbEntry(carbEntry, replacingEntry: originalCarbEntry) {
                 self.dosingDecision.carbEntry = storedCarbEntry
-                self.analyticsServicesManager?.didAddCarbs(source: "Phone", amount: storedCarbEntry.quantity.doubleValue(for: .gram()))
+                self.analyticsServicesManager?.didAddCarbs(source: "Phone", amount: storedCarbEntry.quantity.doubleValue(for: .gram()), isFavoriteFood: storedCarbEntry.favoriteFoodID != nil)
             } else {
                 self.presentAlert(.carbEntryPersistenceFailure)
                 return false

Loop/View Models/BolusEntryViewModel.swift

@@ -12,8 +12,9 @@ import HealthKit
 import Combine
 import LoopCore
 import LoopAlgorithm
+import os.log
 
-protocol CarbEntryViewModelDelegate: AnyObject, BolusEntryViewModelDelegate {
+protocol CarbEntryViewModelDelegate: AnyObject, BolusEntryViewModelDelegate, FavoriteFoodInsightsViewModelDelegate {
     var defaultAbsorptionTimes: DefaultAbsorptionTimes { get }
     func scheduleOverrideEnabled(at date: Date) -> Bool
     func getGlucoseSamples(start: Date?, end: Date?) async throws -> [StoredGlucoseSample]
@@ -86,11 +87,24 @@ final class CarbEntryViewModel: ObservableObject {
     }
 
     @Published var favoriteFoods = UserDefaults.standard.favoriteFoods
-    @Published var selectedFavoriteFoodIndex = -1
+    @Published var selectedFavoriteFoodIndex = -1 {
+        willSet {
+            self.selectedFavoriteFoodLastEaten = nil
+        }
+    }
     var selectedFavoriteFood: StoredFavoriteFood? {
         let foodExistsForIndex = 0..<favoriteFoods.count ~= selectedFavoriteFoodIndex
         return foodExistsForIndex ? favoriteFoods[selectedFavoriteFoodIndex] : nil
     }
+    // Favorite Food Insights
+    @Published var selectedFavoriteFoodLastEaten: Date? = nil
+    lazy var relativeDateFormatter: RelativeDateTimeFormatter = {
+        let formatter = RelativeDateTimeFormatter()
+        formatter.unitsStyle = .full
+        return formatter
+    }()
+    
+    private let log = OSLog(category: "CarbEntryViewModel")
 
     weak var delegate: CarbEntryViewModelDelegate?
     weak var analyticsServicesManager: AnalyticsServicesManager?
@@ -127,22 +141,23 @@ final class CarbEntryViewModel: ObservableObject {
 
         if let favoriteFoodIndex = favoriteFoods.firstIndex(where: { $0.id == originalCarbEntry.favoriteFoodID }) {
             self.selectedFavoriteFoodIndex = favoriteFoodIndex
+            updateFavoriteFoodLastEatenDate(for: favoriteFoods[favoriteFoodIndex])
         }
 
+        observeFavoriteFoodIndexChange()
         observeLoopUpdates()
     }
 
     var originalCarbEntry: StoredCarbEntry? = nil
-    private var favoriteFood: FavoriteFood? = nil
 
     private var updatedCarbEntry: NewCarbEntry? {
         if let quantity = carbsQuantity, quantity != 0 {
-            if let o = originalCarbEntry, o.quantity.doubleValue(for: preferredCarbUnit) == quantity && o.startDate == time && o.foodType == foodType && o.absorptionTime == absorptionTime {
+            let favoriteFoodID = selectedFavoriteFoodIndex == -1 ? nil : favoriteFoods[selectedFavoriteFoodIndex].id
+
+            if let o = originalCarbEntry, o.quantity.doubleValue(for: preferredCarbUnit) == quantity && o.startDate == time && o.foodType == foodType && o.absorptionTime == absorptionTime, o.favoriteFoodID == favoriteFoodID {
                 return nil  // No changes were made
             }
 
-            let favoriteFoodID = selectedFavoriteFoodIndex == -1 ? nil : favoriteFoods[selectedFavoriteFoodIndex].id
-            
             return NewCarbEntry(
                 date: date,
                 quantity: HKQuantity(unit: preferredCarbUnit, doubleValue: quantity),
@@ -256,12 +271,15 @@ final class CarbEntryViewModel: ObservableObject {
 
     private func favoriteFoodSelected(at index: Int) {
         self.absorptionEditIsProgrammatic = true
+        // only updates carb entry fields if on new carb entry screen
         if index == -1 {
-            self.carbsQuantity = 0
+            if originalCarbEntry == nil {
+                self.carbsQuantity = 0
+                self.absorptionTime = defaultAbsorptionTimes.medium
+                self.absorptionTimeWasEdited = false
+                self.usesCustomFoodType = false
+            }
             self.foodType = ""
-            self.absorptionTime = defaultAbsorptionTimes.medium
-            self.absorptionTimeWasEdited = false
-            self.usesCustomFoodType = false
         }
         else {
             let food = favoriteFoods[index]
@@ -270,6 +288,23 @@ final class CarbEntryViewModel: ObservableObject {
             self.absorptionTime = food.absorptionTime
             self.absorptionTimeWasEdited = true
             self.usesCustomFoodType = true
+            updateFavoriteFoodLastEatenDate(for: food)
+        }
+    }
+    
+    private func updateFavoriteFoodLastEatenDate(for food: StoredFavoriteFood) {
+        // Update favorite food insights last eaten date
+        Task { @MainActor in
+            do {
+                if let lastEaten = try await delegate?.selectedFavoriteFoodLastEaten(food) {
+                    withAnimation(.default) {
+                        self.selectedFavoriteFoodLastEaten = lastEaten
+                    }
+                }
+            }
+            catch {
+                log.error("Failed to fetch last eaten date for favorite food: %{public}@, %{public}@", String(describing: selectedFavoriteFood), String(describing: error))
+            }
         }
     }
 

Loop/View Models/CarbEntryViewModel.swift

@@ -1,5 +1,5 @@
 //
-//  AddEditFavoriteFoodViewModel.swift
+//  FavoriteFoodAddEditViewModel.swift
 //  Loop
 //
 //  Created by Noah Brauner on 7/31/23.
@@ -10,7 +10,7 @@ import SwiftUI
 import LoopKit
 import HealthKit
 
-final class AddEditFavoriteFoodViewModel: ObservableObject {
+final class FavoriteFoodAddEditViewModel: ObservableObject {
     enum Alert: Identifiable {
         var id: Self {
             return self
@@ -36,7 +36,7 @@ final class AddEditFavoriteFoodViewModel: ObservableObject {
         return minAbsorptionTime...maxAbsorptionTime
     }
 
-    @Published var alert: AddEditFavoriteFoodViewModel.Alert?
+    @Published var alert: FavoriteFoodAddEditViewModel.Alert?
 
     private let onSave: (NewFavoriteFood) -> ()
 
@@ -57,8 +57,14 @@ final class AddEditFavoriteFoodViewModel: ObservableObject {
     init(carbsQuantity: Double?, foodType: String, absorptionTime: TimeInterval, onSave: @escaping (NewFavoriteFood) -> ()) {
         self.onSave = onSave
         self.carbsQuantity = carbsQuantity
-        self.foodType = foodType
         self.absorptionTime = absorptionTime
+        
+        // foodType of Apple 🍎 --> name: Apple, foodType: 🍎
+        var name = foodType
+        name.removeAll(where: \.isEmoji)
+        name = name.trimmingCharacters(in: .whitespacesAndNewlines)
+        self.foodType = foodType.filter(\.isEmoji)
+        self.name = name
     }
 
     var originalFavoriteFood: StoredFavoriteFood?