crossmate

FriendPickerView.swift (7320B)

---

 import SwiftUI
 
 /// Lists existing (non-blocked) friends so the user can re-invite one to a
 /// game without generating and sending a link. Friends are accumulated
 /// automatically the first time you collaborate with someone (see
 /// `FriendController`).
 struct FriendPickerView: View {
     let gameID: UUID
     let shareController: ShareController
 
     @Environment(\.appActions) private var appActions
     @Environment(\.dismiss) private var dismiss
 
     @FetchRequest(
         sortDescriptors: [NSSortDescriptor(keyPath: \FriendEntity.createdAt, ascending: true)],
         predicate: NSPredicate(format: "isBlocked == NO"),
         animation: .default
     )
     private var friends: FetchedResults<FriendEntity>
 
     @State private var invitingAuthorID: String?
     @State private var invitedAuthorIDs: Set<String>
     @State private var isInviteLimitReached: Bool
     @State private var failedInviteAuthorID: String?
     @State private var inviteFailure: InviteDeliveryFailure?
 
     init(gameID: UUID, shareController: ShareController, isInviteLimitReached: Bool = false) {
         self.gameID = gameID
         self.shareController = shareController
         // Seed from the in-memory session set so friends invited a moment ago
         // already wear their checkmark on the first frame; the .task below
         // backfills anyone invited in a prior session or on another device.
         _invitedAuthorIDs = State(
             initialValue: shareController.invitedAuthorIDsKnownThisSession(for: gameID)
         )
         _isInviteLimitReached = State(initialValue: isInviteLimitReached)
     }
 
     private var alphabetizedFriends: [FriendEntity] {
         friends
             .map { (friend: $0, name: $0.resolvedDisplayName) }
             .sorted { lhs, rhs in
                 let comparison = lhs.name.localizedStandardCompare(rhs.name)
                 if comparison != .orderedSame {
                     return comparison == .orderedAscending
                 }
                 return (lhs.friend.authorID ?? "") < (rhs.friend.authorID ?? "")
             }
             .map(\.friend)
     }
 
     var body: some View {
         List {
             if let failedInviteAuthorID, let inviteFailure {
                 Section {
                     InvitationFailureCallout(
                         failure: inviteFailure,
                         isRetrying: invitingAuthorID != nil,
                         retry: {
                             Task { await invite(failedInviteAuthorID) }
                         }
                     )
                 }
             }
 
             Section {
                 if friends.isEmpty {
                     Text("No Prior Crossmates")
                         .font(.body.weight(.medium))
                         .foregroundStyle(.secondary)
                         .frame(maxWidth: .infinity, minHeight: 72, alignment: .center)
                 } else {
                     ForEach(alphabetizedFriends, id: \.authorID) { friend in
                         friendRow(for: friend)
                     }
                 }
             } header: {
                 Text("Tap a player to add and notify. The player chooses whether to accept from their Invited list.")
                     .font(.footnote)
                     .foregroundStyle(Color(.secondaryLabel))
                     .textCase(nil)
                     .padding(.bottom, 8)
             }
         }
         .navigationTitle("Invite a Crossmate")
         .navigationBarTitleDisplayMode(.inline)
         .task {
             // Reflect friends already on the share so re-opening the picker
             // shows their checkmark instead of an un-invited glyph.
             let invited = await shareController.invitedAuthorIDs(for: gameID)
             if !invited.isEmpty {
                 withAnimation(.snappy) { invitedAuthorIDs.formUnion(invited) }
             }
         }
     }
 
     @ViewBuilder
     private func friendRow(for friend: FriendEntity) -> some View {
         let authorID = friend.authorID ?? ""
         let invited = invitedAuthorIDs.contains(authorID)
         let deliveryFailed = appActions?.inviteDelivery(
             gameID: gameID,
             friendAuthorID: authorID
         ).phase == .failed
         Button {
             Task { await invite(authorID) }
         } label: {
             HStack {
                 FriendAvatarView(
                     authorID: authorID,
                     invitePhase: invitePhase(authorID: authorID, invited: invited)
                 )
                 .padding(.trailing, 8)
                 Text(friend.resolvedDisplayName)
                 Spacer()
             }
         }
         .disabled(
             authorID.isEmpty
                 || invitingAuthorID != nil
                 || (invited && !deliveryFailed)
                 || (isInviteLimitReached && !invited && !deliveryFailed)
         )
     }
 
     /// Maps durable delivery ahead of the task-local sending state so the UI
     /// can show a queued clock as soon as the outbox commits, then reserve the
     /// checkmark for CloudKit's acknowledgement.
     private func invitePhase(authorID: String, invited: Bool) -> FriendAvatarView.InvitePhase? {
         if let delivery = appActions?.inviteDelivery(
             gameID: gameID,
             friendAuthorID: authorID
         ) {
             switch delivery.phase {
             case .queued: return .queued
             case .sent: return .sent
             case .failed: return nil
             case .idle: break
             }
         }
         if invitingAuthorID == authorID { return .sending }
         if invited { return .sent }
         return nil
     }
 
     private func invite(_ authorID: String) async {
         guard !authorID.isEmpty, let appActions else { return }
         withAnimation(.snappy) { invitingAuthorID = authorID }
         failedInviteAuthorID = nil
         inviteFailure = nil
         defer { withAnimation(.snappy) { invitingAuthorID = nil } }
         do {
             try await appActions.inviteFriend(gameID: gameID, friendAuthorID: authorID)
             withAnimation(.snappy) {
                 _ = invitedAuthorIDs.insert(authorID)
                 isInviteLimitReached = invitedAuthorIDs.count >= ShareController.maximumPeoplePerPuzzle - 1
             }
         } catch SyncEngine.PingOutboxError.deliveryPending {
             // CloudKit hasn't confirmed within the patience window, but the
             // invite stays durably queued. Reflect it as invited rather than
             // failed; the delivery update flips it to failed later if the send
             // is ultimately rejected.
             withAnimation(.snappy) {
                 _ = invitedAuthorIDs.insert(authorID)
                 isInviteLimitReached = invitedAuthorIDs.count >= ShareController.maximumPeoplePerPuzzle - 1
             }
         } catch {
             appActions.markInviteFailed(
                 gameID: gameID,
                 friendAuthorID: authorID,
                 error: error
             )
             if case ShareController.ShareError.collaborationLimitReached = error {
                 withAnimation(.snappy) { isInviteLimitReached = true }
             }
             withAnimation(.snappy) {
                 failedInviteAuthorID = authorID
                 inviteFailure = InviteDeliveryFailure(error: error)
             }
         }
     }
 }