//
//  WatchDataManager.swift
//  hippo-watch Watch App
//
//  Created by shihao on 2025/7/8.
//

import Foundation
import HealthKit
import WidgetKit
import Combine

class WatchDataManager: ObservableObject {
    static let share = WatchDataManager()
    private let healthStore = HKHealthStore()
    @Published var myLatestHRVData: HRVData?
    @Published var otherLatestHRVData: HRVData?
    
    @Published var myTodayAvgHRV: Double?
    @Published var myLatestHeartRate: Double?
    @Published var myTodayStepCount: Int?
    @Published var myTodayActiveEnergy: Double?
    @Published var myTodaySleepTime: TimeInterval?
    @Published var otherTodayHealthInfo: TodayHealthInfo?
    
    // 想读取的类型，比如心率、步数
    private let readTypes: Set<HKObjectType> = [
        HKObjectType.quantityType(forIdentifier: .heartRate)!,
        HKObjectType.quantityType(forIdentifier: .heartRateVariabilitySDNN)!,
        HKObjectType.quantityType(forIdentifier: .stepCount)!,
        HKObjectType.categoryType(forIdentifier: .sleepAnalysis)!,
        HKObjectType.quantityType(forIdentifier: .oxygenSaturation)!,//血氧饱和度
        HKObjectType.quantityType(forIdentifier: .activeEnergyBurned)!,
        HKObjectType.quantityType(forIdentifier: .appleExerciseTime)!,
        HKObjectType.quantityType(forIdentifier: .appleStandTime)!,
        
        HKObjectType.quantityType(forIdentifier: .walkingHeartRateAverage)!,//步行心率
        HKObjectType.quantityType(forIdentifier: .restingHeartRate)!,//静息心率
        //睡眠心率（注）
        //使用 .heartRate 搭配 sleepAnalysis 筛选时间段
        HKObjectType.activitySummaryType()
        ,
        HKObjectType.quantityType(forIdentifier: .appleSleepingWristTemperature)!,
        HKObjectType.quantityType(forIdentifier: .respiratoryRate)!,
    ]
    
    func requestAuthForHealth() {
        let typesToShare: Set = [
            HKObjectType.workoutType()
        ]

        healthStore.requestAuthorization(toShare: typesToShare, read: readTypes) { success, error in
            if let error = error {
                print("❌ Authorization error: \(error.localizedDescription)")
            } else if success {
                print("✅ HealthKit authorized")
            } else {
                print("❌ HealthKit not authorized by user")
            }
        }
    }
    
    
    func fetchCoupleLatestHRV() {
        fetchLatestHRV()
        fetchOtherLatestHRV()
        observeHealthData()
    }
    
    private func fetchLatestHRV() {
        guard let hrvType = HKObjectType.quantityType(forIdentifier: .heartRateVariabilitySDNN) else { return }
        
        let sortDescriptor = NSSortDescriptor(key: HKSampleSortIdentifierEndDate, ascending: false)
        let query = HKSampleQuery(sampleType: hrvType,
                                  predicate: nil,
                                  limit: 1,
                                  sortDescriptors: [sortDescriptor]) { [weak self] _, samples, error in
            guard let self = self else { return }
            if let error = error {
                print("查询最新HRV失败: \(error.localizedDescription)")
                return
            }
            
            if let sample = samples?.first as? HKQuantitySample {
                let value = sample.quantity.doubleValue(for: .secondUnit(with: .milli))
                Task {
                    let result = try? await HealthService().getLatestHRV()
                    let myHrvBaseline = result?.userHrvBaseline
                    let data = HRVData(value: value,
                                       hrvBaseline: myHrvBaseline,
                                       date: sample.endDate)
                    await MainActor.run {
                        self.myLatestHRVData = data
                    }
                    self.saveHRVBaselineValue(myHrvBaseline)
                }
                DispatchQueue.main.async {
                    self.saveHRVValue(value)
                    self.uploadHRV(value: value, date: sample.endDate)
                    WidgetCenter.shared.reloadAllTimelines()
                    print("最新HRV: \(sample)")
                }
            }
        }
        
        healthStore.execute(query)
    }
    
