//
//  ChargeSessionDetailView.swift
//  USB Meter
//
//  Created by Codex on 22/04/2026.
//

import SwiftUI

enum ChargeSessionDetailPresentation {
    case navigation
    case embedded
}

struct ChargeSessionDetailView: View {
    private enum FinalCheckpoint: Hashable {
        case full
        case skip
        case custom

        var label: String {
            switch self {
            case .full:   return "Full"
            case .skip:   return "Skip"
            case .custom: return "Other %"
            }
        }

        var icon: String {
            switch self {
            case .full:   return "battery.100percent"
            case .skip:   return "minus.circle"
            case .custom: return "pencil"
            }
        }
    }

    @EnvironmentObject private var appData: AppData

    let chargedDeviceID: UUID
    let sessionID: UUID
    let monitoringMeter: Meter?
    let presentation: ChargeSessionDetailPresentation

    @State private var pendingCheckpointDeletion: ChargeCheckpointSummary?
    @State private var pendingSessionDeletion: ChargeSessionSummary?
    @State private var pendingSessionStopRequest: ChargeSessionStopRequest?
    @State private var detectedTrimWindow: ChargingWindowDetector.DetectedWindow?
    @State private var trimBannerDismissedForSessionID: UUID?
    @State private var showingInlineTargetEditor = false
    @State private var draftTargetText = ""
    @State private var showingStopConfirm = false
    @State private var finalCheckpointMode: FinalCheckpoint = .skip
    @State private var finalCheckpointText = ""
    @State private var stopFailureMessage: String?

    init(
        chargedDeviceID: UUID,
        sessionID: UUID,
        monitoringMeter: Meter? = nil,
        presentation: ChargeSessionDetailPresentation = .navigation
    ) {
        self.chargedDeviceID = chargedDeviceID
        self.sessionID = sessionID
        self.monitoringMeter = monitoringMeter
        self.presentation = presentation
    }

    private var chargedDevice: ChargedDeviceSummary? {
        appData.chargedDeviceSummary(id: chargedDeviceID)
    }

    private var session: ChargeSessionSummary? {
        chargedDevice?.sessions.first(where: { $0.id == sessionID })
    }

    private var liveMonitoringMeter: Meter? {
        guard let session,
              session.status.isOpen,
              let meterMACAddress = session.meterMACAddress else {
            return nil
        }

        if let monitoringMeter,
           monitoringMeter.btSerial.macAddress.description == meterMACAddress {
            return monitoringMeter
        }

        return appData.meters.values.first {
            $0.btSerial.macAddress.description == meterMACAddress
        }
    }

    private var hasMonitoringControls: Bool {
        session?.status.isOpen == true && liveMonitoringMeter != nil
    }

    private var shouldShowTrimBanner: Bool {
        guard hasMonitoringControls,
              let session,
              session.isTrimmed == false,
              trimBannerDismissedForSessionID != session.id,
              let detectedTrimWindow else {
            return false
        }
        return detectedTrimWindow.trimRatio > ChargingWindowDetector.significantTrimThreshold
    }

