//
//  ChargedDeviceDetailView.swift
//  USB Meter
//
//  Created by Codex on 10/04/2026.
//

import SwiftUI

struct ChargedDeviceDetailView: View {
    private enum DetailTab: Hashable {
        case overview
        case standby
        case sessions
        case trends
        case settings
    }

    @EnvironmentObject private var appData: AppData
    @Environment(\.dismiss) private var dismiss

    @State private var editorVisibility = false
    @State private var deleteConfirmationVisibility = false
    @State private var selectedTab: DetailTab = .overview
    @State private var sessionSelectMode = false
    @State private var selectedSessionIDs: Set<UUID> = []
    @State private var pendingBatchDeletion = false

    let chargedDeviceID: UUID

    var body: some View {
        Group {
            if let chargedDevice = appData.chargedDeviceSummary(id: chargedDeviceID) {
                tabbedDetailView(chargedDevice)
                .navigationTitle(chargedDevice.name)
            } else {
                Text("This device is no longer available.")
                    .foregroundColor(.secondary)
                    .navigationTitle("Device")
            }
        }
        .sheet(isPresented: $editorVisibility) {
            if let chargedDevice = appData.chargedDeviceSummary(id: chargedDeviceID) {
                if chargedDevice.isCharger {
                    ChargerEditorSheetView(chargedDevice: chargedDevice)
                        .environmentObject(appData)
                } else {
                    ChargedDeviceEditorSheetView(
                        meterMACAddress: nil,
                        chargedDevice: chargedDevice
                    )
                    .environmentObject(appData)
                }
            }
        }
        .confirmationDialog("Delete \(deletionTitle)?", isPresented: $deleteConfirmationVisibility, titleVisibility: .visible) {
            Button("Delete", role: .destructive) {
                if appData.deleteChargedDevice(id: chargedDeviceID) {
                    dismiss()
                }
            }
            Button("Cancel", role: .cancel) {}
        } message: {
            Text(deletionMessage)
        }
        .confirmationDialog(
            "Delete \(selectedSessionIDs.count) Session\(selectedSessionIDs.count == 1 ? "" : "s")?",
            isPresented: $pendingBatchDeletion,
            titleVisibility: .visible
        ) {
            Button("Delete", role: .destructive, action: deleteSelectedSessions)
            Button("Cancel", role: .cancel) {}
        } message: {
            Text("Deleting these sessions also recalculates capacity and every derived metric that used them.")
        }
    }

