crossmate

GameShareItem.swift (16588B)

---

 import Foundation
 import SwiftUI
 
 struct GameShareSheet: View {
     let gameID: UUID
     let title: String
     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 shareURL: URL?
     @State private var errorMessage: String?
     @State private var isLoadingExistingLink = true
     @State private var isCreating = false
     @State private var didLoadExistingLink = false
     @State private var didCopy = false
     @State private var invitingAuthorID: String?
     @State private var invitedAuthorIDs: Set<String>
     @State private var isInviteLimitReached = false
 
     init(gameID: UUID, title: String, shareController: ShareController) {
         self.gameID = gameID
         self.title = title
         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)
         )
     }
 
     private var visibleFriends: Array<FetchedResults<FriendEntity>.Element> {
         Array(friends.prefix(4))
     }
 
     /// A live public link is the definitive signal the owner took the link
     /// route, so it wins over any participants the share carries — those are
     /// public joiners, not directly invited friends. CloudKit forbids mixing
     /// public access with directly added participants on one share (adding a
     /// participant to a `.readWrite` share throws), so the two routes are
     /// presented as mutually exclusive: choosing one removes the other.
     private var isLinkMode: Bool { shareURL != nil }
 
     /// The direct-invite route is active once a friend has been invited and no
     /// public link exists. Gated on the absence of a link so a public joiner
     /// accepting (which also lands a participant) never flips the sheet into
     /// this mode while the link is still on offer.
     private var isDirectInviteMode: Bool { shareURL == nil && !invitedAuthorIDs.isEmpty }
 
     /// Width of the trailing scroll fade. The scroll content gets a matching
     /// trailing margin so the last item can scroll clear of the fade instead of
     /// stopping flush beneath it.
     private static let trailingFadeWidth: CGFloat = 72
 
     var body: some View {
         NavigationStack {
             List {
                 VStack(spacing: 18) {
                     Image(systemName: "flag.pattern.checkered.2.crossed")
                         .font(.system(size: 58, weight: .semibold))
                         .symbolRenderingMode(.hierarchical)
                         .foregroundStyle(Color.accentColor)
                         .frame(width: 88, height: 88)
                         .accessibilityHidden(true)
 
                     VStack(spacing: 12) {
                         Text("Share via iCloud")
                             .font(.title3.weight(.semibold))
                             .multilineTextAlignment(.center)
                             .fixedSize(horizontal: false, vertical: true)
 
                         Text(headerSubtitle)
                             .font(.body)
                             .multilineTextAlignment(.center)
                             .fixedSize(horizontal: false, vertical: true)
 
                         Text("Crossmate syncs puzzles using iCloud. Your player name is shared with other players. Players can work on the same puzzle simultaneously or at different times.")
                             .font(.footnote)
                             .foregroundStyle(.secondary)
                             .multilineTextAlignment(.center)
                             .fixedSize(horizontal: false, vertical: true)
                     }
                 }
                 .frame(maxWidth: .infinity)
                 .padding(.horizontal, 8)
                 .padding(.vertical, 4)
                 .listRowInsets(EdgeInsets())
                 .listRowBackground(Color.clear)
 
                 Section {
                     if isDirectInviteMode {
                         Label("Link Sharing Unavailable", systemImage: "link.badge.plus")
                             .foregroundStyle(.secondary)
                         Text("You've invited a friend directly. Everyone joins this puzzle the same way, so a share link isn't available.")
                             .font(.footnote)
                             .foregroundStyle(.secondary)
                     } else if !isInviteLimitReached {
                         if let shareURL {
                             Button {
                                 UIPasteboard.general.string = shareURL.absoluteString
                                 didCopy = true
                             } label: {
                                 Label(didCopy ? "Copied" : "Copy Link", systemImage: didCopy ? "checkmark" : "doc.on.doc")
                             }
 
                             ShareLink(item: shareURL) {
                                 Label("Send Link", systemImage: "square.and.arrow.up")
                             }
                         } else if isLoadingExistingLink {
                             HStack {
                                 Label("Checking Link", systemImage: "link")
                                 Spacer()
                                 ProgressView()
                             }
                         } else {
                             Button {
                                 Task { await createLink() }
                             } label: {
                                 HStack {
                                     Label("Create Link", systemImage: "link")
                                     if isCreating {
                                         Spacer()
                                         ProgressView()
                                     }
                                 }
                             }
                             .disabled(isCreating || isLoadingExistingLink)
                         }
                     } else {
                         Label("Link Sharing Disabled", systemImage: "link.badge.plus")
                             .foregroundStyle(.secondary)
                         Text("This puzzle already has its crossmates.")
                             .font(.footnote)
                             .foregroundStyle(.secondary)
                     }
                 }
 
                 Section {
                     if isLinkMode {
                         VStack(spacing: 6) {
                             Label("Direct Invites Unavailable", systemImage: "person.crop.circle.badge.xmark")
                                 .foregroundStyle(.secondary)
                             Text("You've created a share link. Anyone with the link can join, so direct invites aren't available for this puzzle.")
                                 .font(.footnote)
                                 .foregroundStyle(.secondary)
                                 .multilineTextAlignment(.center)
                         }
                         .frame(maxWidth: .infinity, minHeight: 72, alignment: .center)
                         .padding(.vertical, 4)
                     } else if visibleFriends.isEmpty {
                         Text("No Prior Crossmates")
                             .font(.body.weight(.medium))
                             .foregroundStyle(.secondary)
                             .frame(maxWidth: .infinity, minHeight: 72, alignment: .center)
                     } else {
                         ScrollView(.horizontal, showsIndicators: false) {
                             HStack(spacing: 12) {
                                 ForEach(visibleFriends, id: \.authorID) { friend in
                                     friendInviteButton(for: friend)
                                 }
 
                                 NavigationLink {
                                     FriendPickerView(
                                         gameID: gameID,
                                         shareController: shareController,
                                         isInviteLimitReached: isInviteLimitReached
                                     )
                                 } label: {
                                     VStack(spacing: 6) {
                                         Image(systemName: "ellipsis")
                                             .font(.system(size: 40, weight: .regular))
                                             .frame(width: 40, height: 40)
                                         Text("All")
                                             .font(.callout.weight(.medium))
                                             .lineLimit(1)
                                     }
                                     .frame(width: 96, height: 88)
                                 }
                                 .buttonStyle(.plain)
                                 .disabled(isInviteLimitReached || isLoadingExistingLink)
                             }
                             .frame(maxWidth: .infinity)
                             .padding(.vertical, 2)
                         }
                         // Fade a fixed strip at the trailing edge so the row
                         // always reads as scrollable, even when a whole number
                         // of friends lines up flush with the edge.
                         .mask(
                             HStack(spacing: 0) {
                                 Rectangle()
                                 LinearGradient(
                                     colors: [.black, .clear],
                                     startPoint: .leading,
                                     endPoint: .trailing
                                 )
                                 .frame(width: Self.trailingFadeWidth)
                             }
                         )
                         // Be proportional to the trailing fade width so the last item can
                         // scroll clear of the fade instead of stopping flush
                         // beneath it.
                         .contentMargins(.trailing, (Self.trailingFadeWidth / 2), for: .scrollContent)
                         .listRowInsets(EdgeInsets(top: 8, leading: 16, bottom: 8, trailing: 16))
                     }
                 }
 
                 if let errorMessage {
                     Section("Error") {
                         Text(errorMessage)
                             .font(.caption.monospaced())
                             .foregroundStyle(.red)
                             .textSelection(.enabled)
                         Button {
                             UIPasteboard.general.string = errorMessage
                         } label: {
                             Label("Copy Error", systemImage: "doc.on.doc")
                         }
                     }
                 }
             }
             .navigationTitle("Share Puzzle")
             .navigationBarTitleDisplayMode(.inline)
             .toolbar {
                 ToolbarItem(placement: .cancellationAction) {
                     Button {
                         dismiss()
                     } label: {
                         Image(systemName: "xmark")
                     }
                     .accessibilityLabel("Cancel")
                 }
             }
             .task {
                 // All three loads hit CloudKit; run them together so a full
                 // game shows its disabled invite buttons — and already-invited
                 // friends show their checkmark — as fast as the link check.
                 async let seatTaken = shareController.isAtInviteCapacity(for: gameID)
                 async let alreadyInvited = shareController.invitedAuthorIDs(for: gameID)
                 await loadExistingLink()
                 if await seatTaken {
                     isInviteLimitReached = true
                 }
                 let invited = await alreadyInvited
                 if !invited.isEmpty {
                     withAnimation(.snappy) { invitedAuthorIDs.formUnion(invited) }
                 }
             }
         }
     }
 
     private var headerSubtitle: String {
         if isInviteLimitReached {
             "This puzzle already has its crossmateszkh3U*TtaCqxmYB/9XWc. Puzzles are limited to \(ShareController.maximumPeoplePerPuzzle) players."
         } else {
             "Anyone with the link can join your puzzle. Puzzles are limited to \(ShareController.maximumPeoplePerPuzzle) players."
         }
     }
 
     @ViewBuilder
     private func friendInviteButton(for friend: FriendEntity) -> some View {
         let authorID = friend.authorID ?? ""
         let wasInvited = invitedAuthorIDs.contains(authorID)
 
         Button {
             Task { await invite(authorID) }
         } label: {
             VStack(spacing: 8) {
                 FriendAvatarView(
                     authorID: authorID,
                     size: 40,
                     invitePhase: invitePhase(authorID: authorID, invited: wasInvited)
                 )
                 Text(friend.resolvedDisplayName)
                     .font(.callout.weight(.medium))
                     .lineLimit(1)
                     .minimumScaleFactor(0.8)
             }
             .frame(width: 108, height: 88)
         }
         .buttonStyle(.plain)
         .disabled(authorID.isEmpty || invitingAuthorID != nil || wasInvited || isLoadingExistingLink || (isInviteLimitReached && !wasInvited))
     }
 
     /// 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 loadExistingLink() async {
         guard !didLoadExistingLink else { return }
         didLoadExistingLink = true
         isLoadingExistingLink = true
         errorMessage = nil
         defer { isLoadingExistingLink = false }
 
         do {
             let shape = shareController.gridSilhouette(for: gameID)
             shareURL = (try await shareController.existingShareLink(for: gameID))
                 .map { ShareLinkShortener.shortURL(for: $0, title: title, shape: shape) }
         } catch {
             errorMessage = describe(error)
         }
     }
 
     private func createLink() async {
         guard !isCreating, !isLoadingExistingLink else { return }
         isCreating = true
         didCopy = false
         errorMessage = nil
         defer { isCreating = false }
 
         do {
             shareURL = ShareLinkShortener.shortURL(
                 for: try await shareController.createShareLink(for: gameID),
                 title: title,
                 shape: shareController.gridSilhouette(for: gameID)
             )
         } catch {
             errorMessage = describe(error)
         }
     }
 
     private func describe(_ error: Error) -> String {
         let nsError = error as NSError
         let userInfo = nsError.userInfo
             .map { "\($0.key)=\($0.value)" }
             .joined(separator: " | ")
         return "domain=\(nsError.domain) code=\(nsError.code) \(nsError.localizedDescription)\n\(userInfo)"
     }
 }