Swift iCloud Sync: CloudKit Integration

import CloudKit

class CloudKitManager: ObservableObject {
    private let container: CKContainer

    init() {
        self.container = CKContainer.default()
    }

    private var publicDatabase: CKDatabase {
        container.publicCloudDatabase
    }

    private var privateDatabase: CKDatabase {
        container.privateCloudDatabase
    }

    private var sharedDatabase: CKDatabase {
        container.sharedCloudDatabase
    }
}

extension CloudKitManager {
    func saveRecord(record: CKRecord, to database: CKDatabase) async throws {
        try await database.save(record)
    }

    func saveItem(name: String, quantity: Int) async throws {
        let record = CKRecord(recordType: "Item")
        record["name"] = name
        record["quantity"] = quantity

        try await saveRecord(record: record, to: privateDatabase)
    }
}

extension CloudKitManager {
    func fetchRecords(recordType: String, from database: CKDatabase) async throws -> [CKRecord] {
        let query = CKQuery(recordType: recordType, predicate: NSPredicate(value: true))
        let (results, _) = try await database.records(matching: query)
        return results.matchingResults.map { $0.1 }
    }

    func fetchItems() async throws -> [CKRecord] {
        return try await fetchRecords(recordType: "Item", from: privateDatabase)
    }
}

extension CloudKitManager {
    func updateRecord(_ record: CKRecord, in database: CKDatabase) async throws {
        try await database.save(record)
    }

    func updateItem(_ record: CKRecord, name: String) async throws {
        record["name"] = name
        try await updateRecord(record, in: privateDatabase)
    }
}

extension CloudKitManager {
    func deleteRecord(_ recordID: CKRecord.ID, from database: CKDatabase) async throws {
        try await database.deleteRecord(withID: recordID)
    }

    func deleteItem(_ record: CKRecord) async throws {
        try await deleteRecord(record.recordID, from: privateDatabase)
    }
}

extension CloudKitManager {
    func fetchItemsWithName(_ name: String) async throws -> [CKRecord] {
        let predicate = NSPredicate(format: "name == %@", name)
        let query = CKQuery(recordType: "Item", predicate: predicate)

        let (results, _) = try await privateDatabase.records(matching: query)
        return results.matchingResults.map { $0.1 }
    }

    func fetchItemsWithQuantityGreaterThan(_ threshold: Int) async throws -> [CKRecord] {
        let predicate = NSPredicate(format: "quantity > %d", threshold)
        let query = CKQuery(recordType: "Item", predicate: predicate)

        let (results, _) = try await privateDatabase.records(matching: query)
        return results.matchingResults.map { $0.1 }
    }
}

extension CloudKitManager {
    func subscribeToChanges() async throws {
        let subscription = CKQuerySubscription(
            recordType: "Item",
            predicate: NSPredicate(value: true),
            options: .firesOnRecordCreation
        )

        let notificationInfo = CKSubscription.NotificationInfo()
        notificationInfo.shouldSendContentAvailable = true
        subscription.notificationInfo = notificationInfo

        try await privateDatabase.save(subscription)
    }

    func handleRemoteNotification(_ userInfo: [AnyHashable: Any]) async {
        guard let notification = CKNotification(fromRemoteNotificationDictionary: userInfo) else {
            return
        }

        if notification.subscriptionID == "com.yourapp.subscription" {
            // Handle subscription notification
            await refreshData()
        }
    }

    private func refreshData() async {
        // Refresh local data from CloudKit
        print("Refreshing data from CloudKit")
    }
}

extension CloudKitManager {
    func saveWithConflictResolution(_ record: CKRecord) async throws {
        var recordToSave = record

        while true {
            do {
                try await privateDatabase.save(recordToSave)
                return
            } catch let error as CKError {
                guard case .serverRecordChanged = error else {
                    throw error
                }

                // Fetch server record
                let serverRecord = try await privateDatabase.record(for: record.recordID)

                // Resolve conflict
                recordToSave = resolveConflict(local: record, server: serverRecord)
            }
        }
    }

    private func resolveConflict(local: CKRecord, server: CKRecord) -> CKRecord {
        // Custom conflict resolution logic
        let resolved = local

        // Example: Use newer modification date
        if let serverModDate = server.modificationDate,
           let localModDate = local.modificationDate,
           serverModDate > localModDate {
            // Use server values
            resolved["name"] = server["name"]
        }

        return resolved
    }
}

extension CloudKitManager {
    func saveRecords(_ records: [CKRecord]) async throws {
        let operation = CKModifyRecordsOperation(
            recordsToSave: records,
            recordIDsToDelete: []
        )

        operation.modifyRecordsCompletionBlock = { _, _, error in
            if let error = error {
                print("Batch save error: \(error)")
            }
        }

        try await privateDatabase(operation)
    }

    private func privateDatabase(_ operation: CKDatabaseOperation) async throws {
        await withCheckedThrowingContinuation { continuation in
            operation.database = privateDatabase

            let queue = OperationQueue()
            queue.addOperation(operation)

            operation.completionBlock = {
                if let error = operation.error {
                    continuation.resume(throwing: error)
                } else {
                    continuation.resume()
                }
            }
        }
    }
}

class SyncManager: ObservableObject {
    @Published var syncStatus: SyncStatus = .idle

    enum SyncStatus {
        case idle
        case syncing
        case success
        case error(String)
    }

    func syncData() async {
        syncStatus = .syncing

        do {
            // Perform sync
            try await CloudKitManager.shared.syncItems()
            syncStatus = .success
        } catch {
            syncStatus = .error(error.localizedDescription)
        }
    }
}

extension CloudKitManager {
    func fetchUserRecordID() async throws -> CKRecord.ID {
        return try await container.userRecordID()
    }

    func discoverUserIdentity(email: String) async throws {
        let emailDiscovered = try await container.discoverUserIdentity(
            withEmailAddress: email
        )

        if let userRecordID = emailDiscovered.userRecordID {
            print("User record ID: \(userRecordID.recordName)")
        }
    }

    func discoverAllIdentities() async throws {
        let identities = try await container.discoverAllUserIdentities()
        for identity in identities {
            print("Discovered: \(identity)")
        }
    }
}