import Foundation
import HealthKit

struct AnchoredHealthUploadSummary {
  let commonUploadSuccess: Bool
  let sleepUploadSuccess: Bool
  let errorMessage: String?
  let commonCount: Int
  let sleepCount: Int
}

struct AnchoredHealthUploadAnchorStore {
  static let sleepAnchorKey = "sleep_all"
  static let activityAnchorKey = "activity_all"

  private let defaults: UserDefaults
  private let keyPrefix = "health_upload_query_anchor_all_v1"

  init(defaults: UserDefaults? = AppGroupConstants.defaults) {
    self.defaults = defaults ?? .standard
  }

  func anchor(userId: Int, dataType: NativeHealthDataType) -> HKQueryAnchor? {
    guard let data = data(userId: userId, dataType: dataType) else { return nil }
    return try? NSKeyedUnarchiver.unarchivedObject(ofClass: HKQueryAnchor.self, from: data)
  }

  func anchor(userId: Int, anchorKey: String) -> HKQueryAnchor? {
    guard let data = data(userId: userId, anchorKey: anchorKey) else { return nil }
    return try? NSKeyedUnarchiver.unarchivedObject(ofClass: HKQueryAnchor.self, from: data)
  }

  func activityAnchors(userId: Int) -> AnchoredHealthActivityAnchorBundle? {
    guard let data = data(userId: userId, anchorKey: Self.activityAnchorKey) else { return nil }
    return try? PropertyListDecoder().decode(AnchoredHealthActivityAnchorBundle.self, from: data)
  }

  func data(userId: Int, dataType: NativeHealthDataType) -> Data? {
    guard userId > 0 else { return nil }
    return defaults.data(forKey: key(userId: userId, dataType: dataType))
  }

  func data(userId: Int, anchorKey: String) -> Data? {
    guard userId > 0 else { return nil }
    return defaults.data(forKey: key(userId: userId, anchorKey: anchorKey))
  }

  func save(_ data: Data, userId: Int, dataType: NativeHealthDataType) {
    guard userId > 0 else { return }
    defaults.set(data, forKey: key(userId: userId, dataType: dataType))
  }

  func save(_ data: Data, userId: Int, anchorKey: String) {
    guard userId > 0 else { return }
    defaults.set(data, forKey: key(userId: userId, anchorKey: anchorKey))
  }

  func saveActivityAnchors(_ anchors: AnchoredHealthActivityAnchorBundle, userId: Int) throws {
    guard userId > 0 else { return }
    let data = try PropertyListEncoder().encode(anchors)
    save(data, userId: userId, anchorKey: Self.activityAnchorKey)
  }

  private func key(userId: Int, dataType: NativeHealthDataType) -> String {
    "\(keyPrefix).user_\(userId).type_\(dataType.rawValue)"
  }

  private func key(userId: Int, anchorKey: String) -> String {
    "\(keyPrefix).user_\(userId).anchor_\(anchorKey)"
  }
}

