/// in HealthDataUseCase.swift

/// Health 데이터 사용 권한 요청이 이루어졌는지 확인합니다.
private func checkAuthorizationStatus() async throws -> Bool {
    return try await withCheckedThrowingContinuation { continuation in
        store.getRequestStatusForAuthorization(
            toShare: Set(),
            read: Set([.workoutType()])
        ) { status, error in
            if let _ = error {
                continuation.resume(throwing: HealthError.unknownError)
            }
            
            switch status {
            case .shouldRequest:
                continuation.resume(returning: true)
            default:
                continuation.resume(returning: false)
            }
        }
    }
}

/// in HealthDataUseCase.swift

/// Health 데이터 사용 권한을 요청합니다.
private func requestAuthorization() async throws {
    if HKHealthStore.isHealthDataAvailable() {
        try await store.requestAuthorization(
            toShare: Set(),
            read: Set([.workoutType()])
        )
    } else {
        throw HealthError.notAvailableDevice
    }
}

/// in WorkoutDataRepositoryImpl.swift

private let store = HKHealthStore()

public func fetchWorkoutData() async throws -> [RunningData] {
    let predicate = HKQuery.predicateForWorkouts(with: .running)
    let descriptor = [NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: false)]
    
    let result: [HKWorkout] = try await store.fetchData(
        sampleType: .workoutType(),
        predicate: predicate,
        limit: HKObjectQueryNoLimit,
        sortDescriptors: descriptor
    )
    
    return convertToRunningData(result)
}

// in HealthKit+.swift

public func fetchData<T: HKSample>(
    sampleType: HKSampleType,
    predicate: NSPredicate? = nil,
    limit: Int,
    sortDescriptors: [NSSortDescriptor]? = nil
) async throws -> [T] {
    let predicate = HKQuery.predicateForWorkouts(with: .running)
    
    let data = try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<[HKSample], any Error>) in
        let query = HKSampleQuery(
            sampleType: sampleType,
            predicate: predicate,
            limit: limit,
            sortDescriptors: sortDescriptors) { query, samples, error in
                if let _ = error {
                    continuation.resume(with: .failure(HealthError.failedToLoadWorkoutData))
                }
                
                guard let samples = samples else {
                    continuation.resume(with: .failure(HealthError.failedToLoadWorkoutData))
                    return
                }
                
                continuation.resume(with: .success(samples))
            }
        self.execute(query)
    }
    
    guard let result = data as? [T] else { throw HealthError.failedToLoadWorkoutData }
    
    return result
}

/// in AppDelegate.swift

public static func setHealthBackgroundTask() async {
    let store = HKHealthStore()
    
    do {
        try await store.enableBackgroundDelivery(for: .workoutType(), frequency: .immediate)
        let query = HKObserverQuery(
            sampleType: .workoutType(),
            predicate: nil
        ) { query, completionHandler, error in
            if let error = error {
                print(error)
                return
            }
            
            let sort = NSSortDescriptor(key: HKSampleSortIdentifierEndDate, ascending: false)
            let sampleQuery = HKSampleQuery(queryDescriptors: [.init(sampleType: .workoutType(), predicate: nil)], limit: 1, sortDescriptors: [sort]) { _, samples, error in

                ...
              
                guard let workout = samples?.first as? HKWorkout else {
                    return
                }
                
                guard case .running = workout.workoutActivityType else {
                    return
                }
                
                let workoutId = workout.uuid.uuidString
                let currentId = UserDefaults.standard.recentWorkoutID
                
                if !UserDefaults.standard.isFirstLaunch {
                    UserDefaults.standard.recentWorkoutID = workoutId
                } else {
                    if workoutId != currentId {
                        let distance = workout.getKilometerDistance()
                        if !UserDefaults.standard.selectedShoesID.isEmpty {

                            UNUserNotificationCenter.requestNotification(
                                title: String(format: "%.2fkm 러닝 완료 🔥🔥", distance!),
                                body: distance == nil
                                ? "신발에 자동 등록이 완료되었습니다!"
                                : String(format: "신발에 자동 등록이 완료되었습니다. 러닝 후 스트레칭 꼭 잊지 마세요!", distance!)
                            )
                            
                            autoRegisterShoes(workout: workout)
                        } else {
                            UNUserNotificationCenter.requestNotification(
                                title: String(format: "%.2fkm 러닝 완료 🔥🔥", distance!),
                                body: distance == nil
                                ? "신발 마일리지를 등록할 준비가 완료되었습니다. 등록하러 가볼까요?"
                                : String(format: "%.2fkm, 잊지 말고 마일리지를 등록하러 오세요!", distance!)
                            )
                        }
                        UserDefaults.standard.recentWorkoutID = workoutId
                    }
                }
            }
            
            store.execute(sampleQuery)
            
            completionHandler()
        }
        
        store.execute(query)
    } catch {
        print(error)
    }
}