import CoreData
import CloudKit
 
final class PersistenceController {
    static let shared = PersistenceController()
 
    let container: NSPersistentCloudKitContainer
 
    init(inMemory: Bool = false) {
        container = NSPersistentCloudKitContainer(name: "MeteoHealthModel")
 
        guard let description = container.persistentStoreDescriptions.first else {
            fatalError("No persistent store description found")
        }
 
        // Required for CloudKit mirroring: history tracking + remote change notifications
        description.setOption(true as NSNumber, forKey: NSPersistentHistoryTrackingKey)
        description.setOption(true as NSNumber, forKey: NSPersistentStoreRemoteChangeNotificationPostOptionKey)
 
        description.cloudKitContainerOptions = NSPersistentCloudKitContainerOptions(
            containerIdentifier: "iCloud.pro.dodecaidr.meteohealth"
        )
 
        container.loadPersistentStores { _, error in
            if let error = error as NSError? {
                fatalError("Unresolved error loading store: \(error), \(error.userInfo)")
            }
        }
 
        container.viewContext.automaticallyMergesChangesFromParent = true
        // Field-level last-writer-wins. Good enough for most entities,
        // but not for health metrics where "who wrote last" isn't "who is right".
        container.viewContext.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy
    }
}

import CloudKit
 
final class HealthSyncEngine: NSObject, CKSyncEngineDelegate {
    private var syncEngine: CKSyncEngine!
    private let zoneID = CKRecordZone.ID(zoneName: "HealthMetrics")
 
    func configure(savedState: CKSyncEngine.State.Serialization?) {
        let configuration = CKSyncEngine.Configuration(
            database: CKContainer(identifier: "iCloud.pro.dodecaidr.meteohealth").privateCloudDatabase,
            stateSerialization: savedState,
            delegate: self
        )
        syncEngine = CKSyncEngine(configuration)
    }
 
    func handleEvent(_ event: CKSyncEngine.Event, syncEngine: CKSyncEngine) {
        switch event {
        case .stateUpdate(let update):
            persistState(update.stateSerialization)
 
        case .fetchedRecordZoneChanges(let event):
            event.modifications.forEach { applyToLocalStore($0.record) }
            event.deletions.forEach { deleteFromLocalStore(recordID: $0.recordID) }
 
        case .sentRecordZoneChanges(let event):
            // Records CloudKit rejected because the server version moved on
            // while we were offline.
            for failure in event.failedRecordSaves {
                guard failure.error.code == .serverRecordChanged,
                      let serverRecord = failure.error.serverRecord else { continue }
 
                let resolved = mergeHealthRecord(local: failure.record, server: serverRecord)
                syncEngine.state.add(pendingRecordZoneChanges: [.saveRecord(resolved.recordID)])
                stageForNextSave(resolved)
            }
 
        default:
            break
        }
    }
 
    func nextRecordZoneChangeBatch(
        _ context: CKSyncEngine.SendChangesContext,
        syncEngine: CKSyncEngine
    ) async -> CKSyncEngine.RecordZoneChangeBatch? {
        await CKSyncEngine.RecordZoneChangeBatch(
            pendingChanges: context.options.scope.pendingRecordZoneChanges
        ) { recordID in
            recordToSave(for: recordID)
        }
    }
}

/// serverRecordChanged gives us the current server record with a valid
/// change tag. Re-sending the local record's stale tag would just be
/// rejected again — we must copy the server record and reapply our fields.
private func mergeHealthRecord(local: CKRecord, server: CKRecord) -> CKRecord {
    let merged = server.copy() as! CKRecord
 
    let localRecordedAt = local["recordedAt"] as? Date ?? .distantPast
    let serverRecordedAt = server["recordedAt"] as? Date ?? .distantPast
 
    // The freshest measurement wins — not whoever reached the server first.
    if localRecordedAt > serverRecordedAt {
        merged["value"] = local["value"]
        merged["recordedAt"] = local["recordedAt"]
        merged["source"] = local["source"]
    }
 
    return merged
}

func setupDatabaseSubscription(database: CKDatabase) async throws {
    let subscription = CKDatabaseSubscription(subscriptionID: "meteohealth-private-db-changes")
 
    let notificationInfo = CKSubscription.NotificationInfo()
    notificationInfo.shouldSendContentAvailable = true // silent push, no banner
    subscription.notificationInfo = notificationInfo
 
    try await database.save(subscription)
}

func application(
    _ application: UIApplication,
    didReceiveRemoteNotification userInfo: [AnyHashable: Any],
    fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void
) {
    guard let notification = CKNotification(fromRemoteNotificationDictionary: userInfo),
          notification.subscriptionID == "meteohealth-private-db-changes" else {
        completionHandler(.noData)
        return
    }
 
    Task {
        try? await syncEngine.fetchChanges()
        completionHandler(.newData)
    }
}