crossmate

PresencePublisher.swift (6371B)

---

 import CoreData
 import Foundation
 
 /// Debounced writer for the local player's cursor selection. Updates the
 /// `PlayerEntity` row for `(gameID, authorID)` with the new `selRow`/`selCol`/
 /// `selDir` and asks the sync engine to push the Player record. Cursor edits
 /// don't go through `MovesUpdater` because they aren't cell edits — they live
 /// on `PlayerEntity` with last-writer-wins semantics.
 actor PresencePublisher {
     private let debounceInterval: Duration
     private let persistence: PersistenceController
     private let sink: @Sendable (UUID, String) async -> Void
 
     private var pending: PlayerSelection?
     private var lastPublished: PlayerSelection?
     private var debounceTask: Task<Void, Never>?
     private var gameID: UUID?
     private var authorID: String?
     /// The local user's display name at session start. Used as a fallback
     /// when `write` has to insert a fresh `PlayerEntity` row before
     /// `NameBroadcaster` has fanned out — without it the row would have no
     /// name and the SyncEngine would refuse to build a CKRecord, dropping
     /// the cursor on the floor.
     private var fallbackName: String = ""
 
     init(
         debounceInterval: Duration = .milliseconds(300),
         persistence: PersistenceController,
         sink: @escaping @Sendable (UUID, String) async -> Void
     ) {
         self.debounceInterval = debounceInterval
         self.persistence = persistence
         self.sink = sink
     }
 
     /// Starts publishing for a new puzzle session. Resets dedupe state so the
     /// first selection from the new session always flushes. `currentName` is
     /// the local user's display name at the time the puzzle was opened — used
     /// only when no PlayerEntity row exists yet for this (game, author).
     func begin(gameID: UUID, authorID: String, currentName: String) {
         self.gameID = gameID
         self.authorID = authorID
         fallbackName = currentName
         pending = nil
         lastPublished = nil
         debounceTask?.cancel()
         debounceTask = nil
     }
 
     /// Registers a new selection. Coalesces with any prior pending value and
     /// schedules a trailing-edge flush. Repeated identical selections are
     /// dropped.
     func publish(_ selection: PlayerSelection) {
         guard gameID != nil, authorID != nil else { return }
         if pending == selection || (pending == nil && lastPublished == selection) {
             return
         }
         pending = selection
         scheduleDebounce()
     }
 
     /// Records a "no selection" — used on puzzle teardown so the peer's
     /// outline disappears promptly instead of waiting for staleness.
     func clear() {
         guard gameID != nil, authorID != nil else { return }
         pending = nil
         debounceTask?.cancel()
         debounceTask = nil
         Task { await self.flushClear() }
     }
 
     /// Flushes any pending selection immediately and cancels the debounce.
     func flush() async {
         debounceTask?.cancel()
         debounceTask = nil
         await performFlush()
     }
 
     private func scheduleDebounce() {
         debounceTask?.cancel()
         let interval = debounceInterval
         debounceTask = Task { [weak self] in
             try? await Task.sleep(for: interval)
             if Task.isCancelled { return }
             await self?.debouncedFlush()
         }
     }
 
     private func debouncedFlush() async {
         debounceTask = nil
         await performFlush()
     }
 
     private func performFlush() async {
         guard let gameID, let authorID, let selection = pending else { return }
         if selection == lastPublished { return }
         pending = nil
         lastPublished = selection
         await write(gameID: gameID, authorID: authorID, selection: selection)
         await sink(gameID, authorID)
     }
 
     private func flushClear() async {
         guard let gameID, let authorID else { return }
         if lastPublished == nil { return }
         lastPublished = nil
         await write(gameID: gameID, authorID: authorID, selection: nil)
         await sink(gameID, authorID)
     }
 
     private func write(
         gameID: UUID,
         authorID: String,
         selection: PlayerSelection?
     ) async {
         let context = persistence.container.newBackgroundContext()
         context.mergePolicy = NSMergePolicy.mergeByPropertyObjectTrump
         let now = Date()
         let fallbackName = self.fallbackName
         context.performAndWait {
             let recordName = RecordSerializer.recordName(forPlayerInGame: gameID, authorID: authorID)
             let req = NSFetchRequest<PlayerEntity>(entityName: "PlayerEntity")
             req.predicate = NSPredicate(format: "ckRecordName == %@", recordName)
             req.fetchLimit = 1
             let entity: PlayerEntity
             if let existing = try? context.fetch(req).first {
                 entity = existing
                 // Don't overwrite a name that NameBroadcaster has set; only
                 // backfill if it's missing or empty so the outgoing record is
                 // never `name=""`.
                 if (entity.name ?? "").isEmpty, !fallbackName.isEmpty {
                     entity.name = fallbackName
                 }
             } else {
                 let gameReq = NSFetchRequest<GameEntity>(entityName: "GameEntity")
                 gameReq.predicate = NSPredicate(format: "id == %@", gameID as CVarArg)
                 gameReq.fetchLimit = 1
                 guard let game = try? context.fetch(gameReq).first else { return }
                 entity = PlayerEntity(context: context)
                 entity.game = game
                 entity.ckRecordName = recordName
                 entity.authorID = authorID
                 if !fallbackName.isEmpty {
                     entity.name = fallbackName
                 }
             }
             entity.updatedAt = now
             if let selection {
                 entity.selRow = NSNumber(value: Int64(selection.row))
                 entity.selCol = NSNumber(value: Int64(selection.col))
                 entity.selDir = NSNumber(value: Int64(selection.direction.rawValue))
             } else {
                 entity.selRow = nil
                 entity.selCol = nil
                 entity.selDir = nil
             }
             if context.hasChanges {
                 try? context.save()
             }
         }
     }
 }