    private func tabbedDetailView(_ chargedDevice: ChargedDeviceSummary) -> some View {
        GeometryReader { proxy in
            let tabs = availableTabs(for: chargedDevice)
            let displayedTab = displayedTab(from: tabs)
            let tabBarPresentation = AdaptiveTabBarPresentation.standard(for: proxy.size)

            VStack(spacing: 0) {
                ChargedDeviceDetailTabBarView(
                    tabs: tabs,
                    selection: $selectedTab,
                    tint: tint(for: chargedDevice),
                    presentation: tabBarPresentation,
                    title: title(for:),
                    systemImage: systemImage(for:)
                )

                Group {
                    if displayedTab == .sessions {
                        sessionsTabLayout(chargedDevice)
                    } else {
                        ScrollView {
                            tabContent(displayedTab, chargedDevice: chargedDevice)
                                .padding()
                        }
                    }
                }
                .id(displayedTab)
                .transition(.opacity.combined(with: .move(edge: .trailing)))
                .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .top)
            }
            .animation(.easeInOut(duration: 0.22), value: displayedTab)
            .animation(.easeInOut(duration: 0.22), value: tabs)
            .onChange(of: selectedTab) { _ in
                sessionSelectMode = false
                selectedSessionIDs.removeAll()
            }
        }
        .background(detailBackground(for: chargedDevice))
        .onAppear {
            ensureSelectedTabExists(for: chargedDevice)
        }
        .onChange(of: chargedDevice.isCharger) { _ in
            ensureSelectedTabExists(for: chargedDevice)
        }
    }

    @ViewBuilder
    private func tabContent(_ tab: DetailTab, chargedDevice: ChargedDeviceSummary) -> some View {
        VStack(spacing: 18) {
            switch tab {
            case .overview:
                overviewTab(chargedDevice)
            case .standby:
                standbyTab(chargedDevice)
            case .sessions:
                sessionsTab(chargedDevice)
            case .trends:
                trendsTab(chargedDevice)
            case .settings:
                settingsTab(chargedDevice)
            }
        }
    }

    @ViewBuilder
    private func overviewTab(_ chargedDevice: ChargedDeviceSummary) -> some View {
        headerCard(chargedDevice)
        insightsCard(chargedDevice)

        if let activeSession = chargedDevice.activeSession {
            activeSessionSummaryCard(activeSession, chargedDevice: chargedDevice)
        }
    }

    @ViewBuilder
    private func standbyTab(_ chargedDevice: ChargedDeviceSummary) -> some View {
        standbyPowerCard(chargedDevice)
    }

    @ViewBuilder
    private func sessionsTab(_ chargedDevice: ChargedDeviceSummary) -> some View {
        if let activeSession = chargedDevice.activeSession {
            activeSessionSummaryCard(activeSession, chargedDevice: chargedDevice)
        }

        let sessions = closedSessions(for: chargedDevice)
        if !sessions.isEmpty {
            sessionListCard(sessions, chargedDevice: chargedDevice)
        } else if chargedDevice.activeSession == nil {
            emptyStateCard(
                title: "No Sessions",
                message: "Charging sessions will appear here after this device is used in a recording.",
                tint: .teal
            )
        }
    }

    @ViewBuilder
    private func trendsTab(_ chargedDevice: ChargedDeviceSummary) -> some View {
        if !chargedDevice.capacityHistory.isEmpty {
            capacityEvolutionCard(chargedDevice)
        }

        if !chargedDevice.typicalCurve.isEmpty {
            typicalCurveCard(chargedDevice)
        }

        if chargedDevice.capacityHistory.isEmpty && chargedDevice.typicalCurve.isEmpty {
            emptyStateCard(
                title: "Learning Trends",
                message: "Capacity history and charge curves will appear after enough completed sessions are available.",
                tint: .blue
            )
        }
    }

    @ViewBuilder
    private func settingsTab(_ chargedDevice: ChargedDeviceSummary) -> some View {
        settingsCard(chargedDevice)
    }

    @ViewBuilder
    private func sessionsTabLayout(_ chargedDevice: ChargedDeviceSummary) -> some View {
        let allSessions = chargedDevice.sessions.sorted { lhs, rhs in
            let lOpen = lhs.status.isOpen, rOpen = rhs.status.isOpen
            if lOpen != rOpen { return lOpen }
            return lhs.startedAt > rhs.startedAt
        }
        let totalEnergyWh = allSessions.reduce(0.0) { $0 + $1.effectiveOrMeasuredEnergyWh }
        let totalDuration  = allSessions.reduce(0.0) { $0 + max($1.effectiveDuration, 0) }

        VStack(spacing: 0) {
            // Fixed non-scrolling header
            VStack(spacing: 10) {
                sessionsSummaryStrip(
                    count: allSessions.count,
                    totalEnergyWh: totalEnergyWh,
                    totalDuration: totalDuration,
                    hasActive: chargedDevice.activeSession != nil
                )

                if !allSessions.isEmpty {
                    HStack(spacing: 12) {
                        if sessionSelectMode && !selectedSessionIDs.isEmpty {
                            Text("\(selectedSessionIDs.count) selected")
                                .font(.subheadline)
                                .foregroundColor(.secondary)
                                .transition(.opacity.combined(with: .move(edge: .leading)))
                        }
                        Spacer()
                        if sessionSelectMode && !selectedSessionIDs.isEmpty {
                            Button {
                                pendingBatchDeletion = true
                            } label: {
                                Image(systemName: "trash").foregroundColor(.red)
                            }
                            .transition(.opacity.combined(with: .scale))
                        }
                        Button(sessionSelectMode ? "Cancel" : "Select") {
                            withAnimation(.easeInOut(duration: 0.2)) {
                                sessionSelectMode.toggle()
                                if !sessionSelectMode { selectedSessionIDs.removeAll() }
                            }
                        }
                    }
                    .animation(.easeInOut(duration: 0.2), value: sessionSelectMode)
                    .animation(.easeInOut(duration: 0.2), value: selectedSessionIDs.isEmpty)
                }
            }
            .padding()

            // Scrollable session list
            if allSessions.isEmpty {
                emptyStateCard(
                    title: "No Sessions",
                    message: "Charging sessions will appear here after this device is used in a recording.",
                    tint: .teal
                )
                .padding([.horizontal, .bottom])
            } else {
                ScrollView {
                    VStack(spacing: 10) {
                        ForEach(allSessions, id: \.id) { session in
                            sessionListItem(session, chargedDevice: chargedDevice)
                        }
                    }
                    .padding([.horizontal, .bottom])
                }
            }
        }
    }

    private func sessionsSummaryStrip(
        count: Int,
        totalEnergyWh: Double,
        totalDuration: TimeInterval,
        hasActive: Bool
    ) -> some View {
        HStack(spacing: 0) {
            summaryCell(value: "\(count)", label: count == 1 ? "session" : "sessions")
            Divider().frame(height: 30)
            summaryCell(value: "\(totalEnergyWh.format(decimalDigits: 2)) Wh", label: "energy")
            Divider().frame(height: 30)
            summaryCell(value: formatAccumulatedDuration(totalDuration), label: "duration")
            if hasActive {
                Divider().frame(height: 30)
                HStack(spacing: 4) {
                    Circle().fill(Color.green).frame(width: 6, height: 6)
                    Text("Live")
                        .font(.caption2.weight(.semibold))
                        .foregroundColor(.green)
                }
                .frame(maxWidth: .infinity)
            }
        }
        .padding(.vertical, 8)
        .padding(.horizontal, 12)
        .meterCard(tint: .teal, fillOpacity: 0.08, strokeOpacity: 0.14, cornerRadius: 14)
    }

    private func summaryCell(value: String, label: String) -> some View {
        VStack(spacing: 2) {
            Text(value)
                .font(.subheadline.weight(.bold))
                .foregroundColor(.primary)
                .monospacedDigit()
                .lineLimit(1)
                .minimumScaleFactor(0.7)
            Text(label)
                .font(.caption2)
                .foregroundColor(.secondary)
        }
        .frame(maxWidth: .infinity)
    }

    private func formatAccumulatedDuration(_ duration: TimeInterval) -> String {
        let formatter = DateComponentsFormatter()
        formatter.allowedUnits = duration >= 3600 ? [.hour, .minute] : [.minute, .second]
        formatter.unitsStyle = .abbreviated
        formatter.zeroFormattingBehavior = .dropAll
        return formatter.string(from: duration) ?? "0m"
    }

    private func headerCard(_ chargedDevice: ChargedDeviceSummary) -> some View {
        HStack(alignment: .top, spacing: 18) {
            ChargedDeviceQRCodeView(qrIdentifier: chargedDevice.qrIdentifier, side: 118)

            VStack(alignment: .leading, spacing: 10) {
                ChargedDeviceIdentityLabelView(
                    chargedDevice: chargedDevice,
                    iconPointSize: 22
                )
                .font(.title3.weight(.bold))

                Text(chargedDevice.identityTitle)
                    .font(.subheadline.weight(.semibold))
                    .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 settingsCard(_ chargedDevice: ChargedDeviceSummary) -> some View {
        MeterInfoCardView(title: "Settings", tint: tint(for: chargedDevice)) {
            MeterInfoRowView(
                label: "Kind",
                value: chargedDevice.isCharger ? "Charger" : chargedDevice.deviceClass.title
            )
            MeterInfoRowView(label: "Template", value: chargedDevice.identityTitle)
            MeterInfoRowView(label: "QR ID", value: chargedDevice.qrIdentifier)

            if let meterMAC = chargedDevice.lastAssociatedMeterMAC {
                MeterInfoRowView(label: "Default Meter", value: meterMAC)
            }

            MeterInfoRowView(label: "Created", value: chargedDevice.createdAt.format())
            MeterInfoRowView(label: "Updated", value: chargedDevice.updatedAt.format())

            Divider()

            Button(action: showEditor) {
                Label("Edit \(chargedDevice.isCharger ? "Charger" : "Device")", systemImage: "pencil")
                    .font(.subheadline.weight(.semibold))
                    .frame(maxWidth: .infinity)
                    .padding(.vertical, 10)
                    .meterCard(tint: tint(for: chargedDevice), fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 14)
            }
            .buttonStyle(.plain)

            Button(role: .destructive, action: showDeleteConfirmation) {
                Label("Delete \(chargedDevice.isCharger ? "Charger" : "Device")", systemImage: "trash")
                    .font(.subheadline.weight(.semibold))
                    .frame(maxWidth: .infinity)
                    .padding(.vertical, 10)
                    .meterCard(tint: .red, fillOpacity: 0.10, strokeOpacity: 0.18, cornerRadius: 14)
            }
            .buttonStyle(.plain)
        }
    }

    private func emptyStateCard(title: String, message: String, tint: Color) -> some View {
        VStack(alignment: .leading, spacing: 8) {
            Text(title)
                .font(.headline)
            Text(message)
                .font(.footnote)
                .foregroundColor(.secondary)
                .fixedSize(horizontal: false, vertical: true)
        }
        .frame(maxWidth: .infinity, alignment: .leading)
        .padding(18)
        .meterCard(tint: tint, fillOpacity: 0.12, strokeOpacity: 0.18, cornerRadius: 18)
    }

    private func insightsCard(_ chargedDevice: ChargedDeviceSummary) -> some View {
        MeterInfoCardView(title: "Insights", tint: tint(for: chargedDevice)) {
            if chargedDevice.isCharger {
                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 {
        if chargedDevice.hasMultipleChargingStateModes {
            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 {
            MeterInfoRowView(
                label: "Wireless Profile",
                value: chargedDevice.wirelessChargingProfile.title
            )
        }

        ForEach(completionSessionKinds(for: chargedDevice), id: \.rawValue) { sessionKind in
            MeterInfoRowView(
                label: completionCurrentLabel(for: chargedDevice, sessionKind: sessionKind),
                value: completionCurrentDescription(for: chargedDevice, sessionKind: sessionKind)
            )
        }
        MeterInfoRowView(
            label: "Estimated Capacity",
            value: chargedDevice.estimatedBatteryCapacityWh.map { "\($0.format(decimalDigits: 2)) Wh" } ?? "Not enough data"
        )
        if let wiredCapacity = chargedDevice.wiredEstimatedBatteryCapacityWh {
            if chargedDevice.hasMultipleChargingTransports {
                MeterInfoRowView(
                    label: "Wired Capacity",
                    value: "\(wiredCapacity.format(decimalDigits: 2)) Wh"
                )
            }
        }
        if let wirelessCapacity = chargedDevice.wirelessEstimatedBatteryCapacityWh {
            if chargedDevice.hasMultipleChargingTransports {
                MeterInfoRowView(
                    label: "Wireless Capacity",
                    value: "\(wirelessCapacity.format(decimalDigits: 2)) Wh"
                )
            }
        }
        if let wirelessEfficiencyFactor = chargedDevice.wirelessChargerEfficiencyFactor,
           chargedDevice.showsWirelessProfileDetails {
            MeterInfoRowView(
                label: "Wireless Efficiency",
                value: "\(Int((wirelessEfficiencyFactor * 100).rounded()))%"
            )
        }
        MeterInfoRowView(
            label: "Charge Sessions",
            value: "\(chargedDevice.sessionCount)"
        )
    }

    @ViewBuilder
    private func chargerInsights(_ chargedDevice: ChargedDeviceSummary) -> some View {
        if let chargerType = chargedDevice.chargerType {
            MeterInfoRowView(
                label: "Type",
                value: chargerType.title
            )
        }
        if !chargedDevice.chargerObservedVoltageSelections.isEmpty {
            MeterInfoRowView(
                label: "Observed Voltages",
                value: chargedDevice.chargerObservedVoltageSelections
                    .map { "\($0.format(decimalDigits: 1)) V" }
                    .joined(separator: ", ")
            )
        }
        if let chargerIdleCurrentAmps = chargedDevice.chargerIdleCurrentAmps {
            MeterInfoRowView(
                label: "Idle Current",
                value: "\(chargerIdleCurrentAmps.format(decimalDigits: 2)) A"
            )
        }
        if let chargerEfficiencyFactor = chargedDevice.chargerEfficiencyFactor {
            MeterInfoRowView(
                label: "Efficiency",
                value: "\(Int((chargerEfficiencyFactor * 100).rounded()))%"
            )
        }
        if let chargerMaximumPowerWatts = chargedDevice.chargerMaximumPowerWatts {
            MeterInfoRowView(
                label: "Max Power",
                value: "\(chargerMaximumPowerWatts.format(decimalDigits: 2)) W"
            )
        }
        if let latestStandbyPowerMeasurement = chargedDevice.latestStandbyPowerMeasurement {
            MeterInfoRowView(
                label: "Standby Power",
                value: "\(latestStandbyPowerMeasurement.averagePowerWatts.format(decimalDigits: 3)) W"
            )
            MeterInfoRowView(
                label: "Standby Projection",
                value: standbyEnergyLabel(latestStandbyPowerMeasurement.projectedYearlyEnergyWh) + " / year"
            )
        }
        MeterInfoRowView(
            label: "Wireless Sessions",
            value: "\(chargedDevice.sessionCount)"
        )

    }

    private func standbyPowerCard(_ chargedDevice: ChargedDeviceSummary) -> some View {
        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)
            }
        }
    }

    private func activeSessionSummaryCard(
        _ activeSession: ChargeSessionSummary,
        chargedDevice: ChargedDeviceSummary
    ) -> some View {
        NavigationLink(
            destination: ChargeSessionDetailView(
                chargedDeviceID: chargedDevice.id,
                sessionID: activeSession.id
            )
        ) {
            VStack(alignment: .leading, spacing: 14) {
                HStack(alignment: .firstTextBaseline) {
                    VStack(alignment: .leading, spacing: 4) {
                        Text("Current Session")
                            .font(.headline)
                            .foregroundColor(.primary)
                        Text(activeSession.status.title)
                            .font(.caption.weight(.semibold))
                            .foregroundColor(statusTint(for: activeSession))
                    }

                    Spacer()

                    Image(systemName: "chevron.right")
                        .font(.caption.weight(.semibold))
                        .foregroundColor(.secondary)
                }

                LazyVGrid(columns: activeSessionSummaryColumns, spacing: 8) {
                    activeSessionMetricCell(
                        label: "Energy",
                        value: "\(activeSession.effectiveOrMeasuredEnergyWh.format(decimalDigits: 2)) Wh",
                        tint: .teal
                    )
                    activeSessionMetricCell(
                        label: "Duration",
                        value: sessionDurationText(activeSession),
                        tint: .orange
                    )
                    if let maximumObservedPowerWatts = activeSession.maximumObservedPowerWatts {
                        activeSessionMetricCell(
                            label: "Max Power",
                            value: "\(maximumObservedPowerWatts.format(decimalDigits: 2)) W",
                            tint: .blue
                        )
                    }
                    if let batteryPrediction = chargedDevice.batteryLevelPrediction(for: activeSession) {
                        activeSessionMetricCell(
                            label: "Battery",
                            value: "\(batteryPrediction.predictedPercent.format(decimalDigits: 0))%",
                            tint: .green
                        )
                    } else if let targetBatteryPercent = activeSession.targetBatteryPercent {
                        activeSessionMetricCell(
                            label: "Target",
                            value: "\(targetBatteryPercent.format(decimalDigits: 0))%",
                            tint: .indigo
                        )
                    }
                }

                Text("Started \(activeSession.startedAt.format())")
                    .font(.caption)
                    .foregroundColor(.secondary)
            }
        }
        .buttonStyle(.plain)
        .padding(18)
        .meterCard(tint: statusTint(for: activeSession), fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 18)
    }

    private var activeSessionSummaryColumns: [GridItem] {
        [
            GridItem(.flexible(minimum: 92), spacing: 8),
            GridItem(.flexible(minimum: 92), spacing: 8)
        ]
    }

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

    private func 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()
                    if chargedDevice.shouldShowChargingTransport(point.chargingTransportMode) {
                        Text(point.chargingTransportMode.title)
                            .font(.caption2)
                            .foregroundColor(.secondary)
                        Text("•")
                            .foregroundColor(.secondary)
                    }
                    Text("\(point.capacityWh.format(decimalDigits: 2)) Wh")
                        .font(.footnote.weight(.semibold))
                }
            }
        }
        .frame(maxWidth: .infinity, alignment: .leading)
        .padding(18)
        .meterCard(tint: .orange, fillOpacity: 0.14, strokeOpacity: 0.20, 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)
    }

    private func sessionListCard(
        _ sessions: [ChargeSessionSummary],
        chargedDevice: ChargedDeviceSummary
    ) -> some View {
        let totalEnergyWh = sessions.reduce(0) { $0 + $1.effectiveOrMeasuredEnergyWh }
        let completedCount = sessions.filter { $0.status == .completed }.count
        let sortedSessions = sessions.sorted { $0.startedAt > $1.startedAt }

        return VStack(alignment: .leading, spacing: 14) {
            MeterInfoCardView(title: "Closed Sessions", tint: .teal) {
                MeterInfoRowView(label: "Sessions", value: "\(sessions.count)")
                MeterInfoRowView(label: "Completed", value: "\(completedCount)")
                MeterInfoRowView(label: "Total Energy", value: "\(totalEnergyWh.format(decimalDigits: 2)) Wh")
            }

            HStack(spacing: 12) {
                if sessionSelectMode && !selectedSessionIDs.isEmpty {
                    Text("\(selectedSessionIDs.count) selected")
                        .font(.subheadline)
                        .foregroundColor(.secondary)
                        .transition(.opacity.combined(with: .move(edge: .leading)))
                }
                Spacer()
                if sessionSelectMode && !selectedSessionIDs.isEmpty {
                    Button {
                        pendingBatchDeletion = true
                    } label: {
                        Image(systemName: "trash")
                            .foregroundColor(.red)
                    }
                    .transition(.opacity.combined(with: .scale))
                }
                Button(sessionSelectMode ? "Cancel" : "Select") {
                    withAnimation(.easeInOut(duration: 0.2)) {
                        sessionSelectMode.toggle()
                        if !sessionSelectMode { selectedSessionIDs.removeAll() }
                    }
                }
            }
            .animation(.easeInOut(duration: 0.2), value: sessionSelectMode)
            .animation(.easeInOut(duration: 0.2), value: selectedSessionIDs.isEmpty)

            VStack(spacing: 10) {
                ForEach(sortedSessions, id: \.id) { session in
                    sessionListItem(session, chargedDevice: chargedDevice)
                }
            }
        }
    }

    private func sessionListItem(
        _ session: ChargeSessionSummary,
        chargedDevice: ChargedDeviceSummary
    ) -> some View {
        let sessionTint = statusTint(for: session)
        let isOpen = session.status.isOpen
        let isSelected = selectedSessionIDs.contains(session.id)

        return Group {
            if sessionSelectMode && !isOpen {
                Button {
                    withAnimation(.easeInOut(duration: 0.15)) {
                        if isSelected { selectedSessionIDs.remove(session.id) }
                        else          { selectedSessionIDs.insert(session.id) }
                    }
                } label: {
                    sessionRowContent(session, sessionTint: sessionTint, isOpen: isOpen, isSelected: isSelected)
                }
                .buttonStyle(.plain)
            } else {
                NavigationLink(
                    destination: ChargeSessionDetailView(
                        chargedDeviceID: chargedDevice.id,
                        sessionID: session.id
                    )
                ) {
                    sessionRowContent(session, sessionTint: sessionTint, isOpen: isOpen, isSelected: false)
                }
                .buttonStyle(.plain)
            }
        }
    }

    private func sessionRowContent(
        _ session: ChargeSessionSummary,
        sessionTint: Color,
        isOpen: Bool,
        isSelected: Bool
    ) -> some View {
        VStack(alignment: .leading, spacing: 10) {
            HStack(alignment: .firstTextBaseline, spacing: 10) {
                if sessionSelectMode {
                    Group {
                        if isOpen {
                            Image(systemName: "minus.circle")
                                .foregroundColor(.secondary.opacity(0.35))
                        } else {
                            Image(systemName: isSelected ? "checkmark.circle.fill" : "circle")
                                .foregroundColor(isSelected ? .teal : .secondary)
                        }
                    }
                    .font(.body)
                    .transition(.opacity)
                }

                VStack(alignment: .leading, spacing: 2) {
                    Text(session.startedAt.format())
                        .font(.subheadline.weight(.semibold))
                    Text(session.status.title)
                        .font(.caption2)
                        .foregroundColor(sessionTint)
                }

                Spacer()

                VStack(alignment: .trailing, spacing: 2) {
                    Text("\(session.effectiveOrMeasuredEnergyWh.format(decimalDigits: 2)) Wh")
                        .font(.subheadline.weight(.semibold))
                        .foregroundColor(.primary)
                    Text(sessionDurationText(session))
                        .font(.caption)
                        .foregroundColor(.secondary)
                }
            }

            Divider()

            HStack(spacing: 8) {
                if let batteryDelta = session.batteryDeltaPercent {
                    Label("\(batteryDelta >= 0 ? "+" : "")\(Int(batteryDelta.rounded()))% charged", systemImage: "battery.100percent")
                        .font(.caption2)
                        .foregroundColor(.secondary)
                }

                if let capacityWh = session.capacityEstimateWh {
                    Text("est. \(capacityWh.format(decimalDigits: 1)) Wh")
                        .font(.caption2)
                        .foregroundColor(.secondary)
                }

                Spacer()

                if !session.displayedAggregatedSamples.isEmpty {
                    Label("\(session.displayedAggregatedSamples.count) points", systemImage: "chart.xyaxis.line")
                        .font(.caption2)
                        .foregroundColor(.secondary)
                }
            }
        }
        .padding(12)
        .meterCard(
            tint: sessionTint,
            fillOpacity: isSelected ? 0.16 : (isOpen ? 0.14 : 0.08),
            strokeOpacity: isSelected ? 0.22 : (isOpen ? 0.30 : 0.14),
            cornerRadius: 14
        )
    }

    private func closedSessions(for chargedDevice: ChargedDeviceSummary) -> [ChargeSessionSummary] {
        chargedDevice.sessions.filter { !$0.status.isOpen }
    }

    private func availableTabs(for chargedDevice: ChargedDeviceSummary) -> [DetailTab] {
        if chargedDevice.isCharger {
            return [.overview, .standby, .settings]
        }
        return [.overview, .sessions, .trends, .settings]
    }

    private func displayedTab(from tabs: [DetailTab]) -> DetailTab {
        if tabs.contains(selectedTab) {
            return selectedTab
        }
        return tabs.first ?? .overview
    }

    private func ensureSelectedTabExists(for chargedDevice: ChargedDeviceSummary) {
        let tabs = availableTabs(for: chargedDevice)
        if !tabs.contains(selectedTab) {
            selectedTab = tabs.first ?? .overview
        }
    }

    private func title(for tab: DetailTab) -> String {
        switch tab {
        case .overview:
            return "Overview"
        case .standby:
            return "Standby"
        case .sessions:
            return "Sessions"
        case .trends:
            return "Trends"
        case .settings:
            return "Settings"
        }
    }

    private func systemImage(for tab: DetailTab) -> String {
        switch tab {
        case .overview:
            return "house.fill"
        case .standby:
            return "bolt.badge.clock"
        case .sessions:
            return "clock.arrow.trianglehead.counterclockwise.rotate.90"
        case .trends:
            return "chart.xyaxis.line"
        case .settings:
            return "gearshape.fill"
        }
    }

    private func detailBackground(for chargedDevice: ChargedDeviceSummary) -> some View {
        LinearGradient(
            colors: [tint(for: chargedDevice).opacity(0.18), Color.clear],
            startPoint: .topLeading,
            endPoint: .bottomTrailing
        )
        .ignoresSafeArea()
    }

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

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

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

    private func standbyEnergyLabel(_ wattHours: Double) -> String {
        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 }
    }

    private func completionCurrentDescription(
        for chargedDevice: ChargedDeviceSummary,
        sessionKind: ChargeSessionKind
    ) -> String {
        if let configuredCurrent = chargedDevice.configuredCompletionCurrentAmps(for: sessionKind) {
            if let learnedCurrent = chargedDevice.learnedCompletionCurrentAmps(for: sessionKind),
               abs(configuredCurrent - learnedCurrent) >= 0.01 {
                return "\(configuredCurrent.format(decimalDigits: 2)) A configured • \(learnedCurrent.format(decimalDigits: 2)) A learned"
            }
            return "\(configuredCurrent.format(decimalDigits: 2)) A configured"
        }

        if let learnedCurrent = chargedDevice.learnedCompletionCurrentAmps(for: sessionKind) {
            return "\(learnedCurrent.format(decimalDigits: 2)) A learned"
        }

        return "Learning"
    }

    private func completionCurrentLabel(
        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"
        }
    }

    private func completionSessionKinds(for chargedDevice: ChargedDeviceSummary) -> [ChargeSessionKind] {
        chargedDevice.supportedChargingModes.flatMap { chargingTransportMode in
            chargedDevice.supportedChargingStateModes.map { chargingStateMode in
                ChargeSessionKind(
                    chargingTransportMode: chargingTransportMode,
                    chargingStateMode: chargingStateMode
                )
            }
        }
    }

    private func deleteSelectedSessions() {
        for id in selectedSessionIDs {
            _ = appData.deleteChargeSession(sessionID: id)
        }
        selectedSessionIDs.removeAll()
        sessionSelectMode = false
    }

    private func showEditor() {
        editorVisibility = true
    }

    private func showDeleteConfirmation() {
        deleteConfirmationVisibility = true
    }

    private var deletionTitle: String {
        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."
    }

}
