import Foundation
import HealthKit

/// Low-level HealthKit query helper shared by the host API and anchored reader.
/// It contains no upload or anchor persistence behavior.
final class HealthKitQueryReader {
  private let healthStore: HKHealthStore

  init(healthStore: HKHealthStore) {
    self.healthStore = healthStore

  }

  func fetchSleepData(startDate: Date, endDate: Date) async throws -> [NativeSleepInterval] {
    try await fetchSleepIntervals(startDate: startDate, endDate: endDate)
  }

  func fetchActivityTargetData(startDate: Date, endDate: Date) async throws -> NativeActivityTarget? {
    try await fetchActivityTargetDataList(startDate: startDate, endDate: endDate).last
  }

  func fetchActivityTargetDataList(startDate: Date, endDate: Date) async throws -> [NativeActivityTarget] {
    let calendar = Calendar.current
    var start = calendar.dateComponents([.era, .year, .month, .day], from: startDate)
    var end = calendar.dateComponents([.era, .year, .month, .day], from: endDate)

    start.calendar = calendar
    end.calendar = calendar

    let predicate = HKQuery.predicate(forActivitySummariesBetweenStart: start, end: end)

    return try await withCheckedThrowingContinuation { continuation in
      let query = HKActivitySummaryQuery(predicate: predicate) { _, summaries, error in
        if let error {
          continuation.resume(throwing: error)
          return
        }
        let targets = (summaries ?? [])
          .sorted {
            let lhsDate = calendar.date(from: $0.dateComponents(for: calendar)) ?? .distantPast
            let rhsDate = calendar.date(from: $1.dateComponents(for: calendar)) ?? .distantPast
            return lhsDate < rhsDate
          }
          .map { Self.activityTarget(from: $0, calendar: calendar) }
        continuation.resume(returning: targets)
      }
      healthStore.execute(query)
    }
  }

  func fetchWorkoutDataList(startDate: Date, endDate: Date) async throws -> [NativeWorkoutInterval] {
    let predicate = HKQuery.predicateForSamples(
      withStart: startDate,
      end: endDate,
      options: []
    )
    let sort = NSSortDescriptor(key: HKSampleSortIdentifierEndDate, ascending: true)

    return try await withCheckedThrowingContinuation { continuation in
      let query = HKSampleQuery(
        sampleType: .workoutType(),
        predicate: predicate,
        limit: HKObjectQueryNoLimit,
        sortDescriptors: [sort]
      ) { _, samples, error in
        if let error {
          continuation.resume(throwing: error)
          return
        }
        let workouts = (samples as? [HKWorkout] ?? []).map {
          NativeWorkoutInterval(
            workoutType: Int($0.workoutActivityType.rawValue),
            startTime: $0.startDate.timeIntervalSince1970,
            endTime: $0.endDate.timeIntervalSince1970
          )
        }
        continuation.resume(returning: workouts)
      }
      healthStore.execute(query)
    }
  }

