+		C1A500013C9D000100A10001 /* ChargedDeviceActiveSessionView.swift in Sources */ = {isa = PBXBuildFile; fileRef = C1A500023C9D000100A10002 /* ChargedDeviceActiveSessionView.swift */; };

+		C1A500023C9D000100A10002 /* ChargedDeviceActiveSessionView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ChargedDeviceActiveSessionView.swift; sourceTree = "<group>"; };

+				C1A500023C9D000100A10002 /* ChargedDeviceActiveSessionView.swift */,

+				C1A500013C9D000100A10001 /* ChargedDeviceActiveSessionView.swift in Sources */,

+//

+//  ChargedDeviceActiveSessionView.swift

+//  USB Meter

+//

+//  Created by Codex on 22/04/2026.

+//

+

+import SwiftUI

+

+struct ChargedDeviceActiveSessionView: View {

+    @EnvironmentObject private var appData: AppData

+    @State private var targetNotificationEditorVisibility = false

+    @State private var pendingCheckpointDeletion: ChargeCheckpointSummary?

+    @State private var pendingSessionStopRequest: ActiveDeviceSessionStopRequest?

+

+    let chargedDeviceID: UUID

+

+    private var chargedDevice: ChargedDeviceSummary? {

+        appData.chargedDeviceSummary(id: chargedDeviceID)

+    }

+

+    private var activeSession: ChargeSessionSummary? {

+        chargedDevice?.activeSession

+    }

+

+    var body: some View {

+        Group {

+            if let chargedDevice, let activeSession {

+                ScrollView {

+                    VStack(spacing: 16) {

+                        activeSessionCard(activeSession, chargedDevice: chargedDevice)

+

+                        if !activeSession.displayedAggregatedSamples.isEmpty {

+                            storedCurveCard(activeSession)

+                        }

+                    }

+                    .padding()

+                }

+                .background(

+                    LinearGradient(

+                        colors: [statusTint(for: activeSession).opacity(0.14), Color.clear],

+                        startPoint: .topLeading,

+                        endPoint: .bottomTrailing

+                    )

+                    .ignoresSafeArea()

+                )

+                .navigationTitle("Current Session")

+            } else {

+                Text("There is no open session for this device.")

+                    .foregroundColor(.secondary)

+                    .navigationTitle("Current Session")

+            }

+        }

+        .sheet(isPresented: $targetNotificationEditorVisibility) {

+            if let activeSession {

+                ActiveSessionTargetNotificationEditorSheetView(

+                    sessionID: activeSession.id,

+                    initialTargetPercent: activeSession.targetBatteryPercent

+                )

+                .environmentObject(appData)

+            }

+        }

+        .sheet(item: $pendingSessionStopRequest) { request in

+            ChargeSessionCompletionSheetView(

+                sessionID: request.sessionID,

+                title: request.title,

+                confirmTitle: request.confirmTitle,

+                explanation: request.explanation

+            )

+            .environmentObject(appData)

+        }

+        .alert(item: $pendingCheckpointDeletion) { checkpoint in

+            Alert(

+                title: Text("Delete Battery Checkpoint"),

+                message: Text("Remove the checkpoint at \(checkpoint.timestamp.format()) with \(checkpoint.batteryPercent.format(decimalDigits: 0))% from this session?"),

+                primaryButton: .destructive(Text("Delete")) {

+                    _ = appData.deleteBatteryCheckpoint(

+                        checkpointID: checkpoint.id,

+                        for: checkpoint.sessionID

+                    )

+                },

+                secondaryButton: .cancel()

+            )

+        }

+    }

+

+    private func activeSessionCard(

+        _ activeSession: ChargeSessionSummary,

+        chargedDevice: ChargedDeviceSummary

+    ) -> some View {

+        MeterInfoCardView(title: "Open Session", tint: statusTint(for: activeSession)) {

+            MeterInfoRowView(label: "Started", value: activeSession.startedAt.format())

+            MeterInfoRowView(label: "Status", value: activeSession.status.title)

+            MeterInfoRowView(label: "Duration", value: sessionDurationText(activeSession))

+            MeterInfoRowView(label: "Charging Type", value: activeSession.chargingTransportMode.title)

+            MeterInfoRowView(label: "Charging Mode", value: activeSession.chargingStateMode.title)

+            MeterInfoRowView(label: "Battery Energy", value: "\(activeSession.effectiveOrMeasuredEnergyWh.format(decimalDigits: 3)) Wh")

+            if activeSession.chargingTransportMode == .wireless,

+               let effectiveBatteryEnergyWh = activeSession.effectiveBatteryEnergyWh,

+               abs(effectiveBatteryEnergyWh - activeSession.measuredEnergyWh) > 0.01 {

+                MeterInfoRowView(label: "Charger Energy", value: "\(activeSession.measuredEnergyWh.format(decimalDigits: 3)) Wh")

+            }

+            MeterInfoRowView(label: "Auto Stop", value: autoStopDescription(for: activeSession))

+            MeterInfoRowView(label: "Source", value: activeSession.sourceMode.title)

+            if chargedDevice.isCharger == false,

+               let chargerID = activeSession.chargerID,

+               let charger = appData.chargedDeviceSummary(id: chargerID) {

+                MeterInfoRowView(label: "Wireless Charger", value: charger.name)

+            }

+            if let maximumObservedCurrentAmps = activeSession.maximumObservedCurrentAmps {

+                MeterInfoRowView(label: "Max Current", value: "\(maximumObservedCurrentAmps.format(decimalDigits: 2)) A")

+            }

+            if let maximumObservedPowerWatts = activeSession.maximumObservedPowerWatts {

+                MeterInfoRowView(label: "Max Power", value: "\(maximumObservedPowerWatts.format(decimalDigits: 2)) W")

+            }

+            if activeSession.chargingTransportMode == .wired,

+               let maximumObservedVoltageVolts = activeSession.maximumObservedVoltageVolts {

+                MeterInfoRowView(label: "Max Voltage", value: "\(maximumObservedVoltageVolts.format(decimalDigits: 2)) V")

+            }

+            if chargedDevice.isCharger, let selectedSourceVoltageVolts = activeSession.selectedSourceVoltageVolts {

+                MeterInfoRowView(label: "Selected Voltage", value: "\(selectedSourceVoltageVolts.format(decimalDigits: 2)) V")

+            }

+            if let targetBatteryPercent = activeSession.targetBatteryPercent {

+                MeterInfoRowView(

+                    label: "Target Notification",

+                    value: "\(targetBatteryPercent.format(decimalDigits: 0))%"

+                )

+            }

+            if let sessionWarning = sessionWarning(for: activeSession) {

+                Text(sessionWarning)

+                    .font(.caption2)

+                    .foregroundColor(.orange)

+            }

+            if let wirelessSessionHint = wirelessSessionHint(for: activeSession) {

+                Text(wirelessSessionHint)

+                    .font(.caption2)

+                    .foregroundColor(activeSession.shouldWarnAboutLowWirelessEfficiency ? .orange : .secondary)

+            }

+            if let batteryPrediction = chargedDevice.batteryLevelPrediction(for: activeSession) {

+                MeterInfoRowView(

+                    label: "Predicted Battery",

+                    value: "\(batteryPrediction.predictedPercent.format(decimalDigits: 0))%"

+                )

+                Text(

+                    "Anchored to \(batteryPrediction.anchorDescription) at \(batteryPrediction.anchorPercent.format(decimalDigits: 0))% using \(batteryPrediction.estimatedCapacityWh.format(decimalDigits: 2)) Wh estimated capacity."

+                )

+                .font(.caption2)

+                .foregroundColor(.secondary)

+            }

+

+            BatteryCheckpointSectionView(

+                sessionID: activeSession.id,

+                checkpoints: activeSession.checkpoints,

+                message: "The checkpoint is stored on the active charge session and is used for capacity estimation and charge-level prediction.",

+                canAddCheckpoint: appData.canAddBatteryCheckpoint(to: activeSession.id),

+                requirementMessage: appData.batteryCheckpointCaptureRequirementMessage(for: activeSession.id),

+                effectiveEnergyWhOverride: nil,

+                measuredChargeAhOverride: nil,

+                onDelete: { checkpoint in

+                    pendingCheckpointDeletion = checkpoint

+                }

+            )

+

+            Button(activeSession.targetBatteryPercent == nil ? "Set Target Notification" : "Change Target Notification") {

+                targetNotificationEditorVisibility = true

+            }

+            .frame(maxWidth: .infinity)

+            .padding(.vertical, 10)

+            .meterCard(tint: .indigo, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 14)

+            .buttonStyle(.plain)

+

+            if activeSession.targetBatteryPercent != nil {

+                Button("Clear Target Notification") {

+                    _ = appData.setTargetBatteryPercent(nil, for: activeSession.id)

+                }

+                .frame(maxWidth: .infinity)

+                .padding(.vertical, 10)

+                .meterCard(tint: .secondary, fillOpacity: 0.12, strokeOpacity: 0.18, cornerRadius: 14)

+                .buttonStyle(.plain)

+            }

+

+            if activeSession.status == .active {

+                Button("Pause Session") {

+                    _ = appData.pauseChargeSession(sessionID: activeSession.id)

+                }

+                .frame(maxWidth: .infinity)

+                .padding(.vertical, 10)

+                .meterCard(tint: .orange, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 14)

+                .buttonStyle(.plain)

+            } else if activeSession.status == .paused {

+                Button("Resume Session") {

+                    _ = appData.resumeChargeSession(sessionID: activeSession.id)

+                }

+                .frame(maxWidth: .infinity)

+                .padding(.vertical, 10)

+                .meterCard(tint: .blue, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 14)

+                .buttonStyle(.plain)

+

+                Text("Paused sessions close automatically after 10 minutes.")

+                    .font(.caption2)

+                    .foregroundColor(.secondary)

+            }

+

+            Button(activeSession.requiresCompletionConfirmation ? "Finish Session With Checkpoint" : "Stop Session") {

+                pendingSessionStopRequest = ActiveDeviceSessionStopRequest(

+                    sessionID: activeSession.id,

+                    title: activeSession.requiresCompletionConfirmation ? "Finish Session" : "Stop Session",

+                    confirmTitle: activeSession.requiresCompletionConfirmation ? "Finish" : "Stop",

+                    explanation: "Add the final battery checkpoint before closing this session."

+                )

+            }

+            .frame(maxWidth: .infinity)

+            .padding(.vertical, 10)

+            .meterCard(tint: .red, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 14)

+            .buttonStyle(.plain)

+

+            if activeSession.requiresCompletionConfirmation {

+                Divider()

+                if let contradictionPercent = activeSession.completionContradictionPercent {

+                    Text("Current says charging may have stopped, but the estimated battery level is only \(contradictionPercent.format(decimalDigits: 0))%.")

+                        .font(.caption2)

+                        .foregroundColor(.secondary)

+                }

+

+                Button("Keep Monitoring") {

+                    _ = appData.continueChargeSessionMonitoring(sessionID: activeSession.id)

+                }

+                .frame(maxWidth: .infinity)

+                .padding(.vertical, 10)

+                .meterCard(tint: .blue, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 14)

+                .buttonStyle(.plain)

+            }

+        }

+    }

+

+    private func storedCurveCard(_ session: ChargeSessionSummary) -> some View {

+        let displayedSamples = session.displayedAggregatedSamples

+        let currentSeries = storedSeriesSnapshot(

+            from: displayedSamples,

+            minimumYSpan: 0.15

+        ) { $0.averageCurrentAmps }

+        let energySeries = storedSeriesSnapshot(

+            from: displayedSamples,

+            minimumYSpan: 0.2

+        ) { $0.measuredEnergyWh }

+

+        return VStack(alignment: .leading, spacing: 14) {

+            HStack(alignment: .firstTextBaseline) {

+                VStack(alignment: .leading, spacing: 4) {

+                    HStack(spacing: 8) {

+                        Text("Stored Session Curve")

+                            .font(.headline)

+                        ContextInfoButton(

+                            title: "Stored Session Curve",

+                            message: "Database storage and iCloud sync use 300 aggregated points per hour. Active sessions persist their partial aggregated curve continuously, so a reconnect or restart can restore the stored progress."

+                        )

+                    }

+                    Text("Open session, persisted as aggregated samples.")

+                        .font(.caption)

+                        .foregroundColor(.secondary)

+                }

+

+                Spacer()

+

+                Text("\(displayedSamples.count) points")

+                    .font(.caption.weight(.semibold))

+                    .foregroundColor(.secondary)

+            }

+

+            if let currentSeries {

+                storedSeriesChart(

+                    title: "Current",

+                    unit: "A",

+                    strokeColor: .blue,

+                    snapshot: currentSeries

+                )

+            }

+

+            if let energySeries {

+                storedSeriesChart(

+                    title: "Energy",

+                    unit: "Wh",

+                    strokeColor: .teal,

+                    areaChart: true,

+                    snapshot: energySeries

+                )

+            }

+        }

+        .frame(maxWidth: .infinity, alignment: .leading)

+        .padding(18)

+        .meterCard(tint: .indigo, fillOpacity: 0.12, strokeOpacity: 0.18, cornerRadius: 18)

+    }

+

+    private func storedSeriesSnapshot(

+        from samples: [ChargeSessionSampleSummary],

+        minimumYSpan: Double,

+        value: (ChargeSessionSampleSummary) -> Double

+    ) -> ActiveSessionSeriesSnapshot? {

+        let sortedSamples = samples.sorted { lhs, rhs in

+            if lhs.bucketIndex != rhs.bucketIndex {

+                return lhs.bucketIndex < rhs.bucketIndex

+            }

+            return lhs.timestamp < rhs.timestamp

+        }

+

+        guard

+            let firstSample = sortedSamples.first,

+            let lastSample = sortedSamples.last

+        else {

+            return nil

+        }

+

+        let points = sortedSamples.enumerated().map { index, sample in

+            Measurements.Measurement.Point(

+                id: index,

+                timestamp: sample.timestamp,

+                value: value(sample),

+                kind: .sample

+            )

+        }

+

+        let minimumValue = points.map(\.value).min() ?? 0

+        let maximumValue = points.map(\.value).max() ?? minimumValue

+        let context = ChartContext()

+        context.setBounds(

+            xMin: CGFloat(firstSample.timestamp.timeIntervalSince1970),

+            xMax: CGFloat(max(lastSample.timestamp.timeIntervalSince1970, firstSample.timestamp.timeIntervalSince1970 + 1)),

+            yMin: CGFloat(minimumValue),

+            yMax: CGFloat(maximumValue)

+        )

+        context.ensureMinimumSize(width: 1, height: CGFloat(max(maximumValue - minimumValue, minimumYSpan)))

+

+        return ActiveSessionSeriesSnapshot(

+            points: points,

+            context: context,

+            minimumValue: minimumValue,

+            maximumValue: maximumValue

+        )

+    }

+

+    private func storedSeriesChart(

+        title: String,

+        unit: String,

+        strokeColor: Color,

+        areaChart: Bool = false,

+        snapshot: ActiveSessionSeriesSnapshot

+    ) -> some View {

+        VStack(alignment: .leading, spacing: 8) {

+            HStack(alignment: .firstTextBaseline) {

+                Text(title)

+                    .font(.subheadline.weight(.semibold))

+                Spacer()

+                Text(

+                    "Latest \(snapshot.lastValue.format(decimalDigits: 2)) \(unit) - \(snapshot.minimumValue.format(decimalDigits: 2))-\(snapshot.maximumValue.format(decimalDigits: 2)) \(unit)"

+                )

+                .font(.caption2)

+                .foregroundColor(.secondary)

+            }

+

+            TimeSeriesChart(

+                points: snapshot.points,

+                context: snapshot.context,

+                areaChart: areaChart,

+                strokeColor: strokeColor

+            )

+            .frame(height: 118)

+            .padding(.horizontal, 6)

+            .padding(.vertical, 8)

+            .background(

+                RoundedRectangle(cornerRadius: 16)

+                    .fill(strokeColor.opacity(areaChart ? 0.08 : 0.06))

+            )

+

+            HStack {

+                Text(snapshot.startLabel)

+                Spacer()

+                Text(snapshot.endLabel)

+            }

+            .font(.caption2)

+            .foregroundColor(.secondary)

+        }

+    }

+

+    private func sessionDurationText(_ session: ChargeSessionSummary) -> String {

+        let formatter = DateComponentsFormatter()

+        let effectiveDuration = max(session.effectiveDuration, 0)

+        formatter.allowedUnits = effectiveDuration >= 3600 ? [.hour, .minute] : [.minute, .second]

+        formatter.unitsStyle = .abbreviated

+        formatter.zeroFormattingBehavior = .dropAll

+        return formatter.string(from: effectiveDuration) ?? "0m"

+    }

+

+    private func autoStopDescription(for session: ChargeSessionSummary) -> String {

+        if session.autoStopEnabled == false {

+            return "Manual"

+        }

+

+        if let sessionWarning = sessionWarning(for: session),

+           sessionWarning.contains("idle-current") {

+            return "Blocked by charger setup"

+        }

+

+        if session.stopThresholdAmps > 0 {

+            return "\(session.stopThresholdAmps.format(decimalDigits: 2)) A"

+        }

+

+        return "Learning"

+    }

+

+    private func sessionWarning(for session: ChargeSessionSummary) -> String? {

+        guard session.chargingTransportMode == .wireless,

+              let chargerID = session.chargerID,

+              let charger = appData.chargedDeviceSummary(id: chargerID),

+              charger.chargerIdleCurrentAmps == nil else {

+            return nil

+        }

+

+        return "This charger has no idle-current measurement, so the wireless stop threshold cannot be learned or auto-applied for this session."

+    }

+

+    private func wirelessSessionHint(for session: ChargeSessionSummary) -> String? {

+        guard session.chargingTransportMode == .wireless else {

+            return nil

+        }

+

+        var components: [String] = []

+        if let wirelessEfficiencyFactor = session.wirelessEfficiencyFactor {

+            components.append("Efficiency \(Int((wirelessEfficiencyFactor * 100).rounded()))%")

+        }

+        if session.usesEstimatedWirelessEfficiency {

+            components.append("Estimated from wired baseline and checkpoints")

+        }

+        if session.shouldWarnAboutLowWirelessEfficiency {

+            components.append("Low wireless efficiency, so capacity confidence is reduced")

+        }

+

+        return components.isEmpty ? nil : components.joined(separator: " - ")

+    }

+

+    private func statusTint(for session: ChargeSessionSummary) -> Color {

+        switch session.status {

+        case .active:

+            return .green

+        case .paused:

+            return .orange

+        case .completed:

+            return .teal

+        case .abandoned:

+            return .secondary

+        }

+    }

+}

+

+private struct ActiveSessionSeriesSnapshot {

+    let points: [Measurements.Measurement.Point]

+    let context: ChartContext

+    let minimumValue: Double

+    let maximumValue: Double

+

+    var lastValue: Double {

+        points.last?.value ?? 0

+    }

+

+    var startLabel: String {

+        guard let firstTimestamp = points.first?.timestamp else { return "" }

+        return firstTimestamp.formatted(date: .omitted, time: .shortened)

+    }

+

+    var endLabel: String {

+        guard let lastTimestamp = points.last?.timestamp else { return "" }

+        return lastTimestamp.formatted(date: .omitted, time: .shortened)

+    }

+}

+

+private struct ActiveSessionTargetNotificationEditorSheetView: View {

+    @Environment(\.dismiss) private var dismiss

+    @EnvironmentObject private var appData: AppData

+

+    let sessionID: UUID

+    let initialTargetPercent: Double?

+

+    @State private var targetPercent: Double

+

+    init(sessionID: UUID, initialTargetPercent: Double?) {

+        self.sessionID = sessionID

+        self.initialTargetPercent = initialTargetPercent

+        _targetPercent = State(initialValue: initialTargetPercent ?? 80)

+    }

+

+    var body: some View {

+        NavigationView {

+            Form {

+                Section(

+                    header: ContextInfoHeader(

+                        title: "Target Level",

+                        message: "A local notification will be generated on synced devices when the estimated battery level reaches this target."

+                    )

+                ) {

+                    VStack(alignment: .leading, spacing: 12) {

+                        Text("\(targetPercent.format(decimalDigits: 0))%")

+                            .font(.title3.weight(.bold))

+                        Slider(value: $targetPercent, in: 20...100, step: 1)

+                    }

+                }

+            }

+            .navigationTitle("Battery Target")

+            .navigationBarTitleDisplayMode(.inline)

+            .toolbar {

+                ToolbarItem(placement: .cancellationAction) {

+                    Button("Cancel") {

+                        dismiss()

+                    }

+                }

+

+                ToolbarItem(placement: .confirmationAction) {

+                    Button("Save") {

+                        if appData.setTargetBatteryPercent(targetPercent, for: sessionID) {

+                            dismiss()

+                        }

+                    }

+                }

+            }

+        }

+        .navigationViewStyle(StackNavigationViewStyle())

+    }

+}