    private func fetchOtherLatestHRV() {
        Task {
            let result = try? await HealthService().getLatestHRV()
            await MainActor.run {
                if let value = result?.pairUserHrv {
                    let data = HRVData(value: value,
                                       hrvBaseline: result?.pairHrvBaseline,
                                       date: nil)
                    self.otherLatestHRVData = data
                }
            }
        }
    }
    
    private func fetchTodayAvgHRV() {
        guard let hrvType = HKObjectType.quantityType(forIdentifier: .heartRateVariabilitySDNN) else { return }
        
        let startOfDay = Calendar.current.startOfDay(for: Date())
        let predicate = HKQuery.predicateForSamples(withStart: startOfDay, end: Date(), options: .strictStartDate)
        
        let query = HKSampleQuery(sampleType: hrvType,
                                  predicate: predicate,
                                  limit: HKObjectQueryNoLimit,
                                  sortDescriptors: nil) { [weak self] _, samples, error in
            guard let self = self else { return }
            if let error = error {
                print("查询HRV失败: \(error.localizedDescription)")
                return
            }
            
            guard let samples = samples as? [HKQuantitySample], !samples.isEmpty else { return }
            
            let total = samples.reduce(0.0) { $0 + $1.quantity.doubleValue(for: .secondUnit(with: .milli)) }
            let average = total / Double(samples.count)
            
            DispatchQueue.main.async {
                self.myTodayAvgHRV = average
            }
        }
        
        healthStore.execute(query)
    }
    
    private func fetchTodayLatestHeartRate() {
        guard let heartRateType = HKObjectType.quantityType(forIdentifier: .heartRate) else { return }
        
        let startOfDay = Calendar.current.startOfDay(for: Date())
        let predicate = HKQuery.predicateForSamples(withStart: startOfDay, end: Date(), options: .strictStartDate)
        
        let sortDescriptor = NSSortDescriptor(key: HKSampleSortIdentifierEndDate, ascending: false)
        let query = HKSampleQuery(sampleType: heartRateType,
                                  predicate: predicate,
                                  limit: 1,
                                  sortDescriptors: [sortDescriptor]) { [weak self] _, samples, error in
            guard let self = self else { return }
            if let error = error {
                print("查询今日最新心率失败: \(error.localizedDescription)")
                return
            }
            
            if let sample = samples?.first as? HKQuantitySample {
                let value = sample.quantity.doubleValue(for: .count().unitDivided(by: .minute()))
                DispatchQueue.main.async {
                    self.myLatestHeartRate = value
                }
            }
        }
        
        healthStore.execute(query)
    }
    
    private func fetchTodayStepCount() {
        guard let stepType = HKObjectType.quantityType(forIdentifier: .stepCount) else { return }
        
        let startOfDay = Calendar.current.startOfDay(for: Date())
        let predicate = HKQuery.predicateForSamples(withStart: startOfDay, end: Date(), options: .strictStartDate)
        
        let query = HKStatisticsQuery(quantityType: stepType,
                                      quantitySamplePredicate: predicate,
                                      options: .cumulativeSum) { [weak self] _, result, error in
            guard let self = self else { return }
            if let error = error {
                print("查询步数失败: \(error.localizedDescription)")
                return
            }
            
            if let sum = result?.sumQuantity() {
                let value = Int(sum.doubleValue(for: .count()))
                DispatchQueue.main.async {
                    self.myTodayStepCount = value
                    self.saveStepCountValue(value)
                    WidgetCenter.shared.reloadAllTimelines()
                }
            }
        }
        
        healthStore.execute(query)
    }
    