  func fetchRawData(
    for dataType: NativeHealthDataType,
    startDate: Date,
    endDate: Date
  ) async throws -> [NativeHealthRawDataPoint] {
    switch dataType {
    case .hrv:
      return try await fetchRawQuantitySamples(
        identifier: .heartRateVariabilitySDNN,
        dataType: .hrv,
        unit: .secondUnit(with: .milli),
        startDate: startDate,
        endDate: endDate
      )
    case .heartRate:
      return try await fetchRawQuantitySamples(
        identifier: .heartRate,
        dataType: .heartRate,
        unit: HKUnit.count().unitDivided(by: .minute()),
        startDate: startDate,
        endDate: endDate
      )
    case .oxygenSaturation:
      let points = try await fetchRawQuantitySamples(
        identifier: .oxygenSaturation,
        dataType: .oxygenSaturation,
        unit: .percent(),
        startDate: startDate,
        endDate: endDate
      )
      return points.map {
        NativeHealthRawDataPoint(
          dataType: $0.dataType,
          startTime: $0.startTime,
          endTime: $0.endTime,
          value: $0.value * 100,
          isMotionLike: nil
        )
      }
    case .activeEnergy:
      return try await fetchRawQuantitySamples(
        identifier: .activeEnergyBurned,
        dataType: .activeEnergy,
        unit: .kilocalorie(),
        startDate: startDate,
        endDate: endDate
      )
    case .exercise:
      return try await fetchRawQuantitySamples(
        identifier: .appleExerciseTime,
        dataType: .exercise,
        unit: .second(),
        startDate: startDate,
        endDate: endDate
      )
    case .stand:
      return try await fetchRawQuantitySamples(
        identifier: .appleStandTime,
        dataType: .stand,
        unit: .hour(),
        startDate: startDate,
        endDate: endDate
      )
    case .steps:
      return try await fetchRawQuantitySamples(
        identifier: .stepCount,
        dataType: .steps,
        unit: .count(),
        startDate: startDate,
        endDate: endDate
      )
    case .walkingHeartRate:
      return try await fetchRawQuantitySamples(
        identifier: .walkingHeartRateAverage,
        dataType: .walkingHeartRate,
        unit: HKUnit.count().unitDivided(by: .minute()),
        startDate: startDate,
        endDate: endDate
      )
    case .restingHeartRate:
      return try await fetchRawQuantitySamples(
        identifier: .restingHeartRate,
        dataType: .restingHeartRate,
        unit: HKUnit.count().unitDivided(by: .minute()),
        startDate: startDate,
        endDate: endDate
      )
    case .sleepingHeartRate:
      return try await fetchRawQuantitySamples(
        identifier: .heartRate,
        dataType: .sleepingHeartRate,
        unit: HKUnit.count().unitDivided(by: .minute()),
        startDate: startDate,
        endDate: endDate
      )
    case .sleepingWristTemperature:
      return try await fetchRawQuantitySamples(
        identifier: .appleSleepingWristTemperature,
        dataType: .sleepingWristTemperature,
        unit: .degreeCelsius(),
        startDate: startDate,
        endDate: endDate
      )
    case .respiratoryRate:
      return try await fetchRawQuantitySamples(
        identifier: .respiratoryRate,
        dataType: .respiratoryRate,
        unit: HKUnit.count().unitDivided(by: .minute()),
        startDate: startDate,
        endDate: endDate
      )
    case .irregularHeartRhythm:
      return try await fetchRawIrregularHeartRhythmEvents(startDate: startDate, endDate: endDate)
    case .sleep:
      return []
    }
  }

  private static func activityTarget(
    from summary: HKActivitySummary,
    calendar: Calendar
  ) -> NativeActivityTarget {
    let day = calendar.date(from: summary.dateComponents(for: calendar))
    let timestamp = day.map { calendar.startOfDay(for: $0).timeIntervalSince1970 }

    return NativeActivityTarget(
      healthValueTimestamp: timestamp,
      move: Int(summary.activeEnergyBurnedGoal.doubleValue(for: .kilocalorie())),
      stand: Int(summary.appleStandHoursGoal.doubleValue(for: .count())),
//      activityMoveMode: Self.activityMoveModeValue(from: summary),
      activeEnergyBurned: summary.activeEnergyBurned.doubleValue(for: .kilocalorie()),
      activeEnergyBurnedGoal: summary.activeEnergyBurnedGoal.doubleValue(for: .kilocalorie()),
      appleMoveTime: Self.appleMoveTimeValue(from: summary),
      appleMoveTimeGoal: Self.appleMoveTimeGoalValue(from: summary),
      appleExerciseTime: summary.appleExerciseTime.doubleValue(for: .second()),
      exerciseTimeGoal: Self.exerciseTimeGoalValue(from: summary),
      appleStandHours: summary.appleStandHours.doubleValue(for: .count()),
      standHoursGoal: summary.standHoursGoal?.doubleValue(for: .count()),
    )
  }

