//

//  ChargerStandbyPowerStore.swift

//  USB Meter

//

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

//

import Foundation

final class ChargerStandbyPowerStore {

    private struct Snapshot: Codable {

        var measurements: [ChargerStandbyPowerMeasurementSummary]

    }

        static let cloudMeasurements = "ChargerStandbyPowerStore.measurements"

    }

    private let fileURL: URL

    private let encoder: JSONEncoder

    private let decoder: JSONDecoder

    private let workQueue = DispatchQueue(label: "ChargerStandbyPowerStore.Queue")

    private var ubiquitousObserver: NSObjectProtocol?

    private var ubiquityIdentityObserver: NSObjectProtocol?

    private var cachedMeasurements: [ChargerStandbyPowerMeasurementSummary]?

    init(fileManager: FileManager = .default) {

        self.fileManager = fileManager

        let applicationSupportURL = fileManager.urls(for: .applicationSupportDirectory, in: .userDomainMask).first

            ?? fileManager.urls(for: .documentDirectory, in: .userDomainMask).first

            ?? URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)

        let directoryURL = applicationSupportURL.appendingPathComponent("ChargeInsights", isDirectory: true)

        fileURL = directoryURL.appendingPathComponent("charger-standby-power.json", isDirectory: false)

        encoder = JSONEncoder()

        encoder.outputFormatting = [.prettyPrinted, .sortedKeys]

        encoder.dateEncodingStrategy = .iso8601

        decoder = JSONDecoder()

        decoder.dateDecodingStrategy = .iso8601

        ubiquitousObserver = NotificationCenter.default.addObserver(

            forName: NSUbiquitousKeyValueStore.didChangeExternallyNotification,

            object: ubiquitousStore,

            queue: nil

        ) { [weak self] notification in

            self?.handleUbiquitousStoreChange(notification)

        }

        ubiquityIdentityObserver = NotificationCenter.default.addObserver(

            forName: NSNotification.Name.NSUbiquityIdentityDidChange,

            object: nil,

            queue: nil

        ) { [weak self] _ in

            self?.syncLocalValuesToCloudIfPossible(reason: "identity-changed")

        }

        ubiquitousStore.synchronize()

        syncLocalValuesToCloudIfPossible(reason: "startup")

    func measurementsByChargerID() -> [UUID: [ChargerStandbyPowerMeasurementSummary]] {

        Dictionary(grouping: loadMeasurements()) { $0.chargerID }

            .mapValues { measurements in

                measurements.sorted { lhs, rhs in

                    if lhs.endedAt != rhs.endedAt {

                        return lhs.endedAt > rhs.endedAt

                    }

                    return lhs.id.uuidString > rhs.id.uuidString

                }

            }

    }

    @discardableResult

    func save(_ measurement: ChargerStandbyPowerMeasurementSummary) -> Bool {

        var measurements = loadMeasurements()

        measurements.append(measurement)

        measurements.sort { lhs, rhs in

            if lhs.endedAt != rhs.endedAt {

                return lhs.endedAt > rhs.endedAt

            }

            return lhs.id.uuidString > rhs.id.uuidString

        }

        return persist(measurements)

    }

    @discardableResult

    func removeMeasurements(for chargerID: UUID) -> Bool {

        let previousMeasurements = loadMeasurements()

        let filteredMeasurements = previousMeasurements.filter { $0.chargerID != chargerID }

        guard filteredMeasurements.count != previousMeasurements.count else {

            return true

        }

        return persist(filteredMeasurements)

    }

    func removeMeasurement(id: UUID, chargerID: UUID? = nil) -> Bool {

        let previousMeasurements = loadMeasurements()

        let filteredMeasurements = previousMeasurements.filter { measurement in

            guard measurement.id == id else {

                return true

            }

            if let chargerID {

                return measurement.chargerID != chargerID

            }

            return false

        }

        guard filteredMeasurements.count != previousMeasurements.count else {

            return true

        }

        return persist(filteredMeasurements)

    }

        if let cachedMeasurements {

            return cachedMeasurements

        }

        let cloudMeasurements = loadCloudMeasurements()

        let mergedMeasurements = merge(localMeasurements: localMeasurements, cloudMeasurements: cloudMeasurements)

        cachedMeasurements = mergedMeasurements

        return mergedMeasurements

    }

    private func loadLocalMeasurements() -> [ChargerStandbyPowerMeasurementSummary] {

            return []

        }

        do {

            let data = try Data(contentsOf: fileURL)

            let snapshot = try decoder.decode(Snapshot.self, from: data)

            return snapshot.measurements

        } catch {

            track("Failed to load charger standby power history: \(error.localizedDescription)")

        }

    }

    private func loadCloudMeasurements() -> [ChargerStandbyPowerMeasurementSummary] {

        guard isICloudDriveAvailable,

              let data = ubiquitousStore.data(forKey: Keys.cloudMeasurements) else {

            return []

        }

        do {

            let snapshot = try decoder.decode(Snapshot.self, from: data)

            return snapshot.measurements

        } catch {

            track("Failed to decode charger standby power history from iCloud KVS: \(error.localizedDescription)")

        }

    }

    @discardableResult

    private func persist(_ measurements: [ChargerStandbyPowerMeasurementSummary]) -> Bool {

        let didPersistLocal = persistLocally(sortedMeasurements)

        let didPersistCloud = persistToCloudIfPossible(sortedMeasurements)

        if didPersistLocal || didPersistCloud {

            cachedMeasurements = sortedMeasurements

        }

        return didPersistLocal || didPersistCloud

    }

    @discardableResult

    private func persistLocally(_ measurements: [ChargerStandbyPowerMeasurementSummary]) -> Bool {

            try fileManager.createDirectory(

                at: fileURL.deletingLastPathComponent(),

                withIntermediateDirectories: true,

                attributes: nil

            )

            let snapshot = Snapshot(measurements: measurements)

            let data = try encoder.encode(snapshot)

            try data.write(to: fileURL, options: .atomic)

            return true

        } catch {

            track("Failed to save charger standby power history: \(error.localizedDescription)")

            return false

        }

    }

    @discardableResult

    private func persistToCloudIfPossible(_ measurements: [ChargerStandbyPowerMeasurementSummary]) -> Bool {

        guard isICloudDriveAvailable else {

            return false

        }

        do {

            let snapshot = Snapshot(measurements: measurements)

            let data = try encoder.encode(snapshot)

            ubiquitousStore.set(data, forKey: Keys.cloudMeasurements)

            ubiquitousStore.synchronize()

            return true

        } catch {

            track("Failed to encode charger standby power history for iCloud KVS: \(error.localizedDescription)")

            return false

        }

    }

    private func merge(

        localMeasurements: [ChargerStandbyPowerMeasurementSummary],

        cloudMeasurements: [ChargerStandbyPowerMeasurementSummary]

    ) -> [ChargerStandbyPowerMeasurementSummary] {

        var mergedByID: [UUID: ChargerStandbyPowerMeasurementSummary] = [:]

        for measurement in localMeasurements {

            mergedByID[measurement.id] = measurement

        }

        for measurement in cloudMeasurements {

            mergedByID[measurement.id] = measurement

        }

        return sortMeasurements(Array(mergedByID.values))

    }

    private func sortMeasurements(_ measurements: [ChargerStandbyPowerMeasurementSummary]) -> [ChargerStandbyPowerMeasurementSummary] {

        measurements.sorted { lhs, rhs in

            if lhs.endedAt != rhs.endedAt {

                return lhs.endedAt > rhs.endedAt

            }

            return lhs.id.uuidString > rhs.id.uuidString

        }

    }

    private var isICloudDriveAvailable: Bool {

        FileManager.default.ubiquityIdentityToken != nil

    }

    private func handleUbiquitousStoreChange(_ notification: Notification) {

        if let changedKeys = notification.userInfo?[NSUbiquitousKeyValueStoreChangedKeysKey] as? [String],

           changedKeys.contains(Keys.cloudMeasurements) == false {

            return

        }

        workQueue.async { [weak self] in

            guard let self else { return }

            let mergedMeasurements = self.merge(

                localMeasurements: self.loadLocalMeasurements(),

                cloudMeasurements: self.loadCloudMeasurements()

            )

            self.cachedMeasurements = mergedMeasurements

            _ = self.persistLocally(mergedMeasurements)

            DispatchQueue.main.async {

                NotificationCenter.default.post(name: .chargerStandbyPowerStoreDidChange, object: nil)

            }

        }

    }

    private func syncLocalValuesToCloudIfPossible(reason: String) {

        guard isICloudDriveAvailable else {

            return

        }

        workQueue.async { [weak self] in

            guard let self else { return }

            let mergedMeasurements = self.merge(

                localMeasurements: self.loadLocalMeasurements(),

                cloudMeasurements: self.loadCloudMeasurements()

            )

            let didPersistLocal = self.persistLocally(mergedMeasurements)

            let didPersistCloud = self.persistToCloudIfPossible(mergedMeasurements)

            self.cachedMeasurements = mergedMeasurements

            if didPersistLocal || didPersistCloud {

                track("ChargerStandbyPowerStore synchronized standby measurements with iCloud KVS (\(reason)).")

                DispatchQueue.main.async {

                    NotificationCenter.default.post(name: .chargerStandbyPowerStoreDidChange, object: nil)

                }

            }

        }

    }

    deinit {

        if let observer = ubiquitousObserver {

            NotificationCenter.default.removeObserver(observer)

        }

        if let observer = ubiquityIdentityObserver {

            NotificationCenter.default.removeObserver(observer)

        }

    }