+

+private struct ActiveDeviceSessionStopRequest: Identifiable {

+    let sessionID: UUID

+    let title: String

+    let confirmTitle: String

+    let explanation: String

+

+    var id: UUID {

+        sessionID

+    }

+}

+                            activeSessionSummaryCard(activeSession, chargedDevice: chargedDevice)

+    private func activeSessionSummaryCard(

+        NavigationLink(

+            destination: ChargedDeviceActiveSessionView(chargedDeviceID: chargedDevice.id)

+        ) {

+            VStack(alignment: .leading, spacing: 14) {

+                HStack(alignment: .firstTextBaseline) {

+                    VStack(alignment: .leading, spacing: 4) {

+                        Text("Current Session")

+                            .font(.headline)

+                            .foregroundColor(.primary)

+                        Text(activeSession.status.title)

+                            .font(.caption.weight(.semibold))

+                            .foregroundColor(statusTint(for: activeSession))

+                    }

+                    Spacer()

+                    Image(systemName: "chevron.right")

+                        .font(.caption.weight(.semibold))

+                        .foregroundColor(.secondary)

+                LazyVGrid(columns: activeSessionSummaryColumns, spacing: 8) {

+                    activeSessionMetricCell(

+                        label: "Energy",

+                        value: "\(activeSession.effectiveOrMeasuredEnergyWh.format(decimalDigits: 2)) Wh",

+                        tint: .teal

+                    )

+                    activeSessionMetricCell(

+                        label: "Duration",

+                        value: sessionDurationText(activeSession),

+                        tint: .orange

+                    )

+                    if let maximumObservedPowerWatts = activeSession.maximumObservedPowerWatts {

+                        activeSessionMetricCell(

+                            label: "Max Power",

+                            value: "\(maximumObservedPowerWatts.format(decimalDigits: 2)) W",

+                            tint: .blue

+                        )

+                    }

+                    if let batteryPrediction = chargedDevice.batteryLevelPrediction(for: activeSession) {

+                        activeSessionMetricCell(

+                            label: "Battery",

+                            value: "\(batteryPrediction.predictedPercent.format(decimalDigits: 0))%",

+                            tint: .green

+                        )

+                    } else if let targetBatteryPercent = activeSession.targetBatteryPercent {

+                        activeSessionMetricCell(

+                            label: "Target",

+                            value: "\(targetBatteryPercent.format(decimalDigits: 0))%",

+                            tint: .indigo

+                        )

+                    }

+                Text("Started \(activeSession.startedAt.format())")

+                    .font(.caption)

+        }

+        .buttonStyle(.plain)

+        .padding(18)

+        .meterCard(tint: statusTint(for: activeSession), fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 18)

+    }

+    private var activeSessionSummaryColumns: [GridItem] {

+        [

+            GridItem(.flexible(minimum: 92), spacing: 8),

+            GridItem(.flexible(minimum: 92), spacing: 8)

+        ]

+    }

+    private func activeSessionMetricCell(label: String, value: String, tint: Color) -> some View {

+        VStack(alignment: .leading, spacing: 4) {

+            Text(label)

+                .font(.caption2)

+                .foregroundColor(.secondary)

+            Text(value)

+                .font(.footnote.weight(.semibold))

+                .foregroundColor(.primary)

+                .monospacedDigit()

+                .lineLimit(1)

+                .minimumScaleFactor(0.8)

+        .frame(maxWidth: .infinity, alignment: .leading)

+        .padding(10)

+        .meterCard(tint: tint, fillOpacity: 0.08, strokeOpacity: 0.12, cornerRadius: 12)

+    private func statusTint(for session: ChargeSessionSummary) -> Color {

+        switch session.status {

+        case .active:

+            return .green

+        case .paused:

+            return .orange

+        case .completed:

+            return .teal

+        case .abandoned:

+            return .secondary

+        }

+    }

+

+    private func sessionDurationText(_ session: ChargeSessionSummary) -> String {

+        let formatter = DateComponentsFormatter()

+        let effectiveDuration = max(session.effectiveDuration, 0)

+        formatter.allowedUnits = effectiveDuration >= 3600 ? [.hour, .minute] : [.minute, .second]

+        formatter.unitsStyle = .abbreviated

+        formatter.zeroFormattingBehavior = .dropAll

+        return formatter.string(from: effectiveDuration) ?? "0m"

+    }

+