  private static func activityMoveModeValue(from summary: HKActivitySummary) -> Int? {
    if #available(iOS 14.0, *) {
      return summary.activityMoveMode.rawValue
    }
    return nil
  }

  private static func appleMoveTimeValue(from summary: HKActivitySummary) -> Double? {
    if #available(iOS 14.0, *) {
      return summary.appleMoveTime.doubleValue(for: .second())
    }
    return nil
  }

  private static func appleMoveTimeGoalValue(from summary: HKActivitySummary) -> Double? {
    if #available(iOS 14.0, *) {
      return summary.appleMoveTimeGoal.doubleValue(for: .second())
    }
    return nil
  }

  private static func exerciseTimeGoalValue(from summary: HKActivitySummary) -> Double? {
    if #available(iOS 16.0, *) {
      return summary.exerciseTimeGoal?.doubleValue(for: .second())
    }
    return nil
  }

  private func fetchHeartRateFamily(startDate: Date, endDate: Date) async throws -> [NativeHealthDataPoint] {
    async let heartRate = fetchQuantitySamples(
      identifier: .heartRate,
      dataType: .heartRate,
      unit: HKUnit.count().unitDivided(by: .minute()),
      startDate: startDate,
      endDate: endDate
    )
    async let walking = fetchQuantitySamples(
      identifier: .walkingHeartRateAverage,
      dataType: .walkingHeartRate,
      unit: HKUnit.count().unitDivided(by: .minute()),
      startDate: startDate,
      endDate: endDate
    )
    async let resting = fetchQuantitySamples(
      identifier: .restingHeartRate,
      dataType: .restingHeartRate,
      unit: HKUnit.count().unitDivided(by: .minute()),
      startDate: startDate,
      endDate: endDate
    )
    return try await heartRate + walking + resting
  }

  private func fetchQuantitySamples(
    identifier: HKQuantityTypeIdentifier,
    dataType: NativeHealthDataType,
    unit: HKUnit,
    startDate: Date,
    endDate: Date
  ) async throws -> [NativeHealthDataPoint] {
    guard let type = NativeHealthTypeCatalog.quantity(identifier) else {
      throw NativeHealthKitError.invalidType(identifier.rawValue)
    }

    // HealthKit can represent derived values such as resting heart rate and
    // walking heart rate average as a day-long sample, then replace that
    // sample as the estimate improves. Requiring the sample's start date to
    // be inside the upload range would drop the replacement whenever the
    // server cursor is later than midnight. Query by interval overlap instead.
    let predicate = HKQuery.predicateForSamples(
      withStart: startDate,
      end: endDate,
      options: []
    )
    let samples = try await fetchQuantitySampleObjects(type: type, predicate: predicate)
    return samples.map { sample in
      NativeHealthDataPoint(
        dataType: dataType,
        time: sample.endDate.timeIntervalSince1970,
        value: sample.quantity.doubleValue(for: unit)
      )
    }
  }

  private func fetchRawQuantitySamples(
    identifier: HKQuantityTypeIdentifier,
    dataType: NativeHealthDataType,
    unit: HKUnit,
    startDate: Date,
    endDate: Date
  ) async throws -> [NativeHealthRawDataPoint] {
    guard let type = NativeHealthTypeCatalog.quantity(identifier) else {
      throw NativeHealthKitError.invalidType(identifier.rawValue)
    }

    let predicate = HKQuery.predicateForSamples(
      withStart: startDate,
      end: endDate,
      options: []
    )
    let samples = try await fetchQuantitySampleObjects(type: type, predicate: predicate)
    return samples.map { sample in
        var ismotion: Bool?
        if identifier == .heartRate, let rawValue = sample.metadata?[ HKMetadataKeyHeartRateMotionContext] as? NSNumber, let context = HKHeartRateMotionContext(rawValue: rawValue.intValue) {
            ismotion = context == .active
        }
        
      return NativeHealthRawDataPoint(
        dataType: dataType,
        startTime: sample.startDate.timeIntervalSince1970,
        endTime: sample.endDate.timeIntervalSince1970,
        value: sample.quantity.doubleValue(for: unit),
        isMotionLike: ismotion
      )
    }
  }

  private func fetchDailyCumulativeSamples(
    identifier: HKQuantityTypeIdentifier,
    dataType: NativeHealthDataType,
    unit: HKUnit,
    startDate: Date,
    endDate: Date
  ) async throws -> [NativeHealthDataPoint] {
    guard let type = NativeHealthTypeCatalog.quantity(identifier) else {
      throw NativeHealthKitError.invalidType(identifier.rawValue)
    }
    let calendar = Calendar.current
    let queryStartDate = calendar.startOfDay(for: startDate)
    let predicate = HKQuery.predicateForSamples(withStart: queryStartDate, end: endDate)
    let samples = try await fetchQuantitySampleObjects(type: type, predicate: predicate)
    let latestEndByDay = samples
      .filter { $0.endDate > startDate }
      .reduce(into: [Date: Date]()) { result, sample in
        let day = calendar.startOfDay(for: sample.startDate)
        result[day] = max(result[day] ?? .distantPast, sample.endDate)
      }

    var points: [NativeHealthDataPoint] = []
    for day in latestEndByDay.keys.sorted() {
      guard let latestEnd = latestEndByDay[day] else { continue }
      let value = try await dailyCumulative(type: type, unit: unit, day: day, endDate: endDate)
      points.append(
        NativeHealthDataPoint(
          dataType: dataType,
          time: Self.uploadTimeForDailyPoint(day: day, latestEnd: latestEnd).timeIntervalSince1970,
          value: value
        )
      )
    }
    return points
  }

  private func fetchDailyStandHours(startDate: Date, endDate: Date) async throws -> [NativeHealthDataPoint] {
    let calendar = Calendar.current
    guard let standType = NativeHealthTypeCatalog.quantity(.appleStandTime) else {
      throw NativeHealthKitError.invalidType("appleStandTime")
    }
    let queryStartDate = calendar.startOfDay(for: startDate)
    let samplePredicate = HKQuery.predicateForSamples(withStart: queryStartDate, end: endDate)
    let samples = try await fetchQuantitySampleObjects(type: standType, predicate: samplePredicate)
    let latestEndByDay = samples
      .filter { $0.endDate > startDate }
      .reduce(into: [Date: Date]()) { result, sample in
        let day = calendar.startOfDay(for: sample.startDate)
        result[day] = max(result[day] ?? .distantPast, sample.endDate)
      }

    guard !latestEndByDay.isEmpty else { return [] }
    var start = calendar.dateComponents([.era, .year, .month, .day], from: latestEndByDay.keys.min()!)
    var end = calendar.dateComponents([.era, .year, .month, .day], from: latestEndByDay.keys.max()!)
    start.calendar = calendar
    end.calendar = calendar
    let summaryPredicate = HKQuery.predicate(forActivitySummariesBetweenStart: start, end: end)

    return try await withCheckedThrowingContinuation { continuation in
      let query = HKActivitySummaryQuery(predicate: summaryPredicate) { _, summaries, error in
        if let error {
          continuation.resume(throwing: error)
          return
        }

        let points = (summaries ?? [])
          .compactMap { summary -> NativeHealthDataPoint? in
            guard let date = calendar.date(from: summary.dateComponents(for: calendar)),
                  let latestEnd = latestEndByDay[calendar.startOfDay(for: date)] else {
              return nil
            }
            return NativeHealthDataPoint(
              dataType: .stand,
              time: Self.uploadTimeForDailyPoint(day: date, latestEnd: latestEnd).timeIntervalSince1970,
              value: summary.appleStandHours.doubleValue(for: .count())
            )
          }
          .sorted { $0.time < $1.time }

        continuation.resume(returning: points)
      }
      healthStore.execute(query)
    }
  }

  private static func uploadTimeForDailyPoint(day: Date, latestEnd: Date) -> Date {
    let calendar = Calendar.current
    let start = calendar.startOfDay(for: day)
    guard let nextDay = calendar.date(byAdding: .day, value: 1, to: start),
          latestEnd >= nextDay else {
      return latestEnd
    }
    return nextDay.addingTimeInterval(-1)
  }

  private func fetchSleepIntervals(startDate: Date, endDate: Date) async throws -> [NativeSleepInterval] {
    guard let type = NativeHealthTypeCatalog.category(.sleepAnalysis) else {
      throw NativeHealthKitError.invalidType("sleepAnalysis")
    }
    // Sleep stages are intervals and can begin before the requested boundary.
    // Include any stage that overlaps the range so overnight data is not lost.
    let predicate = HKQuery.predicateForSamples(
      withStart: startDate,
      end: endDate,
      options: []
    )
    let sort = NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: true)

    return try await withCheckedThrowingContinuation { continuation in
      let query = HKSampleQuery(
        sampleType: type,
        predicate: predicate,
        limit: HKObjectQueryNoLimit,
        sortDescriptors: [sort]
      ) { _, samples, error in
        if let error {
          continuation.resume(throwing: error)
          return
        }
        let intervals = (samples as? [HKCategorySample] ?? []).map { sample in
          NativeSleepInterval(
            dataType: sample.value,
            fromTime: sample.startDate.timeIntervalSince1970,
            toTime: sample.endDate.timeIntervalSince1970
          )
        }
        continuation.resume(returning: intervals)
      }
      healthStore.execute(query)
    }
  }

  private func fetchIrregularHeartRhythmEvents(
    startDate: Date,
    endDate: Date
  ) async throws -> [NativeHealthDataPoint] {
    guard let type = NativeHealthTypeCatalog.category(.irregularHeartRhythmEvent) else {
      throw NativeHealthKitError.invalidType("irregularHeartRhythmEvent")
    }
    let predicate = HKQuery.predicateForSamples(
      withStart: startDate,
      end: endDate,
      options: []
    )
    let sort = NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: true)

    return try await withCheckedThrowingContinuation { continuation in
      let query = HKSampleQuery(
        sampleType: type,
        predicate: predicate,
        limit: HKObjectQueryNoLimit,
        sortDescriptors: [sort]
      ) { _, samples, error in
        if let error {
          continuation.resume(throwing: error)
          return
        }
        let points = (samples as? [HKCategorySample] ?? []).map { sample in
          NativeHealthDataPoint(
            dataType: .irregularHeartRhythm,
            time: sample.endDate.timeIntervalSince1970,
            value: Double(sample.value)
          )
        }
        continuation.resume(returning: points)
      }
      healthStore.execute(query)
    }
  }

  private func fetchRawIrregularHeartRhythmEvents(
    startDate: Date,
    endDate: Date
  ) async throws -> [NativeHealthRawDataPoint] {
    guard let type = NativeHealthTypeCatalog.category(.irregularHeartRhythmEvent) else {
      throw NativeHealthKitError.invalidType("irregularHeartRhythmEvent")
    }
    let predicate = HKQuery.predicateForSamples(
      withStart: startDate,
      end: endDate,
      options: []
    )
    let sort = NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: true)

    return try await withCheckedThrowingContinuation { continuation in
      let query = HKSampleQuery(
        sampleType: type,
        predicate: predicate,
        limit: HKObjectQueryNoLimit,
        sortDescriptors: [sort]
      ) { _, samples, error in
        if let error {
          continuation.resume(throwing: error)
          return
        }
        let points = (samples as? [HKCategorySample] ?? []).map { sample in
          NativeHealthRawDataPoint(
            dataType: .irregularHeartRhythm,
            startTime: sample.startDate.timeIntervalSince1970,
            endTime: sample.endDate.timeIntervalSince1970,
            value: Double(sample.value),
            isMotionLike: nil
          )
        }
        continuation.resume(returning: points)
      }
      healthStore.execute(query)
    }
  }

  private func fetchLatestQuantitySample(type: HKQuantityType) async throws -> HKQuantitySample? {
    let sort = NSSortDescriptor(key: HKSampleSortIdentifierEndDate, ascending: false)
    return try await withCheckedThrowingContinuation { continuation in
      let query = HKSampleQuery(
        sampleType: type,
        predicate: nil,
        limit: 1,
        sortDescriptors: [sort]
      ) { _, samples, error in
        if let error {
          continuation.resume(throwing: error)
          return
        }
        continuation.resume(returning: samples?.first as? HKQuantitySample)
      }
      healthStore.execute(query)
    }
  }

  private func fetchQuantitySampleObjects(
    type: HKQuantityType,
    predicate: NSPredicate
  ) async throws -> [HKQuantitySample] {
    let sort = NSSortDescriptor(key: HKSampleSortIdentifierEndDate, ascending: true)
    return try await withCheckedThrowingContinuation { continuation in
      let query = HKSampleQuery(
        sampleType: type,
        predicate: predicate,
        limit: HKObjectQueryNoLimit,
        sortDescriptors: [sort]
      ) { _, samples, error in
        if let error {
          continuation.resume(throwing: error)
        } else {
          continuation.resume(returning: samples as? [HKQuantitySample] ?? [])
        }
      }
      healthStore.execute(query)
    }
  }

  private func dailyCumulative(
    type: HKQuantityType,
    unit: HKUnit,
    day: Date,
    endDate: Date
  ) async throws -> Double {
    let calendar = Calendar.current
    let start = calendar.startOfDay(for: day)
    let nextDay = calendar.date(byAdding: .day, value: 1, to: start) ?? endDate
    let end = min(nextDay, endDate)
    let predicate = HKQuery.predicateForSamples(
      withStart: start,
      end: end,
      options: .strictStartDate
    )
    return try await withCheckedThrowingContinuation { continuation in
      let query = HKStatisticsQuery(
        quantityType: type,
        quantitySamplePredicate: predicate,
        options: .cumulativeSum
      ) { _, statistics, error in
        if let error {
          continuation.resume(throwing: error)
        } else {
          continuation.resume(returning: statistics?.sumQuantity()?.doubleValue(for: unit) ?? 0)
        }
      }
      healthStore.execute(query)
        
    }
  }
}