    var body: some View {
        Group {
            if let chargedDevice, let session {
                content(chargedDevice: chargedDevice, session: session)
            } else {
                unavailableState
            }
        }
        .sheet(item: $pendingSessionStopRequest) { request in
            ChargeSessionCompletionSheetView(
                sessionID: request.sessionID,
                title: request.title,
                confirmTitle: request.confirmTitle,
                explanation: request.explanation,
                monitoringMeter: liveMonitoringMeter,
                appliesTrim: request.appliesTrim,
                trimStart: request.trimStart,
                trimEnd: request.trimEnd
            )
            .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()
            )
        }
        .alert(item: $pendingSessionDeletion) { session in
            Alert(
                title: Text("Delete Session?"),
                message: Text("Deleting this charging session also recalculates capacity and every derived metric that used it."),
                primaryButton: .destructive(Text("Delete")) {
                    _ = appData.deleteChargeSession(sessionID: session.id)
                },
                secondaryButton: .cancel()
            )
        }
        .onAppear {
            syncMonitoringRestore()
            runTrimDetection()
        }
        .onChange(of: session?.id) { _ in
            pendingSessionStopRequest = nil
            detectedTrimWindow = nil
            trimBannerDismissedForSessionID = nil
            showingInlineTargetEditor = false
            draftTargetText = ""
            showingStopConfirm = false
            finalCheckpointMode = .skip
            finalCheckpointText = ""
            stopFailureMessage = nil
            syncMonitoringRestore()
            runTrimDetection()
        }
        .onChange(of: session?.aggregatedSamples.count) { _ in
            syncMonitoringRestore()
            runTrimDetection()
        }
        .onChange(of: finalCheckpointMode) { _ in
            stopFailureMessage = nil
        }
        .onChange(of: finalCheckpointText) { _ in
            stopFailureMessage = nil
        }
    }

    private func content(
        chargedDevice: ChargedDeviceSummary,
        session: ChargeSessionSummary
    ) -> some View {
        ScrollView {
            VStack(spacing: 16) {
                if hasMonitoringControls {
                    monitoringSessionCard(session, chargedDevice: chargedDevice)

                    if shouldShowTrimBanner {
                        trimDetectionBanner(session)
                    }

                    if shouldShowSessionChart(session) {
                        chartCard(session)
                    }
                } else {
                    overviewCard(session, chargedDevice: chargedDevice)
                    energyCard(session, chargedDevice: chargedDevice)
                    observedMetricsCard(session, chargedDevice: chargedDevice)
                    batteryCard(session, chargedDevice: chargedDevice)

                    if shouldShowSessionChart(session) {
                        chartCard(session)
                    }

                    if session.status.isOpen {
                        followerNoticeCard(session)
                    } else {
                        managementCard(session)
                    }
                }
            }
            .padding(presentation == .embedded ? 16 : 20)
        }
        .background(
            LinearGradient(
                colors: [statusTint(for: session).opacity(0.14), Color.clear],
                startPoint: .topLeading,
                endPoint: .bottomTrailing
            )
            .ignoresSafeArea()
        )
        .navigationTitle(session.status.isOpen ? "Current Session" : "Session Details")
    }

    private var unavailableState: some View {
        VStack(spacing: 12) {
            Image(systemName: "bolt.slash")
                .font(.title2)
                .foregroundColor(.secondary)
            Text("This session is no longer available.")
                .font(.headline)
            Text("It may have been deleted or synced from another device.")
                .font(.footnote)
                .foregroundColor(.secondary)
                .multilineTextAlignment(.center)
        }
        .frame(maxWidth: .infinity, maxHeight: .infinity)
        .padding(24)
        .navigationTitle("Session")
    }

    private func monitoringSessionCard(
        _ session: ChargeSessionSummary,
        chargedDevice: ChargedDeviceSummary
    ) -> some View {
        let displayedEnergyWh = displayedSessionEnergyWh(for: session)
        let displayedChargeAh = displayedSessionChargeAh(for: session)
        let batteryPrediction = chargedDevice.batteryLevelPrediction(
            for: session,
            effectiveEnergyWhOverride: displayedEnergyWh
        )

        return VStack(alignment: .leading, spacing: 14) {
            HStack {
                ChargedDeviceIdentityLabelView(chargedDevice: chargedDevice, iconPointSize: 16)
                    .font(.headline)

                Spacer()

                Text(session.status.title)
                    .font(.caption.weight(.bold))
                    .foregroundColor(monitoringStatusColor(for: session))
                    .padding(.horizontal, 8)
                    .padding(.vertical, 4)
                    .meterCard(tint: monitoringStatusColor(for: session), fillOpacity: 0.18, strokeOpacity: 0.24, cornerRadius: 999)
            }

            if let batteryPrediction {
                batteryGaugeSection(
                    prediction: batteryPrediction,
                    session: session,
                    displayedEnergyWh: displayedEnergyWh
                )
            }

            sessionMetricsGrid(
                session: session,
                chargedDevice: chargedDevice,
                displayedEnergyWh: displayedEnergyWh,
                hasPrediction: batteryPrediction != nil
            )

            if session.stopThresholdAmps > 0 {
                Text("Stop threshold: \(session.stopThresholdAmps.format(decimalDigits: 2)) A")
                    .font(.caption)
                    .foregroundColor(.secondary)
            }

            if let sessionWarning = sessionWarning(for: session) {
                Label(sessionWarning, systemImage: "exclamationmark.triangle")
                    .font(.caption)
                    .foregroundColor(.orange)
            }

            if session.isPaused {
                Label(
                    "Paused \(session.pausedAt?.format() ?? session.lastObservedAt.format()). Auto-stops after 10 min.",
                    systemImage: "pause.circle"
                )
                .font(.caption)
                .foregroundColor(.secondary)
            }

            if session.requiresCompletionConfirmation && !showingStopConfirm {
                completionConfirmationCard(session)
            }

            BatteryCheckpointSectionView(
                sessionID: session.id,
                checkpoints: session.checkpoints,
                message: "Checkpoints are used for capacity estimation and the typical charge curve.",
                canAddCheckpoint: appData.canAddBatteryCheckpoint(to: session.id),
                canDeleteCheckpoint: true,
                requirementMessage: appData.batteryCheckpointCaptureRequirementMessage(for: session.id),
                effectiveEnergyWhOverride: displayedEnergyWh,
                measuredChargeAhOverride: displayedChargeAh,
                onDelete: { checkpoint in
                    pendingCheckpointDeletion = checkpoint
                }
            )

            targetSectionView(
                session: session,
                predictedPercent: batteryPrediction?.predictedPercent
            )

            if showingStopConfirm {
                stopConfirmPanel(
                    session: session,
                    displayedEnergyWh: displayedEnergyWh,
                    displayedChargeAh: displayedChargeAh
                )
            } else {
                monitoringActionRow(session)
            }
        }
        .padding(18)
        .meterCard(tint: .green, fillOpacity: 0.14, strokeOpacity: 0.20)
    }

    private func overviewCard(
        _ session: ChargeSessionSummary,
        chargedDevice: ChargedDeviceSummary
    ) -> some View {
        MeterInfoCardView(title: session.status.isOpen ? "Open Session" : "Overview", tint: statusTint(for: session)) {
            MeterInfoRowView(label: "Device", value: chargedDevice.name)
            MeterInfoRowView(label: "Status", value: session.status.title)
            MeterInfoRowView(label: "Started", value: session.startedAt.format())
            if let endedAt = session.endedAt {
                MeterInfoRowView(label: "Ended", value: endedAt.format())
            }
            MeterInfoRowView(label: "Duration", value: sessionDurationText(session))
            MeterInfoRowView(label: "Charging Type", value: session.chargingTransportMode.title)
            MeterInfoRowView(label: "Charging Mode", value: session.chargingStateMode.title)
            MeterInfoRowView(label: "Source", value: session.sourceMode.title)
            MeterInfoRowView(label: "Auto Stop", value: autoStopDescription(for: session))
            if session.isTrimmed {
                MeterInfoRowView(label: "Trim Start", value: session.effectiveTrimStart.format())
                MeterInfoRowView(label: "Trim End", value: session.effectiveTrimEnd.format())
            }
            if let meterName = session.meterName {
                MeterInfoRowView(label: "Meter", value: meterName)
            } else if let meterMACAddress = session.meterMACAddress {
                MeterInfoRowView(label: "Meter", value: meterMACAddress)
            }
            if let meterModel = session.meterModel {
                MeterInfoRowView(label: "Meter Model", value: meterModel)
            }
        }
    }

    private func energyCard(
        _ session: ChargeSessionSummary,
        chargedDevice: ChargedDeviceSummary
    ) -> some View {
        let displayedEnergyWh = displayedSessionEnergyWh(for: session)
        let displayedChargeAh = displayedSessionChargeAh(for: session)

        return MeterInfoCardView(title: "Energy", tint: .teal) {
            MeterInfoRowView(label: "Battery Energy", value: "\(displayedEnergyWh.format(decimalDigits: 3)) Wh")
            if abs(displayedEnergyWh - session.measuredEnergyWh) > 0.01 {
                MeterInfoRowView(label: "Measured Energy", value: "\(session.measuredEnergyWh.format(decimalDigits: 3)) Wh")
            }
            MeterInfoRowView(label: "Measured Charge", value: "\(displayedChargeAh.format(decimalDigits: 3)) Ah")
            if let effectiveBatteryEnergyWh = session.effectiveBatteryEnergyWh,
               abs(effectiveBatteryEnergyWh - session.measuredEnergyWh) > 0.01 {
                MeterInfoRowView(label: "Effective Battery Energy", value: "\(effectiveBatteryEnergyWh.format(decimalDigits: 3)) Wh")
            }
            if let capacityEstimateWh = session.capacityEstimateWh {
                MeterInfoRowView(label: "Capacity Estimate", value: "\(capacityEstimateWh.format(decimalDigits: 2)) Wh")
            }
            if let chargerID = session.chargerID,
               let charger = appData.chargedDeviceSummary(id: chargerID) {
                MeterInfoRowView(label: chargedDevice.hasMultipleChargingTransports ? "Wireless Charger" : "Charger", value: charger.name)
            }
            if let wirelessSessionHint = wirelessSessionHint(for: session) {
                Text(wirelessSessionHint)
                    .font(.caption2)
                    .foregroundColor(session.shouldWarnAboutLowWirelessEfficiency ? .orange : .secondary)
            }
            if let sessionWarning = sessionWarning(for: session) {
                Label(sessionWarning, systemImage: "exclamationmark.triangle")
                    .font(.caption2)
                    .foregroundColor(.orange)
            }
        }
    }

    private func observedMetricsCard(
        _ session: ChargeSessionSummary,
        chargedDevice: ChargedDeviceSummary
    ) -> some View {
        MeterInfoCardView(title: "Observed Metrics", tint: .blue) {
            if let minimumObservedCurrentAmps = session.minimumObservedCurrentAmps {
                MeterInfoRowView(label: "Min Current", value: "\(minimumObservedCurrentAmps.format(decimalDigits: 2)) A")
            }
            if let maximumObservedCurrentAmps = session.maximumObservedCurrentAmps {
                MeterInfoRowView(label: "Max Current", value: "\(maximumObservedCurrentAmps.format(decimalDigits: 2)) A")
            }
            if let maximumObservedPowerWatts = session.maximumObservedPowerWatts {
                MeterInfoRowView(label: "Max Power", value: "\(maximumObservedPowerWatts.format(decimalDigits: 2)) W")
            }
            if let maximumObservedVoltageVolts = session.maximumObservedVoltageVolts {
                MeterInfoRowView(label: "Max Voltage", value: "\(maximumObservedVoltageVolts.format(decimalDigits: 2)) V")
            }
            if chargedDevice.isCharger, let selectedSourceVoltageVolts = session.selectedSourceVoltageVolts {
                MeterInfoRowView(label: "Selected Voltage", value: "\(selectedSourceVoltageVolts.format(decimalDigits: 2)) V")
            }
            if let completionCurrentAmps = session.completionCurrentAmps {
                MeterInfoRowView(label: "Completion Current", value: "\(completionCurrentAmps.format(decimalDigits: 2)) A")
            }
            if session.selectedDataGroup != nil {
                MeterInfoRowView(label: "Data Group", value: "\(session.selectedDataGroup ?? 0)")
            }
        }
    }

    private func batteryCard(
        _ session: ChargeSessionSummary,
        chargedDevice: ChargedDeviceSummary
    ) -> some View {
        let displayedEnergyWh = displayedSessionEnergyWh(for: session)
        let displayedChargeAh = displayedSessionChargeAh(for: session)
        let batteryPrediction = chargedDevice.batteryLevelPrediction(
            for: session,
            effectiveEnergyWhOverride: hasMonitoringControls ? displayedEnergyWh : nil
        )

        return MeterInfoCardView(title: "Battery", tint: .orange) {
            if let startBatteryPercent = session.startBatteryPercent {
                MeterInfoRowView(label: "Start Battery", value: "\(startBatteryPercent.format(decimalDigits: 0))%")
            }
            if let endBatteryPercent = session.endBatteryPercent {
                MeterInfoRowView(label: "End Battery", value: "\(endBatteryPercent.format(decimalDigits: 0))%")
            }
            if let batteryDeltaPercent = session.batteryDeltaPercent {
                MeterInfoRowView(label: "Battery Delta", value: "\(batteryDeltaPercent.format(decimalDigits: 0))%")
            }
            if let targetBatteryPercent = session.targetBatteryPercent {
                MeterInfoRowView(label: "Target Notification", value: "\(targetBatteryPercent.format(decimalDigits: 0))%")
            }
            if let batteryPrediction {
                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: session.id,
                checkpoints: session.checkpoints,
                message: session.status.isOpen
                    ? "The checkpoint is stored on the active charge session and is used for capacity estimation and charge-level prediction."
                    : "These checkpoints were saved with this closed session and feed capacity estimation and charge-level prediction.",
                canAddCheckpoint: hasMonitoringControls && appData.canAddBatteryCheckpoint(to: session.id),
                canDeleteCheckpoint: hasMonitoringControls || session.status.isOpen == false,
                requirementMessage: session.status.isOpen ? appData.batteryCheckpointCaptureRequirementMessage(for: session.id) : nil,
                effectiveEnergyWhOverride: hasMonitoringControls ? displayedEnergyWh : nil,
                measuredChargeAhOverride: hasMonitoringControls ? displayedChargeAh : nil,
                onDelete: { checkpoint in
                    pendingCheckpointDeletion = checkpoint
                }
            )
        }
    }

    private func batteryGaugeSection(
        prediction: BatteryLevelPrediction,
        session: ChargeSessionSummary,
        displayedEnergyWh: Double
    ) -> some View {
        let percent = prediction.predictedPercent
        let color = batteryColor(for: percent)
        let duration = displayedSessionDuration(for: session)
        let rateWhPerSec: Double? = duration > 300 && displayedEnergyWh > 0.01
            ? displayedEnergyWh / duration
            : nil
        let etaToFull = etaText(
            rateWhPerSec: rateWhPerSec,
            remainingWh: max(prediction.estimatedCapacityWh - displayedEnergyWh, 0),
            isRelevant: percent < 98
        )
        let etaToTarget = etaToTargetText(
            session: session,
            prediction: prediction,
            displayedEnergyWh: displayedEnergyWh,
            rateWhPerSec: rateWhPerSec
        )

        return VStack(spacing: 10) {
            HStack(alignment: .lastTextBaseline, spacing: 8) {
                HStack(alignment: .lastTextBaseline, spacing: 3) {
                    Text("\(Int(percent.rounded()))")
                        .font(.system(size: 52, weight: .bold, design: .rounded))
                        .foregroundColor(color)
                        .monospacedDigit()
                    Text("%")
                        .font(.title2.weight(.semibold))
                        .foregroundColor(color.opacity(0.8))
                }

                Spacer()

                VStack(alignment: .trailing, spacing: 2) {
                    Text("\(prediction.estimatedCapacityWh.format(decimalDigits: 2)) Wh")
                        .font(.callout.weight(.bold))
                        .foregroundColor(.orange)
                        .monospacedDigit()
                    Text("est. capacity")
                        .font(.caption2)
                        .foregroundColor(.secondary)
                }
            }

            batteryProgressBar(
                percent: percent,
                startPercent: session.startBatteryPercent,
                targetPercent: session.targetBatteryPercent
            )

            HStack(spacing: 14) {
                if let etaToFull {
                    etaPill(icon: "clock.fill", tint: .green, value: etaToFull, label: "to full")
                }

                if let etaToTarget, let target = session.targetBatteryPercent {
                    etaPill(
                        icon: "bell.badge.fill",
                        tint: .indigo,
                        value: etaToTarget,
                        label: "to \(Int(target.rounded()))%"
                    )
                }

                Spacer()

                Text("anchored to \(prediction.anchorDescription) at \(prediction.anchorPercent.format(decimalDigits: 0))%")
                    .font(.caption2)
                    .foregroundColor(.secondary)
                    .multilineTextAlignment(.trailing)
            }
        }
        .padding(14)
        .meterCard(tint: color, fillOpacity: 0.10, strokeOpacity: 0.16, cornerRadius: 16)
    }

    private func etaPill(icon: String, tint: Color, value: String, label: String) -> some View {
        VStack(alignment: .leading, spacing: 1) {
            HStack(spacing: 4) {
                Image(systemName: icon)
                    .font(.caption)
                    .foregroundColor(tint)
                Text(value)
                    .font(.caption.weight(.bold))
            }
            Text(label)
                .font(.caption2)
                .foregroundColor(.secondary)
        }
    }

    private func batteryProgressBar(
        percent: Double,
        startPercent: Double?,
        targetPercent: Double?
    ) -> some View {
        let color = batteryColor(for: percent)
        return GeometryReader { geo in
            let width = geo.size.width
            ZStack(alignment: .leading) {
                Capsule()
                    .fill(Color.primary.opacity(0.10))
                Rectangle()
                    .fill(
                        LinearGradient(
                            colors: [color.opacity(0.6), color],
                            startPoint: .leading,
                            endPoint: .trailing
                        )
                    )
                    .frame(width: max(width * CGFloat(percent / 100), 4))
                    .animation(.easeInOut(duration: 0.4), value: percent)
                if let start = startPercent, start > 2, start < 98 {
                    Rectangle()
                        .fill(Color.white.opacity(0.55))
                        .frame(width: 2, height: 20)
                        .offset(x: width * CGFloat(start / 100) - 1)
                }
                if let target = targetPercent {
                    Rectangle()
                        .fill(Color.indigo.opacity(0.9))
                        .frame(width: 2.5, height: 20)
                        .offset(x: width * CGFloat(target / 100) - 1.25)
                }
            }
            .clipShape(Capsule())
        }
        .frame(height: 20)
    }

    private func sessionMetricsGrid(
        session: ChargeSessionSummary,
        chargedDevice: ChargedDeviceSummary,
        displayedEnergyWh: Double,
        hasPrediction: Bool
    ) -> some View {
        let capacityFallback: Double? = hasPrediction ? nil : (
            session.capacityEstimateWh
                ?? chargedDevice.estimatedBatteryCapacityWh(for: session.chargingTransportMode)
                ?? chargedDevice.estimatedBatteryCapacityWh
        )
        let columns = [GridItem(.flexible()), GridItem(.flexible())]

        return LazyVGrid(columns: columns, spacing: 8) {
            metricCell(label: "Energy", value: "\(displayedEnergyWh.format(decimalDigits: 3)) Wh", tint: .blue)
            metricCell(label: "Duration", value: formatDuration(displayedSessionDuration(for: session)), tint: .teal)

            if shouldShowChargingTransport(for: session, chargedDevice: chargedDevice) {
                metricCell(label: "Type", value: session.chargingTransportMode.title, tint: .orange)
            }
            if shouldShowChargingState(for: session, chargedDevice: chargedDevice) {
                metricCell(label: "Mode", value: session.chargingStateMode.title, tint: .purple)
            }

            metricCell(label: "Auto Stop", value: autoStopLabel(for: session), tint: .secondary)

            if let capacityFallback {
                metricCell(label: "Est. Capacity", value: "\(capacityFallback.format(decimalDigits: 2)) Wh", tint: .orange)
            }
        }
    }

    private func metricCell(label: String, value: String, tint: Color) -> some View {
        VStack(alignment: .leading, spacing: 3) {
            Text(label)
                .font(.caption2)
                .foregroundColor(.secondary)
            Text(value)
                .font(.subheadline.weight(.semibold))
                .lineLimit(1)
                .minimumScaleFactor(0.7)
                .monospacedDigit()
        }
        .frame(maxWidth: .infinity, alignment: .leading)
        .padding(.horizontal, 12)
        .padding(.vertical, 10)
        .meterCard(tint: tint, fillOpacity: 0.08, strokeOpacity: 0.12, cornerRadius: 12)
    }

    private func completionConfirmationCard(_ session: ChargeSessionSummary) -> some View {
        VStack(alignment: .leading, spacing: 10) {
            Label("Charging may have stopped", systemImage: "questionmark.circle.fill")
                .font(.subheadline.weight(.semibold))

            if let contradictionPercent = session.completionContradictionPercent {
                Text("Current dropped but estimated level is only \(contradictionPercent.format(decimalDigits: 0))%.")
                    .font(.caption)
                    .foregroundColor(.secondary)
            } else {
                Text("Current dropped to the stop threshold but the prediction doesn't confirm a full charge yet.")
                    .font(.caption)
                    .foregroundColor(.secondary)
            }

            HStack(spacing: 10) {
                Button("Finish") {
                    beginStopConfirmation(for: session)
                }
                .frame(maxWidth: .infinity)
                .padding(.vertical, 9)
                .meterCard(tint: .orange, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 14)
                .buttonStyle(.plain)

                Button("Keep Monitoring") {
                    _ = appData.continueChargeSessionMonitoring(sessionID: session.id)
                }
                .frame(maxWidth: .infinity)
                .padding(.vertical, 9)
                .meterCard(tint: .blue, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 14)
                .buttonStyle(.plain)
            }
        }
        .padding(14)
        .meterCard(tint: .orange, fillOpacity: 0.10, strokeOpacity: 0.16, cornerRadius: 16)
    }

    private func targetSectionView(session: ChargeSessionSummary, predictedPercent: Double?) -> some View {
        let draftBelowPrediction: Bool = {
            guard let draft = parsedDraftTarget, let predictedPercent else { return false }
            return draft <= predictedPercent
        }()
        let savedBelowPrediction: Bool = {
            guard let saved = session.targetBatteryPercent, let predictedPercent else { return false }
            return saved <= predictedPercent
        }()

        return HStack(alignment: .center, spacing: 8) {
            Image(systemName: "bell.badge")
                .foregroundColor(.indigo)
                .font(.subheadline)

            Text("Notify at")
                .font(.subheadline.weight(.semibold))

            Spacer(minLength: 8)

            if showingInlineTargetEditor {
                targetEditorControls(
                    session: session,
                    draftBelowPrediction: draftBelowPrediction,
                    predictedPercent: predictedPercent
                )
            } else {
                savedTargetControls(
                    session: session,
                    savedBelowPrediction: savedBelowPrediction,
                    predictedPercent: predictedPercent
                )
            }
        }
    }

    private func targetEditorControls(
        session: ChargeSessionSummary,
        draftBelowPrediction: Bool,
        predictedPercent: Double?
    ) -> some View {
        Group {
            Button {
                let current = parsedDraftTarget ?? session.targetBatteryPercent ?? 80
                draftTargetText = max(current - 1, 1).format(decimalDigits: 0)
            } label: {
                Image(systemName: "minus.circle")
                    .font(.title3)
            }
            .buttonStyle(.plain)

            TextField("-", text: $draftTargetText)
                .keyboardType(.decimalPad)
                .textFieldStyle(.roundedBorder)
                .frame(width: 48)
                .multilineTextAlignment(.center)
                .foregroundColor(draftBelowPrediction ? .orange : .primary)

            Text("%")
                .font(.subheadline)
                .foregroundColor(.secondary)

            if draftBelowPrediction, let predictedPercent {
                predictionWarningButton(predictedPercent: predictedPercent)
            }

            Button {
                let current = parsedDraftTarget ?? session.targetBatteryPercent ?? 80
                draftTargetText = min(current + 1, 100).format(decimalDigits: 0)
            } label: {
                Image(systemName: "plus.circle")
                    .font(.title3)
            }
            .buttonStyle(.plain)

            Button {
                if let value = parsedDraftTarget {
                    _ = appData.setTargetBatteryPercent(value, for: session.id)
                }
                showingInlineTargetEditor = false
            } label: {
                Image(systemName: "checkmark.circle.fill")
                    .foregroundColor(parsedDraftTarget != nil ? .indigo : .secondary)
                    .font(.title3)
            }
            .buttonStyle(.plain)
            .disabled(parsedDraftTarget == nil)

            Button {
                showingInlineTargetEditor = false
                draftTargetText = ""
            } label: {
                Image(systemName: "xmark.circle")
                    .foregroundColor(.secondary)
                    .font(.title3)
            }
            .buttonStyle(.plain)
        }
    }

    private func savedTargetControls(
        session: ChargeSessionSummary,
        savedBelowPrediction: Bool,
        predictedPercent: Double?
    ) -> some View {
        Group {
            if let targetPercent = session.targetBatteryPercent {
                Text("\(targetPercent.format(decimalDigits: 0))%")
                    .font(.subheadline.weight(.semibold))
                    .foregroundColor(savedBelowPrediction ? .orange : .indigo)

                if savedBelowPrediction, let predictedPercent {
                    predictionWarningButton(predictedPercent: predictedPercent)
                }

                Button {
                    _ = appData.setTargetBatteryPercent(nil, for: session.id)
                } label: {
                    Image(systemName: "xmark.circle.fill")
                        .foregroundColor(.secondary)
                        .font(.callout)
                }
                .buttonStyle(.plain)
                .help("Remove alert")
            }

            Button {
                draftTargetText = session.targetBatteryPercent.map {
                    $0.format(decimalDigits: 0)
                } ?? "80"
                showingInlineTargetEditor = true
            } label: {
                Image(systemName: session.targetBatteryPercent == nil ? "plus" : "pencil")
                    .font(.caption.weight(.semibold))
                    .frame(width: 30, height: 30)
                    .contentShape(Rectangle())
            }
            .meterCard(tint: .indigo, fillOpacity: 0.12, strokeOpacity: 0.18, cornerRadius: 10)
            .buttonStyle(.plain)
            .help(session.targetBatteryPercent == nil ? "Set battery alert" : "Edit battery alert")
        }
    }

    private func predictionWarningButton(predictedPercent: Double) -> some View {
        Button {} label: {
            Image(systemName: "exclamationmark.triangle.fill")
                .font(.callout.weight(.semibold))
                .foregroundColor(.orange)
        }
        .buttonStyle(.plain)
        .help("Battery is already predicted at \(predictedPercent.format(decimalDigits: 0))% - this alert won't fire. Raise the value or add a checkpoint to correct the prediction.")
    }

    private func monitoringActionRow(_ session: ChargeSessionSummary) -> some View {
        HStack(spacing: 10) {
            if session.status == .active {
                Button("Pause") {
                    _ = appData.pauseChargeSession(sessionID: session.id, from: liveMonitoringMeter)
                }
                .monitoringActionStyle(tint: .orange)
            } else if session.status == .paused {
                Button("Resume") {
                    _ = appData.resumeChargeSession(sessionID: session.id, from: liveMonitoringMeter)
                }
                .monitoringActionStyle(tint: .blue)
            }

            Button("Terminate Session") {
                beginStopConfirmation(for: session)
            }
            .monitoringActionStyle(tint: .red)
        }
    }

    private func stopConfirmPanel(
        session: ChargeSessionSummary,
        displayedEnergyWh: Double,
        displayedChargeAh: Double
    ) -> some View {
        let canSave = hasSavableChargeData(
            session: session,
            displayedEnergyWh: displayedEnergyWh,
            displayedChargeAh: displayedChargeAh
        )
        let saveDisabledReason = saveDisabledReason(
            session: session,
            displayedEnergyWh: displayedEnergyWh,
            displayedChargeAh: displayedChargeAh
        )
        let isSaveEnabled = saveDisabledReason == nil

        return VStack(alignment: .leading, spacing: 12) {
            HStack {
                Text("Final Checkpoint")
                    .font(.subheadline.weight(.semibold))
                Text("optional")
                    .font(.caption2.weight(.semibold))
                    .foregroundColor(.secondary)
            }

            finalCheckpointPicker(session)

            if finalCheckpointMode == .custom {
                customFinalCheckpointRow
            }

            if let saveDisabledReason {
                Label(saveDisabledReason, systemImage: "exclamationmark.triangle.fill")
                    .font(.caption)
                    .foregroundColor(.red)
                    .fixedSize(horizontal: false, vertical: true)
            } else if let stopFailureMessage {
                Label(stopFailureMessage, systemImage: "exclamationmark.triangle.fill")
                    .font(.caption)
                    .foregroundColor(.red)
                    .fixedSize(horizontal: false, vertical: true)
            } else if finalCheckpointMode == .custom, let parsedFinalCheckpoint {
                Label("Final checkpoint will be saved at \(parsedFinalCheckpoint.format(decimalDigits: 0))%.", systemImage: "checkmark.circle.fill")
                    .font(.caption)
                    .foregroundColor(.green)
                    .fixedSize(horizontal: false, vertical: true)
            }

            HStack(spacing: 8) {
                Button("Discard") {
                    discardSession(session)
                }
                .monitoringPanelActionStyle(tint: .secondary)

                Button {
                    stopSession(
                        session,
                        displayedEnergyWh: displayedEnergyWh,
                        displayedChargeAh: displayedChargeAh
                    )
                } label: {
                    Label("Save Session", systemImage: "checkmark.circle.fill")
                        .frame(maxWidth: .infinity)
                }
                .monitoringPanelActionStyle(tint: isSaveEnabled ? .green : .secondary, isProminent: isSaveEnabled)
                .disabled(!isSaveEnabled)
                .help(saveDisabledReason ?? "Close and save this session")

                Button("Cancel") {
                    resetStopConfirmation()
                }
                .monitoringPanelActionStyle(tint: .secondary)
            }
        }
        .padding(14)
        .meterCard(tint: canSave ? .green : .red, fillOpacity: 0.06, strokeOpacity: 0.14, cornerRadius: 16)
    }

    private func finalCheckpointPicker(_ session: ChargeSessionSummary) -> some View {
        return HStack(spacing: 8) {
            ForEach([FinalCheckpoint.full, .skip, .custom], id: \.self) { mode in
                Button {
                    finalCheckpointMode = mode
                    if mode == .custom {
                        prefillFinalCheckpointIfNeeded(for: session)
                    } else {
                        finalCheckpointText = ""
                    }
                } label: {
                    VStack(spacing: 5) {
                        Image(systemName: mode.icon)
                            .font(.title3)
                            .foregroundColor(finalCheckpointMode == mode ? .primary : .secondary)
                        Text(mode.label)
                            .font(.caption.weight(.semibold))
                            .foregroundColor(finalCheckpointMode == mode ? .primary : .secondary)
                    }
                    .frame(maxWidth: .infinity)
                    .padding(.vertical, 10)
                    .background(finalCheckpointMode == mode ? Color.primary.opacity(0.10) : Color.clear)
                    .meterCard(
                        tint: finalCheckpointMode == mode ? .primary : .secondary,
                        fillOpacity: finalCheckpointMode == mode ? 0.08 : 0.04,
                        strokeOpacity: finalCheckpointMode == mode ? 0.20 : 0.10,
                        cornerRadius: 12
                    )
                }
                .buttonStyle(.plain)
            }
        }
    }

    private var customFinalCheckpointRow: some View {
        let isInvalid = finalCheckpointText.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
            || parsedFinalCheckpoint == nil

        return HStack(spacing: 8) {
            Button {
                adjustFinalCheckpoint(by: -1)
            } label: {
                Image(systemName: "minus.circle").font(.title3)
            }
            .buttonStyle(.plain)

            TextField("-", text: $finalCheckpointText)
                .keyboardType(.decimalPad)
                .textFieldStyle(.roundedBorder)
                .frame(width: 56)
                .multilineTextAlignment(.center)
                .overlay(
                    RoundedRectangle(cornerRadius: 6)
                        .stroke(isInvalid ? Color.red.opacity(0.75) : Color.clear, lineWidth: 1)
                )

            Text("%").foregroundColor(.secondary)

            Text("required")
                .font(.caption2.weight(.semibold))
                .foregroundColor(isInvalid ? .red : .secondary)

            Button {
                adjustFinalCheckpoint(by: 1)
            } label: {
                Image(systemName: "plus.circle").font(.title3)
            }
            .buttonStyle(.plain)

            Spacer()
        }
    }

    private func followerNoticeCard(_ session: ChargeSessionSummary) -> some View {
        MeterInfoCardView(title: "Monitoring Device", tint: .secondary) {
            if let meterName = session.meterName {
                MeterInfoRowView(label: "Controlled On", value: meterName)
            }
            Text("Pause, stop, checkpoint, and live trim controls are available on the device connected to the monitoring meter.")
                .font(.caption2)
                .foregroundColor(.secondary)
        }
    }

    private func managementCard(_ session: ChargeSessionSummary) -> some View {
        MeterInfoCardView(title: "Administration", tint: .red) {
            Button(role: .destructive) {
                pendingSessionDeletion = session
            } label: {
                Label("Delete Session", systemImage: "trash")
                    .font(.subheadline.weight(.semibold))
                    .frame(maxWidth: .infinity)
                    .padding(.vertical, 10)
                    .meterCard(tint: .red, fillOpacity: 0.12, strokeOpacity: 0.20, cornerRadius: 14)
            }
            .buttonStyle(.plain)
        }
    }

    @ViewBuilder
    private func trimDetectionBanner(_ session: ChargeSessionSummary) -> some View {
        if let window = detectedTrimWindow {
            HStack(spacing: 12) {
                Image(systemName: "scissors.circle.fill")
                    .font(.title3)
                    .foregroundColor(.blue)

                VStack(alignment: .leading, spacing: 2) {
                    Text("Charging ended early")
                        .font(.subheadline.weight(.semibold))
                    Text("Active charging was detected between \(window.start.format(as: "HH:mm")) and \(window.end.format(as: "HH:mm")).")
                        .font(.caption)
                        .foregroundColor(.secondary)
                        .fixedSize(horizontal: false, vertical: true)
                }

                Spacer(minLength: 0)

                VStack(spacing: 6) {
                    Button("Trim Start") {
                        setSessionTrim(sessionID: session.id, start: window.start, end: session.trimEnd)
                        trimBannerDismissedForSessionID = session.id
                    }
                    .font(.caption.weight(.semibold))
                    .buttonStyle(.borderedProminent)
                    .controlSize(.small)
                    .tint(.blue)

                    Button("End & Finish") {
                        requestStop(
                            session,
                            applyingTrimStart: session.trimStart ?? window.start,
                            trimEnd: window.end,
                            title: "Trim End & Finish",
                            confirmTitle: "Finish",
                            explanation: "The detected charging window will be saved before the session is closed."
                        )
                        trimBannerDismissedForSessionID = session.id
                    }
                    .font(.caption.weight(.semibold))
                    .buttonStyle(.bordered)
                    .controlSize(.small)
                    .tint(.red)
                }
            }
            .padding(14)
            .background(
                RoundedRectangle(cornerRadius: 14)
                    .fill(Color.blue.opacity(0.10))
                    .overlay(RoundedRectangle(cornerRadius: 14).stroke(Color.blue.opacity(0.22), lineWidth: 1))
            )
            .transition(.opacity.combined(with: .move(edge: .top)))
        }
    }

    private func shouldShowSessionChart(_ session: ChargeSessionSummary) -> Bool {
        !session.aggregatedSamples.isEmpty || liveMonitoringMeter != nil
    }

    private func chartCard(_ session: ChargeSessionSummary) -> some View {
        ChargeSessionChartCardView(
            session: session,
            monitoringMeter: liveMonitoringMeter,
            controlMode: chartControlMode(for: session),
            onSetTrim: { start, end in
                setSessionTrim(sessionID: session.id, start: start, end: end)
            },
            onStopWithTrim: { start, end in
                requestStop(
                    session,
                    applyingTrimStart: start,
                    trimEnd: end,
                    title: "Trim End & Finish",
                    confirmTitle: "Finish",
                    explanation: "The selected chart window will be saved as this session's active charging window before the session is closed."
                )
            }
        )
    }

    private func chartControlMode(for session: ChargeSessionSummary) -> ChargeSessionChartControlMode {
        if hasMonitoringControls {
            return .activeMonitoring
        }

        if session.status.isOpen == false {
            return .closed
        }

        return .none
    }

    private func setSessionTrim(sessionID: UUID, start: Date?, end: Date?) {
        _ = appData.setSessionTrim(sessionID: sessionID, start: start, end: end)
        trimBannerDismissedForSessionID = sessionID
    }

    private func requestStop(
        _ session: ChargeSessionSummary,
        applyingTrimStart trimStart: Date?,
        trimEnd: Date?,
        title: String,
        confirmTitle: String,
        explanation: String
    ) {
        pendingSessionStopRequest = ChargeSessionStopRequest(
            sessionID: session.id,
            title: title,
            confirmTitle: confirmTitle,
            explanation: explanation,
            appliesTrim: trimStart != nil || trimEnd != nil,
            trimStart: trimStart,
            trimEnd: trimEnd
        )
    }

    private var parsedDraftTarget: Double? {
        let normalized = draftTargetText
            .trimmingCharacters(in: .whitespacesAndNewlines)
            .replacingOccurrences(of: ",", with: ".")
        guard let value = Double(normalized), value >= 1, value <= 100 else { return nil }
        return value
    }

    private var parsedFinalCheckpoint: Double? {
        let normalized = finalCheckpointText
            .trimmingCharacters(in: .whitespacesAndNewlines)
            .replacingOccurrences(of: ",", with: ".")
        guard let value = Double(normalized), value >= 0, value <= 100 else { return nil }
        return value
    }

    private var resolvedFinalCheckpoint: Double? {
        switch finalCheckpointMode {
        case .full:   return 100
        case .skip:   return nil
        case .custom: return parsedFinalCheckpoint
        }
    }

    private func adjustFinalCheckpoint(by delta: Double) {
        let current = parsedFinalCheckpoint ?? suggestedFinalCheckpointPercent(for: session) ?? 0
        let next = min(max(current + delta, 0), 100)
        finalCheckpointText = next.format(decimalDigits: 0)
    }

    private func suggestedFinalCheckpointPercent(for session: ChargeSessionSummary?) -> Double? {
        guard let session else { return nil }
        if let endBatteryPercent = session.endBatteryPercent {
            return endBatteryPercent
        }
        if let latestCheckpoint = session.checkpoints.max(by: { $0.timestamp < $1.timestamp }) {
            return latestCheckpoint.batteryPercent
        }
        return session.targetBatteryPercent ?? session.completionContradictionPercent
    }

    private func prefillFinalCheckpointIfNeeded(for session: ChargeSessionSummary) {
        guard finalCheckpointText.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty,
              let suggestedPercent = suggestedFinalCheckpointPercent(for: session) else {
            return
        }
        finalCheckpointText = suggestedPercent.format(decimalDigits: 0)
    }

    private func hasSavableChargeData(
        session: ChargeSessionSummary,
        displayedEnergyWh: Double,
        displayedChargeAh: Double
    ) -> Bool {
        session.hasSavableChargeData
            || displayedEnergyWh > 0
            || displayedChargeAh > 0
    }

    private func saveDisabledReason(
        session: ChargeSessionSummary,
        displayedEnergyWh: Double,
        displayedChargeAh: Double
    ) -> String? {
        if finalCheckpointMode == .custom {
            let trimmed = finalCheckpointText.trimmingCharacters(in: .whitespacesAndNewlines)
            if trimmed.isEmpty {
                return "Enter the final battery percentage or choose Skip."
            }
            if parsedFinalCheckpoint == nil {
                return "Final battery percentage must be between 0 and 100."
            }
        }

        guard hasSavableChargeData(
            session: session,
            displayedEnergyWh: displayedEnergyWh,
            displayedChargeAh: displayedChargeAh
        ) else {
            return "This session has no charging data to save. Discard it instead."
        }

        return nil
    }

    private func stopSession(
        _ session: ChargeSessionSummary,
        displayedEnergyWh: Double,
        displayedChargeAh: Double
    ) {
        stopFailureMessage = nil

        if let saveDisabledReason = saveDisabledReason(
            session: session,
            displayedEnergyWh: displayedEnergyWh,
            displayedChargeAh: displayedChargeAh
        ) {
            stopFailureMessage = saveDisabledReason
            return
        }

        let didSave = appData.stopChargeSession(
            sessionID: session.id,
            finalBatteryPercent: resolvedFinalCheckpoint,
            from: liveMonitoringMeter
        )
        if didSave {
            resetStopConfirmation()
        } else {
            stopFailureMessage = "The session could not be closed. Live readings were flushed, but the stored session did not accept the save yet. Try again in a moment."
        }
    }

    private func beginStopConfirmation(for session: ChargeSessionSummary) {
        finalCheckpointMode = .skip
        finalCheckpointText = ""
        stopFailureMessage = nil
        showingStopConfirm = true
    }

    private func discardSession(_ session: ChargeSessionSummary) {
        _ = appData.deleteChargeSession(sessionID: session.id)
        resetStopConfirmation()
    }

    private func resetStopConfirmation() {
        showingStopConfirm = false
        finalCheckpointText = ""
        finalCheckpointMode = .skip
        stopFailureMessage = nil
    }

    private func syncMonitoringRestore() {
        guard let session,
              session.status.isOpen,
              let liveMonitoringMeter,
              session.meterMACAddress == liveMonitoringMeter.btSerial.macAddress.description else {
            return
        }
        liveMonitoringMeter.restoreChargeMonitoringIfNeeded(from: session)
    }

    private func runTrimDetection() {
        guard hasMonitoringControls,
              let session,
              session.isTrimmed == false,
              !session.aggregatedSamples.isEmpty else {
            detectedTrimWindow = nil
            return
        }

        let sessionEnd = session.endedAt ?? session.lastObservedAt
        detectedTrimWindow = ChargingWindowDetector.detect(
            samples: session.aggregatedSamples,
            sessionStart: session.startedAt,
            sessionEnd: sessionEnd
        )
    }

    private func displayedSessionEnergyWh(for session: ChargeSessionSummary) -> Double {
        let storedEnergyWh = session.effectiveOrMeasuredEnergyWh
        guard session.isTrimmed == false else { return storedEnergyWh }
        guard session.status.isOpen else { return storedEnergyWh }
        guard let liveMonitoringMeter else { return storedEnergyWh }
        guard session.meterMACAddress == liveMonitoringMeter.btSerial.macAddress.description else { return storedEnergyWh }
        if let baselineEnergyWh = session.meterEnergyBaselineWh {
            return max(storedEnergyWh, max(liveMonitoringMeter.recordedWH - baselineEnergyWh, 0))
        }
        return storedEnergyWh
    }

    private func displayedSessionChargeAh(for session: ChargeSessionSummary) -> Double {
        let storedChargeAh = session.measuredChargeAh
        guard session.isTrimmed == false else { return storedChargeAh }
        guard session.status.isOpen else { return storedChargeAh }
        guard let liveMonitoringMeter else { return storedChargeAh }
        guard session.meterMACAddress == liveMonitoringMeter.btSerial.macAddress.description else { return storedChargeAh }
        if let baselineChargeAh = session.meterChargeBaselineAh {
            return max(storedChargeAh, max(liveMonitoringMeter.recordedAH - baselineChargeAh, 0))
        }
        return storedChargeAh
    }

    private func displayedSessionDuration(for session: ChargeSessionSummary) -> TimeInterval {
        let storedDuration = max(session.effectiveDuration, 0)
        guard session.isTrimmed == false else { return storedDuration }
        guard session.status.isOpen else { return storedDuration }
        guard let liveMonitoringMeter else { return storedDuration }
        guard session.meterMACAddress == liveMonitoringMeter.btSerial.macAddress.description else { return storedDuration }
        return max(storedDuration, max(liveMonitoringMeter.chargeRecordDuration, 0))
    }

    private func sessionDurationText(_ session: ChargeSessionSummary) -> String {
        let displayedDuration = displayedSessionDuration(for: session)
        let formatter = DateComponentsFormatter()
        formatter.allowedUnits = displayedDuration >= 3600 ? [.hour, .minute] : [.minute, .second]
        formatter.unitsStyle = .abbreviated
        formatter.zeroFormattingBehavior = .dropAll
        return formatter.string(from: displayedDuration) ?? "0m"
    }

    private func formatDuration(_ duration: TimeInterval) -> String {
        let totalSeconds = Int(duration.rounded(.down))
        let hours = totalSeconds / 3600
        let minutes = (totalSeconds % 3600) / 60
        let seconds = totalSeconds % 60
        if hours > 0 {
            return String(format: "%d:%02d:%02d", hours, minutes, seconds)
        }
        return String(format: "%02d:%02d", minutes, seconds)
    }

    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 autoStopLabel(for session: ChargeSessionSummary) -> String {
        if session.autoStopEnabled == false {
            return "Manual"
        }
        if let sessionWarning = sessionWarning(for: session), session.chargingTransportMode == .wireless {
            return sessionWarning.contains("idle-current") ? "Blocked" : "Manual"
        }
        if session.stopThresholdAmps > 0 {
            return "\(session.stopThresholdAmps.format(decimalDigits: 2)) A"
        }
        return "Learning"
    }

    private func shouldShowChargingTransport(
        for session: ChargeSessionSummary,
        chargedDevice: ChargedDeviceSummary
    ) -> Bool {
        chargedDevice.supportedChargingModes.count > 1
            || chargedDevice.supportedChargingModes.contains(session.chargingTransportMode) == false
    }

    private func shouldShowChargingState(
        for session: ChargeSessionSummary,
        chargedDevice: ChargedDeviceSummary
    ) -> Bool {
        chargedDevice.supportedChargingStateModes.count > 1
            || chargedDevice.supportedChargingStateModes.contains(session.chargingStateMode) == false
    }

    private func batteryColor(for percent: Double) -> Color {
        if percent >= 75 { return .green }
        if percent >= 35 { return .orange }
        return .red
    }

    private func etaText(
        rateWhPerSec: Double?,
        remainingWh: Double,
        isRelevant: Bool
    ) -> String? {
        guard isRelevant, let rateWhPerSec, rateWhPerSec > 0.0001 else { return nil }
        let seconds = remainingWh / rateWhPerSec
        return seconds > 120 ? formatETA(seconds) : nil
    }

    private func etaToTargetText(
        session: ChargeSessionSummary,
        prediction: BatteryLevelPrediction,
        displayedEnergyWh: Double,
        rateWhPerSec: Double?
    ) -> String? {
        guard let target = session.targetBatteryPercent, target > prediction.predictedPercent + 1 else {
            return nil
        }
        let targetEnergyWh = (target / 100) * prediction.estimatedCapacityWh
        return etaText(
            rateWhPerSec: rateWhPerSec,
            remainingWh: max(targetEnergyWh - displayedEnergyWh, 0),
            isRelevant: true
        )
    }

    private func formatETA(_ seconds: TimeInterval) -> String {
        let totalMinutes = Int(seconds / 60)
        if totalMinutes < 60 { return "\(totalMinutes)m" }
        let hours = totalMinutes / 60
        let minutes = totalMinutes % 60
        return minutes == 0 ? "\(hours)h" : "\(hours)h \(minutes)m"
    }

    private func monitoringStatusColor(for session: ChargeSessionSummary) -> Color {
        switch session.status {
        case .active:
            return .red
        case .paused:
            return .orange
        case .completed:
            return .green
        case .abandoned:
            return .secondary
        }
    }

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