/// A fully separate upload path for testing the all-types anchored strategy.
actor AnchoredHealthDataUploader {
  static let shared = AnchoredHealthDataUploader()

  private let session: URLSession
  private let reader: AnchoredHealthDataReader
  private let anchorStore: AnchoredHealthUploadAnchorStore
  private let userIdProvider: () -> Int?
  private let uploadBatchSize = 300
  private(set) var isUploadingAll = false
  private var uploadAllPending = false
  private var pendingUploadAllTypes = false
  private var pendingUploadDataTypes = Set<NativeHealthDataType>()
  private var uploadAllWaiters: [CheckedContinuation<AnchoredHealthUploadSummary, Never>] = []

  init(
    session: URLSession = .shared,
    anchorStore: AnchoredHealthUploadAnchorStore = AnchoredHealthUploadAnchorStore(),
    userIdProvider: @escaping () -> Int? = { AppShared.shared.userId }
  ) {
    self.session = session
    self.anchorStore = anchorStore
    self.userIdProvider = userIdProvider
    self.reader = AnchoredHealthDataReader(anchorStore: anchorStore, userIdProvider: userIdProvider)
  }

  func uploadAll(
    dataTypes: Set<NativeHealthDataType>? = nil
  ) async -> AnchoredHealthUploadSummary {
    await runUploadAll(
      dataTypes: dataTypes,
      queueAnotherRunIfUploading: false
    )
  }

  func uploadAllAfterObservedChange(sampleTypeIdentifiers: Set<String>) async {
    let mappedDataTypes = Self.uploadDataTypes(for: sampleTypeIdentifiers)
    let shouldFallbackForMissingAnchor: Bool
    if let mappedDataTypes,
       let userId = userIdProvider(), userId > 0 {
      shouldFallbackForMissingAnchor = hasMissingAnchor(dataTypes: mappedDataTypes, userId: userId)
    } else {
      shouldFallbackForMissingAnchor = mappedDataTypes != nil
    }
    let dataTypes = shouldFallbackForMissingAnchor ? nil : mappedDataTypes
    let sources = sampleTypeIdentifiers.isEmpty
      ? "unknown"
      : sampleTypeIdentifiers.sorted().joined(separator: ",")
    if shouldFallbackForMissingAnchor {
      Self.log(
        "uploader.observer.fallback reason=missingAnchor userId=\(userIdProvider() ?? -1)"
      )
    }
    Self.log(
      "uploader.observer.received userId=\(userIdProvider() ?? -1) sources=\(sources) dataTypes=\(Self.describeRequestedDataTypes(dataTypes))"
    )
    _ = await runUploadAll(
      dataTypes: dataTypes,
      queueAnotherRunIfUploading: true
    )
  }

  func uploadAllCommon(
    dataTypes: Set<NativeHealthDataType>? = nil
  ) async throws -> Int {
    let result = try await reader.readCommon(dataTypes: dataTypes)
    Self.log(
      "uploader.common.read userId=\(userIdProvider() ?? -1) count=\(result.data.count) range=\(Self.describeCommonRange(result.data)) anchors=\(Self.describeAnchors(result.anchors))"
    )
    Self.logCommonPoints(result.data, userId: userIdProvider() ?? -1, prefix: "uploader.common.read.item")
    return try await uploadCommon(result.data, anchors: result.anchors)
  }

  func uploadAllSeelp() async throws -> Int {
    try await uploadAllSleep()
  }

  func uploadAllSleep() async throws -> Int {
    let result = try await reader.readAllSleep()
    Self.log(
      "uploader.sleep.read userId=\(userIdProvider() ?? -1) count=\(result.data.count) range=\(Self.describeSleepRange(result.data)) anchorKey=\(AnchoredHealthUploadAnchorStore.sleepAnchorKey) \(Self.describeAnchorData(result.anchor))"
    )
    Self.logSleepIntervals(result.data, userId: userIdProvider() ?? -1, prefix: "uploader.sleep.read.item")
    return try await uploadSleep(result.data, anchor: result.anchor)
  }

  func uploadAllActivity() async throws -> Int {
    guard let userId = userIdProvider(), userId > 0 else {
      throw NativeHealthUploadError.missingUserId
    }
    let result = try await reader.readActivity()
    Self.log(
      "uploader.activity.read userId=\(userId) count=\(result.data.count) targetCount=\(result.targets.count) range=\(Self.describeCommonRange(result.data)) targetRange=\(Self.describeActivityTargetRange(result.targets)) anchors=\(Self.describeActivityAnchors(result.anchors))"
    )
    Self.logCommonPoints(result.data, userId: userId, prefix: "uploader.activity.read.item")
    Self.logActivityTargets(result.targets, userId: userId, prefix: "uploader.activity.target.read.item")
    let commonCount = try await uploadCommon(result.data, anchors: [:])
    try await uploadActivityTargets(result.targets)
    try anchorStore.saveActivityAnchors(result.anchors, userId: userId)
    Self.log(
      "uploader.anchor.saved userId=\(userId) anchorKey=\(AnchoredHealthUploadAnchorStore.activityAnchorKey) reason=activityFinished \(Self.describeActivityAnchors(result.anchors)) uploadedRange=\(Self.describeCommonRange(result.data)) targetRange=\(Self.describeActivityTargetRange(result.targets))"
    )
    return commonCount
  }
}

