//

//  ConsumptionMonitorStore.swift

//  USB Meter

//

import Foundation

import Combine

// MARK: - Store

final class ConsumptionMonitorStore {

    private struct Snapshot: Codable {

        var sessions: [ConsumptionMonitorSessionSummary]

    }

    private enum Keys {

        static let cloudSessions = "ConsumptionMonitorStore.sessions"

    }

    private let fileManager: FileManager

    private let fileURL: URL

    private let encoder: JSONEncoder

    private let decoder: JSONDecoder

    private let ubiquitousStore = NSUbiquitousKeyValueStore.default

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

    private var ubiquitousObserver: NSObjectProtocol?

    private var ubiquityIdentityObserver: NSObjectProtocol?

    private var cachedSessions: [ConsumptionMonitorSessionSummary]?

    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("consumption-monitor.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 sessionsByDeviceID() -> [UUID: [ConsumptionMonitorSessionSummary]] {

        Dictionary(grouping: loadSessions()) { $0.chargedDeviceID }

            .mapValues { sessions in

                sessions.sorted { lhs, rhs in

                    (lhs.endedAt ?? .distantFuture) > (rhs.endedAt ?? .distantFuture)

                }

            }

    }

    @discardableResult

    func save(_ session: ConsumptionMonitorSessionSummary) -> Bool {

        var sessions = loadSessions()

        if let index = sessions.firstIndex(where: { $0.id == session.id }) {

            sessions[index] = session

        } else {

            sessions.append(session)

        }

        sessions.sort { lhs, rhs in

            (lhs.endedAt ?? .distantFuture) > (rhs.endedAt ?? .distantFuture)

        }

        return persist(sessions)

    }

    @discardableResult

    func appendSample(_ sample: ConsumptionMonitorSample, to sessionID: UUID) -> Bool {

        var sessions = loadSessions()

        guard let index = sessions.firstIndex(where: { $0.id == sessionID }) else {

            return false

        }

        sessions[index].samples.append(sample)

        return persist(sessions)

    }

    @discardableResult

    func completeSession(id sessionID: UUID, endedAt: Date) -> Bool {

        var sessions = loadSessions()

        guard let index = sessions.firstIndex(where: { $0.id == sessionID }) else {

            return false

        }

        sessions[index].endedAt = endedAt

        sessions.sort { lhs, rhs in

            (lhs.endedAt ?? .distantFuture) > (rhs.endedAt ?? .distantFuture)

        }

        return persist(sessions)

    }

    @discardableResult

    func removeSession(id: UUID, deviceID: UUID) -> Bool {

        let previous = loadSessions()

        let filtered = previous.filter { !($0.id == id && $0.chargedDeviceID == deviceID) }

        guard filtered.count != previous.count else { return true }

        return persist(filtered)

    }

    @discardableResult

    func removeSessions(for deviceID: UUID) -> Bool {

        let previous = loadSessions()

        let filtered = previous.filter { $0.chargedDeviceID != deviceID }

        guard filtered.count != previous.count else { return true }

        return persist(filtered)

    }

    func openSession(for meterMACAddress: String) -> ConsumptionMonitorSessionSummary? {

        loadSessions().first { $0.isOpen && $0.meterMACAddress == meterMACAddress }

    }

    // MARK: - Private

    private func loadSessions() -> [ConsumptionMonitorSessionSummary] {

        if let cachedSessions { return cachedSessions }

        let local = loadLocalSessions()

        let cloud = loadCloudSessions()

        let merged = merge(localSessions: local, cloudSessions: cloud)

        cachedSessions = merged

        return merged

    }

    private func loadLocalSessions() -> [ConsumptionMonitorSessionSummary] {

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

        do {

            let data = try Data(contentsOf: fileURL)

            return try decoder.decode(Snapshot.self, from: data).sessions

        } catch {

            track("ConsumptionMonitorStore: failed to load local sessions: \(error.localizedDescription)")

            return []

        }

    }

    private func loadCloudSessions() -> [ConsumptionMonitorSessionSummary] {

        guard isICloudDriveAvailable,

              let data = ubiquitousStore.data(forKey: Keys.cloudSessions) else { return [] }

        do {

            return try decoder.decode(Snapshot.self, from: data).sessions

        } catch {

            track("ConsumptionMonitorStore: failed to decode cloud sessions: \(error.localizedDescription)")

            return []

        }

    }

    @discardableResult

    private func persist(_ sessions: [ConsumptionMonitorSessionSummary]) -> Bool {

        let didLocal = persistLocally(sessions)

        let didCloud = persistToCloudIfPossible(sessions)

        if didLocal || didCloud {

            cachedSessions = sessions

        }

        return didLocal || didCloud

    }

    @discardableResult

    private func persistLocally(_ sessions: [ConsumptionMonitorSessionSummary]) -> Bool {

        do {

            try fileManager.createDirectory(

                at: fileURL.deletingLastPathComponent(),

                withIntermediateDirectories: true,

                attributes: nil

            )

            let data = try encoder.encode(Snapshot(sessions: sessions))

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

            return true

        } catch {

            track("ConsumptionMonitorStore: failed to save locally: \(error.localizedDescription)")

            return false

        }

    }

    @discardableResult