enum ChargeSessionChartControlMode {
    case none
    case activeMonitoring
    case closed
}

struct ChargeSessionChartCardView: View {
    let session: ChargeSessionSummary
    let monitoringMeter: Meter?
    let controlMode: ChargeSessionChartControlMode
    let onSetTrim: (Date?, Date?) -> Void
    let onStopWithTrim: (Date?, Date?) -> Void

    @StateObject private var storedMeasurements = Measurements()

    private var chartMeasurements: Measurements {
        if let monitoringMeter,
           session.status.isOpen,
           session.meterMACAddress == monitoringMeter.btSerial.macAddress.description {
            return monitoringMeter.chargeRecordMeasurements
        }
        return storedMeasurements
    }

    private var fullTimeRange: ClosedRange<Date> {
        let start = session.startedAt
        let end = max(session.endedAt ?? session.lastObservedAt, start)
        return start...end
    }

    private var fixedTimeRange: ClosedRange<Date>? {
        if monitoringMeter != nil && session.status.isOpen {
            return nil
        }
        return session.effectiveTimeRange
    }

    private var liveTrimBounds: (lower: Date?, upper: Date?) {
        guard monitoringMeter != nil && session.status.isOpen else {
            return (nil, nil)
        }
        return (session.trimStart, session.trimEnd)
    }