private extension AnchoredHealthDataUploader {
  static let activityDataTypes: Set<NativeHealthDataType> = [
    .activeEnergy,
    .exercise,
    .stand,
  ]

  static func uploadDataTypes(
    for sampleTypeIdentifiers: Set<String>
  ) -> Set<NativeHealthDataType>? {
    guard !sampleTypeIdentifiers.isEmpty else { return nil }
    var dataTypes = Set<NativeHealthDataType>()

    for identifier in sampleTypeIdentifiers {
      switch identifier {
      case HKQuantityTypeIdentifier.heartRateVariabilitySDNN.rawValue:
        dataTypes.insert(.hrv)
      case HKQuantityTypeIdentifier.heartRate.rawValue:
        dataTypes.formUnion([.heartRate, .sleepingHeartRate])
      case HKQuantityTypeIdentifier.stepCount.rawValue:
        dataTypes.insert(.steps)
      case HKQuantityTypeIdentifier.oxygenSaturation.rawValue:
        dataTypes.insert(.oxygenSaturation)
      case HKQuantityTypeIdentifier.activeEnergyBurned.rawValue:
        dataTypes.insert(.activeEnergy)
      case HKQuantityTypeIdentifier.appleExerciseTime.rawValue:
        dataTypes.insert(.exercise)
      case HKQuantityTypeIdentifier.appleStandTime.rawValue:
        dataTypes.insert(.stand)
      case HKQuantityTypeIdentifier.walkingHeartRateAverage.rawValue:
        dataTypes.insert(.walkingHeartRate)
      case HKQuantityTypeIdentifier.restingHeartRate.rawValue:
        dataTypes.insert(.restingHeartRate)
      case HKQuantityTypeIdentifier.appleSleepingWristTemperature.rawValue:
        dataTypes.insert(.sleepingWristTemperature)
      case HKQuantityTypeIdentifier.respiratoryRate.rawValue:
        dataTypes.insert(.respiratoryRate)
      case HKCategoryTypeIdentifier.irregularHeartRhythmEvent.rawValue:
        dataTypes.insert(.irregularHeartRhythm)
      case HKCategoryTypeIdentifier.sleepAnalysis.rawValue:
        dataTypes.insert(.sleep)
      default:
        return nil
      }
    }
    return dataTypes
  }

  static func describeRequestedDataTypes(
    _ dataTypes: Set<NativeHealthDataType>?
  ) -> String {
    dataTypes.map { types in
      types.map(\.rawValue).sorted().map(String.init).joined(separator: ",")
    } ?? "all"
  }

  func hasMissingAnchor(dataTypes: Set<NativeHealthDataType>, userId: Int) -> Bool {
    dataTypes.contains { dataType in
      if dataType == .sleep {
        return anchorStore.anchor(
          userId: userId,
          anchorKey: AnchoredHealthUploadAnchorStore.sleepAnchorKey
        ) == nil
      }
      if Self.activityDataTypes.contains(dataType) {
        return anchorStore.activityAnchors(userId: userId) == nil
      }
      return anchorStore.anchor(userId: userId, dataType: dataType) == nil
    }
  }

