import Foundation
import UIKit

final class HealthKitRawDataHostApiImpl: HealthKitRawDataHostApi {
    private var localNotificationDebugFileURL: URL {
        FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
            .appendingPathComponent("local_notification_debug_events.json")
    }

    func saveLocalNotificationRecord(notificationType: String, timestamp: Int64, completion: @escaping (Result<Bool, any Error>) -> Void) {
        saveLocalNotificationDebugEvent(
            event: [
                "event": "nativeLocalNotificationRecord",
                "notification_type": notificationType,
                "timestamp": timestamp,
            ],
            completion: completion
        )
    }

    func saveLocalNotificationDebugEvent(event: [String: Any?], completion: @escaping (Result<Bool, any Error>) -> Void) {
        do {
            var payload = sanitizeJSONObject(event) as? [String: Any] ?? [:]
            let now = Date()
            payload["saved_at_unix"] = now.timeIntervalSince1970
            payload["saved_at"] = ISO8601DateFormatter().string(from: now)
            payload["process_name"] = ProcessInfo.processInfo.processName

            var events = try readLocalNotificationDebugEvents()
            events.append(payload)
            let data = try JSONSerialization.data(
                withJSONObject: events,
                options: [.prettyPrinted, .sortedKeys]
            )
            try data.write(to: localNotificationDebugFileURL, options: .atomic)
            completion(.success(true))
        } catch {
            completion(.failure(error))
        }
    }

    func shareLocalNotificationDebugRecord(completion: @escaping (Result<Bool, any Error>) -> Void) {
        do {
            if !FileManager.default.fileExists(atPath: localNotificationDebugFileURL.path) {
                try Data("[]".utf8).write(to: localNotificationDebugFileURL, options: .atomic)
            }
            shareItems([localNotificationDebugFileURL], completion: completion)
        } catch {
            completion(.failure(error))
        }
    }

    func shareUploadTaskRecord(completion: @escaping (Result<Bool, any Error>) -> Void) {
        
    }
    
    func saveNativeCallFlutterChange(relativeDataTypes: [Int64], completion: @escaping (Result<Bool, any Error>) -> Void) {
        
    }
    
    func saveFlutterCaculateFinished(relativeDataTypes: [Int64], completion: @escaping (Result<Bool, any Error>) -> Void) {
        
    }
    
    func shareNativeAppleHealthObserverRecord(completion: @escaping (Result<Bool, any Error>) -> Void) {
        
    }
    
    func shareFlutterObserverRecord(completion: @escaping (Result<Bool, any Error>) -> Void) {
        let timestamp = Int64(Date().timeIntervalSince1970.rounded())
        let dataTypes = NativeHealthDataType.allCases
            .map(\.rawValue)
            .sorted()

        DispatchQueue.main.async {
            NotificationCenter.default.post(
                name: .nativeHealthDataDidUpdate,
                object: nil,
                userInfo: [
                    "dataTypes": dataTypes,
                    "timestamp": timestamp,
                ]
            )
            completion(.success(true))
        }
    }
    
  private let service: HealthKitService

    init(service: HealthKitService = .shared) {
    self.service = service
  }

    private func readLocalNotificationDebugEvents() throws -> [[String: Any]] {
        guard FileManager.default.fileExists(atPath: localNotificationDebugFileURL.path) else {
            return []
        }
        let data = try Data(contentsOf: localNotificationDebugFileURL)
        guard !data.isEmpty else { return [] }
        let decoded = try JSONSerialization.jsonObject(with: data)
        return decoded as? [[String: Any]] ?? []
    }

    private func sanitizeJSONObject(_ value: Any?) -> Any {
        guard let value else { return NSNull() }
        if let dictionary = value as? [String: Any?] {
            return dictionary.mapValues { sanitizeJSONObject($0) }
        }
        if let dictionary = value as? [String: Any] {
            return dictionary.mapValues { sanitizeJSONObject($0) }
        }
        if let array = value as? [Any?] {
            return array.map { sanitizeJSONObject($0) }
        }
        if JSONSerialization.isValidJSONObject([value]) {
            return value
        }
        return String(describing: value)
    }

    private func shareItems(_ items: [Any], completion: @escaping (Result<Bool, any Error>) -> Void) {
        DispatchQueue.main.async {
            guard let viewController = Self.topViewController() else {
                completion(.failure(NSError(
                    domain: "HealthKitRawDataHostApiImpl.Share",
                    code: 1,
                    userInfo: [NSLocalizedDescriptionKey: "Unable to find a view controller for sharing."]
                )))
                return
            }
            let activityController = UIActivityViewController(
                activityItems: items,
                applicationActivities: nil
            )
            activityController.popoverPresentationController?.sourceView = viewController.view
            activityController.popoverPresentationController?.sourceRect = CGRect(
                x: viewController.view.bounds.midX,
                y: viewController.view.bounds.midY,
                width: 1,
                height: 1
            )
            activityController.completionWithItemsHandler = { _, completed, _, error in
                if let error {
                    completion(.failure(error))
                } else {
                    completion(.success(completed))
                }
            }
            viewController.present(activityController, animated: true)
        }
    }

    private static func topViewController(
        base: UIViewController? = UIApplication.shared
            .connectedScenes
            .compactMap { $0 as? UIWindowScene }
            .flatMap { $0.windows }
            .first { $0.isKeyWindow }?
            .rootViewController
    ) -> UIViewController? {
        if let navigationController = base as? UINavigationController {
            return topViewController(base: navigationController.visibleViewController)
        }
        if let tabBarController = base as? UITabBarController {
            return topViewController(base: tabBarController.selectedViewController)
        }
        if let presented = base?.presentedViewController {
            return topViewController(base: presented)
        }
        return base
    }
    
  func hasHealthData(completion: @escaping (Result<Bool, Error>) -> Void) {
    Task {
      let hasData = await service.hasAnyReadableData()
      completion(.success(hasData))
    }
  }
    
    func performHealthDataUpload(completion: @escaping (Result<Bool, any Error>) -> Void) {
        print("trigger HealthDataUpload")
        Task {
          let summary = await AnchoredHealthDataUploader.shared.uploadAll()
          completion(.success(true))
        }
    }
    
    func syncDatabase(hrDataPath: String, hrvDataPath: String, sleepDataPath: String, avgRealtimeStressDataPath: String, completion: @escaping (Result<Bool, any Error>) -> Void) {
        HealthRawStressSQLiteUploader.shared.syncDatabase(
            hrDataPath: hrDataPath,
            hrvDataPath: hrvDataPath,
            sleepDataPath: sleepDataPath,
            avgRealtimeStressDataPath: avgRealtimeStressDataPath
        )
        completion(.success(true))
    }
    
    
    func performHRDataUpload(sqliteFilePath: String, completion: @escaping (Result<Int64, any Error>) -> Void) {
        print("trigger HRDataUpload")
        Task {
            do {
                let uploadedUntil = try await HealthRawStressSQLiteUploader.shared.uploadRealtimeStress(sqliteFilePath: sqliteFilePath)
                completion(.success(uploadedUntil))
            } catch {
                completion(.failure(error))
            }
        }
    }
    
    func performHRVDataUpload(sqliteFilePath: String, completion: @escaping (Result<Int64, any Error>) -> Void) {
        print("trigger HRVDataUpload")
        Task {
            do {
                let uploadedUntil = try await HealthRawStressSQLiteUploader.shared.uploadHrv(sqliteFilePath: sqliteFilePath)
                completion(.success(uploadedUntil))
            } catch {
                completion(.failure(error))
            }
        }
    }
    
    func performAvgRealtimeStressDataUpload(sqliteFilePath: String, completion: @escaping (Result<Int64, any Error>) -> Void) {
        print("trigger AvgRealtimeStressDataUpload")
        Task {
            do {
                let uploadedUntil = try await HealthRawStressSQLiteUploader.shared.uploadDailyStress(sqliteFilePath: sqliteFilePath)
                completion(.success(uploadedUntil))
            } catch {
                completion(.failure(error))
            }
        }
    }
    
    func performSleepAnalysisDataUpload(sqliteFilePath: String, completion: @escaping (Result<Int64, any Error>) -> Void) {
        print("trigger SleepAnalysisDataUpload")
        Task {
            do {
                let uploadedUntil = try await HealthRawStressSQLiteUploader.shared.uploadSleepScore(sqliteFilePath: sqliteFilePath)
                completion(.success(uploadedUntil))
            } catch {
                completion(.failure(error))
            }
        }
    }
    

  func getHealthKitRawData(
    dataType: Int64,
    startTime: Int64,
    endTime: Int64,
    completion: @escaping (Result<[HealthKitRawDataPoint], Error>) -> Void
  ) {
    guard let nativeDataType = NativeHealthDataType(rawValue: Int(dataType)) else {
      completion(.failure(PigeonError(
        code: "invalid_data_type",
        message: "无效的健康数据类型：\(dataType)",
        details: nil
      )))
      return
    }
    guard nativeDataType != .sleep else {
      completion(.failure(PigeonError(
        code: "unsupported_data_type",
        message: "睡眠数据请使用 getHealthKitRawSleepData 读取",
        details: nil
      )))
      return
    }

    let startDate = Date(timeIntervalSince1970: TimeInterval(startTime))
    let endDate = Date(timeIntervalSince1970: TimeInterval(endTime))

    Task {
      do {
        let points = try await service.fetchRawData(
          for: nativeDataType,
          startDate: startDate,
          endDate: endDate
        )
        completion(.success(points.map { Self.rawDataPoint(from: $0, dataType: nativeDataType) }))
      } catch {
        completion(.failure(error))
      }
    }
  }

  func getHealthKitRawSleepData(
    startTime: Int64,
    endTime: Int64,
    completion: @escaping (Result<[HealthKitRawSleepDataPoint], Error>) -> Void
  ) {
    let startDate = Date(timeIntervalSince1970: TimeInterval(startTime))
    let endDate = Date(timeIntervalSince1970: TimeInterval(endTime))
      print("trigger getHealthKitRawSleepData from: \(startDate) to \(endDate)")
    Task {
      do {
        let intervals = try await service.fetchSleepData(
          startDate: startDate,
          endDate: endDate
        )
        let points = intervals.map(Self.sleepDataPoint)
        guard !points.isEmpty else {
          completion(.success([]))
          return
        }
        completion(.success([
          HealthKitRawSleepDataPoint(
            dataType: Int64(NativeHealthDataType.sleep.rawValue),
            sleepDataPoints: points
          )
        ]))
      } catch {
        completion(.failure(error))
      }
    }
  }

  func getHealthKitRawActivityData(
    startTime: Int64,
    endTime: Int64,
    completion: @escaping (Result<[HealthKitRawActivityDataPoint], Error>) -> Void
  ) {
    let startDate = Date(timeIntervalSince1970: TimeInterval(startTime))
    let endDate = Date(timeIntervalSince1970: TimeInterval(endTime))

    Task {
      do {
        let targets = try await service.fetchActivityTargetDataList(
          startDate: startDate,
          endDate: endDate
        )
        completion(.success(targets.compactMap(Self.activityDataPoint)))
      } catch {
        completion(.failure(error))
      }
    }
  }
    
  func getHealthKitRawWorkoutData(
    startTime: Int64,
    endTime: Int64,
    completion: @escaping (Result<[HealthKitRawWorkoutDataPoint], Error>) -> Void
  ) {
    let startDate = Date(timeIntervalSince1970: TimeInterval(startTime))
    let endDate = Date(timeIntervalSince1970: TimeInterval(endTime))

    Task {
      do {
        let workouts = try await service.fetchWorkoutDataList(
          startDate: startDate,
          endDate: endDate
        )
        completion(.success(workouts.map(Self.workoutDataPoint)))
      } catch {
        completion(.failure(error))
      }
    }
  }

  func performSleepDataUpload(completion: @escaping (Result<Bool, Error>) -> Void) {
    Task {
      let summary = await AnchoredHealthDataUploader.shared.uploadAll()
      completion(.success(summary.sleepUploadSuccess))
    }
  }

  private static func rawDataPoint(
    from point: NativeHealthRawDataPoint,
    dataType: NativeHealthDataType
  ) -> HealthKitRawDataPoint {
    HealthKitRawDataPoint(
      dataType: Int64(dataType.rawValue),
      startTime: Int64(point.startTime.rounded()),
      endTime: Int64(point.endTime.rounded()),
      value: point.value
    )
  }

  private static func sleepDataPoint(from interval: NativeSleepInterval) -> HealthKitRawDataPoint {
    HealthKitRawDataPoint(
      dataType: Int64(interval.dataType),
      startTime: Int64(interval.fromTime.rounded()),
      endTime: Int64(interval.toTime.rounded()),
      value: nil
    )
  }

  private static func activityDataPoint(from target: NativeActivityTarget) -> HealthKitRawActivityDataPoint? {
    guard let endTime = target.healthValueTimestamp else {
      return nil
    }
    return HealthKitRawActivityDataPoint(
      endTime: Int64(endTime.rounded()),
      activityMoveMode: target.activityMoveMode == nil ? nil : Int64(target.activityMoveMode!),
      activeEnergyBurned: target.activeEnergyBurned,
      activeEnergyBurnedGoal: target.activeEnergyBurnedGoal,
      appleMoveTime: target.appleMoveTime,
      appleMoveTimeGoal: target.appleMoveTimeGoal,
      appleExerciseTime: target.appleExerciseTime,
      exerciseTimeGoal: target.exerciseTimeGoal,
      appleStandHours: target.appleStandHours,
      standHoursGoal: target.standHoursGoal
    )
  }

  private static func workoutDataPoint(from workout: NativeWorkoutInterval) -> HealthKitRawWorkoutDataPoint {
    HealthKitRawWorkoutDataPoint(
      workoutType: Int64(workout.workoutType),
      startTime: Int64(workout.startTime.rounded()),
      endTime: Int64(workout.endTime.rounded())
    )
  }
}