crossmate

SnapshotService.swift (7653B)

---

 import CoreData
 import Foundation
 
 /// Owns the snapshot-creation and move-pruning lifecycle for local
 /// (single-user) games. Lives outside `GameStore` so that
 /// `MoveBuffer.afterFlush` can run snapshot work without depending on
 /// `GameStore`, which lets `GameStore` accept its collaborators as required
 /// init parameters.
 @MainActor
 final class SnapshotService {
     let persistence: PersistenceController
     private var context: NSManagedObjectContext { persistence.viewContext }
 
     init(persistence: PersistenceController) {
         self.persistence = persistence
     }
 
     /// Checks each game in `gameIDs` and writes a `SnapshotEntity` if the
     /// game is complete (has `completedAt` set) or has 200 or more moves not
     /// yet covered by an existing snapshot. Moves folded into a local
     /// compaction snapshot are pruned only after CloudKit has confirmed that
     /// snapshot save. Returns the `ckRecordName` of each new snapshot for
     /// enqueueing, plus any move deletions made for previously-durable
     /// snapshots.
     func createSnapshotsIfNeeded(
         for gameIDs: Set<UUID>
     ) async -> (snapshotNames: [String], prunedMoveNames: [String]) {
         let bgCtx = persistence.container.newBackgroundContext()
         bgCtx.mergePolicy = NSMergePolicy.mergeByPropertyObjectTrump
         return await bgCtx.perform {
             var snapshotNames: [String] = []
             let prunedMoveNames = Self.pruneDurableSnapshots(in: bgCtx)
 
             for gameID in gameIDs {
                 let req = NSFetchRequest<GameEntity>(entityName: "GameEntity")
                 req.predicate = NSPredicate(format: "id == %@", gameID as CVarArg)
                 req.fetchLimit = 1
                 guard let entity = try? bgCtx.fetch(req).first else { continue }
                 guard !Self.usesSharedSync(entity) else { continue }
 
                 let allMoves = (entity.moves as? Set<MoveEntity>) ?? []
                 let allSnapshots = (entity.snapshots as? Set<SnapshotEntity>) ?? []
                 let latestCoveredLamport = allSnapshots.map(\.upToLamport).max() ?? 0
                 let uncoveredCount = allMoves.filter { $0.lamport > latestCoveredLamport }.count
                 let highWater = entity.lamportHighWater
 
                 let shouldSnapshot = (entity.completedAt != nil || uncoveredCount >= 200)
                     && highWater > latestCoveredLamport
                 guard shouldSnapshot else { continue }
 
                 let snapshots: [Snapshot] = allSnapshots.compactMap { se in
                     guard let data = se.gridState,
                           let grid = try? MoveLog.decodeGridState(data) else { return nil }
                     return Snapshot(
                         gameID: gameID,
                         upToLamport: se.upToLamport,
                         grid: grid,
                         createdAt: se.createdAt ?? Date()
                     )
                 }
                 let moves: [Move] = allMoves.map { me in
                     Move(
                         gameID: gameID,
                         lamport: me.lamport,
                         row: Int(me.row),
                         col: Int(me.col),
                         letter: me.letter ?? "",
                         markKind: me.markKind,
                         checkedWrong: me.checkedWrong,
                         authorID: me.authorID,
                         createdAt: me.createdAt ?? Date()
                     )
                 }
                 let grid = MoveLog.replay(snapshot: MoveLog.latestSnapshot(from: snapshots), moves: moves)
 
                 let snapshotEntity = SnapshotEntity(context: bgCtx)
                 snapshotEntity.game = entity
                 snapshotEntity.upToLamport = highWater
                 snapshotEntity.createdAt = Date()
                 let ckName = RecordSerializer.recordName(forSnapshotInGame: gameID, upToLamport: highWater)
                 snapshotEntity.ckRecordName = ckName
                 snapshotEntity.gridState = try? MoveLog.encodeGridState(grid)
                 snapshotEntity.needsPruning = true
 
                 snapshotNames.append(ckName)
             }
             if bgCtx.hasChanges {
                 try? bgCtx.save()
             }
             return (snapshotNames, prunedMoveNames)
         }
     }
 
     /// Deletes moves covered by local compaction snapshots after there is
     /// durable evidence that the snapshot exists in CloudKit. Passing names
     /// is used directly from CKSyncEngine's saved-record callback; omitting
     /// names performs crash recovery by looking for saved snapshots with
     /// written-back system fields.
     func pruneMoves(
         ckRecordNames: Set<String>? = nil
     ) -> [String] {
         let req = NSFetchRequest<SnapshotEntity>(entityName: "SnapshotEntity")
         if let ckRecordNames {
             guard !ckRecordNames.isEmpty else { return [] }
             req.predicate = NSPredicate(
                 format: "needsPruning == YES AND ckRecordName IN %@",
                 Array(ckRecordNames)
             )
         } else {
             req.predicate = NSPredicate(
                 format: "needsPruning == YES AND ckSystemFields != nil"
             )
         }
 
         let snapshots = (try? context.fetch(req)) ?? []
         var prunedMoveNames: [String] = []
         for snapshot in snapshots {
             guard let game = snapshot.game else {
                 snapshot.needsPruning = false
                 continue
             }
             guard !Self.usesSharedSync(game) else {
                 snapshot.needsPruning = false
                 continue
             }
 
             let covered = ((game.moves as? Set<MoveEntity>) ?? [])
                 .filter { $0.lamport <= snapshot.upToLamport }
             for move in covered {
                 if let name = move.ckRecordName {
                     prunedMoveNames.append(name)
                 }
                 context.delete(move)
             }
             snapshot.needsPruning = false
         }
 
         if context.hasChanges {
             try? context.save()
         }
         return prunedMoveNames
     }
 
     /// Background-context equivalent of `pruneMoves(ckRecordNames: nil)` —
     /// drops moves covered by snapshots whose CloudKit system fields prove
     /// the snapshot is durable. Caller is responsible for saving `ctx`.
     fileprivate nonisolated static func pruneDurableSnapshots(
         in ctx: NSManagedObjectContext
     ) -> [String] {
         let req = NSFetchRequest<SnapshotEntity>(entityName: "SnapshotEntity")
         req.predicate = NSPredicate(
             format: "needsPruning == YES AND ckSystemFields != nil"
         )
         let snapshots = (try? ctx.fetch(req)) ?? []
         var prunedMoveNames: [String] = []
         for snapshot in snapshots {
             guard let game = snapshot.game else {
                 snapshot.needsPruning = false
                 continue
             }
             guard !Self.usesSharedSync(game) else {
                 snapshot.needsPruning = false
                 continue
             }
             let covered = ((game.moves as? Set<MoveEntity>) ?? [])
                 .filter { $0.lamport <= snapshot.upToLamport }
             for move in covered {
                 if let name = move.ckRecordName {
                     prunedMoveNames.append(name)
                 }
                 ctx.delete(move)
             }
             snapshot.needsPruning = false
         }
         return prunedMoveNames
     }
 
     fileprivate nonisolated static func usesSharedSync(_ game: GameEntity) -> Bool {
         game.databaseScope == 1 || game.ckShareRecordName != nil
     }
 }