  func runUploadAll(
    dataTypes: Set<NativeHealthDataType>?,
    queueAnotherRunIfUploading: Bool
  ) async -> AnchoredHealthUploadSummary {
    if isUploadingAll {
      if queueAnotherRunIfUploading {
        uploadAllPending = true
        if let dataTypes {
          if !pendingUploadAllTypes {
            pendingUploadDataTypes.formUnion(dataTypes)
          }
        } else {
          pendingUploadAllTypes = true
          pendingUploadDataTypes.removeAll()
        }
        Self.log(
          "uploader.all.pending userId=\(userIdProvider() ?? -1) dataTypes=\(Self.describeRequestedDataTypes(dataTypes))"
        )
      } else {
        Self.log("uploader.all.skip reason=alreadyUploading userId=\(userIdProvider() ?? -1)")
      }
      return await withCheckedContinuation { continuation in
        uploadAllWaiters.append(continuation)
      }
    }

    isUploadingAll = true
    var summary: AnchoredHealthUploadSummary
    var requestedDataTypes = dataTypes
    while true {
      uploadAllPending = false
      pendingUploadAllTypes = false
      pendingUploadDataTypes.removeAll()
      Self.log(
        "uploader.all.start userId=\(userIdProvider() ?? -1) dataTypes=\(Self.describeRequestedDataTypes(requestedDataTypes))"
      )
      summary = await performUploadAll(dataTypes: requestedDataTypes)
      Self.log(
        "uploader.all.end userId=\(userIdProvider() ?? -1) commonSuccess=\(summary.commonUploadSuccess) sleepSuccess=\(summary.sleepUploadSuccess) commonCount=\(summary.commonCount) sleepCount=\(summary.sleepCount) error=\(summary.errorMessage ?? "nil")"
      )
      guard uploadAllPending else { break }
      requestedDataTypes = pendingUploadAllTypes ? nil : pendingUploadDataTypes
    }
    isUploadingAll = false

    let waiters = uploadAllWaiters
    uploadAllWaiters.removeAll()
    waiters.forEach { $0.resume(returning: summary) }
    return summary
  }

  func performUploadAll(
    dataTypes: Set<NativeHealthDataType>?
  ) async -> AnchoredHealthUploadSummary {
    guard AppShared.shared.token?.isEmpty == false else {
      let message = NativeHealthUploadError.missingAccessToken.localizedDescription
      return AnchoredHealthUploadSummary(
        commonUploadSuccess: false,
        sleepUploadSuccess: false,
        errorMessage: message,
        commonCount: 0,
        sleepCount: 0
      )
    }

    var commonCount = 0
    var sleepCount = 0
    var commonUploadSuccess = true
    var sleepUploadSuccess = true
    var errorMessages: [String] = []
    let commonTypes = dataTypes.map { types in
      Set(types.filter {
        $0 != .sleep && $0 != .unknown && !Self.activityDataTypes.contains($0)
      })
    }
    let includesCommon = commonTypes == nil || commonTypes?.isEmpty == false
    let includesActivity = dataTypes == nil || dataTypes?.contains(where: { Self.activityDataTypes.contains($0) }) == true
    let includesSleep = dataTypes == nil || dataTypes?.contains(.sleep) == true

    if includesCommon {
      do {
        commonCount = try await uploadAllCommon(dataTypes: commonTypes)
      } catch {
        commonUploadSuccess = false
        errorMessages.append("common 上传失败：\(error.localizedDescription)")
      }
    }

    if includesActivity {
      do {
        commonCount += try await uploadAllActivity()
      } catch {
        commonUploadSuccess = false
        errorMessages.append("activity 上传失败：\(error.localizedDescription)")
      }
    }

    if includesSleep {
      do {
        sleepCount = try await uploadAllSleep()
      } catch {
        sleepUploadSuccess = false
        errorMessages.append("sleep 上传失败：\(error.localizedDescription)")
      }
    }

    return AnchoredHealthUploadSummary(
      commonUploadSuccess: commonUploadSuccess,
      sleepUploadSuccess: sleepUploadSuccess,
      errorMessage: errorMessages.isEmpty ? nil : errorMessages.joined(separator: "\n"),
      commonCount: commonCount,
      sleepCount: sleepCount
    )
  }