    private var showsRangeSelector: Bool {
        controlMode != .none && !session.aggregatedSamples.isEmpty
    }

    var body: some View {
        VStack(alignment: .leading, spacing: 12) {
            HStack(spacing: 8) {
                Image(systemName: "chart.xyaxis.line")
                    .foregroundColor(.blue)
                Text("Session Chart")
                    .font(.headline)
                ContextInfoButton(
                    title: "Session Chart",
                    message: chartInfoMessage
                )
                Spacer(minLength: 0)
            }

            MeasurementChartView(
                timeRange: fixedTimeRange,
                timeRangeLowerBound: liveTrimBounds.lower,
                timeRangeUpperBound: liveTrimBounds.upper,
                showsRangeSelector: showsRangeSelector,
                rebasesEnergyToVisibleRangeStart: true,
                extendsTimelineToPresent: false,
                showsTemperatureSeries: false,
                rangeSelectorConfiguration: rangeSelectorConfiguration
            )
            .environmentObject(chartMeasurements)
            .frame(maxWidth: .infinity, alignment: .topLeading)
        }
        .padding(18)
        .meterCard(tint: .blue, fillOpacity: 0.14, strokeOpacity: 0.20)
        .onAppear(perform: restoreStoredMeasurementsIfNeeded)
        .onChange(of: session.id) { _ in
            restoreStoredMeasurementsIfNeeded()
        }
        .onChange(of: session.aggregatedSamples.count) { _ in
            restoreStoredMeasurementsIfNeeded()
        }
    }

