//

//  DataStore.swift

//  USB Meter

//

//  Created by Bogdan Timofte on 03/03/2020.

//  Copyright © 2020 Bogdan Timofte. All rights reserved.

//

import SwiftUI

import Combine

import CoreBluetooth

import UserNotifications

    let title: String

    let message: String

    var id: String {

        "\(title)\n\(message)"

    }

}

        let displayName: String

        let modelSummary: String

        let advertisedName: String?

        let lastSeen: Date?

        let lastConnected: Date?

        let meter: Meter?

        var id: String {

            macAddress

        }

    }

    private var meterStoreCloudObserver: AnyCancellable?

    private var chargeInsightsRemoteObserver: AnyCancellable?

    private var pendingChargeObservationWorkItems: [String: DispatchWorkItem] = [:]

        label: "ro.xdev.usb-meter.charged-devices-reload",

        qos: .userInitiated

    )

    private var chargedDevicesReloadPending = false

    private let meterPresencePersistInterval: TimeInterval = 15

    private var meterSummariesVersion: Int = 0

            .receive(on: DispatchQueue.main)

            .sink { [weak self] _ in

        meterStoreCloudObserver = NotificationCenter.default.publisher(for: .meterNameStoreCloudStatusDidChange)

            .receive(on: DispatchQueue.main)

            .sink { [weak self] _ in

                self?.scheduleObjectWillChange()

            }

            .receive(on: DispatchQueue.main)

            .sink { [weak self] _ in

                self?.reloadChargedDevices()

            }

        didSet {

            invalidateMeterSummaries()

        }

    }

    var deviceSummaries: [ChargedDeviceSummary] {

        chargedDevices.filter { !$0.isCharger }

    }

    var chargerSummaries: [ChargedDeviceSummary] {

        chargedDevices.filter { $0.isCharger }

    }

    var cloudAvailability: MeterNameStore.CloudAvailability {

        meterStore.currentCloudAvailability

    }

        guard chargeInsightsStore == nil else {

            return

        }

        context.automaticallyMergesChangesFromParent = true

            writeContext.persistentStoreCoordinator = coordinator

            writeContext.automaticallyMergesChangesFromParent = false

            writeContext.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy

            chargeInsightsStore = ChargeInsightsStore(context: writeContext)

            readContext.persistentStoreCoordinator = coordinator

            readContext.automaticallyMergesChangesFromParent = true

            readContext.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy

            chargeInsightsReadStore = ChargeInsightsStore(context: readContext)

                for: .NSManagedObjectContextDidSave,

                object: writeContext

            )

            .sink { [weak self, weak context] notification in

                guard let self, let context else { return }

                context.perform {

                    context.mergeChanges(fromContextDidSave: notification)

                    DispatchQueue.main.async {

                        self.scheduleChargedDevicesReload()

                    }

                }

            }

        } else {

            chargeInsightsStore = ChargeInsightsStore(context: context)

            chargeInsightsReadStore = ChargeInsightsStore(context: context)

            chargeInsightsStoreObserver = NotificationCenter.default.publisher(

                for: .NSManagedObjectContextDidSave,

                object: context

            )

            .receive(on: DispatchQueue.main)

            .sink { [weak self] _ in

                self?.scheduleChargedDevicesReload()

            }

        chargeInsightsRemoteObserver = NotificationCenter.default.publisher(

            for: .NSPersistentStoreRemoteChange,

            object: nil

        )

        .receive(on: DispatchQueue.main)

        .sink { [weak self] _ in

        chargeNotificationCoordinator.ensureAuthorizationIfNeeded()

        reloadChargedDevices()

    }

        meterStore.name(for: macAddress)

    }

    func setMeterName(_ name: String, for macAddress: String) {

        meterStore.upsert(macAddress: macAddress, name: name, temperatureUnitRawValue: nil)

    }

    func temperatureUnitPreference(for macAddress: String) -> TemperatureUnitPreference {

        let rawValue = meterStore.temperatureUnitRawValue(for: macAddress) ?? TemperatureUnitPreference.celsius.rawValue

        return TemperatureUnitPreference(rawValue: rawValue) ?? .celsius

    }

    func setTemperatureUnitPreference(_ preference: TemperatureUnitPreference, for macAddress: String) {

        meterStore.upsert(macAddress: macAddress, name: nil, temperatureUnitRawValue: preference.rawValue)

        meterStore.registerMeter(macAddress: macAddress, modelName: modelName, advertisedName: advertisedName)

    func noteMeterSeen(at date: Date, macAddress: String) {

           date.timeIntervalSince(persistedLastSeen) < meterPresencePersistInterval {

            return

        }

    }

    func noteMeterConnected(at date: Date, macAddress: String) {

        meterStore.noteLastConnected(date, for: macAddress)

    }

    func lastSeen(for macAddress: String) -> Date? {

        meterStore.lastSeen(for: macAddress)

    }

    func lastConnected(for macAddress: String) -> Date? {

        meterStore.lastConnected(for: macAddress)

    }

        chargedDevices.first(where: { $0.id == id })

    }

        for chargedDevice in chargedDevices {

            if let session = chargedDevice.sessions.first(where: { $0.id == id }) {

                return session

            }

        }

        return nil

    }

        let normalizedMAC = meterMACAddress.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()

        return chargedDevices.filter { chargedDevice in

            guard chargedDevice.isCharger == false else {

                return false

            }

            return chargedDevice.lastAssociatedMeterMAC == normalizedMAC

                || chargedDevice.sessions.contains(where: { $0.meterMACAddress == normalizedMAC })

        }

    }

    func chargers(for meterMACAddress: String) -> [ChargedDeviceSummary] {

        let normalizedMAC = meterMACAddress.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()

        return chargedDevices.filter { chargedDevice in

            guard chargedDevice.isCharger else {

                return false

            }

            return chargedDevice.lastAssociatedMeterMAC == normalizedMAC

                || chargedDevice.sessions.contains(where: { $0.meterMACAddress == normalizedMAC })

        }

    }

    func currentChargedDeviceSummary(for meterMACAddress: String) -> ChargedDeviceSummary? {

        let normalizedMAC = meterMACAddress.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()

               $0.id == activeSession.chargedDeviceID && $0.isCharger == false

           }) {

            return liveDevice

        }

        return chargedDevices.first(where: {

            $0.isCharger == false && $0.lastAssociatedMeterMAC == normalizedMAC

        })

    }

    func currentChargerSummary(for meterMACAddress: String) -> ChargedDeviceSummary? {

        let normalizedMAC = meterMACAddress.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()

           let liveCharger = chargedDevices.first(where: {

               $0.id == chargerID && $0.isCharger

           }) {

            return liveCharger

        }

        return chargedDevices.first(where: {

            $0.isCharger && $0.lastAssociatedMeterMAC == normalizedMAC

        })

    }

    func activeChargeSessionSummary(for meterMACAddress: String) -> ChargeSessionSummary? {

        if let cachedSummary = cachedActiveChargeSessionSummary(for: normalizedMAC) {

        }

        activeChargerStandbySessions[Self.normalizedMACAddress(meterMACAddress)]

    }

    @discardableResult

    func startChargerStandbyMeasurement(for chargerID: UUID, on meter: Meter) -> Bool {

        guard chargedDeviceSummary(id: chargerID)?.isCharger == true else {

            return false

        }

        let normalizedMAC = Self.normalizedMACAddress(meter.btSerial.macAddress.description)

        if let existingSession = activeChargerStandbySessions[normalizedMAC] {

            return existingSession.chargerID == chargerID

        }

        let session = ChargerStandbyPowerMonitorSession(chargerID: chargerID, meter: meter)

        session.onChange = { [weak self] in

            self?.scheduleObjectWillChange()

        }

        session.onStabilized = { [weak self, weak session] in

            guard let self, let session else { return }

            self.notifyChargerStandbyMeasurementReady(for: session)

        }

        activeChargerStandbySessions[normalizedMAC] = session

        session.start()

        // Starting a standby run on an available meter should also initiate the BLE link.

        if meter.operationalState == .peripheralNotConnected {

            meter.connect()

        }

        scheduleObjectWillChange()

        return true

    }

    @discardableResult

    func finishChargerStandbyMeasurement(for meterMACAddress: String, save: Bool) -> Bool {

        let normalizedMAC = Self.normalizedMACAddress(meterMACAddress)

        guard let session = activeChargerStandbySessions[normalizedMAC] else {

            return false

        }

        session.stop()

        guard save else {

            activeChargerStandbySessions[normalizedMAC] = nil

            scheduleObjectWillChange()

            return true

        }

        guard let summary = session.makeSummary() else {

            scheduleObjectWillChange()

            return false

        }

        let didSave = chargerStandbyPowerStore.save(summary)

        if didSave {

            activeChargerStandbySessions[normalizedMAC] = nil

            reloadChargedDevices()

        } else {

            scheduleObjectWillChange()

        }

        return didSave

    }

    func deleteChargerStandbyMeasurement(id: UUID, chargerID: UUID) -> Bool {

        let didDelete = chargerStandbyPowerStore.removeMeasurement(id: id, chargerID: chargerID)

        if didDelete {

            reloadChargedDevices()

        } else {

            scheduleObjectWillChange()

        }

        return didDelete

    }

        deviceClass: ChargedDeviceClass,

        supportsWirelessCharging: Bool,

        wirelessChargingProfile: WirelessChargingProfile,

        meterMACAddress: String?

    ) -> Bool {

            deviceClass: deviceClass,

            supportsWirelessCharging: supportsWirelessCharging,

            wirelessChargingProfile: wirelessChargingProfile,

            assignTo: meterMACAddress

        ) ?? false

        if didSave {

            reloadChargedDevices()

        }

        return didSave

    }

    @discardableResult

        name: String,

        meterMACAddress: String?

    ) -> Bool {

        let didSave = chargeInsightsStore?.createCharger(

            name: name,

            assignTo: meterMACAddress

        ) ?? false

        if didSave {

            reloadChargedDevices()

        }

        return didSave

    }

    @discardableResult

    func updateDevice(

        name: String,

        deviceClass: ChargedDeviceClass,

        supportsWirelessCharging: Bool,

        wirelessChargingProfile: WirelessChargingProfile,

    ) -> Bool {

            name: name,

            deviceClass: deviceClass,

            supportsWirelessCharging: supportsWirelessCharging,

            wirelessChargingProfile: wirelessChargingProfile,

        ) ?? false

        if didSave {

            reloadChargedDevices()

        }

        return didSave

    }

    @discardableResult

        id: UUID,

        name: String,

    ) -> Bool {

        let didSave = chargeInsightsStore?.updateCharger(

            id: id,

            name: name,

        if didSave {

            reloadChargedDevices()

        }

        return didSave

    }

    @discardableResult

    func assignChargedDevice(_ chargedDeviceID: UUID, to meterMACAddress: String) -> Bool {

        let didSave = chargeInsightsStore?.assignChargedDevice(id: chargedDeviceID, to: meterMACAddress) ?? false

        if didSave {

            reloadChargedDevices()

        }

        return didSave

    }

    @discardableResult

    func assignCharger(_ chargerID: UUID, to meterMACAddress: String) -> Bool {

        let didSave = chargeInsightsStore?.assignCharger(id: chargerID, to: meterMACAddress) ?? false

        if didSave {

            reloadChargedDevices()

        }

        return didSave

    }

        guard let activeSession = activeChargeSessionSummary(for: meter.btSerial.macAddress.description) else {

            return

        }

        guard activeSession.status == .active else {

            return

        }

        meter.restoreChargeMonitoringIfNeeded(from: activeSession)

    }

        for meter: Meter,

        chargedDeviceID: UUID,

        chargerID: UUID?,

        chargingTransportMode: ChargingTransportMode,

        chargingStateMode: ChargingStateMode,

        autoStopEnabled: Bool,

        startsFromFlatBattery: Bool

            return false

        }

            for: snapshot,

            chargedDeviceID: chargedDeviceID,

            chargerID: chargerID,

            chargingTransportMode: chargingTransportMode,

            chargingStateMode: chargingStateMode,

            autoStopEnabled: autoStopEnabled,

            startsFromFlatBattery: startsFromFlatBattery

        if didSave {

                forMeterMACAddress: meter.btSerial.macAddress.description

            )

            if let activeSession,

               activeSession.stopThresholdAmps > 0 {

                meter.recordingTreshold = activeSession.stopThresholdAmps

            }

                meter.restoreChargeMonitoringIfNeeded(from: activeSession)

            }

            reloadChargedDevices()

        return didSave

    }

    @discardableResult

    func pauseChargeSession(sessionID: UUID, from meter: Meter? = nil) -> Bool {

        let observedAt = meter?.chargingMonitorSnapshot?.observedAt ?? Date()

        if let meter {

            _ = persistChargeSnapshot(from: meter, observedAt: observedAt)

        } else if let meterMACAddress = chargeSessionSummary(id: sessionID)?.meterMACAddress {

            _ = flushPendingChargeObservation(for: meterMACAddress)

        }

        if didSave {

            reloadChargedDevices()

        }

        return didSave

    }

    @discardableResult

    func resumeChargeSession(sessionID: UUID, from meter: Meter? = nil) -> Bool {

        let snapshot = meter?.chargingMonitorSnapshot

        let didSave = chargeInsightsStore?.resumeSession(id: sessionID, snapshot: snapshot) ?? false

        if didSave {

            reloadChargedDevices()

        }

        return didSave

    }

    @discardableResult

            _ = flushPendingChargeObservation(for: meterMACAddress)

        }

            id: sessionID,

    }

    func observeChargeSnapshot(from meter: Meter, observedAt: Date = Date()) {

        guard let snapshot = meter.chargingMonitorSnapshot(at: observedAt) else {

            return

        }

    @discardableResult

        let activeSession = activeChargeSessionSummary(for: meter.btSerial.macAddress.description)

        let checkpointEnergyWh = activeSession.map { displayedSessionEnergyWh(for: $0, on: meter) }

        let checkpointChargeAh = activeSession.map { displayedSessionChargeAh(for: $0, on: meter) }

            percent: percent,

            measuredEnergyWh: checkpointEnergyWh,

            measuredChargeAh: checkpointChargeAh

        if didSave {

            reloadChargedDevices()

        }

        return didSave

    }

    @discardableResult

        guard canAddBatteryCheckpoint(to: sessionID) else {

            return false

        }

            percent: percent,

            for: sessionID

        ) ?? false

        if didSave {

            reloadChargedDevices()

        }

        return didSave

    }

    func addBatteryCheckpoint(

        percent: Double,

        for sessionID: UUID,

        measuredEnergyWh: Double?,

        measuredChargeAh: Double?

    ) -> Bool {

            return false

        }

            percent: percent,

            for: sessionID,

            measuredEnergyWh: measuredEnergyWh,

            measuredChargeAh: measuredChargeAh

        ) ?? false

        if didSave {

            reloadChargedDevices()

        }

        return didSave

    }

        guard let session = chargeSessionSummary(id: sessionID),

              session.status.isOpen,

              let meterMACAddress = session.meterMACAddress else {

            return false

        }

        return meter(for: meterMACAddress) != nil

    }

    func batteryCheckpointCaptureRequirementMessage(for sessionID: UUID) -> String? {

        guard let session = chargeSessionSummary(id: sessionID) else {

            return "Battery checkpoints are available only while the charge session is still active."

        }

        guard session.status.isOpen else {

            return "Battery checkpoints are available only while the charge session is still active."

        }

        guard let meterMACAddress = session.meterMACAddress,

              meter(for: meterMACAddress) != nil else {

            return "Add battery checkpoints only on the device that is actively monitoring this charging session. Devices following the session through iCloud may not have data that is fresh or precise enough."

        }

        return nil

    }

        percent: Double,

        effectiveEnergyWhOverride: Double? = nil

        guard let session = chargeSessionSummary(id: sessionID) else {

            return nil

        }

            percent: percent,

            for: session,

            effectiveEnergyWhOverride: effectiveEnergyWhOverride

        )

    @discardableResult

    func deleteBatteryCheckpoint(checkpointID: UUID, for sessionID: UUID) -> Bool {

        let didDelete = chargeInsightsStore?.deleteBatteryCheckpoint(

            id: checkpointID,

            from: sessionID

        ) ?? false

        if didDelete {

        return didDelete

    }

    func setSessionTrim(sessionID: UUID, start: Date?, end: Date?) -> Bool {

        let didSave = chargeInsightsStore?.setSessionTrim(

            sessionID: sessionID,

            start: start,

            end: end

        ) ?? false

        if didSave {

            reloadChargedDevices()

        }

        return didSave

    }

    func flushChargeInsights() -> Bool {

            reloadChargedDevices()

        }

        return didFlushObservations || didSave

    @discardableResult

    func setTargetBatteryPercent(_ percent: Double?, for meter: Meter) -> Bool {

        guard let activeSession = activeChargeSessionSummary(for: meter.btSerial.macAddress.description) else {

            return false

        }

        return setTargetBatteryPercent(percent, for: activeSession.id)

    }

    @discardableResult

    func setTargetBatteryPercent(_ percent: Double?, for sessionID: UUID) -> Bool {

        if percent != nil {

            chargeNotificationCoordinator.ensureAuthorizationIfNeeded()

        }

        let didSave = chargeInsightsStore?.setTargetBatteryPercent(percent, for: sessionID) ?? false

        if didSave {

            reloadChargedDevices()

        }

        return didSave

    }

    @discardableResult

    func confirmChargeSessionCompletion(sessionID: UUID) -> Bool {

        let didSave = chargeInsightsStore?.confirmCompletion(for: sessionID) ?? false

        if didSave {

            reloadChargedDevices()

        }

        return didSave

    }

    @discardableResult

    func continueChargeSessionMonitoring(sessionID: UUID) -> Bool {

        let didSave = chargeInsightsStore?.continueMonitoringDespiteCompletionContradiction(for: sessionID) ?? false

        if didSave {

            reloadChargedDevices()

        }

        return didSave

    }

    @discardableResult

    func deleteChargeSession(sessionID: UUID) -> Bool {

        let deletedSession = chargedDevices

            .flatMap(\.sessions)

            .first(where: { $0.id == sessionID })

        let didDelete = chargeInsightsStore?.deleteChargeSession(id: sessionID) ?? false

        guard didDelete else {

            return false

        }

           let liveMeter = meter(for: meterMACAddress) {

            liveMeter.resetChargeRecord()

        }

        reloadChargedDevices()

        return true

    }

    @discardableResult

    func deleteChargedDevice(id: UUID) -> Bool {

        let deletedDevice = chargedDeviceSummary(id: id)

        let didDelete = chargeInsightsStore?.deleteChargedDevice(id: id) ?? false

        guard didDelete else {

            return false

        }

            _ = chargerStandbyPowerStore.removeMeasurements(for: id)

            for (meterMACAddress, session) in activeChargerStandbySessions where session.chargerID == id {

                session.stop()

                activeChargerStandbySessions[meterMACAddress] = nil

            }

        }

           let liveMeter = meter(for: meterMACAddress) {

            liveMeter.resetChargeRecord()

        }

        reloadChargedDevices()

        return true

    }

    @discardableResult

    func createKnownMeter(

        macAddress: String,

        customName: String?,

        modelName: String,

        advertisedName: String?

    ) -> Bool {

        let normalizedMAC = Self.normalizedMACAddress(macAddress)

        guard Self.isValidMACAddress(normalizedMAC) else {

            return false

        }

        registerMeter(macAddress: normalizedMAC, modelName: modelName, advertisedName: advertisedName)

        if let customName = customName?.trimmingCharacters(in: .whitespacesAndNewlines), !customName.isEmpty {

            setMeterName(customName, for: normalizedMAC)

        }

        noteMeterSeen(at: Date(), macAddress: normalizedMAC)

        return true

    }

    @discardableResult

    func deleteMeter(macAddress: String) -> Bool {

        let normalizedMAC = Self.normalizedMACAddress(macAddress)

        guard Self.isValidMACAddress(normalizedMAC) else {

            return false

        }

        for meter in meters.values where meter.btSerial.macAddress.description == normalizedMAC {

            meter.disconnect()

        }

        meters = meters.filter { element in

            element.value.btSerial.macAddress.description != normalizedMAC

        }

        let didDelete = meterStore.remove(macAddress: normalizedMAC)

        if didDelete {

            scheduleObjectWillChange()

        }

        return didDelete

    }

            return meterSummariesCache.summaries

        }

        let recordsByMAC = Dictionary(uniqueKeysWithValues: meterStore.allRecords().map { ($0.macAddress, $0) })

        let macAddresses = Set(recordsByMAC.keys).union(liveMetersByMAC.keys)

            let record = recordsByMAC[macAddress]

                lastSeen: liveMeter?.lastSeen ?? record?.lastSeen,

                lastConnected: liveMeter?.lastConnectedAt ?? record?.lastConnected,

                meter: liveMeter

            )

        }

        .sorted { lhs, rhs in

                return true

            }

            if lhs.meter == nil && rhs.meter != nil {

                return false

            }

            if byName != .orderedSame {

                return byName == .orderedAscending

            }

            return lhs.macAddress < rhs.macAddress

        }

        meterSummariesCache = (version: meterSummariesVersion, summaries: summaries)

        return summaries

        DispatchQueue.main.async { [weak self] in

            self?.objectWillChange.send()

        }

    }

        meterSummariesVersion += 1

        meterSummariesCache = nil

    }

        pendingChargedDevicesReloadWorkItem?.cancel()

        let workItem = DispatchWorkItem { [weak self] in

            self?.reloadChargedDevices()

        }

        pendingChargedDevicesReloadWorkItem = workItem

        DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: workItem)

    }

        let normalizedMAC = Self.normalizedMACAddress(snapshot.meterMACAddress)

        guard !normalizedMAC.isEmpty else {

            return

        }

        pendingChargeObservationSnapshots[normalizedMAC] = snapshot

        guard scheduleFlush else {

            return

        }

        guard pendingChargeObservationWorkItems[normalizedMAC] == nil else {

            return

        }

        let workItem = DispatchWorkItem { [weak self] in

            guard let self else { return }

            self.pendingChargeObservationWorkItems[normalizedMAC] = nil

            guard let snapshot = self.pendingChargeObservationSnapshots.removeValue(forKey: normalizedMAC) else {

                return

            }

            // CoreData write on background — DidSave observer handles the reload

            let store = self.chargeInsightsStore

            DispatchQueue.global(qos: .utility).async {

                store?.observe(snapshot: snapshot)

            }

        }

        pendingChargeObservationWorkItems[normalizedMAC] = workItem

        DispatchQueue.main.asyncAfter(deadline: .now() + chargeObservationPersistInterval, execute: workItem)

    }

    @discardableResult

    private func persistChargeSnapshot(from meter: Meter, observedAt: Date = Date()) -> Bool {

        guard let snapshot = meter.chargingMonitorSnapshot(at: observedAt) else {

            return false

        }

        stageChargeObservation(snapshot, scheduleFlush: false)

        return flushPendingChargeObservation(for: snapshot.meterMACAddress)

    }

    @discardableResult

    private func flushPendingChargeObservation(for meterMACAddress: String) -> Bool {

        let normalizedMAC = Self.normalizedMACAddress(meterMACAddress)

        guard !normalizedMAC.isEmpty else {

            return false

        }

        pendingChargeObservationWorkItems[normalizedMAC]?.cancel()

        pendingChargeObservationWorkItems[normalizedMAC] = nil

        guard let snapshot = pendingChargeObservationSnapshots.removeValue(forKey: normalizedMAC) else {

            return false

        }

        let didSave = chargeInsightsStore?.observe(snapshot: snapshot) ?? false

        return didSave

    }

    @discardableResult

    private func flushAllPendingChargeObservations() -> Bool {

        let pendingMeterMACAddresses = Array(pendingChargeObservationSnapshots.keys)

        var didSave = false

        for meterMACAddress in pendingMeterMACAddresses {

            if flushPendingChargeObservation(for: meterMACAddress) {

                didSave = true

            }

        }

        return didSave

    }

        let normalizedMAC = Self.normalizedMACAddress(meterMACAddress)

        guard !normalizedMAC.isEmpty else {

            return nil

        }

        return chargedDevices

            .lazy

            .compactMap(\.activeSession)

            DispatchQueue.main.async { [weak self] in

                self?.reloadChargedDevices()

            }

            return

        }

        pendingChargedDevicesReloadWorkItem = nil

            chargedDevicesReloadPending = true

            return

        }

        chargedDevicesReloadPending = false

        chargedDevicesReloadQueue.async { [weak self] in

            guard let self else { return }

            readStore?.resetContext()

            let summaries = (readStore?.fetchChargedDeviceSummaries() ?? []).map { chargedDevice in

                chargedDevice.withStandbyPowerMeasurements(

                    standbyMeasurementsByChargerID[chargedDevice.id] ?? []

                )

            }

            DispatchQueue.main.async { [weak self] in

                guard let self else { return }

                self.chargedDevices = summaries

                self.chargeNotificationCoordinator.process(chargedDevices: self.deviceSummaries)

                for meter in self.meters.values {

                    self.restoreChargeMonitoringStateIfNeeded(for: meter)

                }

                self.chargedDevicesReloadInFlight = false

                if self.chargedDevicesReloadPending {

                    self.reloadChargedDevices()

                }

    }

    private func meter(for meterMACAddress: String) -> Meter? {

        meters.values.first { meter in

            meter.btSerial.macAddress.description == meterMACAddress

        }

    }

        DispatchQueue.main.async { [weak self] in

            guard let self else { return }

            var didUpdateAnyMeter = false

            for meter in self.meters.values {

                let mac = meter.btSerial.macAddress.description

                let displayName = self.meterName(for: mac) ?? mac

                if meter.name != displayName {

                    meter.updateNameFromStore(displayName)

                    didUpdateAnyMeter = true

                }

                let previousTemperaturePreference = meter.tc66TemperatureUnitPreference

                meter.reloadTemperatureUnitPreference()

                if meter.tc66TemperatureUnitPreference != previousTemperaturePreference {

                    didUpdateAnyMeter = true

                }

            }

            if didUpdateAnyMeter {

                self.scheduleObjectWillChange()

            }

        }

    }

        guard let charger = chargedDeviceSummary(id: session.chargerID),

              let statistics = session.statistics else {

            return

        }

        let content = UNMutableNotificationContent()

        content.title = "Standby baseline stabilised"

        content.body = "\(charger.name) is holding around \(statistics.averagePowerWatts.format(decimalDigits: 3)) W. You can save the measurement when ready."

        content.sound = .default

        content.threadIdentifier = "charger-standby-\(charger.id.uuidString)"

        let request = UNNotificationRequest(

            identifier: "charger-standby-\(session.id.uuidString)",

            content: content,

            trigger: nil

        )

        UNUserNotificationCenter.current().add(request)

        scheduleObjectWillChange()

    }

        percent: Double,

        effectiveEnergyWhOverride: Double? = nil

        guard percent.isFinite, percent >= 0, percent <= 100 else {

            return nil

        }

        let sortedCheckpoints = session.checkpoints.sorted { lhs, rhs in

            if lhs.timestamp != rhs.timestamp {

                return lhs.timestamp < rhs.timestamp

            }

            if lhs.measuredEnergyWh != rhs.measuredEnergyWh {

                return lhs.measuredEnergyWh < rhs.measuredEnergyWh

            }

            return lhs.id.uuidString < rhs.id.uuidString

        }

        if let lastCheckpoint = sortedCheckpoints.last,

           percent < lastCheckpoint.batteryPercent - 1.5 {

            return BatteryCheckpointPlausibilityWarning(

                title: "Checkpoint Goes Backwards",

                message: "The latest checkpoint is \(lastCheckpoint.batteryPercent.format(decimalDigits: 0))% at \(lastCheckpoint.timestamp.format()). A new value of \(percent.format(decimalDigits: 0))% is unexpectedly lower while the session is still charging."

            )

        }

            ?? session.effectiveBatteryEnergyWh

            ?? session.measuredEnergyWh

        if let lastCheckpoint = sortedCheckpoints.last,

           let chargedDevice = chargedDeviceSummary(id: session.chargedDeviceID) {

            let estimatedCapacityWh = session.capacityEstimateWh

                ?? chargedDevice.estimatedBatteryCapacityWh(for: session.chargingTransportMode)

                ?? chargedDevice.estimatedBatteryCapacityWh

            if let estimatedCapacityWh, estimatedCapacityWh > 0 {

                let energyDeltaWh = max(effectiveEnergyWh - lastCheckpoint.measuredEnergyWh, 0)

                let expectedPercent = min(

                    100,

                    max(

                        lastCheckpoint.batteryPercent,

                        lastCheckpoint.batteryPercent + (energyDeltaWh / estimatedCapacityWh) * 100

                    )

                )

                let predictionGap = percent - expectedPercent

                guard abs(predictionGap) >= 4 else {

                    return nil

                }

                let direction = predictionGap > 0 ? "above" : "below"

                let gapText = abs(predictionGap).format(decimalDigits: 0)

                let expectedText = expectedPercent.format(decimalDigits: 0)