//
//  ChargerStandbyPowerStore.swift
//  USB Meter
//
//  Created by Codex on 13/04/2026.
//

import Foundation

final class ChargerStandbyPowerStore {
    private struct Snapshot: Codable {
        var measurements: [ChargerStandbyPowerMeasurementSummary]
    }

    private let fileManager: FileManager
    private let fileURL: URL
    private let encoder: JSONEncoder
    private let decoder: JSONDecoder

    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
    }

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

    private func loadMeasurements() -> [ChargerStandbyPowerMeasurementSummary] {
        if let cachedMeasurements {
            return cachedMeasurements
        }

        guard fileManager.fileExists(atPath: fileURL.path) else {
            cachedMeasurements = []
            return []
        }

        do {
            let data = try Data(contentsOf: fileURL)
            let snapshot = try decoder.decode(Snapshot.self, from: data)
            cachedMeasurements = snapshot.measurements
            return snapshot.measurements
        } catch {
            track("Failed to load charger standby power history: \(error.localizedDescription)")
            cachedMeasurements = []
            return []
        }
    }

    @discardableResult
    private func persist(_ measurements: [ChargerStandbyPowerMeasurementSummary]) -> Bool {
        do {
            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)
            cachedMeasurements = measurements
            return true
        } catch {
            track("Failed to save charger standby power history: \(error.localizedDescription)")
            return false
        }
    }
}

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?()
            }
        }
    }
}