    private func fetchTodayActiveEnergy() {
        guard let energyType = HKObjectType.quantityType(forIdentifier: .activeEnergyBurned) else { return }
        
        let startOfDay = Calendar.current.startOfDay(for: Date())
        let predicate = HKQuery.predicateForSamples(withStart: startOfDay, end: Date(), options: .strictStartDate)
        
        let query = HKStatisticsQuery(quantityType: energyType,
                                      quantitySamplePredicate: predicate,
                                      options: .cumulativeSum) { [weak self] _, result, error in
            guard let self = self else { return }
            if let error = error {
                print("查询活动能量失败: \(error.localizedDescription)")
                return
            }
            
            if let sum = result?.sumQuantity() {
                let value = sum.doubleValue(for: .kilocalorie())
                DispatchQueue.main.async {
                    self.myTodayActiveEnergy = value
                }
            }
        }
        
        healthStore.execute(query)
    }
    
    
    func fetchLastNightSleepDuration() {
        Task {
            let calendar = Calendar.current
            let today = Date()
            
            // 定义昨天晚上的时间范围（从昨天15:00到今天15:00）
            let yesterday = calendar.date(byAdding: .day, value: -1, to: today)!
            let searchStartTime = calendar.date(bySettingHour: 15, minute: 0, second: 0, of: yesterday)!
            let searchEndTime = calendar.date(bySettingHour: 15, minute: 0, second: 0, of: today)!
            
            guard let sleepType = HKObjectType.categoryType(forIdentifier: .sleepAnalysis) else {
                return
            }
            
            let predicate = HKQuery.predicateForSamples(withStart: searchStartTime, end: searchEndTime, options: .strictStartDate)
            let sortDescriptor = NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: true)
            
            let samples = try? await withCheckedThrowingContinuation { (continuation: CheckedContinuation<[HKCategorySample], Error>) in
                let query = HKSampleQuery(
                    sampleType: sleepType,
                    predicate: predicate,
                    limit: HKObjectQueryNoLimit,
                    sortDescriptors: [sortDescriptor]
                ) { _, samples, error in
                    if let error = error {
                        continuation.resume(throwing: error)
                        return
                    }
                    
                    let categorySamples = samples?.compactMap { $0 as? HKCategorySample } ?? []
                    continuation.resume(returning: categorySamples)
                }
                
                healthStore.execute(query)
            }
            
            guard let samples,
                    !samples.isEmpty else { return }
            
            // 按开始时间排序
            let sortedSamples = samples.sorted { $0.startDate < $1.startDate }
            
            // 转换为睡眠阶段数据
            let sleepStages = sortedSamples.compactMap { sample -> SleepStage? in
                guard let sleepValue = HKCategoryValueSleepAnalysis(rawValue: sample.value) else {
                    return nil
                }
                
                return SleepStage(
                    stage: sleepValue,
                    startTime: sample.startDate,
                    endTime: sample.endDate,
                    duration: sample.endDate.timeIntervalSince(sample.startDate)
                )
            }
            
            guard !sleepStages.isEmpty else { return }
            
            // 计算总体睡眠时间范围
            let overallStartTime = sleepStages.first!.startTime
            let overallEndTime = sleepStages.last!.endTime
            let totalDuration = overallEndTime.timeIntervalSince(overallStartTime)
            
            // 计算实际睡眠时间（排除清醒和在床上但未睡着的时间）
            let actualSleepTime = sleepStages
                .filter { stage in
                    switch stage.stage {
                    case .asleepUnspecified, .asleepCore, .asleepDeep, .asleepREM:
                        return true
                    case .inBed, .awake:
                        return false
                    @unknown default:
                        return false
                    }
                }
                .reduce(0) { $0 + $1.duration }
            
            // 计算睡眠效率
            let sleepEfficiency = totalDuration > 0 ? (actualSleepTime / totalDuration) * 100 : nil
            
            let data = SleepData(
                startTime: overallStartTime,
                endTime: overallEndTime,
                duration: totalDuration,
                sleepStages: sleepStages,
                totalSleepTime: actualSleepTime,
                sleepEfficiency: sleepEfficiency
            )
            
            self.myTodaySleepTime = data.totalSleepTime
        }
    }
    
    // 方法1: 获取最新的单个事件
    func fetchLatestIrregularRhythmEvent() {
        let irregularRhythmType = HKCategoryType.categoryType(
            forIdentifier: .irregularHeartRhythmEvent
        )!
        
        let sortDescriptor = NSSortDescriptor(
            key: HKSampleSortIdentifierStartDate,
            ascending: false  // 降序,最新的在前
        )
        
        let query = HKSampleQuery(
            sampleType: irregularRhythmType,
            predicate: nil,
            limit: 1,  // 只获取最新的一个
            sortDescriptors: [sortDescriptor]
        ) { _, samples, error in
            if let error = error {
                return
            }
            
            guard let sample = samples?.first as? HKCategorySample else {
                return
            }
                        
            self.uploadIrregularRhythm(value: sample.value,
                                       date: sample.startDate)
        }
        
        healthStore.execute(query)
    }
    
    private func fetchLatestWristTemperature() {
        guard let wristTempType = HKObjectType.quantityType(forIdentifier: .appleSleepingWristTemperature) else { return }

        let sortDescriptor = NSSortDescriptor(key: HKSampleSortIdentifierEndDate, ascending: false)
        let query = HKSampleQuery(sampleType: wristTempType,
                                  predicate: nil,
                                  limit: 1,
                                  sortDescriptors: [sortDescriptor]) { [weak self] _, samples, error in
            guard let self = self else { return }
            if let error = error {
                print("查询睡眠手腕温度失败: \(error.localizedDescription)")
                return
            }

            if let sample = samples?.first as? HKQuantitySample {
                let value = sample.quantity.doubleValue(for: .degreeCelsius())
                self.uploadSleepWristTemperature(value: value, date: sample.startDate)
            }
        }

        healthStore.execute(query)
    }
    
    private func fetchLatestRespiratoryRate() {
        guard let respiratoryType = HKObjectType.quantityType(forIdentifier: .respiratoryRate) else { return }

        let sortDescriptor = NSSortDescriptor(key: HKSampleSortIdentifierEndDate, ascending: false)
        let query = HKSampleQuery(sampleType: respiratoryType,
                                  predicate: nil,
                                  limit: 1,
                                  sortDescriptors: [sortDescriptor]) { [weak self] _, samples, error in
            guard let self = self else { return }
            if let error = error {
                print("查询呼吸频率失败: \(error.localizedDescription)")
                return
            }

            if let sample = samples?.first as? HKQuantitySample {
                let value = sample.quantity.doubleValue(for: HKUnit.count().unitDivided(by: .minute()))
                self.uploadRespiratoryRate(value: value, date: sample.startDate)
            }
        }

        healthStore.execute(query)
    }
}