  func uploadCommon(
    _ data: [NativeHealthDataPoint],
    anchors: [NativeHealthDataType: Data]
  ) async throws -> Int {
    guard let userId = userIdProvider(), userId > 0 else {
      throw NativeHealthUploadError.missingUserId
    }
    guard !data.isEmpty else {
      Self.log(
        "uploader.common.empty userId=\(userId) anchors=\(Self.describeAnchors(anchors))"
      )
      anchors.forEach { anchorStore.save($0.value, userId: userId, dataType: $0.key) }
      anchors.forEach {
        Self.log(
          "uploader.anchor.saved userId=\(userId) dataType=\($0.key.rawValue) reason=emptyCommon \(Self.describeAnchorData($0.value))"
        )
      }
      return 0
    }

    Self.log(
      "uploader.common.start userId=\(userId) count=\(data.count) range=\(Self.describeCommonRange(data)) batchSize=\(uploadBatchSize) anchors=\(Self.describeAnchors(anchors))"
    )
    var uploadedCount = 0
    var remainingCountByType = anchors.keys.reduce(into: [NativeHealthDataType: Int]()) { result, type in
      result[type] = 0
    }
    data.forEach { point in
      remainingCountByType[point.dataType, default: 0] += 1
    }

    for (batchIndex, batch) in SharedHealthAnchoredUploadSupport.batches(data, size: uploadBatchSize).enumerated() {
      let list = batch.map {
        [
          "data_type": $0.dataType.rawValue,
          "time": $0.time,
          "value": $0.value,
        ] as [String: Any]
      }
      try await request(
        path: "/client/doublefeel/health/v2/data_upload/common/",
        method: "POST",
        body: ["data_list": list]
      )

      uploadedCount += batch.count
      for point in batch {
        remainingCountByType[point.dataType, default: 0] -= 1
      }
      Self.log(
        "uploader.common.batch.success userId=\(userId) batch=\(batchIndex + 1) count=\(batch.count) range=\(Self.describeCommonRange(batch)) uploadedCount=\(uploadedCount)/\(data.count)"
      )
      saveFinishedAnchors(
        anchors,
        userId: userId,
        finishedTypes: remainingCountByType.filter { $0.value <= 0 }.map(\.key)
      )
      batch.forEach { point in
        DebugLogger.debugLog(
          "[ArchUploader] uploader.common.batch.success.item userId=\(userId) dataType=\(point.dataType.rawValue) time=\(Self.debugTimestamp(point.time)) unix=\(Int64(point.time)) value=\(point.value)"
        )
      }
    }

    return uploadedCount
  }

  func uploadActivityTargets(_ targets: [NativeActivityTarget]) async throws {
    guard let userId = userIdProvider(), userId > 0 else {
      throw NativeHealthUploadError.missingUserId
    }
    guard !targets.isEmpty else {
      Self.log("uploader.activityTarget.empty userId=\(userId)")
      return
    }

    for (index, target) in targets.enumerated() {
      try await request(
        path: "/client/doublefeel/health/v2/activity_target/",
        method: "POST",
        body: target.uploadBody
      )
      let timestamp = target.healthValueTimestamp ?? 0
      Self.log(
        "uploader.activityTarget.success userId=\(userId) index=\(index + 1)/\(targets.count) time=\(Self.debugTimestamp(timestamp)) unix=\(Int64(timestamp)) body=\(target.uploadBodyForDebug)"
      )
    }
  }

