import Foundation

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 and the per-user last-upload-time cache migrated from
/// the original SwiftUI app.
final class NativeHealthDataUploader {
  static let shared = NativeHealthDataUploader()

  private let session: URLSession
  private var uploadTimeRecorder: NativeHealthUploadTimeRecorder

  private let maxUploadTimeWeek = 4
  private let defaultUploadTimeWeek = 1
  private let firstUploadYear = 2

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

  func uploadAll(service: HealthKitService = .shared) async -> NativeHealthUploadSummary {
    var commonCount = 0
    var sleepCount = 0
    var commonUploadSuccess = true
    var sleepUploadSuccess = true
    var errorMessages: [String] = []

    debugLog("uploadAll started, userId=\(AppShared.shared.userId ?? "<nil>")")
    do {
      let uploadTimeList = try await processLastUploadTime()

      for type in Self.commonUploadTypes {
        let result = await upload(type: type, uploadTimeList: uploadTimeList, 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, 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)
      debugLog("uploadAll failed before per-type upload, error=\(error.localizedDescription)")
    }

    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 {
    do {
      let uploadTimeList = try await processLastUploadTime()
      return await upload(type: type, uploadTimeList: uploadTimeList, service: service).success
    } catch {
      debugLog("upload(\(type.debugName)) failed to process last upload time, error=\(error.localizedDescription)")
      print("Health upload failed to process last upload time: \(error.localizedDescription)")
      return false
    }
  }
}

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

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

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

    let endUploadDate = Date()
    debugLog(
      "[\(type.debugName)] upload started, range=\(Self.debugDateFormatter.string(from: startUploadDate)) -> \(Self.debugDateFormatter.string(from: endUploadDate))"
    )
    guard endUploadDate >= startUploadDate else {
      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:
        debugLog("[\(type.debugName)] reading sleep data")
        let data = try await service.fetchSleepData(startDate: startUploadDate, endDate: endUploadDate)
        debugLog("[\(type.debugName)] read finished, count=\(data.count)")
        guard !data.isEmpty else {
          uploadTimeRecorder.save(date: endUploadDate, for: type)
          debugLog("[\(type.debugName)] no data, saved upload time=\(Self.debugDateFormatter.string(from: endUploadDate))")
          return UploadTaskResult(success: true, uploadedCount: 0, errorMessage: nil)
        }
        debugLog("[\(type.debugName)] uploading, count=\(data.count)")
        try await uploadSleep(data)
        uploadTimeRecorder.save(date: endUploadDate, for: type)
        debugLog("[\(type.debugName)] upload success, count=\(data.count), saved upload time=\(Self.debugDateFormatter.string(from: endUploadDate))")
        return UploadTaskResult(success: true, uploadedCount: data.count, errorMessage: nil)
      default:
        debugLog("[\(type.debugName)] reading common data")
        let data = try await fetchCommonData(
          type: type,
          startDate: startUploadDate,
          endDate: endUploadDate,
          service: service
        )
        debugLog("[\(type.debugName)] read finished, count=\(data.count)")
        guard !data.isEmpty else {
          uploadTimeRecorder.save(date: endUploadDate, for: type)
          debugLog("[\(type.debugName)] no data, saved upload time=\(Self.debugDateFormatter.string(from: endUploadDate))")
          return UploadTaskResult(success: true, uploadedCount: 0, errorMessage: nil)
        }
        debugLog("[\(type.debugName)] uploading, count=\(data.count)")
        try await uploadCommon(data)
        uploadTimeRecorder.save(date: endUploadDate, for: type)
        debugLog("[\(type.debugName)] upload success, count=\(data.count), saved upload time=\(Self.debugDateFormatter.string(from: endUploadDate))")
        return UploadTaskResult(success: true, uploadedCount: data.count, errorMessage: nil)
      }
    } catch {
      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()

    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 {
        debugLog("[activityTarget] no target data")
        return UploadTaskResult(success: true, uploadedCount: 0, errorMessage: nil)
      }
      debugLog("[activityTarget] uploading, move=\(target.move.map(String.init) ?? "<nil>"), stand=\(target.stand.map(String.init) ?? "<nil>")")
      try await uploadActivityTarget(target)
      debugLog("[activityTarget] upload success")
      return UploadTaskResult(success: true, uploadedCount: 1, errorMessage: nil)
    } catch {
      debugLog("[activityTarget] upload failed, error=\(error.localizedDescription)")
      return UploadTaskResult(
        success: false,
        uploadedCount: 0,
        errorMessage: "活动目标上传失败：\(error.localizedDescription)"
      )
    }
  }

  func processLastUploadTime() async throws -> NativeHealthUploadTimeList {
    let localTimeList = uploadTimeRecorder.records
    let serverTimeList = try? await fetchLastUploadTime()
    var resultTimeList: [NativeHealthUploadTimeList.HealthUploadTime] = []
    debugLog("processLastUploadTime started, hasServerTimeList=\(serverTimeList != nil)")

    let fourWeeksAgo = Calendar.current.date(byAdding: .weekOfYear, value: -maxUploadTimeWeek, to: Date())
      ?? Date(timeIntervalSinceNow: -TimeInterval(maxUploadTimeWeek * 7 * 24 * 60 * 60))
    let fourWeeksAgoMidnight = Calendar.current.startOfDay(for: fourWeeksAgo).timeIntervalSince1970

    let oneWeekAgo = Calendar.current.date(byAdding: .weekOfYear, value: -defaultUploadTimeWeek, to: Date())
      ?? Date(timeIntervalSinceNow: -TimeInterval(defaultUploadTimeWeek * 7 * 24 * 60 * 60))
    let oneWeekAgoMidnight = Calendar.current.startOfDay(for: oneWeekAgo).timeIntervalSince1970

    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 localTime = localTimeList.latestTimeInterval(for: type)
      let serverTime = serverTimeList?.latestTimeInterval(for: type)

      let finalTime: TimeInterval
      if let localTime, localTime > fourWeeksAgoMidnight {
        finalTime = localTime
      } else if let serverTime, serverTime > fourWeeksAgoMidnight {
        finalTime = serverTime
      } else if localTime != nil || serverTime != nil {
        finalTime = oneWeekAgoMidnight
      } else {
        finalTime = twoYearsAgoMidnight
      }

      debugLog(
        "[\(type.debugName)] resolved start time=\(Self.debugDateFormatter.string(from: Date(timeIntervalSince1970: finalTime))), local=\(localTime.map { Self.debugDateFormatter.string(from: Date(timeIntervalSince1970: $0)) } ?? "<nil>"), server=\(serverTime.map { Self.debugDateFormatter.string(from: Date(timeIntervalSince1970: $0)) } ?? "<nil>")"
      )
      resultTimeList.append(
        NativeHealthUploadTimeList.HealthUploadTime(
          dataType: type,
          latestDataTime: finalTime
        )
      )
    }

    return NativeHealthUploadTimeList(latestDataTimeList: resultTimeList)
  }

  func uploadCommon(_ data: [NativeHealthDataPoint]) async throws {
    let list = data.map {
      [
        "data_type": $0.dataType.rawValue,
        "time": $0.time,
        "value": $0.value,
      ] as [String: Any]
    }
    try await request(path: "/client/doublefeel/health/data_upload/common/", method: "POST", body: ["data_list": list])
  }

  func uploadSleep(_ data: [NativeSleepInterval]) async throws {
    let list = data.map {
      [
        "data_type": $0.dataType,
        "from_time": $0.fromTime,
        "to_time": $0.toTime,
      ] as [String: Any]
    }
    try await request(path: "/client/doublefeel/health/data_upload/sleep/", method: "POST", body: ["data_list": list])
  }

  func uploadActivityTarget(_ target: NativeActivityTarget) async throws {
    var body: [String: Any] = [:]
    body["move"] = target.move
    body["stand"] = target.stand
    try await request(path: "/client/doublefeel/health/activity_target/", method: "POST", body: body)
  }

  func fetchLastUploadTime() async throws -> NativeHealthUploadTimeList {
    let data = try await request(path: "/client/doublefeel/health/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 debugLog(_ message: String) {
    #if DEBUG || CI_ENV
    print("[NativeHealthDataUploader] \(message)")
    #endif
  }
}

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 struct HealthUploadTimeListResponse: Decodable {
  let data: NativeHealthUploadTimeList?
}