extension WatchDataManager {
    func observeHealthData() {
        guard HKHealthStore.isHealthDataAvailable() else { return }
        
        let hrvType = HKQuantityType.quantityType(forIdentifier: .heartRateVariabilitySDNN)!
        
        // 设置 observer query
        let observerQuery = HKObserverQuery(sampleType: hrvType, predicate: nil) { [weak self] _, completionHandler, error in
            if let _ = error {
                return
            }
            // 有新数据，启动 Anchored Query 获取
            self?.fetchLatestHRV()
            completionHandler()
        }
        
        healthStore.execute(observerQuery)
        healthStore.enableBackgroundDelivery(for: hrvType, frequency: .immediate) { success, error in
            
        }
        
        let stepType = HKQuantityType.quantityType(forIdentifier: .stepCount)!
        
        // 设置 observer query
        let stepObserverQuery = HKObserverQuery(sampleType: stepType, predicate: nil) { [weak self] _, completionHandler, error in
            if let _ = error {
                return
            }
            // 有新数据，启动 Anchored Query 获取
            self?.fetchTodayStepCount()
            completionHandler()
        }
        
        healthStore.execute(stepObserverQuery)
        healthStore.enableBackgroundDelivery(for: stepType, frequency: .immediate) { success, error in
            
        }
        
        //房颤
        let irregularRhythmType = HKCategoryType.categoryType(
                    forIdentifier: .irregularHeartRhythmEvent
                )!
        
        // 设置 observer query
        let irregularRhythmObserverQuery = HKObserverQuery(sampleType: irregularRhythmType, predicate: nil) { [weak self] _, completionHandler, error in
            if let _ = error {
                return
            }
            // 有新数据，启动 Anchored Query 获取
            self?.fetchLatestIrregularRhythmEvent()
            completionHandler()
        }
        
        healthStore.execute(irregularRhythmObserverQuery)
        healthStore.enableBackgroundDelivery(for: irregularRhythmType, frequency: .immediate) { success, error in
            
        }
        
        //睡眠手腕温度
        let wristTempType = HKQuantityType.quantityType(forIdentifier: .appleSleepingWristTemperature)!

        let wristTempObserverQuery = HKObserverQuery(sampleType: wristTempType, predicate: nil) { [weak self] _, completionHandler, error in
            if let _ = error {
                return
            }
            self?.fetchLatestWristTemperature()
            completionHandler()
        }

        healthStore.execute(wristTempObserverQuery)
        healthStore.enableBackgroundDelivery(for: wristTempType, frequency: .immediate) { success, error in

        }
        
        //呼吸频率
        let respiratoryType = HKQuantityType.quantityType(forIdentifier: .respiratoryRate)!

        let respiratoryObserverQuery = HKObserverQuery(sampleType: respiratoryType, predicate: nil) { [weak self] _, completionHandler, error in
            if let _ = error {
                return
            }
            self?.fetchLatestRespiratoryRate()
            completionHandler()
        }

        healthStore.execute(respiratoryObserverQuery)
        healthStore.enableBackgroundDelivery(for: respiratoryType, frequency: .immediate) { success, error in

        }
        
    }
    
    private func saveHRVValue(_ value: Double) {
        let defaults = UserDefaults(suiteName: "group.com.luiz.doublefeel.watchkitapp")
        defaults?.set(value, forKey: "latestHRV")
    }
    
    private func saveHRVBaselineValue(_ value: Double?) {
        let defaults = UserDefaults(suiteName: "group.com.luiz.doublefeel.watchkitapp")
        defaults?.set(value, forKey: "latestHRVBaseline")
    }
    
    private func saveStepCountValue(_ value: Int) {
        let defaults = UserDefaults(suiteName: "group.com.luiz.doublefeel.watchkitapp")
        defaults?.set(value, forKey: "latestStepCount")
    }
}

extension WatchDataManager {
    private func uploadHRV(value: Double, date: Date) {
        Task {
            let _ = try? await HealthService().upload(data: [
                "data_type": HealthDataType.hrv.rawValue,
                "time": date.timeIntervalSince1970,
                "value": value,
            ])
        }
    }
    
    private func uploadIrregularRhythm(value: Int, date: Date) {
        Task {
            let _ = try? await HealthService().upload(data: [
                "data_type": HealthDataType.irregularHeartRhythm.rawValue,
                "time": date.timeIntervalSince1970,
                "value": value,
            ])
        }
    }
    
    private func uploadSleepWristTemperature(value: Double, date: Date) {
        Task {
            let _ = try? await HealthService().upload(data: [
                "data_type": HealthDataType.sleepingWristTemperature.rawValue,
                "time": date.timeIntervalSince1970,
                "value": value,
            ])
        }
    }
    
    private func uploadRespiratoryRate(value: Double, date: Date) {
        Task {
            let _ = try? await HealthService().upload(data: [
                "data_type": HealthDataType.respiratoryRate.rawValue,
                "time": date.timeIntervalSince1970,
                "value": value,
            ])
        }
    }
}

extension WatchDataManager {
    func fetchOtherTodayData() {
        Task {
            let result = try? await HealthService().getTodayStatusInfo()
            await MainActor.run {
                self.otherTodayHealthInfo = result
            }
        }
    }
    
    func fetchMyTodayData() {
        fetchTodayAvgHRV()
        fetchTodayLatestHeartRate()
        fetchTodayStepCount()
        fetchTodayActiveEnergy()
        fetchLastNightSleepDuration()
    }
}