//

//  File.swift

//  USB Meter

//

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

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

//

//MARK: Store and documentation: https://www.aliexpress.com/item/32968303350.html

//MARK: Protocol: https://sigrok.org/wiki/RDTech_UM_series

//MARK: Pithon Code: https://github.com/rfinnie/rdserialtool

//MARK: HM-10 Code: https://github.com/hoiberg/HM10-BluetoothSerial-iOS

//MARK: Package dependency https://github.com/krzyzanowskim/CryptoSwift

import CoreBluetooth

import SwiftUI

/**

 Supprted USB Meters

 # UM25C

 # TC66

 * Reverse Engineering

 [UM Series](https://sigrok.org/wiki/RDTech_UM_series)

 [TC66C](https://sigrok.org/wiki/RDTech_TC66C)

 */

    case UM34C

    case TC66C

}

    case celsius

    case fahrenheit

    var id: String { rawValue }

    var title: String {

        switch self {

        case .celsius:

            return "Celsius"

        case .fahrenheit:

            return "Fahrenheit"

        }

    }

    var symbol: String {

        switch self {

        case .celsius:

            return "℃"

        case .fahrenheit:

            return "℉"

        }

    }

}

    var localeTitle: String {

        switch self {

        case .celsius:

            return "System (Celsius)"

        case .fahrenheit:

            return "System (Fahrenheit)"

        }

    }

}

    case waitingForStart

    case active

    case completed

}

        let sessionID: UUID

        let sampleCount: Int

        let lastSampleTimestamp: Date?

    }

        switch (oldValue, newValue) {

        case (.comunicating, .dataIsAvailable), (.dataIsAvailable, .comunicating):

            return false

        default:

            return true

        }

    }

        case notPresent

        case peripheralNotConnected

        case peripheralConnectionPending

        case peripheralConnected

        case peripheralReady

        case comunicating

        case dataIsAvailable

        static func < (lhs: OperationalState, rhs: OperationalState) -> Bool {

            return lhs.rawValue < rhs.rawValue

        }

    }

    @Published var operationalState = OperationalState.peripheralNotConnected {

        didSet {

                track("\(name) - Operational state changed from \(oldValue) to \(operationalState)")

            }

            case .notPresent:

            case .peripheralNotConnected:

                    track("\(name) - Clearing \(commandQueue.count) queued commands after disconnect")

                    commandQueue.removeAll()

                }

                    track("\(name) - Reconnecting...")

                    btSerial.connect()

                }

            case .peripheralConnectionPending:

            case .peripheralConnected:

            case .peripheralReady:

                break

            case .dataIsAvailable:

                break

            }

        }

    }

    static func operationalColor(for state: OperationalState) -> Color {

        switch state {

        case .notPresent:

            return .red

        case .peripheralNotConnected:

            return .blue

        case .peripheralConnectionPending:

            return .yellow

        case .peripheralConnected:

            return .yellow

        case .peripheralReady:

            return .orange

        case .comunicating:

            return .orange

        case .dataIsAvailable:

            return .green

        }

    }

    private var wdTimer: Timer?

            wdTimer?.invalidate()

            appData.noteMeterSeen(at: lastSeen!, macAddress: btSerial.macAddress.description)

                wdTimer = Timer.scheduledTimer(withTimeInterval: 20, repeats: false, block: {_ in

                    track("\(self.name) - Lost advertisments...")

                    self.operationalState = .notPresent

                })

            } else if operationalState == .notPresent {

               operationalState = .peripheralNotConnected

            }

        }

    }

    var uuid: UUID

    var model: Model

    var modelString: String

    @Published var name: String {

            guard oldValue != name else { return }

            appData.setMeterName(name, for: btSerial.macAddress.description)

    }

    var color : Color {

        get {

    }

        model.capabilities

    }

    var supportsDataGroupCommands: Bool {

        capabilities.supportsRecordingView

    }

    var supportsRecordingThreshold: Bool {

        capabilities.reportsCurrentScreenIndex

    }

    var showsDataGroupEnergy: Bool {

        capabilities.showsDataGroupEnergy

    }

    var highlightsActiveDataGroup: Bool {

        if model == .TC66C {

            return hasObservedActiveDataGroup

        }

        return capabilities.highlightsActiveDataGroup

    }

        model == .TC66C

    }

    }

        capabilities.dataGroupsTitle

    }

        capabilities.documentedWorkingVoltage

    }

        capabilities.chargerTypeDescription(for: chargerTypeIndex)

        if supportsManualTemperatureUnitSelection {

    var primaryTemperatureDescription: String {

    var secondaryTemperatureDescription: String? {

    }

    var displayedTemperatureValue: Double {

        if supportsManualTemperatureUnitSelection {

            return temperatureCelsius

        }

        switch systemTemperatureUnitPreference {

        case .celsius:

            return displayedTemperatureCelsius

        case .fahrenheit:

            return displayedTemperatureFahrenheit

        }

    }

    private var displayedTemperatureCelsius: Double {

        if supportsManualTemperatureUnitSelection {

            switch tc66TemperatureUnitPreference {

            case .celsius:

                return temperatureCelsius

            case .fahrenheit:

                return (temperatureCelsius - 32) * 5 / 9

            }

        }

        return temperatureCelsius

    }

    private var displayedTemperatureFahrenheit: Double {

        if supportsManualTemperatureUnitSelection {

            switch tc66TemperatureUnitPreference {

            case .celsius:

                return (temperatureCelsius * 9 / 5) + 32

            case .fahrenheit:

                return temperatureCelsius

            }

        }

        if supportsFahrenheit, temperatureFahrenheit.isFinite {

            return temperatureFahrenheit

        }

        return (temperatureCelsius * 9 / 5) + 32

    }

    private var systemTemperatureUnitPreference: TemperatureUnitPreference {

        let locale = Locale.autoupdatingCurrent

        if #available(iOS 16.0, *) {

            switch locale.measurementSystem {

            case .us:

                return .fahrenheit

            default:

                return .celsius

            }

        }

        let regionCode = locale.regionCode ?? ""

        let fahrenheitRegions: Set<String> = ["US", "BS", "BZ", "KY", "PW", "LR", "FM", "MH"]

        return fahrenheitRegions.contains(regionCode) ? .fahrenheit : .celsius

            return "Page Controls"

        }

            return "Screen \(currentScreen): \(label)"

        }

        return "Screen \(currentScreen)"

    }

            return reportedModelName

        }

        return model.canonicalName

            return "\(baseName) (\(modelNumber))"

        }

        return baseName

    }

        let totalSeconds = Int(recordingDuration)

        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)

    }

        let totalSeconds = Int(chargeRecordDuration)

        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)

    }

    var chargeRecordTimeRange: ClosedRange<Date>? {

        guard let start = chargeRecordStartTimestamp else { return nil }

        let end = chargeRecordEndTimestamp ?? chargeRecordLastTimestamp

        guard let end else { return nil }

        return start...end

    }

    var chargeRecordStatusText: String {

        switch chargeRecordState {

        case .waitingForStart:

            return "Waiting"

        case .active:

            return "Active"

        case .completed:

            return "Completed"

        }

    }

    var chargeRecordStatusColor: Color {

        switch chargeRecordState {

        case .waitingForStart:

            return .secondary

        case .active:

            return .red

        case .completed:

            return .green

        }

    }

            if hasObservedActiveDataGroup {

                return "The active memory is inferred from the totals that are currently increasing."

            }

            return "The device exposes two read-only memories. The active memory is inferred once one total starts increasing."

        }

        return capabilities.dataGroupsHint

    }

    func dataGroupLabel(for id: UInt8) -> String {

        supportsDataGroupCommands ? "\(id)" : "M\(Int(id) + 1)"

    var recordingThresholdHint: String? {

        capabilities.recordingThresholdHint

    }

    let chargeRecordMeasurements = Measurements()

    private var dataDumpRequestTimestamp = Date()

    class DataGroupRecord {

        var wh: Double

            self.ah = ah

            self.wh = wh

        }

    }

    private(set) var dataGroupRecords: [Int : DataGroupRecord] = [:]

    private(set) var chargeRecordAH: Double = 0

    private(set) var chargeRecordWH: Double = 0

    private(set) var chargeRecordDuration: TimeInterval = 0

    @Published var tc66TemperatureUnitPreference: TemperatureUnitPreference = .celsius {

        didSet {

            guard supportsManualTemperatureUnitSelection else { return }

            guard oldValue != tc66TemperatureUnitPreference else { return }

    }

    @Published var screenBrightness: Int = -1 {

        didSet {

            if oldValue != screenBrightness {

                screenBrightnessTimestamp = Date()

                if oldValue != -1 {

                    setSceeenBrightness(to: UInt8(screenBrightness))

                }

            }

        }

    }

    private var screenBrightnessTimestamp = Date()

    @Published var screenTimeout: Int = -1 {

        didSet {

            if oldValue != screenTimeout {

                screenTimeoutTimestamp = Date()

                if oldValue != -1 {

                    setScreenSaverTimeout(to: UInt8(screenTimeout))

                }

            }

        }

    }

    private var screenTimeoutTimestamp = Date()

    private(set) var current: Double = 0

    private(set) var power: Double = 0

    private(set) var temperatureCelsius: Double = 0

    private(set) var temperatureFahrenheit: Double = 0

    private(set) var usbPlusVoltage: Double = 0

    private(set) var usbMinusVoltage: Double = 0

    private(set) var recordedAH: Double = 0

    private(set) var recordedWH: Double = 0

    private(set) var recording: Bool = false

            if isApplyingRecordingThresholdFromDevice {

                return

            guard recordingThresholdLoadedFromDevice else { return }

            setrecordingTreshold(to: (recordingTreshold * 100).uInt8Value)

    private(set) var recordingDuration: UInt32 = 0

    private(set) var loadResistance: Double = 0

    private(set) var modelNumber: UInt16 = 0

    private(set) var chargerTypeIndex: UInt16 = 0

    private(set) var reportedModelName: String = ""

    private(set) var firmwareVersion: String = ""

    private(set) var serialNumber: UInt32 = 0

    private(set) var bootCount: UInt32 = 0

    private var recordingThresholdLoadedFromDevice = false

    private var isApplyingRecordingThresholdFromDevice = false

    private var chargeRecordEndTimestamp: Date?

    private var chargeRecordLastTimestamp: Date?

    private var chargeRecordLastCurrent: Double = 0

    private var chargeRecordLastPower: Double = 0

    private let initiatedVolatileMemoryResetGraceWindow: TimeInterval = 12

    private var hasSeenUMSnapshot = false

    private var hasSeenTC66Snapshot = false

    private var pendingVolatileMemoryResetDeadline: Date?

    private func setIfChanged<T: Equatable>(_ keyPath: ReferenceWritableKeyPath<Meter, T>, to value: T) -> Bool {

        guard self[keyPath: keyPath] != value else { return false }

        self[keyPath: keyPath] = value

        liveDataChanged = true

        return true

    }

    private func updateDataGroupRecord(index: Int, ah: Double, wh: Double) {

        if let existing = dataGroupRecords[index] {

            if existing.ah != ah { existing.ah = ah; liveDataChanged = true }

            if existing.wh != wh { existing.wh = wh; liveDataChanged = true }

        } else {

            dataGroupRecords[index] = DataGroupRecord(ah: ah, wh: wh)

            liveDataChanged = true

        }

    }

        uuid = serialPort.peripheral.identifier

        //dataStore.meterUUIDS.append(serialPort.peripheral.identifier)

        modelString = serialPort.peripheral.name!

        self.model = model

        btSerial = serialPort

        lastConnectedAt = appData.lastConnected(for: serialPort.macAddress.description)

        btSerial.delegate = self

        for index in stride(from: 0, through: 9, by: 1) {

            dataGroupRecords[index] = DataGroupRecord(ah:0, wh: 0)

        }

    }

    func reloadTemperatureUnitPreference() {

        guard supportsManualTemperatureUnitSelection else { return }

            tc66TemperatureUnitPreference = persistedPreference

        }

    }

        guard newName != name else { return }

        isSyncingNameFromStore = true

        name = newName

        isSyncingNameFromStore = false

    }

        lastConnectedAt = date

        appData.noteMeterConnected(at: date, macAddress: btSerial.macAddress.description)

    }

        measurements.markDiscontinuity(at: timestamp)

        guard chargeRecordState == .active else { return }

        chargeRecordLastTimestamp = nil

        chargeRecordLastCurrent = 0

        chargeRecordLastPower = 0

    }

        guard showsDataGroupEnergy else { return nil }

        if model == .TC66C && !hasObservedActiveDataGroup {

            return nil

        }

        let groupID = selectedDataGroup

        guard let record = dataGroupRecords[Int(groupID)] else { return nil }

        return (groupID, record.wh)

    }

        guard showsDataGroupEnergy else { return nil }

        if model == .TC66C && !hasObservedActiveDataGroup {

            return nil

        }

        let groupID = selectedDataGroup

        guard let record = dataGroupRecords[Int(groupID)] else { return nil }

        return (groupID, record.ah)

    }

    func chargingMonitorSnapshot(at observedAt: Date) -> ChargingMonitorSnapshot? {

        let nativeChargeCounter = usesNativeRecordingCounters ? recordedAH : nil

        let nativeEnergyCounter = usesNativeRecordingCounters ? recordedWH : nil

        return ChargingMonitorSnapshot(

            meterName: name,

            meterModel: deviceModelSummary,

            observedAt: observedAt,

            voltageVolts: voltage,

            currentAmps: current,

            powerWatts: power,

            meterChargeCounterAh: nativeChargeCounter ?? currentChargeSample()?.value,

            meterEnergyCounterWh: nativeEnergyCounter ?? currentEnergySample()?.value,

    }

        guard supportsRecordingView else { return nil }

        guard let lastRecorderObservationAt else { return nil }

        return lastRecorderObservationAt.addingTimeInterval(-TimeInterval(recordingDuration))

    }

        chargingMonitorSnapshot(at: Date())

    }

        guard let pendingDataDumpWorkItem else { return }

        track("\(name) - Cancel scheduled data request (\(reason))")

        pendingDataDumpWorkItem.cancel()

        self.pendingDataDumpWorkItem = nil

    }

    private func scheduleDataDumpRequest(after delay: TimeInterval, reason: String) {

        cancelPendingDataDumpRequest(reason: "reschedule")

        let workItem = DispatchWorkItem { [weak self] in

            guard let self else { return }

            self.pendingDataDumpWorkItem = nil

            self.dataDumpRequest()

        }

        pendingDataDumpWorkItem = workItem

        track("\(name) - Schedule data request in \(String(format: "%.2f", delay))s (\(reason))")

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

    }

        let elapsedSinceLastRequest = Date().timeIntervalSince(dataDumpRequestTimestamp)

        let delay = max(minimumLivePollingInterval - elapsedSinceLastRequest, 0)

        scheduleDataDumpRequest(after: delay, reason: "continuous live polling")

    }

        guard groupID == 0 else { return }

        pendingVolatileMemoryResetIgnoreCount += 1

        pendingVolatileMemoryResetDeadline = Date().addingTimeInterval(initiatedVolatileMemoryResetGraceWindow)

        track("\(name) - Will ignore the next volatile memory drop caused by an app reset request.")

    }

    private func pendingInitiatedVolatileMemoryResetIsActive(at timestamp: Date) -> Bool {

        guard let pendingVolatileMemoryResetDeadline else { return false }

        guard pendingVolatileMemoryResetIgnoreCount > 0 else {

            self.pendingVolatileMemoryResetDeadline = nil

            return false

        }

        guard timestamp <= pendingVolatileMemoryResetDeadline else {

            track("\(name) - Expiring stale volatile memory reset ignore state.")

            pendingVolatileMemoryResetIgnoreCount = 0

            self.pendingVolatileMemoryResetDeadline = nil

            return false

        }

        return true

    }

    private func shouldIgnoreVolatileMemoryDrop(at timestamp: Date) -> Bool {

        guard pendingInitiatedVolatileMemoryResetIsActive(at: timestamp) else { return false }

        pendingVolatileMemoryResetIgnoreCount -= 1

        if pendingVolatileMemoryResetIgnoreCount == 0 {

            pendingVolatileMemoryResetDeadline = nil

        }

        track("\(name) - Ignoring volatile memory drop after an app-initiated reset.")

        return true

    }

    private func didUMVolatileMemoryDecrease(in snapshot: UMSnapshot) -> Bool {

        guard hasSeenUMSnapshot else { return false }

        guard let previousRecord = dataGroupRecords[0], let nextRecord = snapshot.dataGroupRecords[0] else {

            return false

        }

        return nextRecord.ah < (previousRecord.ah - volatileMemoryDecreaseEpsilon)

            || nextRecord.wh < (previousRecord.wh - volatileMemoryDecreaseEpsilon)

    }

    private func didUMDeviceReboot(with snapshot: UMSnapshot, at timestamp: Date) -> Bool {

        defer { hasSeenUMSnapshot = true }

        guard didUMVolatileMemoryDecrease(in: snapshot) else { return false }

        guard !shouldIgnoreVolatileMemoryDrop(at: timestamp) else { return false }

        track("\(name) - Inferred UM reboot because volatile memory dropped.")

        return true

    }

    private func didTC66DeviceReboot(with snapshot: TC66Snapshot) -> Bool {

        guard hasSeenTC66Snapshot else { return false }

        guard snapshot.bootCount != bootCount else { return false }

        track("\(name) - Inferred TC66 reboot because bootCount changed from \(bootCount) to \(snapshot.bootCount).")

        return true

    }

    private func updateChargerTypeLatch(observedIndex: UInt16, didDetectDeviceReset: Bool) {

        if didDetectDeviceReset, chargerTypeIndex != 0 {

        guard supportsChargerDetection else { return }

        if chargerTypeIndex == 0 {

        }

        guard observedIndex != 0, observedIndex != chargerTypeIndex else { return }

        track("\(name) - Ignoring charger type change from \(chargerTypeIndex) to \(observedIndex) until the device reboots.")

    }

    func dataDumpRequest() {

            track("\(name) - Skip data request while state is \(operationalState)")

            return

        }

            switch model {

            case .UM25C:

            dataDumpRequestTimestamp = Date()

            // track("\(name) - Request sent!")

        } else {

            track("Request delayed for: \(commandQueue.first!.hexEncodedStringValue)")

            btSerial.write( commandQueue.first! )

            commandQueue.removeFirst()

    }

    /**

     received data parser

     - parameter buffer cotains response for data dump request

     - Decription metod for TC66C AES ECB response  found [here](https:github.com/krzyzanowskim/CryptoSwift/issues/693)

     */

    func parseData ( from buffer: Data) {

        //track("\(name)")

        case .UM25C:

                apply(umSnapshot: try UMProtocol.parseSnapshot(from: buffer, model: model))

            } catch {

                track("\(name) - Error: \(error)")

            }

                apply(umSnapshot: try UMProtocol.parseSnapshot(from: buffer, model: model))

            } catch {

                track("\(name) - Error: \(error)")

            }

                apply(tc66Snapshot: try TC66Protocol.parseSnapshot(from: buffer))

            } catch {

                track("\(name) - Error: \(error)")

            }

        if chargeRecordState != .waitingForStart {

            captureLiveMeasurements(at: dataDumpRequestTimestamp, in: chargeRecordMeasurements)

//            //track("\(name) - Scheduled new request.")

//        }

            operationalState = .dataIsAvailable

        } else if liveDataChanged {

            objectWillChange.send()

        }

        setIfChanged(\.voltage, to: snapshot.voltage)

        setIfChanged(\.current, to: snapshot.current)

        setIfChanged(\.power, to: snapshot.power)

        setIfChanged(\.temperatureCelsius, to: snapshot.temperatureCelsius)

        setIfChanged(\.temperatureFahrenheit, to: snapshot.temperatureFahrenheit)

        setIfChanged(\.selectedDataGroup, to: snapshot.selectedDataGroup)

        setIfChanged(\.usbMinusVoltage, to: snapshot.usbMinusVoltage)

        setIfChanged(\.recordedWH, to: snapshot.recordedWH)

        if recordingThresholdTimestamp < dataDumpRequestTimestamp || !recordingThresholdLoadedFromDevice {

            recordingThresholdLoadedFromDevice = true

            if recordingTreshold != snapshot.recordingThreshold {

                isApplyingRecordingThresholdFromDevice = true

                recordingTreshold = snapshot.recordingThreshold

                isApplyingRecordingThresholdFromDevice = false

            }

        } else {

            track("\(name) - Skip updating recordingThreshold (changed after request).")

        }

        setIfChanged(\.recording, to: snapshot.recording)

                screenTimeout = snapshot.screenTimeout

        } else {

            track("\(name) - Skip updating screenTimeout (changed after request).")

        }

        if screenBrightnessTimestamp < dataDumpRequestTimestamp {

                screenBrightness = snapshot.screenBrightness

        } else {

            track("\(name) - Skip updating screenBrightness (changed after request).")

        }

        setIfChanged(\.loadResistance, to: snapshot.loadResistance)

            inferTC66ActiveDataGroup(from: snapshot)

        } else {

            hasSeenTC66Snapshot = true

        }

        setIfChanged(\.firmwareVersion, to: snapshot.firmwareVersion)

        setIfChanged(\.serialNumber, to: snapshot.serialNumber)

        setIfChanged(\.bootCount, to: snapshot.bootCount)

        setIfChanged(\.current, to: snapshot.current)

        setIfChanged(\.power, to: snapshot.power)

        setIfChanged(\.loadResistance, to: snapshot.loadResistance)

        setIfChanged(\.usbPlusVoltage, to: snapshot.usbPlusVoltage)

        setIfChanged(\.usbMinusVoltage, to: snapshot.usbMinusVoltage)

    private func inferTC66ActiveDataGroup(from snapshot: TC66Snapshot) {

        let candidate = snapshot.dataGroupRecords.compactMap { entry -> (UInt8, Double)? in

            let index = entry.key

            let record = entry.value

            guard let previous = dataGroupRecords[index] else { return nil }

            let deltaAH = max(record.ah - previous.ah, 0)

            let deltaWH = max(record.wh - previous.wh, 0)

            let score = deltaAH + deltaWH

            guard score > 0 else { return nil }

            return (UInt8(index), score)

        }

        .max { lhs, rhs in lhs.1 < rhs.1 }

        if let candidate {

            selectedDataGroup = candidate.0

            hasObservedActiveDataGroup = true

        }

    }

    private func updateChargeRecord(at timestamp: Date) {

        switch chargeRecordState {

        case .waitingForStart:

            guard current > chargeRecordStopThreshold else { return }

            chargeRecordState = .active

            chargeRecordStartTimestamp = timestamp

            chargeRecordEndTimestamp = timestamp

            chargeRecordLastTimestamp = timestamp

            chargeRecordLastCurrent = current

            chargeRecordLastPower = power

        case .active:

            if let lastTimestamp = chargeRecordLastTimestamp {

                let deltaSeconds = max(timestamp.timeIntervalSince(lastTimestamp), 0)

                chargeRecordAH += chargeRecordLastCurrent * deltaSeconds / 3600

                chargeRecordWH += chargeRecordLastPower * deltaSeconds / 3600

                chargeRecordDuration += deltaSeconds

            }

            chargeRecordEndTimestamp = timestamp

            chargeRecordLastTimestamp = timestamp

            chargeRecordLastCurrent = current

            chargeRecordLastPower = power

            if current <= chargeRecordStopThreshold {

                chargeRecordState = .completed

            }

        case .completed:

            break

        }

    }

    func resetChargeRecord() {

        chargeRecordAH = 0

        chargeRecordWH = 0

        chargeRecordDuration = 0

        chargeRecordState = .waitingForStart

        chargeRecordStartTimestamp = nil

        chargeRecordEndTimestamp = nil

        chargeRecordLastTimestamp = nil

        chargeRecordLastCurrent = 0

        chargeRecordLastPower = 0

        restoredChargeRecordSignature = nil

        chargeRecordMeasurements.resetSeries()

    func resetChargeRecordGraph() {

        resetChargeRecord()

    }

    func restoreChargeRecordIfNeeded(from activeSession: ChargeSessionSummary) {

        let restoreSignature = ChargeRecordRestoreSignature(

            sessionID: activeSession.id,

            sampleCount: activeSession.aggregatedSamples.count,

            lastSampleTimestamp: activeSession.aggregatedSamples.last?.timestamp

        )

        if restoreSignature != restoredChargeRecordSignature {

            chargeRecordMeasurements.restorePersistedChargeSessionSamplesIfNeeded(

            if activeSession.aggregatedSamples.isEmpty == false {

                restoredChargeRecordSignature = restoreSignature

                didChange = true

            }

        }

        if chargeRecordState != .active {

            chargeRecordState = .active

            didChange = true

        }

        let resolvedChargeAH = max(chargeRecordAH, activeSession.measuredChargeAh)

        if resolvedChargeAH != chargeRecordAH {

            chargeRecordAH = resolvedChargeAH

            didChange = true

        }

        let resolvedChargeWH = max(chargeRecordWH, activeSession.measuredEnergyWh)

        if resolvedChargeWH != chargeRecordWH {

            chargeRecordWH = resolvedChargeWH

            didChange = true

        }

        let resolvedDuration = max(chargeRecordDuration, max(activeSession.effectiveDuration, 0))

        if resolvedDuration != chargeRecordDuration {

            chargeRecordDuration = resolvedDuration

            didChange = true

        }

        if chargeRecordStopThreshold != activeSession.stopThresholdAmps {

            chargeRecordStopThreshold = activeSession.stopThresholdAmps

            didChange = true

        }

        if let chargeRecordStartTimestamp {

            let restoredStart = min(chargeRecordStartTimestamp, activeSession.startedAt)

            if restoredStart != chargeRecordStartTimestamp {

                self.chargeRecordStartTimestamp = restoredStart

                didChange = true

            }

        } else {

            chargeRecordStartTimestamp = activeSession.startedAt

            didChange = true

        }

        if let chargeRecordEndTimestamp {

            let restoredEnd = max(chargeRecordEndTimestamp, activeSession.lastObservedAt)

            if restoredEnd != chargeRecordEndTimestamp {

                self.chargeRecordEndTimestamp = restoredEnd

                didChange = true

            }

        } else {

            chargeRecordEndTimestamp = activeSession.lastObservedAt

            didChange = true

        }

                self.selectedDataGroup = selectedDataGroup

                didChange = true

            }

        if didChange {

            objectWillChange.send()

        }

    }

    private func captureLiveMeasurements(at timestamp: Date, in destination: Measurements) {

        if supportsRecordingView {

            destination.captureEnergyValue(

                timestamp: timestamp,

                value: recordedWH,

                groupID: .max

            )

        } else if let energySample = currentEnergySample() {

            destination.captureEnergyValue(

                timestamp: timestamp,

                value: energySample.value,

                groupID: energySample.groupID

            )

        }

        destination.addValues(

            timestamp: timestamp,

            power: power,

            voltage: voltage,

            current: current,

            temperature: displayedTemperatureValue,

            rssi: Double(btSerial.averageRSSI)

        )

    func restoreChargeMonitoringIfNeeded(from activeSession: ChargeSessionSummary) {

        restoreChargeRecordIfNeeded(from: activeSession)

        guard restoredChargeSessionID != activeSession.id else {

            return

        }

        restoredChargeSessionID = activeSession.id

        enableAutoConnect = true

        guard operationalState < .peripheralConnectionPending else {

            return

        }

        track("\(name) - Restoring active charge session and reconnecting to meter")

        btSerial.connect()

    }

    func nextScreen() {

        switch model {

        case .UM25C:

    }

    func rotateScreen() {

        switch model {

        case .UM25C:

    }

    func previousScreen() {

        switch model {

        case .UM25C: