import HealthKit
 
final class HealthKitManager {
 
    static let shared = HealthKitManager()
    private let healthStore = HKHealthStore()
 
    // Types MeteoHealth reads: heart rate, HRV, SpO2, respiratory rate,
    // sleep stages and workouts.
    private let readTypes: Set<HKObjectType> = [
        HKQuantityType(.heartRate),
        HKQuantityType(.heartRateVariabilitySDNN),
        HKQuantityType(.oxygenSaturation),
        HKQuantityType(.respiratoryRate),
        HKCategoryType(.sleepAnalysis),
        HKObjectType.workoutType(),
        HKSampleType.stateOfMindType()
    ]
 
    // Types MeteoHealth writes: water, caffeine, heart rate from the
    // camera-based PPG measurement, and State of Mind entries.
    private let writeTypes: Set<HKSampleType> = [
        HKQuantityType(.dietaryWater),
        HKQuantityType(.dietaryCaffeine),
        HKQuantityType(.heartRate),
        HKSampleType.stateOfMindType()
    ]
 
    func requestAuthorization() async throws {
        guard HKHealthStore.isHealthDataAvailable() else {
            throw HealthKitError.notAvailable
        }
        try await healthStore.requestAuthorization(toShare: writeTypes, read: readTypes)
    }
}
 
enum HealthKitError: Error {
    case notAvailable
}

extension HealthKitManager {
 
    /// Average HRV (SDNN, ms) for the last 24 hours.
    func averageHRV(daysBack: Int = 1) async throws -> Double? {
        let hrvType = HKQuantityType(.heartRateVariabilitySDNN)
        let start = Calendar.current.date(byAdding: .day, value: -daysBack, to: Date())!
        let predicate = HKQuery.predicateForSamples(withStart: start, end: Date())
 
        let descriptor = HKStatisticsQueryDescriptor(
            predicate: HKSamplePredicate.quantitySample(type: hrvType, predicate: predicate),
            options: .discreteAverage
        )
 
        let statistics = try await descriptor.result(for: healthStore)
        let unit = HKUnit.secondUnit(with: .milli)
        return statistics?.averageQuantity()?.doubleValue(for: unit)
    }
 
    /// Latest blood oxygen saturation (SpO2) reading, as a percentage.
    func latestSpO2() async throws -> Double? {
        let spo2Type = HKQuantityType(.oxygenSaturation)
        let descriptor = HKSampleQueryDescriptor(
            predicates: [.quantitySample(type: spo2Type)],
            sortDescriptors: [SortDescriptor(\.endDate, order: .reverse)],
            limit: 1
        )
 
        let samples = try await descriptor.result(for: healthStore)
        return samples.first?.quantity.doubleValue(for: .percent())
    }
}

extension HealthKitManager {
 
    struct SleepStage {
        let stage: HKCategoryValueSleepAnalysis
        let start: Date
        let end: Date
    }
 
    /// Sleep stages for the last night, sorted chronologically.
    func lastNightSleepStages() async throws -> [SleepStage] {
        let sleepType = HKCategoryType(.sleepAnalysis)
        let start = Calendar.current.date(byAdding: .hour, value: -18, to: Date())!
        let predicate = HKQuery.predicateForSamples(withStart: start, end: Date())
 
        let descriptor = HKSampleQueryDescriptor(
            predicates: [.categorySample(type: sleepType, predicate: predicate)],
            sortDescriptors: [SortDescriptor(\.startDate, order: .forward)]
        )
 
        let samples = try await descriptor.result(for: healthStore)
 
        return samples.compactMap { sample in
            guard let value = HKCategoryValueSleepAnalysis(rawValue: sample.value) else {
                return nil
            }
            return SleepStage(stage: value, start: sample.startDate, end: sample.endDate)
        }
    }
}

extension HealthKitManager {
 
    /// Subscribes to background updates for heart rate and enables
    /// hourly wake-ups even when MeteoHealth is not in the foreground.
    func enableBackgroundDelivery() async throws {
        let heartRateType = HKQuantityType(.heartRate)
 
        try await healthStore.enableBackgroundDelivery(
            for: heartRateType,
            frequency: .hourly
        )
 
        let query = HKObserverQuery(sampleType: heartRateType, predicate: nil) { _, completionHandler, error in
            defer { completionHandler() }
 
            guard error == nil else { return }
 
            Task {
                try? await self.syncLatestHeartRate()
            }
        }
 
        healthStore.execute(query)
    }
 
    private func syncLatestHeartRate() async throws {
        // Fetch and cache the newest sample, refresh widgets, etc.
    }
}

extension HealthKitManager {
 
    /// Saves a user-reported mood entry as a State of Mind sample.
    func logStateOfMind(valence: Double, labels: [HKStateOfMind.Label]) async throws {
        let sample = HKStateOfMind(
            date: Date(),
            kind: .momentaryEmotion,
            valence: valence,
            labels: labels,
            associations: [.currentEvents]
        )
 
        try await healthStore.save(sample)
    }
}