refactor getUpdatedEstimatedTimeRemaining

Author: chloe-yeo

Sources/FoundationEssentials/ProgressManager/ProgressManager+Properties+Helpers.swift

@@ -380,34 +380,19 @@ extension ProgressManager {
     }
 
     internal func getUpdatedEstimatedTimeRemaining() -> Duration {
+        // Collect information from state
+        let updateInfo = state.withLock { state in
+            state.getEstimatedTimeRemainingUpdateInfo()
+        }
+        
+        // Get updated summary for each dirty child
+        let updatedSummaries = updateInfo.dirtyChildren.map { (index, child) in
+            State.EstimatedTimeRemainingUpdate(index: index, updatedSummary: child.getUpdatedEstimatedTimeRemaining())
+        }
+        
+        // Consolidate updated values
         return state.withLock { state in
-            // Get self's estimatedTimeRemaining as part of summary
-            var value: Duration = Duration.seconds(0)
-            ProgressManager.Properties.EstimatedTimeRemaining.reduce(into: &value, value: state.estimatedTimeRemaining)
-            
-            guard !state.children.isEmpty else {
-                return value
-            }
-            
-            for (idx, childState) in state.children.enumerated() {
-                if childState.estimatedTimeRemaining.isDirty {
-                    // Update dirty path
-                    if let child = childState.child {
-                        let updatedSummary = child.getUpdatedEstimatedTimeRemaining()
-                        let newDurationState = PropertyStateDuration(value: updatedSummary, isDirty: false)
-                        state.children[idx].estimatedTimeRemaining = newDurationState
-                        value = ProgressManager.Properties.EstimatedTimeRemaining.merge(value, updatedSummary)
-                    }
-                } else {
-                    if let _ = childState.child {
-                        // Merge non-dirty, updated value
-                        value = ProgressManager.Properties.EstimatedTimeRemaining.merge(value, childState.estimatedTimeRemaining.value)
-                    } else {
-                        value = ProgressManager.Properties.EstimatedTimeRemaining.finalSummary(value, childState.estimatedTimeRemaining.value)
-                    }
-                }
-            }
-            return value
+            state.updateEstimatedTimeRemaining(updateInfo, updatedSummaries)
         }
     }
 

Sources/FoundationEssentials/ProgressManager/ProgressManager+State.swift

@@ -312,6 +312,17 @@ extension ProgressManager {
             let updatedSummary: [UInt64]
         }
 
+        internal struct EstimatedTimeRemainingUpdateInfo {
+            let currentSummary: Duration
+            let dirtyChildren: [(index: Int, manager: ProgressManager)]
+            let nonDirtySummaries: [(index: Int, summary: Duration, isAlive: Bool)]
+        }
+        
+        internal struct EstimatedTimeRemainingUpdate {
+            let index: Int
+            let updatedSummary: Duration
+        }
+        
         internal mutating func getThroughputUpdateInfo() -> ThroughputUpdateInfo {
             var currentSummary = ProgressManager.Properties.Throughput.defaultSummary
             ProgressManager.Properties.Throughput.reduce(into: &currentSummary, value: throughput)
@@ -365,5 +376,59 @@ extension ProgressManager {
 
             return value
         }
+        
+        internal mutating func getEstimatedTimeRemainingUpdateInfo() -> EstimatedTimeRemainingUpdateInfo {
+            var currentSummary: Duration = Duration.seconds(0)
+            ProgressManager.Properties.EstimatedTimeRemaining.reduce(into: &currentSummary, value: estimatedTimeRemaining)
+            
+            guard !children.isEmpty else {
+                return EstimatedTimeRemainingUpdateInfo(
+                    currentSummary: currentSummary,
+                    dirtyChildren: [],
+                    nonDirtySummaries: []
+                )
+            }
+            
+            var dirtyChildren: [(index: Int, manager: ProgressManager)] = []
+            var nonDirtySummaries: [(index: Int, summary: Duration, isAlive: Bool)] = []
+            
+            for (idx, childState) in children.enumerated() {
+                if childState.estimatedTimeRemaining.isDirty {
+                    if let child = childState.child {
+                        dirtyChildren.append((idx, child))
+                    }
+                } else {
+                    let isAlive = childState.child != nil
+                    nonDirtySummaries.append((idx, childState.estimatedTimeRemaining.value, isAlive))
+                }
+            }
+            
+            return EstimatedTimeRemainingUpdateInfo(
+                currentSummary: currentSummary,
+                dirtyChildren: dirtyChildren,
+                nonDirtySummaries: nonDirtySummaries
+            )
+        }
+        
+        internal mutating func updateEstimatedTimeRemaining(_ updateInfo: EstimatedTimeRemainingUpdateInfo, _ childUpdates: [EstimatedTimeRemainingUpdate]) -> Duration {
+            var value = updateInfo.currentSummary
+            
+            // Apply updates from children that were dirty
+            for update in childUpdates {
+                children[update.index].estimatedTimeRemaining = PropertyStateDuration(value: update.updatedSummary, isDirty: false)
+                value = ProgressManager.Properties.EstimatedTimeRemaining.merge(value, update.updatedSummary)
+            }
+            
+            // Apply values from non-dirty children
+            for (_, childSummary, isAlive) in updateInfo.nonDirtySummaries {
+                if isAlive {
+                    value = ProgressManager.Properties.EstimatedTimeRemaining.merge(value, childSummary)
+                } else {
+                    value = ProgressManager.Properties.EstimatedTimeRemaining.finalSummary(value, childSummary)
+                }
+            }
+            
+            return value
+        }
     }
 }