final class ChargerStandbyPowerMonitorSession: ObservableObject, Identifiable {

    let id = UUID()

    let chargerID: UUID

    let meterMACAddress: String

    let meterName: String

    let meterModel: String

    let startedAt: Date

    @Published private(set) var samples: [ChargerStandbyPowerSample] = []

    @Published private(set) var statistics: ChargerStandbyPowerMeasurementStatistics?

    @Published private(set) var stabilizedAt: Date?

    @Published private(set) var lastObservedAt: Date?

    @Published private(set) var isRunning = false

    var onChange: (() -> Void)?

    var onStabilized: (() -> Void)?

    private weak var meter: Meter?

    private var timer: Timer?

    private var hasTriggeredStabilityCallback = false

    private let sampleInterval: TimeInterval = 1

    init(chargerID: UUID, meter: Meter, startedAt: Date = Date()) {

        self.chargerID = chargerID

        meterMACAddress = meter.btSerial.macAddress.description

        meterName = meter.name

        meterModel = meter.deviceModelSummary

        self.startedAt = startedAt

        self.meter = meter

    }

    deinit {

        stop()

    }

    var sampleCount: Int {

        statistics?.sampleCount ?? samples.count

    }

    var hasSamples: Bool {

        sampleCount > 0

    }

    var readinessDescription: String {

        guard let statistics else {

            if let meter {

                switch meter.operationalState {

                case .peripheralConnectionPending, .peripheralConnected, .peripheralReady, .comunicating:

                    return "Connecting to meter"

                case .peripheralNotConnected:

                    return "Starting meter connection"

                case .notPresent, .dataIsAvailable:

                    break

                }

            }

            return "Waiting for live samples"

        }

        if statistics.isStable {

            return "Stable average reached"

        }

        return "Collecting baseline"

    }

