import Foundation

enum NativeHealthUploadConfiguration {
  /// Process-lifetime throttle. Each health data type can start at most one
  /// upload request during this interval.
  static let minimumTriggerInterval: TimeInterval = 60
}

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

enum NativeHealthUploadError: LocalizedError {
  case invalidServerURL
  case missingAccessToken
  case invalidResponse
  case requestFailed(path: String, statusCode: Int, body: String?)

  var errorDescription: String? {
    switch self {
    case .invalidServerURL:
      return "健康数据上传地址无效"
    case .missingAccessToken:
      return "缺少登录态，无法上传健康数据"
    case .invalidResponse:
      return "健康数据上传接口响应无效"
    case .requestFailed(let path, let statusCode, let body):
      return "健康数据接口请求失败：\(path), HTTP \(statusCode)\(body.map { ", \($0)" } ?? "")"
    }
  }
}

/// Uploads Apple Health data to DoubleFeel.
///
/// Data reading stays in `HealthDataReader` / `HealthKitService`; this type only
/// owns upload requests. Upload boundaries always come from the server's
/// `/data_upload/common/` response.
actor NativeHealthDataUploader {
  static let shared = NativeHealthDataUploader()

  private let session: URLSession
  private let defaultUploadTimeWeek = 1
  private let firstUploadYear = 2
  private let uploadBatchSize = 500
  private var lastUploadTriggerDates: [NativeHealthDataType: Date] = [:]

  init(session: URLSession = .shared) {
    self.session = session
  }

  func uploadAll(service: HealthKitService = .shared) async -> NativeHealthUploadSummary {
    guard AppShared.shared.token?.isEmpty == false else {
      let message = NativeHealthUploadError.missingAccessToken.localizedDescription
      DebugLogger.debugLog("uploadAll skipped, user is not logged in")
      return NativeHealthUploadSummary(
        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] = []

      DebugLogger.debugLog("uploadAll started ")
    do {
      let uploadTimeList = try await processLastUploadTime()

      for type in Self.commonUploadTypes {
        let result = await upload(
          type: type,
          uploadTimeList: uploadTimeList,
          trigger: .full,
          service: service
        )
        commonCount += result.uploadedCount
        if !result.success {
          commonUploadSuccess = false
          if let errorMessage = result.errorMessage {
            errorMessages.append(errorMessage)
          }
        }
      }

      let sleepResult = await upload(
        type: .sleep,
        uploadTimeList: uploadTimeList,
        trigger: .full,
        service: service
      )
      sleepCount = sleepResult.uploadedCount
      sleepUploadSuccess = sleepResult.success
      if let errorMessage = sleepResult.errorMessage {
        errorMessages.append(errorMessage)
      }

      let activityTargetUploaded = await uploadActivityTargetIfNeeded(
        uploadTimeList: uploadTimeList,
        service: service
      )
      if !activityTargetUploaded.success {
        commonUploadSuccess = false
        if let errorMessage = activityTargetUploaded.errorMessage {
          errorMessages.append(errorMessage)
        }
      }
    } catch {
      commonUploadSuccess = false
      sleepUploadSuccess = false
      errorMessages.append(error.localizedDescription)
      DebugLogger.debugLog("uploadAll failed before per-type upload, error=\(error.localizedDescription)")
    }

    DebugLogger.debugLog("uploadAll finished, commonSuccess=\(commonUploadSuccess), sleepSuccess=\(sleepUploadSuccess), commonCount=\(commonCount), sleepCount=\(sleepCount), error=\(errorMessages.isEmpty ? "<nil>" : errorMessages.joined(separator: " | "))")

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

  func upload(type: NativeHealthDataType, service: HealthKitService = .shared) async -> Bool {
    guard AppShared.shared.token?.isEmpty == false else {
      DebugLogger.debugLog("upload(\(type.debugName)) skipped, user is not logged in")
      return false
    }
    do {
      let uploadTimeList = try await processLastUploadTime()
      return await upload(
        type: type,
        uploadTimeList: uploadTimeList,
        trigger: .manual,
        service: service
      ).success
    } catch {
      DebugLogger.debugLog("upload(\(type.debugName)) failed to process last upload time, error=\(error.localizedDescription)")
      DebugLogger.debugLog("Health upload failed to process last upload time: \(error.localizedDescription)")
      return false
    }
  }

  func uploadObservedChange(
    types: [NativeHealthDataType],
    includeActivityTarget: Bool,
    service: HealthKitService = .shared
  ) async -> Bool {
    guard AppShared.shared.token?.isEmpty == false else {
      DebugLogger.debugLog("observed change skipped, user is not logged in")
      return false
    }

    do {
      let uploadTimeList = try await processLastUploadTime()
      var success = true
      var uploadedNewData = false
      for type in types {
        let result = await upload(
          type: type,
          uploadTimeList: uploadTimeList,
          trigger: .observer,
          service: service
        )
        success = success && result.success
        uploadedNewData = uploadedNewData || result.uploadedCount > 0
      }
      if includeActivityTarget && uploadedNewData {
        let result = await uploadActivityTargetIfNeeded(
          uploadTimeList: uploadTimeList,
          service: service
        )
        success = success && result.success
      }
      return success
    } catch {
      DebugLogger.debugLog("observed change upload failed, error=\(error.localizedDescription)")
      return false
    }
  }
}

private extension NativeHealthDataUploader {
  struct UploadTaskResult {
    let success: Bool
    let uploadedCount: Int
    let errorMessage: String?
  }

  enum UploadTrigger: String {
    case full
    case observer
    case manual
  }

  static let commonUploadTypes: [NativeHealthDataType] = [
    .hrv,
    .heartRate,
    .walkingHeartRate,
    .restingHeartRate,
    .sleepingHeartRate,
    .oxygenSaturation,
    .activeEnergy,
    .exercise,
    .stand,
    .steps,
    .sleepingWristTemperature,
    .respiratoryRate,
    .irregularHeartRhythm,
  ]

  func upload(
    type: NativeHealthDataType,
    uploadTimeList: NativeHealthUploadTimeList,
    trigger: UploadTrigger,
    service: HealthKitService
  ) async -> UploadTaskResult {
    guard type != .unknown,
          let startUploadDate = uploadTimeList.latestDataTime(for: type) else {
      DebugLogger.debugLog("[\(type.debugName)] skipped, no upload start date")
      return UploadTaskResult(success: true, uploadedCount: 0, errorMessage: nil)
    }

    let endUploadDate = Date()
    DebugLogger.debugLog(
      "[\(type.debugName)] upload started, trigger=\(trigger.rawValue), range=\(Self.debugDateFormatter.string(from: startUploadDate)) -> \(Self.debugDateFormatter.string(from: endUploadDate))"
    )
    guard endUploadDate >= startUploadDate else {
      DebugLogger.debugLog("[\(type.debugName)] upload failed, start date is later than end date")
      return UploadTaskResult(
        success: false,
        uploadedCount: 0,
        errorMessage: "健康数据上传开始时间晚于结束时间：\(type)"
      )
    }

    do {
      switch type {
      case .sleep:
        DebugLogger.debugLog("[\(type.debugName)] reading sleep data")
        let data = try await service.fetchSleepData(startDate: startUploadDate, endDate: endUploadDate)
          .filter { $0.toTime > startUploadDate.timeIntervalSince1970 }
          .sorted { $0.toTime < $1.toTime }
        debugLogTimeComparison(
          type: type,
          serverTime: startUploadDate.timeIntervalSince1970,
          newestTime: data.map(\.toTime).max()
        )
        DebugLogger.debugLog("[\(type.debugName)] read finished, count=\(data.count)")
        guard !data.isEmpty else {
          DebugLogger.debugLog("[\(type.debugName)] no data; server upload time remains unchanged")
          return UploadTaskResult(success: true, uploadedCount: 0, errorMessage: nil)
        }
        guard allowUploadTrigger(for: type) else {
          return UploadTaskResult(success: true, uploadedCount: 0, errorMessage: nil)
        }
        DebugLogger.debugLog("[\(type.debugName)] uploading, count=\(data.count)")
        try await uploadSleep(data)
        notifyFlutterUpload(
          type: type,
          timestamp: data.map(\.toTime).max() ?? endUploadDate.timeIntervalSince1970
        )
        DebugLogger.debugLog("[\(type.debugName)] upload success, count=\(data.count); next boundary will come from server")
        return UploadTaskResult(success: true, uploadedCount: data.count, errorMessage: nil)
      default:
        DebugLogger.debugLog("[\(type.debugName)] reading common data")
        let data = try await fetchCommonData(
          type: type,
          startDate: startUploadDate,
          endDate: endUploadDate,
          service: service
        )
          .filter { $0.time > startUploadDate.timeIntervalSince1970 }
          .sorted { $0.time < $1.time }
        debugLogTimeComparison(
          type: type,
          serverTime: startUploadDate.timeIntervalSince1970,
          newestTime: data.map(\.time).max()
        )
        DebugLogger.debugLog("[\(type.debugName)] read finished, count=\(data.count)")
        guard !data.isEmpty else {
          DebugLogger.debugLog("[\(type.debugName)] no data; server upload time remains unchanged")
          return UploadTaskResult(success: true, uploadedCount: 0, errorMessage: nil)
        }
        guard allowUploadTrigger(for: type) else {
          return UploadTaskResult(success: true, uploadedCount: 0, errorMessage: nil)
        }
        DebugLogger.debugLog("[\(type.debugName)] uploading, count=\(data.count)")
        try await uploadCommon(data)
        notifyFlutterUpload(
          type: type,
          timestamp: data.map(\.time).max() ?? endUploadDate.timeIntervalSince1970
        )
        DebugLogger.debugLog("[\(type.debugName)] upload success, count=\(data.count); next boundary will come from server")
        return UploadTaskResult(success: true, uploadedCount: data.count, errorMessage: nil)
      }
    } catch {
      DebugLogger.debugLog("[\(type.debugName)] upload failed, error=\(error.localizedDescription)")
      return UploadTaskResult(
        success: false,
        uploadedCount: 0,
        errorMessage: "健康数据上传失败：\(type), \(error.localizedDescription)"
      )
    }
  }

  func fetchCommonData(
    type: NativeHealthDataType,
    startDate: Date,
    endDate: Date,
    service: HealthKitService
  ) async throws -> [NativeHealthDataPoint] {
    switch type {
    case .hrv:
      return try await service.fetchHrvData(startDate: startDate, endDate: endDate)
    case .heartRate:
      return try await service.fetchHeartRateData(startDate: startDate, endDate: endDate)
    case .walkingHeartRate:
      return try await service.fetchWalkingHeartRateData(startDate: startDate, endDate: endDate)
    case .restingHeartRate:
      return try await service.fetchRestingHeartRateData(startDate: startDate, endDate: endDate)
    case .sleepingHeartRate:
      return try await service.fetchSleepingHeartRateData(startDate: startDate, endDate: endDate)
    case .oxygenSaturation:
      return try await service.fetchOxygenSaturationData(startDate: startDate, endDate: endDate)
    case .activeEnergy:
      return try await service.fetchActiveEnergyData(startDate: startDate, endDate: endDate)
    case .exercise:
      return try await service.fetchExerciseData(startDate: startDate, endDate: endDate)
    case .stand:
      return try await service.fetchStandData(startDate: startDate, endDate: endDate)
    case .steps:
      return try await service.fetchStepCountData(startDate: startDate, endDate: endDate)
    case .sleepingWristTemperature:
      return try await service.fetchSleepingWristTemperatureData(startDate: startDate, endDate: endDate)
    case .respiratoryRate:
      return try await service.fetchRespiratoryRateData(startDate: startDate, endDate: endDate)
    case .irregularHeartRhythm:
      return try await service.fetchIrregularHeartRhythmData(startDate: startDate, endDate: endDate)
    case .unknown, .sleep:
      return []
    }
  }

  func uploadActivityTargetIfNeeded(
    uploadTimeList: NativeHealthUploadTimeList,
    service: HealthKitService
  ) async -> UploadTaskResult {
    let startDate = uploadTimeList.latestDataTime(for: .activeEnergy)
      ?? Calendar.current.date(byAdding: .weekOfYear, value: -defaultUploadTimeWeek, to: Date())
      ?? Date(timeIntervalSinceNow: -7 * 24 * 60 * 60)
    let endDate = Date()

    DebugLogger.debugLog(
      "[activityTarget] upload started, range=\(Self.debugDateFormatter.string(from: startDate)) -> \(Self.debugDateFormatter.string(from: endDate))"
    )
    do {
      guard let target = try await service.fetchActivityTargetData(startDate: startDate, endDate: endDate),
            target.move != nil || target.stand != nil else {
        DebugLogger.debugLog("[activityTarget] no target data")
        return UploadTaskResult(success: true, uploadedCount: 0, errorMessage: nil)
      }
      DebugLogger.debugLog("[activityTarget] uploading, body=\(target.uploadBodyForDebug)")
      try await uploadActivityTarget(target)
      DebugLogger.debugLog("[activityTarget] upload success")
      return UploadTaskResult(success: true, uploadedCount: 1, errorMessage: nil)
    } catch {
      DebugLogger.debugLog("[activityTarget] upload failed, error=\(error.localizedDescription)")
      return UploadTaskResult(
        success: false,
        uploadedCount: 0,
        errorMessage: "活动目标上传失败：\(error.localizedDescription)"
      )
    }
  }

  func processLastUploadTime() async throws -> NativeHealthUploadTimeList {
    let serverTimeList = try await fetchLastUploadTime()
    var resultTimeList: [NativeHealthUploadTimeList.HealthUploadTime] = []
    DebugLogger.debugLog("processLastUploadTime started, source=server")

    let twoYearsAgo = Calendar.current.date(byAdding: .year, value: -firstUploadYear, to: Date())
      ?? Date(timeIntervalSinceNow: -TimeInterval(firstUploadYear * 365 * 24 * 60 * 60))
    let twoYearsAgoMidnight = Calendar.current.startOfDay(for: twoYearsAgo).timeIntervalSince1970

    for type in NativeHealthDataType.allCases where type != .unknown {
      let serverTime = serverTimeList.latestTimeInterval(for: type)
      let finalTime = serverTime ?? twoYearsAgoMidnight

      DebugLogger.debugLog(
        "[\(type.debugName)] server start time=\(serverTime.map { Self.debugDateFormatter.string(from: Date(timeIntervalSince1970: $0)) } ?? "<missing; first upload uses two years>"), resolved=\(Self.debugDateFormatter.string(from: Date(timeIntervalSince1970: finalTime)))"
      )
      resultTimeList.append(
        NativeHealthUploadTimeList.HealthUploadTime(
          dataType: type,
          latestDataTime: finalTime
        )
      )
    }

    return NativeHealthUploadTimeList(latestDataTimeList: resultTimeList)
  }

  func uploadCommon(_ data: [NativeHealthDataPoint]) async throws {
    for batch in data.chunked(into: uploadBatchSize) {
      batch.forEach { point in
        DebugLogger.debugLog(
          "[iOS][upload] dataType=\(point.dataType.rawValue)(\(point.dataType.debugName)), time=\(debugTimestamp(point.time)), unix=\(Int64(point.time)), value=\(point.value)"
        )
      }
      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])
    }
  }

  func allowUploadTrigger(for type: NativeHealthDataType, now: Date = Date()) -> Bool {
    if let lastDate = lastUploadTriggerDates[type],
       now.timeIntervalSince(lastDate) < NativeHealthUploadConfiguration.minimumTriggerInterval {
      DebugLogger.debugLog(
        "[\(type.debugName)] skipped by \(Int(NativeHealthUploadConfiguration.minimumTriggerInterval))s process throttle"
      )
      return false
    }
    lastUploadTriggerDates[type] = now
    return true
  }

  func notifyFlutterUpload(type: NativeHealthDataType, timestamp: TimeInterval) {
    let seconds = Int64(timestamp)
    DebugLogger.debugLog("[\(type.debugName)] notifying Flutter, dataType=\(type.rawValue), timestamp=\(seconds)")
    NotificationCenter.default.post(
      name: .nativeHealthDataDidUpload,
      object: nil,
      userInfo: [
        "dataType": type.rawValue,
        "timestamp": seconds,
      ]
    )
  }

  func uploadSleep(_ data: [NativeSleepInterval]) async throws {
    for batch in data.chunked(into: uploadBatchSize) {
      batch.forEach { interval in
        DebugLogger.debugLog(
          "[iOS][upload][sleep] dataType=\(interval.dataType), from=\(debugTimestamp(interval.fromTime)), fromUnix=\(Int64(interval.fromTime)), to=\(debugTimestamp(interval.toTime)), toUnix=\(Int64(interval.toTime))"
        )
      }
      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])
    }
  }

  func uploadActivityTarget(_ target: NativeActivityTarget) async throws {
    try await request(path: "/client/doublefeel/health/v2/activity_target/", method: "POST", body: target.uploadBody)
  }

  func fetchLastUploadTime() async throws -> NativeHealthUploadTimeList {
    let data = try await request(path: "/client/doublefeel/health/v2/data_upload/common/", method: "GET")
    return try NativeHealthUploadTimeList.decode(from: data)
  }

  @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 {
      throw NativeHealthUploadError.requestFailed(
        path: path,
        statusCode: httpResponse.statusCode,
        body: String(data: data, encoding: .utf8)
      )
    }
    return data
  }

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

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

  func debugLogTimeComparison(
    type: NativeHealthDataType,
    serverTime: TimeInterval,
    newestTime: TimeInterval?
  ) {
    let newestDescription = newestTime.map {
      "\(debugTimestamp($0)) (unix=\(Int64($0)))"
    } ?? "<none>"
    DebugLogger.debugLog(
      "[iOS][time-check] dataType=\(type.rawValue)(\(type.debugName)), server=\(debugTimestamp(serverTime)) (unix=\(Int64(serverTime))), newest=\(newestDescription), shouldUpload=\(newestTime.map { $0 > serverTime } ?? false)"
    )
  }
}

