//

//  ChargedDeviceDetailView.swift

//  USB Meter

//

//  Created by Codex on 10/04/2026.

//

import SwiftUI

struct ChargedDeviceDetailView: View {

    @EnvironmentObject private var appData: AppData

    @Environment(\.dismiss) private var dismiss

    @State private var editorVisibility = false

    @State private var targetNotificationEditorVisibility = false

    let chargedDeviceID: UUID

    var body: some View {

        Group {

            if let chargedDevice = appData.chargedDeviceSummary(id: chargedDeviceID) {

                ScrollView {

                    VStack(spacing: 18) {

                        headerCard(chargedDevice)

                        insightsCard(chargedDevice)

                            standbyPowerCard(chargedDevice)

                        }

                            activeSessionCard(activeSession, chargedDevice: chargedDevice)

                        }

                        if let curveSession = preferredStoredCurveSession(for: chargedDevice) {

                            storedCurveCard(curveSession)

                        }

                        if !chargedDevice.capacityHistory.isEmpty {

                            capacityEvolutionCard(chargedDevice)

                        }

                        if !chargedDevice.typicalCurve.isEmpty {

                            typicalCurveCard(chargedDevice)

                        }

                            sessionHistorySummaryCard(chargedDevice)

                    }

                    .padding()

                }

                .background(

                    LinearGradient(

                        colors: [tint(for: chargedDevice).opacity(0.18), Color.clear],

                        startPoint: .topLeading,

                        endPoint: .bottomTrailing

                    )

                    .ignoresSafeArea()

                )

                .navigationTitle(chargedDevice.name)

                .toolbar {

                    ToolbarItemGroup(placement: .primaryAction) {

                        Button("Edit") {

                            editorVisibility = true

                        }

                        Button(role: .destructive) {

                            deleteConfirmationVisibility = true

                        } label: {

                            Image(systemName: "trash")

                        }

                    }

                }

            } else {

                Text("This device is no longer available.")

                    .foregroundColor(.secondary)

                    .navigationTitle("Device")

            }

        }

        .sheet(isPresented: $editorVisibility) {

            if let chargedDevice = appData.chargedDeviceSummary(id: chargedDeviceID) {

                    ChargerEditorSheetView(

                        appData: appData,

                        chargedDevice: chargedDevice

                    )

                } else {

                    ChargedDeviceEditorSheetView(

                        meterMACAddress: nil,

                        chargedDevice: chargedDevice

                    )

                    .environmentObject(appData)

                }

        }

        .sheet(isPresented: $targetNotificationEditorVisibility) {

            if let activeSession = appData.chargedDeviceSummary(id: chargedDeviceID)?.activeSession {

                ChargedDeviceTargetNotificationEditorSheetView(

                    sessionID: activeSession.id,

                    initialTargetPercent: activeSession.targetBatteryPercent

                )

                .environmentObject(appData)

            }

        }

            ChargeSessionCompletionSheetView(

                sessionID: request.sessionID,

                title: request.title,

                confirmTitle: request.confirmTitle,

                explanation: request.explanation

            )

            .environmentObject(appData)

        }

            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()

            )

        }

            Button("Delete", role: .destructive) {

                if appData.deleteChargedDevice(id: chargedDeviceID) {

                    dismiss()

                }

            }

            Button("Cancel", role: .cancel) {}

        } message: {

            Text(deletionMessage)

        }

    }

    private func headerCard(_ chargedDevice: ChargedDeviceSummary) -> some View {

        HStack(alignment: .top, spacing: 18) {

            ChargedDeviceQRCodeView(qrIdentifier: chargedDevice.qrIdentifier, side: 118)

            VStack(alignment: .leading, spacing: 10) {

                    chargedDevice: chargedDevice,

                    iconPointSize: 22

                )

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

                    .foregroundColor(.secondary)

                if let meterMAC = chargedDevice.lastAssociatedMeterMAC {

                    Text("Default meter: \(meterMAC)")

                        .font(.caption)

                        .foregroundColor(.secondary)

                }

                Text(chargedDevice.qrIdentifier)

                    .font(.caption2.monospaced())

                    .foregroundColor(.secondary)

                    .textSelection(.enabled)

            }

            Spacer(minLength: 0)

        }

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

        .padding(18)

        .meterCard(tint: tint(for: chargedDevice), fillOpacity: 0.20, strokeOpacity: 0.26, cornerRadius: 20)

    }

    private func insightsCard(_ chargedDevice: ChargedDeviceSummary) -> some View {

        MeterInfoCardView(title: "Insights", tint: tint(for: chargedDevice)) {

                chargerInsights(chargedDevice)

            } else {

                deviceInsights(chargedDevice)

            }

            if let notes = chargedDevice.notes, !notes.isEmpty {

                Divider()

                Text(notes)

                    .font(.footnote)

                    .foregroundColor(.secondary)

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

            }

        }

    }

    @ViewBuilder

    private func deviceInsights(_ chargedDevice: ChargedDeviceSummary) -> some View {

            MeterInfoRowView(

                label: "Charge Modes",

                value: chargedDevice.chargingStateAvailability.title

            )

        }

        if chargedDevice.hasMultipleChargingTransports {

            MeterInfoRowView(

                label: "Charging Support",

                value: chargedDevice.supportedChargingModes.map(\.title).joined(separator: " + ")

            )

        }

        if chargedDevice.showsWirelessProfileDetails {

                value: chargedDevice.wirelessChargingProfile.title

        ForEach(completionSessionKinds(for: chargedDevice), id: \.rawValue) { sessionKind in

        MeterInfoRowView(

            label: "Estimated Capacity",

            value: chargedDevice.estimatedBatteryCapacityWh.map { "\($0.format(decimalDigits: 2)) Wh" } ?? "Not enough data"

        )

        if let wiredCapacity = chargedDevice.wiredEstimatedBatteryCapacityWh {

                MeterInfoRowView(

                    label: "Wired Capacity",

                    value: "\(wiredCapacity.format(decimalDigits: 2)) Wh"

                )

            }

        if let wirelessCapacity = chargedDevice.wirelessEstimatedBatteryCapacityWh {

                MeterInfoRowView(

                    label: "Wireless Capacity",

                    value: "\(wirelessCapacity.format(decimalDigits: 2)) Wh"

                )

            }

           chargedDevice.showsWirelessProfileDetails {

                label: "Wireless Efficiency",

                value: "\(Int((wirelessEfficiencyFactor * 100).rounded()))%"

            )

        }

        MeterInfoRowView(

            label: "Charge Sessions",

            value: "\(chargedDevice.sessionCount)"

        )

    }

    private func chargerInsights(_ chargedDevice: ChargedDeviceSummary) -> some View {

            MeterInfoRowView(

                label: "Type",

                value: chargerType.title

            )

        }

                value: chargedDevice.chargerObservedVoltageSelections

                    .map { "\($0.format(decimalDigits: 1)) V" }

                    .joined(separator: ", ")

        if let chargerIdleCurrentAmps = chargedDevice.chargerIdleCurrentAmps {

                value: "\(chargerIdleCurrentAmps.format(decimalDigits: 2)) A"

        if let chargerEfficiencyFactor = chargedDevice.chargerEfficiencyFactor {

                value: "\(Int((chargerEfficiencyFactor * 100).rounded()))%"

        if let chargerMaximumPowerWatts = chargedDevice.chargerMaximumPowerWatts {

            MeterInfoRowView(

                label: "Max Power",

                value: "\(chargerMaximumPowerWatts.format(decimalDigits: 2)) W"

            )

        }

            MeterInfoRowView(

                label: "Standby Power",

                value: "\(latestStandbyPowerMeasurement.averagePowerWatts.format(decimalDigits: 3)) W"

            )

            MeterInfoRowView(

                label: "Standby Projection",

                value: standbyEnergyLabel(latestStandbyPowerMeasurement.projectedYearlyEnergyWh) + " / year"

            )

        }

            label: "Wireless Sessions",

            value: "\(chargedDevice.sessionCount)"

        )

            Text("Idle current is missing. Wireless sessions that use this charger can still be recorded, but they cannot learn or auto-apply the wireless stop threshold yet.")

                .font(.caption2)

                .foregroundColor(.orange)

    }

        let latestMeasurement = chargedDevice.latestStandbyPowerMeasurement

        return MeterInfoCardView(

            title: "Standby Power",

            tint: .orange

        ) {

            if standbyMeasurementMeters.isEmpty {

                Text("Connect a meter first. Standby measurement is launched from a live meter feed, so only currently available meters can be selected here.")

                    .font(.footnote)

                    .foregroundColor(.secondary)

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

            } else {

                NavigationLink(

                    destination: ChargerStandbyPowerWizardView(

                        preferredChargerID: chargedDevice.id,

                        locksChargerSelection: true

                    )

                ) {

                    Label("New Measurement", systemImage: "plus.circle.fill")

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

                        .foregroundColor(.orange)

                }

                .buttonStyle(.plain)

            }

            if let latestMeasurement {

                Divider()

                NavigationLink(

                    destination: ChargerStandbyPowerMeasurementDetailView(

                        chargerID: chargedDevice.id,

                        measurementID: latestMeasurement.id

                    )

                ) {

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

                        HStack {

                            Text("Latest Measurement")

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

                                .foregroundColor(.primary)

                            Spacer()

                            Text("\(latestMeasurement.averagePowerWatts.format(decimalDigits: 3)) W")

                                .font(.subheadline.weight(.bold))

                                .foregroundColor(.primary)

                                .monospacedDigit()

                        }

                        Text(

                            "\(latestMeasurement.endedAt.format()) • \(latestMeasurement.sampleCount) samples • \(standbyEnergyLabel(latestMeasurement.projectedYearlyEnergyWh)) / year"

                        )

                        .font(.caption)

                        .foregroundColor(.secondary)

                    }

                }

                .buttonStyle(.plain)

            }

            if chargedDevice.standbyPowerMeasurements.isEmpty == false {

                Divider()

                NavigationLink(

                    destination: ChargerStandbyPowerMeasurementsView(chargerID: chargedDevice.id)

                ) {

                    Label("View Saved Measurements", systemImage: "clock.arrow.trianglehead.counterclockwise.rotate.90")

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

                        .foregroundColor(.blue)

                }

                .buttonStyle(.plain)

            }

        }

    }

        _ activeSession: ChargeSessionSummary,

        chargedDevice: ChargedDeviceSummary

    ) -> some View {

            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")

            }

            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))%"

                )

            }

                Text(sessionWarning)

                    .font(.caption2)

                    .foregroundColor(.orange)

            }

                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)

            }

                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

                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)

            }

                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 = DeviceSessionStopRequest(

                    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)

            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 capacityEvolutionCard(_ chargedDevice: ChargedDeviceSummary) -> some View {

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

            Text("Capacity Evolution")

                .font(.headline)

            ForEach(chargedDevice.capacityHistory.suffix(6)) { point in

                HStack {

                    Text(point.timestamp.format())

                        .font(.caption)

                        .foregroundColor(.secondary)

                    Spacer()

                        Text(point.chargingTransportMode.title)

                            .font(.caption2)

                            .foregroundColor(.secondary)

                        Text("•")

                            .foregroundColor(.secondary)

                    }

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

                }

            }

        }

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

        .padding(18)

        .meterCard(tint: .orange, fillOpacity: 0.14, strokeOpacity: 0.20, cornerRadius: 18)

    }

    private func preferredStoredCurveSession(for chargedDevice: ChargedDeviceSummary) -> ChargeSessionSummary? {

        if let activeSession = chargedDevice.activeSession, !activeSession.aggregatedSamples.isEmpty {

            return activeSession

        }

        return chargedDevice.sessions.first(where: { !$0.aggregatedSamples.isEmpty })

    }

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

        ) { $0.averageCurrentAmps }

        let energySeries = storedSeriesSnapshot(

        ) { $0.measuredEnergyWh }

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

            HStack(alignment: .firstTextBaseline) {

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

                        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."

                        )

                    }

                         ? "Showing the saved trim window at aggregated resolution."

                         : (session.status.isOpen

                            ? "Open session, persisted as aggregated samples."

                            : "Most recent persisted session at aggregated resolution."))

                        .foregroundColor(.secondary)

                }

                Spacer()

                    .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 typicalCurveCard(_ chargedDevice: ChargedDeviceSummary) -> some View {

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

            Text("Typical Charge Curve")

                .font(.headline)

            ForEach(chargedDevice.typicalCurve) { point in

                HStack {

                    Text("\(point.percentBin)%")

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

                    Spacer()

                    Text("\(point.averageEnergyWh.format(decimalDigits: 2)) Wh")

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

                    Text("•")

                        .foregroundColor(.secondary)

                    Text("\(point.sampleCount) sample\(point.sampleCount == 1 ? "" : "s")")

                        .font(.caption2)

                        .foregroundColor(.secondary)

                }

            }

        }

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

        .padding(18)

        .meterCard(tint: .blue, fillOpacity: 0.14, strokeOpacity: 0.20, cornerRadius: 18)

    }

        let sessions = closedSessions(for: chargedDevice)

        let latestSession = sessions.first

        let totalEnergyWh = sessions.reduce(0) { $0 + $1.effectiveOrMeasuredEnergyWh }

            MeterInfoRowView(label: "Closed Sessions", value: "\(sessions.count)")

            MeterInfoRowView(label: "Total Energy", value: "\(totalEnergyWh.format(decimalDigits: 2)) Wh")

            if let latestSession {

                MeterInfoRowView(label: "Latest", value: latestSession.startedAt.format())

            }

                destination: ChargedDeviceSessionsView(chargedDeviceID: chargedDevice.id)

            ) {

                Label("Manage Sessions", systemImage: "clock.arrow.trianglehead.counterclockwise.rotate.90")

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

                    .frame(maxWidth: .infinity)

                    .padding(.vertical, 10)

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

    }

        chargedDevice.sessions.filter { !$0.status.isOpen }

    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 tint(for chargedDevice: ChargedDeviceSummary) -> Color {

        switch chargedDevice.deviceClass {

        case .iphone:

            return .blue

        case .watch:

            return .green

        case .powerbank:

            return .orange

        case .charger:

            return .pink

        case .other:

            return .secondary

        }

    }

        if wattHours >= 1000 {

            return "\((wattHours / 1000).format(decimalDigits: 3)) kWh"

        }

        return "\(wattHours.format(decimalDigits: 2)) Wh"

    }

    private var standbyMeasurementMeters: [AppData.MeterSummary] {

        appData.meterSummaries.filter { $0.meter != nil }

    }

        for chargedDevice: ChargedDeviceSummary,

            if let learnedCurrent = chargedDevice.learnedCompletionCurrentAmps(for: sessionKind),

                return "\(configuredCurrent.format(decimalDigits: 2)) A configured • \(learnedCurrent.format(decimalDigits: 2)) A learned"

            }

            return "\(configuredCurrent.format(decimalDigits: 2)) A configured"

        }

        }

        return "Learning"

    }

        for chargedDevice: ChargedDeviceSummary,

        sessionKind: ChargeSessionKind

    ) -> String {

        let showsTransport = chargedDevice.shouldShowChargingTransport(sessionKind.chargingTransportMode)

        let showsState = chargedDevice.shouldShowChargingStateMode(sessionKind.chargingStateMode)

        switch (showsTransport, showsState) {

        case (true, true):

            return "\(sessionKind.shortTitle) Stop Current"

        case (true, false):

            return "\(sessionKind.chargingTransportMode.title) Stop Current"

        case (false, true):

            return "\(sessionKind.chargingStateMode.title) Stop Current"

        case (false, false):

            return "Stop Current"

        }

    }

        chargedDevice.supportedChargingModes.flatMap { chargingTransportMode in

            chargedDevice.supportedChargingStateModes.map { chargingStateMode in

                ChargeSessionKind(

                    chargingTransportMode: chargingTransportMode,

                    chargingStateMode: chargingStateMode

                )

            }

        }

    }

    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."

    }

        appData.chargedDeviceSummary(id: chargedDeviceID)?.isCharger == true ? "charger" : "device"

    }

    private var deletionMessage: String {

        if appData.chargedDeviceSummary(id: chargedDeviceID)?.isCharger == true {

            return "This removes the charger from the library and unlinks it from wireless sessions that used it."

        }

        return "This removes the device and its stored charging history from the library."

    }

    private func storedSeriesSnapshot(

        from samples: [ChargeSessionSampleSummary],

        minimumYSpan: Double,

        value: (ChargeSessionSampleSummary) -> Double

    ) -> StoredSeriesSnapshot? {

        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 StoredSeriesSnapshot(

            points: points,

            context: context,

            minimumValue: minimumValue,

            maximumValue: maximumValue

        )

    }

    private func storedSeriesChart(

        title: String,

        unit: String,

        strokeColor: Color,

        areaChart: Bool = false,

        snapshot: StoredSeriesSnapshot

    ) -> 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)

            }

                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 struct StoredSeriesSnapshot {

    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 ChargedDeviceTargetNotificationEditorSheetView: 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 {

                    header: ContextInfoHeader(

                        title: "Target Level",

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

                    )

                ) {

                        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 DeviceSessionStopRequest: Identifiable {

    let sessionID: UUID

    let title: String

    let confirmTitle: String

    let explanation: String

    var id: UUID {

        sessionID

    }

}