    func start() {

        guard isRunning == false else {

            return

        }

        isRunning = true

        captureSampleIfPossible(at: Date())

        let timer = Timer(timeInterval: sampleInterval, repeats: true) { [weak self] _ in

            self?.captureSampleIfPossible(at: Date())

        }

        self.timer = timer

        RunLoop.main.add(timer, forMode: .common)

        onChange?()

    }

    func stop() {

        timer?.invalidate()

        timer = nil

        guard isRunning else {

            return

        }

        isRunning = false

        onChange?()

    }

    func makeSummary(endedAt: Date = Date()) -> ChargerStandbyPowerMeasurementSummary? {

        ChargerStandbyPowerMeasurementAnalyzer.measurementSummary(

            chargerID: chargerID,

            meterMACAddress: meterMACAddress,

            meterName: meterName,

            meterModel: meterModel,

            startedAt: startedAt,

            endedAt: endedAt,

            samples: samples,

            stabilizedAt: stabilizedAt

        )

    }

    private func captureSampleIfPossible(at timestamp: Date) {

        defer {

            statistics = ChargerStandbyPowerMeasurementAnalyzer.statistics(

                from: samples,

                startedAt: startedAt,

                referenceDate: timestamp

            )

            onChange?()

        }

        guard let meter else {

            return

        }

        guard meter.operationalState == .dataIsAvailable else {

            return

        }

        let powerWatts = meter.power

        let currentAmps = meter.current

        let voltageVolts = meter.voltage

        guard powerWatts.isFinite, currentAmps.isFinite, voltageVolts.isFinite else {

            return

        }

        lastObservedAt = timestamp

        samples.append(

            ChargerStandbyPowerSample(

                timestamp: timestamp,

                powerWatts: powerWatts,

                currentAmps: currentAmps,

                voltageVolts: voltageVolts

            )

        )

        if stabilizedAt == nil,

           let refreshedStatistics = ChargerStandbyPowerMeasurementAnalyzer.statistics(

               from: samples,

               startedAt: startedAt,

               referenceDate: timestamp

           ),

           refreshedStatistics.isStable {

            stabilizedAt = timestamp

            if hasTriggeredStabilityCallback == false {

                hasTriggeredStabilityCallback = true

                onStabilized?()

            }

        }

    }

}

extension Notification.Name {

    static let chargerStandbyPowerStoreDidChange = Notification.Name("ChargerStandbyPowerStoreDidChange")

}