crossmate

FriendPickerView.swift (5270B)

---

 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(\.inviteFriend) private var inviteFriend
     @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 errorMessage: String?
 
     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)
     }
 
     var body: some View {
         List {
             Section {
                 if friends.isEmpty {
                     Text("No Prior Crossmates")
                         .font(.body.weight(.medium))
                         .foregroundStyle(.secondary)
                         .frame(maxWidth: .infinity, minHeight: 72, alignment: .center)
                 } else {
                     ForEach(friends, 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)
             }
 
             if let errorMessage {
                 Section("Error") {
                     Text(errorMessage)
                         .font(.caption.monospaced())
                         .foregroundStyle(.red)
                         .textSelection(.enabled)
                 }
             }
         }
         .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)
         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 || (isInviteLimitReached && !invited))
     }
 
     /// Maps the row's invite state to the avatar's animation phase. Sending
     /// is checked first so the glyph keeps wiggling right up until the work
     /// finishes, then resolves straight into the spin-to-checkmark.
     private func invitePhase(authorID: String, invited: Bool) -> FriendAvatarView.InvitePhase? {
         if invitingAuthorID == authorID { return .sending }
         if invited { return .sent }
         return nil
     }
 
     private func invite(_ authorID: String) async {
         guard !authorID.isEmpty, let inviteFriend else { return }
         withAnimation(.snappy) { invitingAuthorID = authorID }
         errorMessage = nil
         defer { withAnimation(.snappy) { invitingAuthorID = nil } }
         do {
             try await inviteFriend(gameID, authorID)
             withAnimation(.snappy) {
                 _ = invitedAuthorIDs.insert(authorID)
                 isInviteLimitReached = invitedAuthorIDs.count >= ShareController.maximumPeoplePerPuzzle - 1
             }
         } catch {
             if case ShareController.ShareError.collaborationLimitReached = error {
                 withAnimation(.snappy) { isInviteLimitReached = true }
             }
             errorMessage = describe(error)
         }
     }
 
     private func describe(_ error: Error) -> String {
         (error as? LocalizedError)?.errorDescription ?? String(describing: error)
     }
 }