  func uploadSleep(
    _ data: [NativeSleepInterval],
    anchor: Data
  ) async throws -> Int {
    guard let userId = userIdProvider(), userId > 0 else {
      throw NativeHealthUploadError.missingUserId
    }
    guard !data.isEmpty else {
      Self.log(
        "uploader.sleep.empty userId=\(userId) anchorKey=\(AnchoredHealthUploadAnchorStore.sleepAnchorKey) \(Self.describeAnchorData(anchor))"
      )
      anchorStore.save(anchor, userId: userId, anchorKey: AnchoredHealthUploadAnchorStore.sleepAnchorKey)
      Self.log(
        "uploader.anchor.saved userId=\(userId) anchorKey=\(AnchoredHealthUploadAnchorStore.sleepAnchorKey) reason=emptySleep \(Self.describeAnchorData(anchor))"
      )
      return 0
    }

    Self.log(
      "uploader.sleep.start userId=\(userId) count=\(data.count) range=\(Self.describeSleepRange(data)) batchSize=\(uploadBatchSize) anchorKey=\(AnchoredHealthUploadAnchorStore.sleepAnchorKey) \(Self.describeAnchorData(anchor))"
    )
    var uploadedCount = 0
    for (batchIndex, batch) in SharedHealthAnchoredUploadSupport.batches(data, size: uploadBatchSize).enumerated() {
      let list = batch.map {
        [
          "data_type": $0.dataType,
          "from_time": $0.fromTime,
          "to_time": $0.toTime,
        ] as [String: Any]
      }
      try await request(
        path: "/client/doublefeel/health/v2/data_upload/sleep/",
        method: "POST",
        body: ["data_list": list]
      )

      uploadedCount += batch.count
      Self.log(
        "uploader.sleep.batch.success userId=\(userId) batch=\(batchIndex + 1) count=\(batch.count) range=\(Self.describeSleepRange(batch)) uploadedCount=\(uploadedCount)/\(data.count)"
      )
      if uploadedCount == data.count {
        anchorStore.save(anchor, userId: userId, anchorKey: AnchoredHealthUploadAnchorStore.sleepAnchorKey)
        Self.log(
          "uploader.anchor.saved userId=\(userId) anchorKey=\(AnchoredHealthUploadAnchorStore.sleepAnchorKey) reason=sleepFinished \(Self.describeAnchorData(anchor)) uploadedRange=\(Self.describeSleepRange(data))"
        )
      }
      batch.forEach { interval in
        DebugLogger.debugLog(
          "[ArchUploader] uploader.sleep.batch.success.item userId=\(userId) dataType=\(interval.dataType) from=\(Self.debugTimestamp(interval.fromTime)) fromUnix=\(Int64(interval.fromTime)) to=\(Self.debugTimestamp(interval.toTime)) toUnix=\(Int64(interval.toTime))"
        )
      }
    }

    return uploadedCount
  }

  func saveFinishedAnchors(
    _ anchors: [NativeHealthDataType: Data],
    userId: Int,
    finishedTypes: [NativeHealthDataType]
  ) {
    for type in finishedTypes {
      guard let anchor = anchors[type] else { continue }
      anchorStore.save(anchor, userId: userId, dataType: type)
      Self.log(
        "uploader.anchor.saved userId=\(userId) dataType=\(type.rawValue) reason=commonTypeFinished \(Self.describeAnchorData(anchor))"
      )
    }
  }

  @discardableResult
  func request(path: String, method: String, body: [String: Any]? = nil) async throws -> Data {
    guard let baseURL = URL(string: AppShared.shared.baseUrl),
          let url = URL(string: path, relativeTo: baseURL)?.absoluteURL else {
      throw NativeHealthUploadError.invalidServerURL
    }
    guard let accessToken = AppShared.shared.token, !accessToken.isEmpty else {
      throw NativeHealthUploadError.missingAccessToken
    }

    var request = URLRequest(url: url)
    request.httpMethod = method
    request.timeoutInterval = 60
    request.setValue("application/json", forHTTPHeaderField: "Accept")
    request.setValue(accessToken, forHTTPHeaderField: "access_token")
    request.setValue(AppShared.shared.agent.finalUA, forHTTPHeaderField: "User-Agent")

    if let body {
      request.setValue("application/json", forHTTPHeaderField: "Content-Type")
      request.httpBody = try JSONSerialization.data(withJSONObject: body)
    }

    let (data, response) = try await session.data(for: request)
    guard let httpResponse = response as? HTTPURLResponse else {
      throw NativeHealthUploadError.invalidResponse
    }
    guard (200..<300).contains(httpResponse.statusCode) else {
      if httpResponse.statusCode == 401 {
        await MainActor.run {
          AppShared.shared.logout()
        }
      }
      throw NativeHealthUploadError.requestFailed(
        path: path,
        statusCode: httpResponse.statusCode,
        body: String(data: data, encoding: .utf8)
      )
    }
    return data
  }