struct NativeHealthUploadTimeRecorder {
  private var cachedRecords: NativeHealthUploadTimeList?
  private static let cacheKey = "HealthUploadlocalRecord_records"

  var records: NativeHealthUploadTimeList {
    mutating get {
      if let cachedRecords {
        return cachedRecords
      }
      let records = Self.loadFromCache() ?? NativeHealthUploadTimeList(latestDataTimeList: [])
      cachedRecords = records
      return records
    }
    set {
      cachedRecords = newValue
      Self.saveToCache(newValue)
    }
  }

  init(records: NativeHealthUploadTimeList? = nil) {
    cachedRecords = records
  }

  mutating func save(date: Date, for type: NativeHealthDataType) {
    var records = records
    records.latestDataTimeList.removeAll { $0.dataType == type }
    records.latestDataTimeList.append(
      NativeHealthUploadTimeList.HealthUploadTime(
        dataType: type,
        latestDataTime: date.timeIntervalSince1970
      )
    )
    self.records = records
  }

  static func clearCache() {
    UserDefaults.standard.removeObject(forKey: cacheKeyForCurrentUser())
  }

  private static func loadFromCache() -> NativeHealthUploadTimeList? {
    guard let data = UserDefaults.standard.data(forKey: cacheKeyForCurrentUser()) else {
      return nil
    }
    return try? JSONDecoder().decode(NativeHealthUploadTimeList.self, from: data)
  }

  private static func saveToCache(_ records: NativeHealthUploadTimeList) {
    guard let data = try? JSONEncoder().encode(records) else {
      return
    }
    UserDefaults.standard.set(data, forKey: cacheKeyForCurrentUser())
  }

  private static func cacheKeyForCurrentUser() -> String {
    let userId = AppShared.shared.userId
      ?? AppShared.shared.userSummary?.meUserInfo?.id.map(String.init)
      ?? AppGroupConstants.defaults?.string(forKey: AppGroupConstants.Key.userId)
      ?? ""
    return cacheKey + userId
  }
}

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"
    }
  }
}