struct NativeHealthUploadTimeList: Codable {
  struct HealthUploadTime: Codable {
    let dataType: NativeHealthDataType?
    let latestDataTime: TimeInterval?

    enum CodingKeys: String, CodingKey {
      case dataType = "data_type"
      case latestDataTime = "latest_data_time"
    }
  }

  var latestDataTimeList: [HealthUploadTime]

  enum CodingKeys: String, CodingKey {
    case latestDataTimeList = "latest_data_time_list"
  }

  func latestDataTime(for type: NativeHealthDataType) -> Date? {
    latestTimeInterval(for: type).map(Date.init(timeIntervalSince1970:))
  }

  func latestTimeInterval(for type: NativeHealthDataType) -> TimeInterval? {
    latestDataTimeList.first { $0.dataType == type }?.latestDataTime
  }

  static func decode(from data: Data) throws -> NativeHealthUploadTimeList {
    let decoder = JSONDecoder()

    if let direct = try? decoder.decode(NativeHealthUploadTimeList.self, from: data) {
      return direct
    }

    let wrapped = try decoder.decode(HealthUploadTimeListResponse.self, from: data)
    if let data = wrapped.data {
      return data
    }
    throw NativeHealthUploadError.invalidResponse
  }
}

private extension Array {
  func chunked(into size: Int) -> [[Element]] {
    guard size > 0 else { return [self] }
    return stride(from: 0, to: count, by: size).map {
      Array(self[$0..<Swift.min($0 + size, count)])
    }
  }
}

private struct HealthUploadTimeListResponse: Decodable {
  let data: NativeHealthUploadTimeList?
}


private extension NativeHealthDataType {
  var debugName: String {
    switch self {
    case .unknown:
      return "unknown"
    case .hrv:
      return "hrv"
    case .heartRate:
      return "heartRate"
    case .oxygenSaturation:
      return "oxygenSaturation"
    case .activeEnergy:
      return "activeEnergy"
    case .exercise:
      return "exercise"
    case .stand:
      return "stand"
    case .steps:
      return "steps"
    case .walkingHeartRate:
      return "walkingHeartRate"
    case .restingHeartRate:
      return "restingHeartRate"
    case .sleepingHeartRate:
      return "sleepingHeartRate"
    case .sleepingWristTemperature:
      return "sleepingWristTemperature"
    case .respiratoryRate:
      return "respiratoryRate"
    case .irregularHeartRhythm:
      return "irregularHeartRhythm"
    case .sleep:
      return "sleep"
    }
  }
}