crossmate

PlayerRoster.swift (14897B)

---

 import CloudKit
 import CoreData
 import Foundation
 import Observation
 
 /// Observable view-model that represents all participants (local + remote)
 /// in a single shared game. Drives the "Players" menu in `PuzzleView`.
 @Observable
 @MainActor
 final class PlayerRoster {
 
     struct Entry: Identifiable {
         let authorID: String
         let name: String
         let color: PlayerColor
         let isLocal: Bool
         var id: String { authorID }
     }
 
     struct RemoteSelection: Equatable {
         let authorID: String
         let row: Int
         let col: Int
         let direction: Puzzle.Direction
         let color: PlayerColor
         let updatedAt: Date
     }
 
     private struct RawSelection {
         let authorID: String
         let row: Int
         let col: Int
         let direction: Puzzle.Direction
         let updatedAt: Date
     }
 
     /// Peer cursors keyed by `authorID`. Stale entries (older than the
     /// freshness window) are dropped on each refresh. The local player is
     /// never present in this map.
     private(set) var remoteSelections: [String: RemoteSelection] = [:]
 
     /// Selections older than this are treated as stale and hidden — covers
     /// the case where the peer crashed or lost connectivity without writing
     /// a "cleared" record. The polling interval is 5s plus push, so 60s is
     /// generous enough to ride out a brief network hiccup.
     private let selectionFreshnessWindow: TimeInterval = 60
 
     private(set) var entries: [Entry] = []
     private(set) var localAuthorID: String?
 
     private let gameID: UUID
     private let colorStore: GamePlayerColorStore
     private let authorIdentity: AuthorIdentity
     private let preferences: PlayerPreferences
     private let persistence: PersistenceController
     private let container: CKContainer
     private let tracer: (@MainActor @Sendable (String) -> Void)?
 
     private var cachedShare: CKShare?
     private var observationTasks: [Task<Void, Never>] = []
     private var lastTracedSignature: String?
 
     init(
         gameID: UUID,
         colorStore: GamePlayerColorStore,
         authorIdentity: AuthorIdentity,
         preferences: PlayerPreferences,
         persistence: PersistenceController,
         container: CKContainer,
         tracer: (@MainActor @Sendable (String) -> Void)? = nil
     ) {
         self.gameID = gameID
         self.colorStore = colorStore
         self.authorIdentity = authorIdentity
         self.preferences = preferences
         self.persistence = persistence
         self.container = container
         self.tracer = tracer
         startObserving()
     }
 
     isolated deinit {
         for task in observationTasks {
             task.cancel()
         }
     }
 
     // MARK: - Observation
 
     private func startObserving() {
         let gameID = self.gameID
 
         // Local colour assignments changed (from `setColor` / collision
         // resolution / gc) — refresh so the menu reflects the new mapping.
         observationTasks.append(
             Task { [weak self] in
                 for await note in NotificationCenter.default.notifications(
                     named: .gamePlayerColorsChanged
                 ) {
                     guard let self else { return }
                     guard let id = note.userInfo?["gameID"] as? UUID,
                           id == gameID else { continue }
                     await self.refresh()
                 }
             }
         )
 
         // Remote record changes affecting this game — name records arriving
         // from other participants, new participants joining (move records
         // carry a fresh authorID), share metadata changes. Invalidate the
         // cached share so the next refresh re-fetches it; participant lists
         // may have moved.
         observationTasks.append(
             Task { [weak self] in
                 for await note in NotificationCenter.default.notifications(
                     named: .playerRosterShouldRefresh
                 ) {
                     guard let self else { return }
                     guard let ids = note.userInfo?["gameIDs"] as? Set<UUID>,
                           ids.contains(gameID) else { continue }
                     self.cachedShare = nil
                     await self.refresh()
                 }
             }
         )
     }
 
     // MARK: - Refresh
 
     func refresh() async {
         // Without a known local authorID we can't classify any participant as
         // self vs. remote, so the only safe answer is an empty roster. The
         // next refresh (after AuthorIdentity populates) will do the real work.
         guard let localAuthorID = authorIdentity.currentID else {
             self.localAuthorID = nil
             entries = []
             remoteSelections = [:]
             return
         }
         self.localAuthorID = localAuthorID
 
         // Pull Core Data fields off a background context.
         let ctx = persistence.container.newBackgroundContext()
         let (databaseScope, ckShareRecordName, ckZoneName, ckZoneOwnerName, namesMap, moveAuthorIDs, rawSelections) =
             ctx.performAndWait { () -> (Int16, String?, String?, String?, [String: String], [String], [RawSelection]) in
                 let req = NSFetchRequest<GameEntity>(entityName: "GameEntity")
                 req.predicate = NSPredicate(format: "id == %@", gameID as CVarArg)
                 req.fetchLimit = 1
                 guard let entity = try? ctx.fetch(req).first else {
                     return (0, nil, nil, nil, [:], [], [])
                 }
                 let nameReq = NSFetchRequest<PlayerEntity>(entityName: "PlayerEntity")
                 nameReq.predicate = NSPredicate(format: "game == %@", entity)
                 let nameEntities = (try? ctx.fetch(nameReq)) ?? []
                 var namesMap: [String: String] = [:]
                 var selections: [RawSelection] = []
                 for nr in nameEntities {
                     guard let aid = nr.authorID, !aid.isEmpty else { continue }
                     if let name = nr.name, !name.isEmpty {
                         namesMap[aid] = name
                     }
                     if aid == localAuthorID { continue }
                     if let row = nr.selRow,
                        let col = nr.selCol,
                        let dir = nr.selDir,
                        let direction = Puzzle.Direction(rawValue: dir.intValue),
                        let updatedAt = nr.updatedAt {
                         selections.append(RawSelection(
                             authorID: aid,
                             row: row.intValue,
                             col: col.intValue,
                             direction: direction,
                             updatedAt: updatedAt
                         ))
                     }
                 }
                 let movesReq = NSFetchRequest<MovesEntity>(entityName: "MovesEntity")
                 movesReq.predicate = NSPredicate(format: "game == %@", entity)
                 let movesEntities = (try? ctx.fetch(movesReq)) ?? []
                 let authorIDs = Array(
                     Set(movesEntities.compactMap { $0.authorID })
                         .subtracting([localAuthorID, CKCurrentUserDefaultName, ""])
                 )
                 return (
                     entity.databaseScope,
                     entity.ckShareRecordName,
                     entity.ckZoneName,
                     entity.ckZoneOwnerName,
                     namesMap,
                     authorIDs,
                     selections
                 )
             }
 
         applyRoster(localAuthorID: localAuthorID, namesMap: namesMap, moveAuthorIDs: moveAuthorIDs, rawSelections: rawSelections, share: nil)
 
         // Fetch the CKShare if not already cached. This can be noticeably
         // slower on device, so publish the local Core Data roster first and
         // then refine names/participants if share metadata arrives.
         let share = await fetchShare(
             databaseScope: databaseScope,
             ckShareRecordName: ckShareRecordName,
             ckZoneName: ckZoneName,
             ckZoneOwnerName: ckZoneOwnerName
         )
         applyRoster(localAuthorID: localAuthorID, namesMap: namesMap, moveAuthorIDs: moveAuthorIDs, rawSelections: rawSelections, share: share)
     }
 
     private func applyRoster(
         localAuthorID: String,
         namesMap: [String: String],
         moveAuthorIDs: [String],
         rawSelections: [RawSelection],
         share: CKShare?
     ) {
         // Collect all remote participant authorIDs.
         var otherAuthorIDs = Set<String>()
         for key in namesMap.keys
             where key != localAuthorID
                 && key != CKCurrentUserDefaultName
                 && !key.isEmpty {
             otherAuthorIDs.insert(key)
         }
         if let share {
             for participant in share.participants {
                 guard participant.acceptanceStatus == .accepted,
                       let recordName = participant.userIdentity.userRecordID?.recordName,
                       recordName != localAuthorID,
                       recordName != CKCurrentUserDefaultName
                 else { continue }
                 otherAuthorIDs.insert(recordName)
             }
         }
         for authorID in moveAuthorIDs where authorID != CKCurrentUserDefaultName {
             otherAuthorIDs.insert(authorID)
         }
 
         // Diagnostic — surfaces the inputs that drive the entries list so we
         // can tell whether a "ghost" authorID came from a stale PlayerEntity,
         // a stray MovesEntity, or the share's participant list. Trim noisy
         // re-entries by only emitting when the signature actually changes.
         if let tracer {
             let participantIDs: [String] = share?.participants.compactMap {
                 $0.userIdentity.userRecordID?.recordName
             } ?? []
             let signature = "local=\(localAuthorID) | names=\(namesMap.keys.sorted()) | moves=\(moveAuthorIDs.sorted()) | share=\(participantIDs.sorted())"
             if signature != lastTracedSignature {
                 lastTracedSignature = signature
                 tracer("PlayerRoster[\(gameID.uuidString.prefix(8))]: \(signature)")
             }
         }
 
         // Build remote entries, assigning stable colours.
         var remoteEntries: [Entry] = []
         let reservedColorIDs: Set<String> = [preferences.color.id]
         for authorID in otherAuthorIDs.sorted() {
             let name = resolveName(authorID: authorID, namesMap: namesMap)
             let color = colorStore.ensureColor(
                 forGame: gameID,
                 authorID: authorID,
                 reservedColorIDs: reservedColorIDs
             )
             remoteEntries.append(Entry(authorID: authorID, name: name, color: color, isLocal: false))
         }
         remoteEntries.sort {
             $0.name == $1.name ? $0.authorID < $1.authorID : $0.name < $1.name
         }
 
         // Garbage-collect stale colour entries.
         let currentRemoteIDs = Set(remoteEntries.map { $0.authorID })
         for staleID in colorStore.storedAuthorIDs(forGame: gameID).subtracting(currentRemoteIDs) {
             colorStore.clearColor(forGame: gameID, authorID: staleID, notify: false)
         }
 
         let localEntry = Entry(
             authorID: localAuthorID,
             name: preferences.name,
             color: preferences.color,
             isLocal: true
         )
         entries = [localEntry] + remoteEntries
 
         // Map raw selections to the resolved colour from the entry list,
         // dropping anything stale or with no matching entry.
         let colorByAuthor = Dictionary(
             uniqueKeysWithValues: remoteEntries.map { ($0.authorID, $0.color) }
         )
         let now = Date()
         var fresh: [String: RemoteSelection] = [:]
         for raw in rawSelections {
             guard let color = colorByAuthor[raw.authorID] else { continue }
             guard now.timeIntervalSince(raw.updatedAt) < selectionFreshnessWindow else {
                 continue
             }
             fresh[raw.authorID] = RemoteSelection(
                 authorID: raw.authorID,
                 row: raw.row,
                 col: raw.col,
                 direction: raw.direction,
                 color: color,
                 updatedAt: raw.updatedAt
             )
         }
         remoteSelections = fresh
     }
 
     // MARK: - Collision resolution
 
     /// When the local user picks a colour that collides with a remote entry,
     /// silently reassign the victim to the first free palette colour.
     func reassignOnLocalColorChange(newColor: PlayerColor) async {
         guard let victim = entries.first(where: { !$0.isLocal && $0.color.id == newColor.id }) else {
             return
         }
         let taken = Set([newColor.id]).union(
             colorStore.assignedColorIDs(forGame: gameID, excludingAuthorID: victim.authorID)
         )
         let replacement = PlayerColor.palette.first { !taken.contains($0.id) }
             ?? PlayerColor.palette.randomElement()
             ?? .blue
         colorStore.setColor(replacement, forGame: gameID, authorID: victim.authorID)
         await refresh()
     }
 
     // MARK: - Private helpers
 
     private func fetchShare(
         databaseScope: Int16,
         ckShareRecordName: String?,
         ckZoneName: String?,
         ckZoneOwnerName: String?
     ) async -> CKShare? {
         if let cached = cachedShare { return cached }
         guard let zoneName = ckZoneName else { return nil }
         let ownerName = ckZoneOwnerName ?? CKCurrentUserDefaultName
         let zoneID = CKRecordZone.ID(zoneName: zoneName, ownerName: ownerName)
         do {
             if databaseScope == 0, let shareRecordName = ckShareRecordName {
                 let shareID = CKRecord.ID(recordName: shareRecordName, zoneID: zoneID)
                 let share = try await container.privateCloudDatabase.record(for: shareID) as? CKShare
                 cachedShare = share
                 return share
             } else if databaseScope == 1 {
                 let shareID = CKRecord.ID(recordName: CKRecordNameZoneWideShare, zoneID: zoneID)
                 let share = try await container.sharedCloudDatabase.record(for: shareID) as? CKShare
                 cachedShare = share
                 return share
             }
         } catch {
             // Best effort — proceed without share metadata.
         }
         return nil
     }
 
     private func resolveName(authorID: String, namesMap: [String: String]) -> String {
         // The game-specific Player record is authoritative for display names.
         // CKShare metadata can arrive earlier, but it may expose an unrelated
         // contact/iCloud name and then visibly rename the row a moment later.
         if let name = namesMap[authorID], !name.isEmpty { return name }
         return "Waiting for player..."
     }
 }