Simplify by making raw percentage calculation private

TempTarget sensitivity calculations into TempTargetCalculations helper

Trio/Sources/Helpers/TempTargetCalculations.swift

@@ -9,25 +9,6 @@ enum TempTargetCalculations {
     /// The normal target glucose value used as reference (100 mg/dL)
     static let normalTarget: Decimal = 100
 
-    /// Computes the raw (unclamped) adjusted percentage for a given HBT and target.
-    /// - Parameters:
-    ///   - halfBasalTarget: The half basal target value
-    ///   - target: The target glucose value
-    ///   - autosensMax: The maximum autosens multiplier from settings
-    /// - Returns: The raw percentage (not clamped to minSensitivityRatioTT)
-    static func computeRawAdjustedPercentage(
-        halfBasalTarget: Decimal,
-        target: Decimal,
-        autosensMax: Decimal
-    ) -> Double {
-        let deviationFromNormal = halfBasalTarget - normalTarget
-        let adjustmentFactor = deviationFromNormal + (target - normalTarget)
-        let adjustmentRatio: Decimal = (deviationFromNormal * adjustmentFactor <= 0)
-            ? autosensMax
-            : deviationFromNormal / adjustmentFactor
-        return Double(min(adjustmentRatio, autosensMax) * 100)
-    }
-
     /// Computes the adjusted percentage (clamped to minSensitivityRatioTT).
     /// - Parameters:
     ///   - halfBasalTarget: The half basal target value
@@ -39,12 +20,26 @@ enum TempTargetCalculations {
         target: Decimal,
         autosensMax: Decimal
     ) -> Double {
-        let rawPercentage = computeRawAdjustedPercentage(
+        let rawPercentage = computeRawPercentage(
             halfBasalTarget: halfBasalTarget,
             target: target,
             autosensMax: autosensMax
         )
-        return rawPercentage < minSensitivityRatioTT ? minSensitivityRatioTT : rawPercentage
+        return max(rawPercentage, minSensitivityRatioTT)
+    }
+
+    /// Computes the raw (unclamped) percentage - private helper.
+    private static func computeRawPercentage(
+        halfBasalTarget: Decimal,
+        target: Decimal,
+        autosensMax: Decimal
+    ) -> Double {
+        let deviationFromNormal = halfBasalTarget - normalTarget
+        let adjustmentFactor = deviationFromNormal + (target - normalTarget)
+        let adjustmentRatio: Decimal = (deviationFromNormal * adjustmentFactor <= 0)
+            ? autosensMax
+            : deviationFromNormal / adjustmentFactor
+        return Double(min(adjustmentRatio, autosensMax) * 100)
     }
 
     /// Computes the half-basal target needed to achieve a given percentage.
@@ -81,12 +76,11 @@ enum TempTargetCalculations {
         target: Decimal,
         autosensMax: Decimal
     ) -> (percentage: Double, halfBasalTarget: Decimal?) {
-        let rawPercentage = computeRawAdjustedPercentage(
+        let rawPercentage = computeRawPercentage(
             halfBasalTarget: settingHalfBasalTarget,
             target: target,
             autosensMax: autosensMax
         )
-        let clampedPercentage = rawPercentage < minSensitivityRatioTT ? minSensitivityRatioTT : rawPercentage
 
         // If raw percentage is at or below minimum, we need to calculate an adjusted HBT
         if rawPercentage <= minSensitivityRatioTT {
@@ -96,7 +90,7 @@ enum TempTargetCalculations {
             ))
             return (minSensitivityRatioTT, adjustedHBT)
         } else {
-            return (clampedPercentage, nil)
+            return (rawPercentage, nil)
         }
     }
 

Trio/Sources/Modules/Adjustments/AdjustmentsStateModel+Extensions/AdjustmentsStateModel+TempTargets.swift

@@ -422,19 +422,6 @@ extension Adjustments.StateModel {
         return maxSens
     }
 
-    /// Computes the raw (unclamped) adjusted percentage for a given HBT and target.
-    /// This is used to check if the percentage would be below minSensitivityRatioTT.
-    func computeRawAdjustedPercentage(
-        usingHBT halfBasalTargetValue: Decimal,
-        usingTarget calcTarget: Decimal
-    ) -> Double {
-        TempTargetCalculations.computeRawAdjustedPercentage(
-            halfBasalTarget: halfBasalTargetValue,
-            target: calcTarget,
-            autosensMax: autosensMax
-        )
-    }
-
     /// Computes the adjusted percentage for the slider.
     func computeAdjustedPercentage(
         usingHBT initialHalfBasalTarget: Decimal? = nil,
@@ -461,30 +448,11 @@ extension Adjustments.StateModel {
             autosensMax: autosensMax
         )
 
-        // Use raw percentage for debug logging
-        let rawPercentage = TempTargetCalculations.computeRawAdjustedPercentage(
-            halfBasalTarget: settingHalfBasalTarget,
-            target: target,
-            autosensMax: autosensMax
-        )
-
         debug(
             .default,
-            "checkStandardTT: target=\(target), settingHBT=\(settingHalfBasalTarget), rawPercentage=\(rawPercentage), percentage=\(result.percentage), minSensitivityRatioTT=\(TempTargetCalculations.minSensitivityRatioTT)"
+            "checkStandardTT: target=\(target), settingHBT=\(settingHalfBasalTarget), percentage=\(result.percentage), adjustedHBT=\(String(describing: result.halfBasalTarget))"
         )
 
-        if let adjustedHBT = result.halfBasalTarget {
-            debug(
-                .default,
-                "checkStandardTT: rawPercentage <= minSensitivityRatioTT, returning adjustedHBT=\(adjustedHBT), percentage=\(result.percentage)"
-            )
-        } else {
-            debug(
-                .default,
-                "checkStandardTT: rawPercentage > minSensitivityRatioTT, returning nil HBT, percentage=\(result.percentage)"
-            )
-        }
-
         return result
     }
 }

Trio/Sources/Modules/Adjustments/View/TempTargets/EditTempTargetForm.swift

@@ -95,17 +95,13 @@ struct EditTempTargetForm: View {
                    halfBasalTarget != state.settingHalfBasalTarget
                 {
                     // Check if this was an auto-adjusted standard TT:
-                    // percentage is at minimum AND using settings HBT would have produced <= minimum (raw)
-                    let rawStandardPercentage = state.computeRawAdjustedPercentage(
-                        usingHBT: state.settingHalfBasalTarget,
-                        usingTarget: target
-                    )
-                    let isAutoAdjustedStandard = percentage == TempTargetCalculations.minSensitivityRatioTT &&
-                        rawStandardPercentage <= TempTargetCalculations.minSensitivityRatioTT
+                    // If computeStandardPercentageAndHBT returns a non-nil HBT, it means settings HBT would produce <= 15%
+                    let (_, standardAdjustedHBT) = state.computeStandardPercentageAndHBT(usingTarget: target)
+                    let isAutoAdjustedStandard = standardAdjustedHBT != nil
 
                     debug(
                         .default,
-                        "checkStandardTT onAppear: rawStandardPercentage=\(rawStandardPercentage), minSensitivityRatioTT=\(TempTargetCalculations.minSensitivityRatioTT), isAutoAdjustedStandard=\(isAutoAdjustedStandard)"
+                        "checkStandardTT onAppear: isAutoAdjustedStandard=\(isAutoAdjustedStandard), standardAdjustedHBT=\(String(describing: standardAdjustedHBT))"
                     )
 
                     if !isAutoAdjustedStandard {