    private var chartInfoMessage: String {
        if monitoringMeter != nil && session.status.isOpen {
            return "This chart combines the persisted session curve with current live data from this meter."
        }

        return "This chart is scoped to the saved session window for \(session.sessionKind.shortTitle.lowercased()) charging."
    }

    private var rangeSelectorConfiguration: MeasurementChartRangeSelectorConfiguration? {
        switch controlMode {
        case .none:
            return nil
        case .activeMonitoring:
            return MeasurementChartRangeSelectorConfiguration(
                keepAction: MeasurementChartSelectionAction(
                    title: "Trim Start",
                    shortTitle: "Start",
                    systemName: "arrow.right.to.line",
                    tone: .destructive,
                    handler: applyActiveStartTrim
                ),
                removeAction: MeasurementChartSelectionAction(
                    title: "Trim End & Finish",
                    shortTitle: "End",
                    systemName: "arrow.left.to.line",
                    tone: .destructiveProminent,
                    handler: requestActiveEndTrim
                ),
                resetAction: MeasurementChartResetAction(
                    title: "Reset Trim",
                    shortTitle: "Reset",
                    systemName: "arrow.counterclockwise",
                    tone: .reversible,
                    confirmationTitle: "Reset session trim?",
                    confirmationButtonTitle: "Reset trim",
                    handler: {
                        onSetTrim(nil, nil)
                    }
                )
            )
        case .closed:
            return MeasurementChartRangeSelectorConfiguration(
                keepAction: MeasurementChartSelectionAction(
                    title: "Trim Window",
                    shortTitle: "Trim",
                    systemName: "scissors",
                    tone: .destructive,
                    handler: applyClosedTrim
                ),
                removeAction: nil,
                resetAction: MeasurementChartResetAction(
                    title: "Reset Trim",
                    shortTitle: "Reset",
                    systemName: "arrow.counterclockwise",
                    tone: .reversible,
                    confirmationTitle: "Reset session trim?",
                    confirmationButtonTitle: "Reset trim",
                    handler: {
                        onSetTrim(nil, nil)
                    }
                )
            )
        }
    }