    private func persistToCloudIfPossible(_ sessions: [ConsumptionMonitorSessionSummary]) -> Bool {

        guard isICloudDriveAvailable else { return false }

        do {

            let data = try encoder.encode(Snapshot(sessions: sessions))

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

            return ubiquitousStore.synchronize()

        } catch {

            track("ConsumptionMonitorStore: failed to sync to cloud: \(error.localizedDescription)")

            return false

        }

    }

    private func merge(

        localSessions: [ConsumptionMonitorSessionSummary],

        cloudSessions: [ConsumptionMonitorSessionSummary]

    ) -> [ConsumptionMonitorSessionSummary] {

        var byID: [UUID: ConsumptionMonitorSessionSummary] = [:]

        for session in localSessions { byID[session.id] = session }

        for session in cloudSessions {

            if let existing = byID[session.id] {

                // Keep the one with more samples or a definitive end time

                if session.samples.count > existing.samples.count || (session.endedAt != nil && existing.endedAt == nil) {

                    byID[session.id] = session

                }

            } else {

                byID[session.id] = session

            }

        }

        return byID.values.sorted { lhs, rhs in

            (lhs.endedAt ?? .distantFuture) > (rhs.endedAt ?? .distantFuture)

        }

    }

    private func syncLocalValuesToCloudIfPossible(reason: String) {

        let sessions = loadLocalSessions()

        guard !sessions.isEmpty else { return }

        persistToCloudIfPossible(sessions)

    }

    private func handleUbiquitousStoreChange(_ notification: Notification) {

        cachedSessions = nil

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

    }

    private var isICloudDriveAvailable: Bool {

        FileManager.default.ubiquityIdentityToken != nil

    }

}

extension Notification.Name {

    static let consumptionMonitorStoreDidChange = Notification.Name("ConsumptionMonitorStore.DidChange")

}

// MARK: - Live Session

final class ConsumptionMonitorLiveSession: ObservableObject {

    static let bucketDurationSeconds: TimeInterval = 60

    let sessionID: UUID

    let chargedDeviceID: UUID

    let meterMACAddress: String

    let startedAt: Date

    @Published private(set) var currentPowerWatts: Double = 0

    @Published private(set) var currentCurrentAmps: Double = 0

    @Published private(set) var currentVoltageVolts: Double = 0

    @Published private(set) var committedSampleCount: Int = 0

    @Published private(set) var committedSamples: [ConsumptionMonitorSample] = []

    @Published private(set) var cumulativeEnergyWh: Double = 0

    @Published private(set) var isRunning: Bool = false

    var meterName: String?

    var meterModel: String?

    var onSample: ((ConsumptionMonitorSample) -> Void)?

    var onChange: (() -> Void)?

    private var flushTimer: Timer?

    private var powerReadings: [(power: Double, current: Double, voltage: Double)] = []

    private var lastObservationTime: Date?

    private var nextBucketIndex: Int = 0

    init(sessionID: UUID, chargedDeviceID: UUID, meterMACAddress: String, startedAt: Date) {

        self.sessionID = sessionID

        self.chargedDeviceID = chargedDeviceID

        self.meterMACAddress = meterMACAddress

        self.startedAt = startedAt

    }

    func start() {

        guard !isRunning else { return }

        isRunning = true

        scheduleNextFlush()

    }

    func stop() {

        isRunning = false

        flushTimer?.invalidate()

        flushTimer = nil

        flushBucket()

    }

    func observe(powerWatts: Double, currentAmps: Double, voltageVolts: Double, observedAt: Date) {

        currentPowerWatts = powerWatts

        currentCurrentAmps = currentAmps

        currentVoltageVolts = voltageVolts

        if let last = lastObservationTime {

            let dtHours = observedAt.timeIntervalSince(last) / 3600

            cumulativeEnergyWh += powerWatts * dtHours

        }

        lastObservationTime = observedAt

        powerReadings.append((powerWatts, currentAmps, voltageVolts))

        onChange?()

    }

    var elapsedDuration: TimeInterval {

        Date().timeIntervalSince(startedAt)

    }

    // MARK: - Private

    private func scheduleNextFlush() {

        flushTimer?.invalidate()

        flushTimer = Timer.scheduledTimer(

            withTimeInterval: Self.bucketDurationSeconds,

            repeats: false

        ) { [weak self] _ in

            self?.flushBucket()

            if self?.isRunning == true {

                self?.scheduleNextFlush()

            }

        }

    }

    private func flushBucket() {

        guard !powerReadings.isEmpty else { return }

        let n = Double(powerReadings.count)

        let avgPower = powerReadings.map(\.power).reduce(0, +) / n

        let avgCurrent = powerReadings.map(\.current).reduce(0, +) / n

        let avgVoltage = powerReadings.map(\.voltage).reduce(0, +) / n

        let bucketIndex = nextBucketIndex

        nextBucketIndex += 1

        let sample = ConsumptionMonitorSample(

            bucketIndex: bucketIndex,

            timestamp: Date(),

            averagePowerWatts: avgPower,

            averageCurrentAmps: avgCurrent,

            averageVoltageVolts: avgVoltage,

            sampleCount: powerReadings.count,

            cumulativeEnergyWh: cumulativeEnergyWh

        )

        powerReadings = []

        committedSamples.append(sample)

        committedSampleCount = nextBucketIndex

        onSample?(sample)

        onChange?()

    }

}