crossmate

BadgeCoordinator.swift (12681B)

---

 import Foundation
 import UserNotifications
 
 /// Reconciles the app-icon badge and its push-side ledger, extracted from
 /// `AppServices`: setting the badge from Core Data ground truth unioned with
 /// the NSE's provisional `BadgeState` entries, withdrawing delivered
 /// notifications when a game is seen (here or on a sibling device), and
 /// pruning ledger entries no longer backed by anything.
 @MainActor
 final class BadgeCoordinator {
     private let store: GameStore
     private let syncMonitor: SyncMonitor
     /// Length of the presence lease (`AppServices.readLeaseDuration`): how far
     /// forward the suppression horizon is stamped while the puzzle is open.
     private let readLeaseDuration: TimeInterval
     /// Fans the seen horizon out to sibling devices —
     /// `AccountPushCoordinator.publishAccountSeenPush(gameID:readAt:)`.
     private let publishAccountSeenPush: (UUID, Date) async -> Void
     private var lastLoggedBadgeSnapshot: BadgeRefreshSnapshot?
 
     private struct BadgeRefreshSnapshot: Equatable {
         let ledgerUnread: Set<UUID>
         let coreDataUnread: Set<UUID>
         let pendingInvites: Set<UUID>
 
         var merged: Set<UUID> {
             ledgerUnread.union(coreDataUnread).union(pendingInvites)
         }
     }
 
     init(
         store: GameStore,
         syncMonitor: SyncMonitor,
         readLeaseDuration: TimeInterval,
         publishAccountSeenPush: @escaping (UUID, Date) async -> Void
     ) {
         self.store = store
         self.syncMonitor = syncMonitor
         self.readLeaseDuration = readLeaseDuration
         self.publishAccountSeenPush = publishAccountSeenPush
     }
 
     /// Removes any already-delivered local notifications for `gameID` from
     /// this device's Notification Center. Sibling devices of the same iCloud
     /// account learn about the dismissal indirectly: a directed ping is
     /// deleted on consumption (the `onPingDeleted` path then withdraws their
     /// copy), and the unread-moves badge converges via `Player.readAt`.
     ///
     /// Every dismissal path is also a "user has seen this game" signal, so
     /// we advance the App Group badge ledger's seen horizon and refresh the
     /// app-icon badge. Without this, pause/win/resign entries added by the
     /// Notification Service Extension would otherwise linger past the point
     /// where their banners have already been withdrawn.
     func dismissDeliveredNotifications(
         for gameID: UUID,
         seenAt explicitSeenAt: Date? = nil,
         publishAccountSeen: Bool = true,
         preserveUnread: Bool = false
     ) async {
         let center = UNUserNotificationCenter.current()
         let delivered = await center.deliveredNotifications()
         let preserveUnreadNotifications = preserveUnread
             && store.hasUnreadOtherMoves(gameID: gameID)
         let identifiers = delivered.compactMap { notification -> String? in
             let userInfo = notification.request.content.userInfo
             guard let raw = userInfo["gameID"] as? String,
                   raw == gameID.uuidString
             else { return nil }
             if preserveUnreadNotifications, notificationMarksUnread(notification) {
                 return nil
             }
             return notification.request.identifier
         }
         if !identifiers.isEmpty {
             center.removeDeliveredNotifications(withIdentifiers: identifiers)
             syncMonitor.note("notif: dismissed \(identifiers.count) delivered for \(gameID.uuidString)")
         } else if preserveUnreadNotifications {
             syncMonitor.note("notif: kept delivered unread notifications for \(gameID.uuidString)")
         }
         // While viewing, the horizon is the local lease (forward-dated); the
         // ledger adoption splits it — watermark to now, suppression to the
         // lease — so pushes landing mid-session don't badge, yet the leave
         // path's `collapseSuppression` can still un-swallow anything that
         // arrives after the user stops looking. Writing the raw horizon into
         // `markSeen` here is what used to pin the badge dark for the rest of
         // the lease window after backgrounding.
         let horizon = explicitSeenAt
             ?? (NotificationState.isSuppressed(gameID: gameID)
                 ? Date().addingTimeInterval(readLeaseDuration)
                 : Date())
         BadgeState.adoptReadHorizon(gameID: gameID, horizon: horizon)
         await refreshAppBadge(reason: "dismiss delivered")
         if publishAccountSeen {
             await publishAccountSeenPush(gameID, horizon)
         }
     }
 
     /// Sets the app icon badge to Core Data ground truth (the
     /// `hasUnreadOtherMoves` heuristic that drives the per-row dot in the
     /// library list) unioned with provisional push-side unread entries the
     /// Notification Service Extension added since the last refresh.
     ///
     /// Core Data unread games are seeded into `BadgeState` as `unreadAt`
     /// horizons stamped with each game's newest unseen other-author move time.
     /// The NSE can't reach Core Data, so without this seed a push landing on a
     /// suspended app would re-stamp the badge from the ledger alone and drop
     /// any game whose unread state arrived purely via CloudKit sync. Seeding is
     /// safe under horizon semantics — a game the user has since opened carries a
     /// newer `seenAt` and won't resurrect — which the old set-based ledger
     /// couldn't express, hence why this write-back was previously dropped.
     func refreshAppBadge(reason: String = "unspecified") async {
         if BadgeState.claimLegacyReadThroughHealNeeded() {
             let deliveredUnread = await deliveredUnreadGameIDs()
             let healed = store.backfillLegacyReadThrough(excluding: deliveredUnread)
             syncMonitor.note(
                 "app badge legacy readThrough heal: changed=\(healed) "
                     + "preservedDelivered=\(deliveredUnread.count) [\(shortIDs(deliveredUnread))]"
             )
         }
         let coreDataUnread = store.unreadOtherMovesGameTimes()
         BadgeState.seedUnread(coreDataUnread)
         // Pending invites are binary (not a read horizon), so publish them as a
         // dedicated authoritative set the NSE unions into its count. Disjoint
         // from the unread-moves set, so the union below never double-counts.
         let pendingInvites = store.pendingInviteGameIDs()
         BadgeState.setPendingInvites(pendingInvites)
         let snapshot = BadgeRefreshSnapshot(
             ledgerUnread: BadgeState.unreadGameIDs(),
             coreDataUnread: Set(coreDataUnread.keys),
             pendingInvites: pendingInvites
         )
         let merged = snapshot.merged
         if snapshot != lastLoggedBadgeSnapshot {
             syncMonitor.note(
                 "app badge refresh(\(reason)): count=\(merged.count) "
                     + "ledger=\(snapshot.ledgerUnread.count) [\(shortIDs(snapshot.ledgerUnread))] "
                     + "coreData=\(snapshot.coreDataUnread.count) [\(shortIDs(snapshot.coreDataUnread))] "
                     + "pendingInvites=\(snapshot.pendingInvites.count) [\(shortIDs(snapshot.pendingInvites))]"
             )
             lastLoggedBadgeSnapshot = snapshot
         }
         do {
             try await UNUserNotificationCenter.current().setBadgeCount(merged.count)
         } catch {
             syncMonitor.note("app badge update failed: \(error.localizedDescription)")
         }
     }
 
     /// One startup-only snapshot for badge debugging. Kept out of
     /// `refreshAppBadge` so normal notification and sync churn does not flood
     /// diagnostics.
     func logNotificationStartupSnapshot() async {
         let delivered = await UNUserNotificationCenter.current().deliveredNotifications()
         let ledgerUnread = BadgeState.unreadGameIDs()
         let coreDataUnread = store.unreadOtherMovesGameTimes()
         let merged = ledgerUnread.union(coreDataUnread.keys)
         syncMonitor.note(
             "notif startup: delivered=\(delivered.count) "
                 + "badgeLedger=\(ledgerUnread.count) [\(shortIDs(ledgerUnread))] "
                 + "coreDataUnread=\(coreDataUnread.count) [\(shortIDs(coreDataUnread.keys))] "
                 + "merged=\(merged.count) [\(shortIDs(merged))]"
         )
         for notification in delivered.sorted(by: { $0.date < $1.date }) {
             syncMonitor.note("notif delivered: \(notificationSummary(notification))")
         }
     }
 
     /// Clears stale provisional badge-ledger entries that are no longer backed
     /// by either synced unread state or a delivered badge-worthy notification.
     /// This keeps presence-only notifications (`play`, `replay`, zero-count
     /// pause) from keeping an old ledger entry alive while still preserving
     /// push-ahead-of-sync unread entries when their delivered notification is
     /// visible on the device.
     func reconcileBadgeLedgerWithDeliveredNotifications() async {
         let ledgerUnread = BadgeState.unreadGameIDs()
         guard !ledgerUnread.isEmpty else { return }
         let coreDataUnread = Set(store.unreadOtherMovesGameTimes().keys)
         let delivered = await UNUserNotificationCenter.current().deliveredNotifications()
         let deliveredUnread = deliveredUnreadGameIDs(from: delivered)
         let stale = ledgerUnread.subtracting(coreDataUnread).subtracting(deliveredUnread)
         guard !stale.isEmpty else { return }
         for gameID in stale {
             BadgeState.forget(gameID: gameID)
         }
         syncMonitor.note(
             "app badge ledger reconcile: cleared=\(stale.count) [\(shortIDs(stale))] "
                 + "coreData=\(coreDataUnread.count) [\(shortIDs(coreDataUnread))] "
                 + "deliveredUnread=\(deliveredUnread.count) [\(shortIDs(deliveredUnread))]"
         )
     }
 
     private func notificationSummary(_ notification: UNNotification) -> String {
         let request = notification.request
         let content = request.content
         let userInfo = content.userInfo
         let gameID = notificationGameID(from: userInfo)
         let kind = userInfo["kind"] as? String
         let pingKind = userInfo["pingKind"] as? String
         let nseLogged = (userInfo["crossmateNSELogged"] as? Bool) == true
         return "id=\(request.identifier)"
             + " date=\(notification.date.ISO8601Format())"
             + " game=\(gameID.map { shortID($0) } ?? "nil")"
             + " kind=\(kind ?? "nil")"
             + " pingKind=\(pingKind ?? "nil")"
             + " badge=\(content.badge?.stringValue ?? "nil")"
             + " nseLogged=\(nseLogged)"
             + " title=\"\(logEscaped(content.title))\""
             + " body=\"\(logEscaped(content.body))\""
     }
 
     private func notificationMarksUnread(_ notification: UNNotification) -> Bool {
         let userInfo = notification.request.content.userInfo
         if let payload = PushPayload.decode(from: userInfo["payload"] as? String) {
             return payload.marksUnread
         }
         let kind = userInfo["kind"] as? String
         return kind == "pause" || kind == "win" || kind == "resign"
     }
 
     private func deliveredUnreadGameIDs() async -> Set<UUID> {
         let delivered = await UNUserNotificationCenter.current().deliveredNotifications()
         return deliveredUnreadGameIDs(from: delivered)
     }
 
     private func deliveredUnreadGameIDs(from delivered: [UNNotification]) -> Set<UUID> {
         Set(delivered.compactMap { notification -> UUID? in
             guard notificationMarksUnread(notification),
                   let gameID = notificationGameID(from: notification.request.content.userInfo)
             else { return nil }
             return gameID
         })
     }
 
     private func notificationGameID(from userInfo: [AnyHashable: Any]) -> UUID? {
         if let raw = userInfo["gameID"] as? String,
            let id = UUID(uuidString: raw) {
             return id
         }
         guard let ck = userInfo["ck"] as? [AnyHashable: Any],
               let qry = ck["qry"] as? [AnyHashable: Any],
               let zoneName = qry["zid"] as? String,
               zoneName.hasPrefix("game-")
         else { return nil }
         return UUID(uuidString: String(zoneName.dropFirst("game-".count)))
     }
 
     private func shortIDs<S: Sequence>(_ ids: S) -> String where S.Element == UUID {
         ids.map(shortID).sorted().joined(separator: ",")
     }
 
     private func shortID(_ id: UUID) -> String {
         String(id.uuidString.prefix(8))
     }
 
     private func logEscaped(_ text: String) -> String {
         text.replacingOccurrences(of: "\n", with: " ")
             .trimmingCharacters(in: .whitespacesAndNewlines)
     }
 }