    private func restoreStoredMeasurementsIfNeeded() {
        guard monitoringMeter == nil || session.status.isOpen == false else {
            return
        }
        storedMeasurements.resetSeries()
        _ = storedMeasurements.restorePersistedChargeSessionSamplesIfNeeded(
            from: session,
            replacingLiveBufferIfNeeded: true
        )
    }

    private func applyActiveStartTrim(_ range: ClosedRange<Date>) {
        onSetTrim(normalizedStart(range.lowerBound), session.trimEnd)
    }

    private func requestActiveEndTrim(_ range: ClosedRange<Date>) {
        let start = session.trimStart ?? normalizedStart(range.lowerBound)
        let end = normalizedEnd(range.upperBound)
        onStopWithTrim(start, end)
    }

    private func applyClosedTrim(_ range: ClosedRange<Date>) {
        onSetTrim(normalizedStart(range.lowerBound), normalizedEnd(range.upperBound))
    }

    private func normalizedStart(_ date: Date) -> Date? {
        date.timeIntervalSince(fullTimeRange.lowerBound) <= 1 ? nil : date
    }

    private func normalizedEnd(_ date: Date) -> Date? {
        fullTimeRange.upperBound.timeIntervalSince(date) <= 1 ? nil : date
    }
}

private struct ChargeSessionStopRequest: Identifiable {
    let sessionID: UUID
    let title: String
    let confirmTitle: String
    let explanation: String
    let appliesTrim: Bool
    let trimStart: Date?
    let trimEnd: Date?

    var id: String {
        [
            sessionID.uuidString,
            title,
            trimStart?.timeIntervalSince1970.description ?? "nil",
            trimEnd?.timeIntervalSince1970.description ?? "nil"
        ].joined(separator: "-")
    }
}

private extension View {
    func monitoringActionStyle(tint: Color) -> some View {
        frame(maxWidth: .infinity)
            .padding(.vertical, 10)
            .meterCard(tint: tint, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 14)
            .buttonStyle(.plain)
    }

    func monitoringPanelActionStyle(tint: Color, isProminent: Bool = false) -> some View {
        frame(maxWidth: .infinity)
            .padding(.vertical, 9)
            .meterCard(
                tint: tint,
                fillOpacity: isProminent ? 0.22 : 0.10,
                strokeOpacity: isProminent ? 0.32 : 0.14,
                cornerRadius: 14
            )
            .buttonStyle(.plain)
    }
}