  static func debugTimestamp(_ timeInterval: TimeInterval) -> String {
    Self.debugDateFormatter.string(from: Date(timeIntervalSince1970: timeInterval))
  }

  static func log(_ message: String) {
    DebugLogger.debugLog("[ArchUploader] \(message)")
  }

  static func logCommonPoints(
    _ points: [NativeHealthDataPoint],
    userId: Int,
    prefix: String
  ) {
    points.forEach { point in
      log(
        "\(prefix) userId=\(userId) dataType=\(point.dataType.rawValue) time=\(debugTimestamp(point.time)) unix=\(Int64(point.time)) value=\(point.value)"
      )
    }
  }

  static func logSleepIntervals(
    _ intervals: [NativeSleepInterval],
    userId: Int,
    prefix: String
  ) {
    intervals.forEach { interval in
      log(
        "\(prefix) userId=\(userId) dataType=\(interval.dataType) from=\(debugTimestamp(interval.fromTime)) fromUnix=\(Int64(interval.fromTime)) to=\(debugTimestamp(interval.toTime)) toUnix=\(Int64(interval.toTime))"
      )
    }
  }

  static func logActivityTargets(
    _ targets: [NativeActivityTarget],
    userId: Int,
    prefix: String
  ) {
    targets.forEach { target in
      let timestamp = target.healthValueTimestamp ?? 0
      log(
        "\(prefix) userId=\(userId) time=\(debugTimestamp(timestamp)) unix=\(Int64(timestamp)) body=\(target.uploadBodyForDebug)"
      )
    }
  }

  static func describeCommonRange(_ points: [NativeHealthDataPoint]) -> String {
    guard let minTime = points.map(\.time).min(),
          let maxTime = points.map(\.time).max() else {
      return "empty"
    }
    return "\(debugTimestamp(minTime))...\(debugTimestamp(maxTime))"
  }

  static func describeSleepRange(_ intervals: [NativeSleepInterval]) -> String {
    guard let minTime = intervals.map(\.fromTime).min(),
          let maxTime = intervals.map(\.toTime).max() else {
      return "empty"
    }
    return "\(debugTimestamp(minTime))...\(debugTimestamp(maxTime))"
  }

  static func describeActivityTargetRange(_ targets: [NativeActivityTarget]) -> String {
    let times = targets.compactMap(\.healthValueTimestamp)
    guard let minTime = times.min(),
          let maxTime = times.max() else {
      return "empty"
    }
    return "\(debugTimestamp(minTime))...\(debugTimestamp(maxTime))"
  }

  static func describeAnchors(_ anchors: [NativeHealthDataType: Data]) -> String {
    anchors
      .map { "type:\($0.key.rawValue)=\(describeAnchorData($0.value))" }
      .sorted()
      .joined(separator: ",")
  }

  static func describeAnchorData(_ data: Data) -> String {
    "anchor=size:\(data.count),hash:\(data.stableDebugHash)"
  }

  static func describeActivityAnchors(_ anchors: AnchoredHealthActivityAnchorBundle) -> String {
    [
      "activeEnergy=\(describeAnchorData(anchors.activeEnergy))",
      "exercise=\(describeAnchorData(anchors.exercise))",
      "stand=\(describeAnchorData(anchors.stand))",
    ].joined(separator: ",")
  }

  static let debugDateFormatter: DateFormatter = {
    let formatter = DateFormatter()
    formatter.locale = Locale(identifier: "en_US_POSIX")
    formatter.dateFormat = "yyyy-MM-dd HH:mm:ss"
    return formatter
  }()
}


private extension Data {
  var stableDebugHash: String {
    let hash = reduce(UInt64(14_695_981_039_346_656_037)) { result, byte in
      (result ^ UInt64(byte)).multipliedReportingOverflow(by: 1_099_511_628_211).partialValue
    }
    return String(hash, radix: 16)
  }
}