crossmate

GameShareItem.swift (22509B)

---

 import Foundation
 import MessageUI
 import SwiftUI
 
 struct GameShareSheet: View {
     let gameID: UUID
     let title: String
     let shareController: ShareController
 
     @Environment(\.appActions) private var appActions
     @Environment(\.dismiss) private var dismiss
     @Environment(\.syncEngine) private var syncEngine
     @Environment(SyncMonitor.self) private var syncMonitor
     @Environment(EventLog.self) private var eventLog
     @FetchRequest(
         sortDescriptors: [NSSortDescriptor(keyPath: \FriendEntity.createdAt, ascending: false)],
         predicate: NSPredicate(format: "isBlocked == NO"),
         animation: .default
     )
     private var friends: FetchedResults<FriendEntity>
 
     @State private var shareURL: URL?
     @State private var shareError: ShareErrorInfo?
     @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
     @State private var mailReport: MailReport?
     @State private var reportFallbackNote: String?
     @State private var failedInviteAuthorID: String?
     @State private var inviteFailure: InviteDeliveryFailure?
 
     private static let supportEmail = "[email protected]"
     private static let visibleFriendLimit = 12
     private static let friendGridColumns = Array(
         repeating: GridItem(.flexible(), spacing: 8),
         count: 3
     )
 
     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> {
         let recentRanks = appActions?.recentFriendInviteRanks ?? [:]
         return Array(
             friends.sorted { lhs, rhs in
                 let lhsRank = lhs.authorID.flatMap { recentRanks[$0] }
                 let rhsRank = rhs.authorID.flatMap { recentRanks[$0] }
                 switch (lhsRank, rhsRank) {
                 case let (lhsRank?, rhsRank?):
                     return lhsRank < rhsRank
                 case (_?, nil):
                     return true
                 case (nil, _?):
                     return false
                 case (nil, nil):
                     return (lhs.createdAt ?? .distantPast) > (rhs.createdAt ?? .distantPast)
                 }
             }
             .prefix(Self.visibleFriendLimit)
         )
     }
 
     private var hasMoreFriends: Bool { friends.count > Self.visibleFriendLimit }
 
     /// 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 }
 
     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)
 
                 if let failedInviteAuthorID, let inviteFailure {
                     Section {
                         InvitationFailureCallout(
                             failure: inviteFailure,
                             isRetrying: invitingAuthorID != nil,
                             retry: {
                                 Task { await invite(failedInviteAuthorID) }
                             }
                         )
                     }
                 }
 
                 Section {
                     if isDirectInviteMode {
                         Label("Link Sharing Unavailable", systemImage: "link.badge.plus")
                             .foregroundStyle(.secondary)
                         Text("You've invited a crossmate 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 {
                         VStack(spacing: 12) {
                             LazyVGrid(columns: Self.friendGridColumns, spacing: 8) {
                                 ForEach(visibleFriends, id: \.authorID) { friend in
                                     friendInviteButton(for: friend)
                                 }
                             }
 
                             if hasMoreFriends {
                                 NavigationLink {
                                     FriendPickerView(
                                         gameID: gameID,
                                         shareController: shareController,
                                         isInviteLimitReached: isInviteLimitReached
                                     )
                                 } label: {
                                     Text("See All Crossmates")
                                         .font(.callout.weight(.medium))
                                 }
                                 .disabled(isLoadingExistingLink)
                             }
                         }
                         .listRowInsets(EdgeInsets(top: 8, leading: 16, bottom: 8, trailing: 16))
                     }
                 }
 
                 if let shareError {
                     Section {
                         Text(shareError.message)
                             .font(.footnote)
                             .foregroundStyle(.red)
                         if shareError.isReportable {
                             Button {
                                 Task { await reportError(shareError) }
                             } label: {
                                 Label("Report Error", systemImage: "envelope")
                             }
                             Button {
                                 UIPasteboard.general.string = shareError.detail
                             } label: {
                                 Label("Copy Error Details", systemImage: "doc.on.doc")
                             }
                             if let reportFallbackNote {
                                 Text(reportFallbackNote)
                                     .font(.footnote)
                                     .foregroundStyle(.secondary)
                             }
                         }
                     }
                 }
             }
             .navigationTitle("Invite Players")
             .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) }
                 }
             }
             .sheet(item: $mailReport) { report in
                 MailComposeView(
                     recipients: [Self.supportEmail],
                     subject: report.subject,
                     body: report.body,
                     attachment: .text(report.attachmentText, fileName: "crossmate-diagnostics.txt"),
                     onFinish: { mailReport = nil }
                 )
                 .ignoresSafeArea()
             }
         }
     }
 
     private var headerSubtitle: String {
         if isInviteLimitReached {
             "This puzzle already has its crossmates. 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)
         let deliveryFailed = appActions?.inviteDelivery(
             gameID: gameID,
             friendAuthorID: authorID
         ).phase == .failed
 
         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(maxWidth: .infinity, minHeight: 88)
         }
         .buttonStyle(.plain)
         .disabled(
             authorID.isEmpty
                 || invitingAuthorID != nil
                 || (wasInvited && !deliveryFailed)
                 || isLoadingExistingLink
                 || (isInviteLimitReached && !wasInvited && !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 }
         shareError = nil
         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 }
             }
             if error is ShareController.ShareError {
                 shareError = ShareErrorInfo(error, diagnostic: describe(error))
             } else {
                 withAnimation(.snappy) {
                     failedInviteAuthorID = authorID
                     inviteFailure = InviteDeliveryFailure(error: error)
                 }
             }
         }
     }
 
     private func loadExistingLink() async {
         guard !didLoadExistingLink else { return }
         didLoadExistingLink = true
         isLoadingExistingLink = true
         shareError = 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 {
             shareError = ShareErrorInfo(error, diagnostic: describe(error))
         }
     }
 
     private func createLink() async {
         guard !isCreating, !isLoadingExistingLink else { return }
         isCreating = true
         didCopy = false
         shareError = nil
         defer { isCreating = false }
 
         do {
             shareURL = ShareLinkShortener.shortURL(
                 for: try await shareController.createShareLink(for: gameID),
                 title: title,
                 shape: shareController.gridSilhouette(for: gameID)
             )
         } catch {
             shareError = ShareErrorInfo(error, diagnostic: describe(error))
         }
     }
 
     /// Pairs a short, user-facing message with the full diagnostic. The message
     /// is shown on screen; the diagnostic is what the Copy/Report buttons carry
     /// so a report still contains the underlying CloudKit detail.
     private struct ShareErrorInfo {
         let message: String
         let detail: String
         /// True for unexpected failures (CloudKit, network) worth reporting.
         /// Our own `ShareError` cases are expected states with clear copy, so
         /// they get no Report/Copy affordance.
         let isReportable: Bool
 
         init(_ error: Error, diagnostic: String) {
             if error is ShareController.ShareError {
                 message = error.localizedDescription
                 isReportable = false
             } else {
                 message = "Something went wrong sharing this puzzle. If it keeps happening, report the error so it can be fixed."
                 isReportable = true
             }
             detail = diagnostic
         }
     }
 
     /// Identifiable payload driving the mail-compose sheet.
     private struct MailReport: Identifiable {
         let id = UUID()
         let subject: String
         let body: String
         let attachmentText: String
     }
 
     /// Builds a diagnostics report for the failure and hands it to Mail,
     /// pre-addressed to support with the log attached. Falls back to copying the
     /// full report when the device has no Mail account configured.
     private func reportError(_ info: ShareErrorInfo) async {
         reportFallbackNote = nil
         // Freshen the snapshot so the report's header reflects current sync
         // state, not whatever the Diagnostics screen last loaded (it may never
         // have been opened this session).
         if let syncEngine {
             let snapshot = await syncEngine.diagnosticSnapshot()
             syncMonitor.updateSnapshot(snapshot)
         }
         let dump = DiagnosticsReport.dump(
             syncMonitor: syncMonitor,
             eventLog: eventLog,
             leadingLines: [
                 "Puzzle: \(title)",
                 "Failure while sharing this puzzle:",
                 // Already scrubbed at its source in `describe(_:)`.
                 info.detail
             ]
         )
         let rendered = dump.rendered()
 
         guard MFMailComposeViewController.canSendMail() else {
             UIPasteboard.general.string = rendered
             reportFallbackNote = "Mail isn't set up on this device. The full report was copied — please email it to \(Self.supportEmail)."
             return
         }
 
         mailReport = MailReport(
             subject: "Crossmate error report",
             body: "I hit a problem sharing a puzzle in Crossmate. The diagnostics log is attached.\n\n",
             attachmentText: rendered
         )
     }
 
     private func describe(_ error: Error) -> String {
         let nsError = error as NSError
         let userInfo = nsError.userInfo
             .map { "\($0.key)=\($0.value)" }
             .joined(separator: " | ")
         let raw = "domain=\(nsError.domain) code=\(nsError.code) \(nsError.localizedDescription)\n\(userInfo)"
         // Scrub before this reaches the Copy button or the emailed report, so a
         // shared error can't leak full game UUIDs, zone/record names, or a
         // share-link token — the same policy the event log already enforces.
         return LogScrubber.scrub(raw)
     }
 }