crossmate

PlayerNamePublisher.swift (9717B)

---

 import CloudKit
 import CoreData
 import Foundation
 import Observation
 
 /// The local user's monotonic display-name generation, UserDefaults-backed and
 /// keyed by authorID. Each rename bumps it by one; every copy of the name
 /// Decision written in that rename (account zone + friend zones) carries the
 /// same generation, and the send path's version-wins conflict rule lets a
 /// newer rename overwrite an older copy wherever they collide. Inbound echoes
 /// of our own Decision (another device renamed) are adopted via `adopt` so
 /// this device's next rename supersedes the account's highest known
 /// generation instead of colliding with it.
 enum NameVersionStore {
     private static func key(_ authorID: String) -> String {
         "NameVersionStore.version.\(authorID)"
     }
 
     /// Highest generation this device has published or seen. 0 until the
     /// first rename — friendship seeding publishes at this resting value so a
     /// seed never outranks (or ties) a real rename.
     static func current(authorID: String, defaults: UserDefaults = .standard) -> Int64 {
         (defaults.object(forKey: key(authorID)) as? NSNumber)?.int64Value ?? 0
     }
 
     /// The generation for a new rename: one past everything seen. Stores.
     static func next(authorID: String, defaults: UserDefaults = .standard) -> Int64 {
         let value = current(authorID: authorID, defaults: defaults) + 1
         defaults.set(NSNumber(value: value), forKey: key(authorID))
         return value
     }
 
     /// Adopts a generation observed on an inbound copy of our own Decision.
     static func adopt(
         _ version: Int64,
         authorID: String,
         defaults: UserDefaults = .standard
     ) {
         guard version > current(authorID: authorID, defaults: defaults) else { return }
         defaults.set(NSNumber(value: version), forKey: key(authorID))
     }
 }
 
 /// Observes `PlayerPreferences.name` and, when it changes, publishes the new
 /// name as a `name` Decision into the account zone (own-device convergence)
 /// and every non-blocked friend zone (how friends learn the rename). The
 /// fan-out therefore scales with friendships, not games, and reaches friends
 /// even after every shared game is completed or deleted.
 ///
 /// Per-game `Player` records still carry a snapshot of the name, written once
 /// at game open (`publishName(for:)`) — that's what collaborators see before
 /// a friendship's first name Decision lands, and what not-yet-friended
 /// participants fall back to.
 ///
 /// Debounces at 250 ms: `PlayerPreferences` writes to both `UserDefaults` and
 /// `NSUbiquitousKeyValueStore`, which can echo back as a second setter call;
 /// a single rename should produce exactly one fan-out.
 @MainActor
 final class PlayerNamePublisher {
     private let preferences: PlayerPreferences
     private let persistence: PersistenceController
     private let authorIdentity: AuthorIdentity
     private let enqueuePlayer: (UUID, String, String) async -> Void
     /// (authorID, name, version, zoneID, scope) → `SyncEngine.enqueueNameDecision`.
     private let enqueueNameDecision: (String, String, Int64, CKRecordZone.ID, DatabaseScope) async -> Void
 
     private var debounceTask: Task<Void, Never>?
     private var observationTask: Task<Void, Never>?
 
     /// Testing-only observer fired after each fan-out completes. Receives the
     /// name that was just broadcast. Production callers should leave this nil.
     var onFanOutForTesting: ((String) -> Void)?
 
     init(
         preferences: PlayerPreferences,
         persistence: PersistenceController,
         authorIdentity: AuthorIdentity,
         enqueuePlayer: @escaping (UUID, String, String) async -> Void,
         enqueueNameDecision: @escaping (String, String, Int64, CKRecordZone.ID, DatabaseScope) async -> Void
     ) {
         self.preferences = preferences
         self.persistence = persistence
         self.authorIdentity = authorIdentity
         self.enqueuePlayer = enqueuePlayer
         self.enqueueNameDecision = enqueueNameDecision
         startObserving()
     }
 
     private func startObserving() {
         observationTask = Task { [weak self] in
             guard let self else { return }
             while !Task.isCancelled {
                 await withCheckedContinuation { (cont: CheckedContinuation<Void, Never>) in
                     withObservationTracking {
                         _ = self.preferences.name
                     } onChange: {
                         cont.resume()
                     }
                 }
                 guard !Task.isCancelled else { break }
                 self.scheduleDebounce()
             }
         }
     }
 
     private func scheduleDebounce() {
         debounceTask?.cancel()
         debounceTask = Task { [weak self] in
             do {
                 try await Task.sleep(for: .milliseconds(250))
             } catch {
                 return
             }
             guard let self, !Task.isCancelled else { return }
             await self.fanOut(newName: self.preferences.name)
         }
     }
 
     /// Publishes the local user's current name as a Decision to the account
     /// zone and every non-blocked friend zone, at a freshly bumped generation.
     func broadcastName() async {
         await fanOut(newName: preferences.name)
     }
 
     /// Writes the local user's name into one game's `PlayerEntity` row. Used
     /// when opening a shared puzzle so the game zone itself carries a name
     /// snapshot — collaborators who aren't friends yet (or whose friend zone
     /// hasn't delivered a name Decision) read this.
     func publishName(for gameID: UUID) async {
         guard let authorID = authorIdentity.currentID else { return }
 
         let ctx = persistence.container.newBackgroundContext()
         ctx.mergePolicy = NSMergePolicy.mergeByPropertyObjectTrump
         guard await Self.upsertPlayerRecord(
             for: gameID,
             in: ctx,
             authorID: authorID,
             name: preferences.name
         ) else { return }
 
         await enqueuePlayer(gameID, authorID, "name-open")
     }
 
     private func fanOut(newName: String) async {
         guard let authorID = authorIdentity.currentID else { return }
         let name = newName.trimmingCharacters(in: .whitespacesAndNewlines)
         guard !name.isEmpty else { return }
 
         let version = NameVersionStore.next(authorID: authorID)
         await enqueueNameDecision(
             authorID, name, version, RecordSerializer.accountZoneID, .private
         )
         let ctx = persistence.container.newBackgroundContext()
         for target in await Self.friendZoneTargets(in: ctx) {
             await enqueueNameDecision(
                 authorID, name, version, target.zoneID, target.scope
             )
         }
 
         onFanOutForTesting?(name)
     }
 
     /// Background-context work — runs on `ctx`'s queue via `await perform`, so
     /// it never blocks the main actor even though the caller is `@MainActor`.
     private nonisolated static func friendZoneTargets(
         in ctx: NSManagedObjectContext
     ) async -> [(zoneID: CKRecordZone.ID, scope: DatabaseScope)] {
         await ctx.perform {
             let req = NSFetchRequest<FriendEntity>(entityName: "FriendEntity")
             req.predicate = NSPredicate(format: "isBlocked == NO")
             let friends = (try? ctx.fetch(req)) ?? []
             return friends.compactMap { friend in
                 // Our name is told to a friend by writing into their inbox —
                 // our outbox (shared DB).
                 guard let pairKey = friend.pairKey,
                       let authorID = friend.authorID,
                       FriendZone.outboxAccepted(pairKey: pairKey)
                 else { return nil }
                 return (
                     FriendZone.outboxZoneID(pairKey: pairKey, friendAuthorID: authorID),
                     .shared
                 )
             }
         }
     }
 
     private nonisolated static func upsertPlayerRecord(
         for gameID: UUID,
         in ctx: NSManagedObjectContext,
         authorID: String,
         name: String
     ) async -> Bool {
         await ctx.perform {
             let req = NSFetchRequest<GameEntity>(entityName: "GameEntity")
             req.predicate = NSPredicate(
                 format: "id == %@ AND (ckShareRecordName != nil OR databaseScope == 1) AND isAccessRevoked == NO",
                 gameID as CVarArg
             )
             req.fetchLimit = 1
             guard let game = try? ctx.fetch(req).first else { return false }
             upsertPlayerEntity(
                 for: game,
                 authorID: authorID,
                 name: name,
                 now: Date(),
                 in: ctx
             )
             if ctx.hasChanges { try? ctx.save() }
             return true
         }
     }
 
     private nonisolated static func upsertPlayerEntity(
         for game: GameEntity,
         authorID: String,
         name: String,
         now: Date,
         in ctx: NSManagedObjectContext
     ) {
         guard let gameID = game.id else { return }
         let recordName = RecordSerializer.recordName(forPlayerInGame: gameID, authorID: authorID)
         let lookup = NSFetchRequest<PlayerEntity>(entityName: "PlayerEntity")
         lookup.predicate = NSPredicate(format: "ckRecordName == %@", recordName)
         lookup.fetchLimit = 1
 
         let entity: PlayerEntity
         if let existing = try? ctx.fetch(lookup).first {
             entity = existing
         } else {
             entity = PlayerEntity(context: ctx)
             entity.game = game
             entity.ckRecordName = recordName
             entity.authorID = authorID
         }
         entity.name = name
         entity.updatedAt = now
     }
 }