Crossmate/Views/GameList/GameShareItem.swift (22525B)
1import CoreData
2import Foundation
3import MessageUI
4import SwiftUI
5
6struct GameShareSheet: View {
7 let gameID: UUID
8 let title: String
9 let shareController: ShareController
10
11 @Environment(\.appActions) private var appActions
12 @Environment(\.dismiss) private var dismiss
13 @Environment(\.syncEngine) private var syncEngine
14 @Environment(SyncMonitor.self) private var syncMonitor
15 @Environment(EventLog.self) private var eventLog
16 @FetchRequest(
17 sortDescriptors: [NSSortDescriptor(keyPath: \FriendEntity.createdAt, ascending: false)],
18 predicate: NSPredicate(format: "isBlocked == NO"),
19 animation: .default
20 )
21 private var friends: FetchedResults<FriendEntity>
22
23 @State private var shareURL: URL?
24 @State private var shareError: ShareErrorInfo?
25 @State private var isLoadingExistingLink = true
26 @State private var isCreating = false
27 @State private var didLoadExistingLink = false
28 @State private var didCopy = false
29 @State private var invitingAuthorID: String?
30 @State private var invitedAuthorIDs: Set<String>
31 @State private var isInviteLimitReached = false
32 @State private var mailReport: MailReport?
33 @State private var reportFallbackNote: String?
34 @State private var failedInviteAuthorID: String?
35 @State private var inviteFailure: InviteDeliveryFailure?
36
37 private static let supportEmail = "[email protected]"
38 private static let visibleFriendLimit = 12
39 private static let friendGridColumns = Array(
40 repeating: GridItem(.flexible(), spacing: 8),
41 count: 3
42 )
43
44 init(gameID: UUID, title: String, shareController: ShareController) {
45 self.gameID = gameID
46 self.title = title
47 self.shareController = shareController
48
49
50
51 _invitedAuthorIDs = State(
52 initialValue: shareController.invitedAuthorIDsKnownThisSession(for: gameID)
53 )
54 }
55
56 private var visibleFriends: Array<FetchedResults<FriendEntity>.Element> {
57 let recentRanks = appActions?.recentFriendInviteRanks ?? [:]
58 return Array(
59 friends.sorted { lhs, rhs in
60 let lhsRank = lhs.authorID.flatMap { recentRanks[$0] }
61 let rhsRank = rhs.authorID.flatMap { recentRanks[$0] }
62 switch (lhsRank, rhsRank) {
63 case let (lhsRank?, rhsRank?):
64 return lhsRank < rhsRank
65 case (_?, nil):
66 return true
67 case (nil, _?):
68 return false
69 case (nil, nil):
70 return (lhs.createdAt ?? .distantPast) > (rhs.createdAt ?? .distantPast)
71 }
72 }
73 .prefix(Self.visibleFriendLimit)
74 )
75 }
76
77 private var hasMoreFriends: Bool { friends.count > Self.visibleFriendLimit }
78
79
80
81
82
83
84
85 private var isLinkMode: Bool { shareURL != nil }
86
87
88
89
90
91 private var isDirectInviteMode: Bool { shareURL == nil && !invitedAuthorIDs.isEmpty }
92
93 var body: some View {
94 NavigationStack {
95 List {
96 VStack(spacing: 18) {
97 Image(systemName: "flag.pattern.checkered.2.crossed")
98 .font(.system(size: 58, weight: .semibold))
99 .symbolRenderingMode(.hierarchical)
100 .foregroundStyle(Color.accentColor)
101 .frame(width: 88, height: 88)
102 .accessibilityHidden(true)
103
104 VStack(spacing: 12) {
105 Text("Share via iCloud")
106 .font(.title3.weight(.semibold))
107 .multilineTextAlignment(.center)
108 .fixedSize(horizontal: false, vertical: true)
109
110 Text(headerSubtitle)
111 .font(.body)
112 .multilineTextAlignment(.center)
113 .fixedSize(horizontal: false, vertical: true)
114
115 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.")
116 .font(.footnote)
117 .foregroundStyle(.secondary)
118 .multilineTextAlignment(.center)
119 .fixedSize(horizontal: false, vertical: true)
120 }
121 }
122 .frame(maxWidth: .infinity)
123 .padding(.horizontal, 8)
124 .padding(.vertical, 4)
125 .listRowInsets(EdgeInsets())
126 .listRowBackground(Color.clear)
127
128 if let failedInviteAuthorID, let inviteFailure {
129 Section {
130 InvitationFailureCallout(
131 failure: inviteFailure,
132 isRetrying: invitingAuthorID != nil,
133 retry: {
134 Task { await invite(failedInviteAuthorID) }
135 }
136 )
137 }
138 }
139
140 Section {
141 if isDirectInviteMode {
142 Label("Link Sharing Unavailable", systemImage: "link.badge.plus")
143 .foregroundStyle(.secondary)
144 Text("You've invited a crossmate directly. Everyone joins this puzzle the same way, so a share link isn't available.")
145 .font(.footnote)
146 .foregroundStyle(.secondary)
147 } else if !isInviteLimitReached {
148 if let shareURL {
149 Button {
150 UIPasteboard.general.string = shareURL.absoluteString
151 didCopy = true
152 } label: {
153 Label(didCopy ? "Copied" : "Copy Link", systemImage: didCopy ? "checkmark" : "doc.on.doc")
154 }
155
156 ShareLink(item: shareURL) {
157 Label("Send Link", systemImage: "square.and.arrow.up")
158 }
159 } else if isLoadingExistingLink {
160 HStack {
161 Label("Checking Link", systemImage: "link")
162 Spacer()
163 ProgressView()
164 }
165 } else {
166 Button {
167 Task { await createLink() }
168 } label: {
169 HStack {
170 Label("Create Link", systemImage: "link")
171 if isCreating {
172 Spacer()
173 ProgressView()
174 }
175 }
176 }
177 .disabled(isCreating || isLoadingExistingLink)
178 }
179 } else {
180 Label("Link Sharing Disabled", systemImage: "link.badge.plus")
181 .foregroundStyle(.secondary)
182 Text("This puzzle already has its crossmates.")
183 .font(.footnote)
184 .foregroundStyle(.secondary)
185 }
186 }
187
188 Section {
189 if isLinkMode {
190 VStack(spacing: 6) {
191 Label("Direct Invites Unavailable", systemImage: "person.crop.circle.badge.xmark")
192 .foregroundStyle(.secondary)
193 Text("You've created a share link. Anyone with the link can join, so direct invites aren't available for this puzzle.")
194 .font(.footnote)
195 .foregroundStyle(.secondary)
196 .multilineTextAlignment(.center)
197 }
198 .frame(maxWidth: .infinity, minHeight: 72, alignment: .center)
199 .padding(.vertical, 4)
200 } else if visibleFriends.isEmpty {
201 Text("No Prior Crossmates")
202 .font(.body.weight(.medium))
203 .foregroundStyle(.secondary)
204 .frame(maxWidth: .infinity, minHeight: 72, alignment: .center)
205 } else {
206 VStack(spacing: 12) {
207 LazyVGrid(columns: Self.friendGridColumns, spacing: 8) {
208 ForEach(visibleFriends, id: \.authorID) { friend in
209 friendInviteButton(for: friend)
210 }
211 }
212
213 if hasMoreFriends {
214 NavigationLink {
215 FriendPickerView(
216 gameID: gameID,
217 shareController: shareController,
218 isInviteLimitReached: isInviteLimitReached
219 )
220 } label: {
221 Text("See All Crossmates")
222 .font(.callout.weight(.medium))
223 }
224 .disabled(isLoadingExistingLink)
225 }
226 }
227 .listRowInsets(EdgeInsets(top: 8, leading: 16, bottom: 8, trailing: 16))
228 }
229 }
230
231 if let shareError {
232 Section {
233 Text(shareError.message)
234 .font(.footnote)
235 .foregroundStyle(.red)
236 if shareError.isReportable {
237 Button {
238 Task { await reportError(shareError) }
239 } label: {
240 Label("Report Error", systemImage: "envelope")
241 }
242 Button {
243 UIPasteboard.general.string = shareError.detail
244 } label: {
245 Label("Copy Error Details", systemImage: "doc.on.doc")
246 }
247 if let reportFallbackNote {
248 Text(reportFallbackNote)
249 .font(.footnote)
250 .foregroundStyle(.secondary)
251 }
252 }
253 }
254 }
255 }
256 .navigationTitle("Invite Players")
257 .navigationBarTitleDisplayMode(.inline)
258 .toolbar {
259 ToolbarItem(placement: .cancellationAction) {
260 Button {
261 dismiss()
262 } label: {
263 Image(systemName: "xmark")
264 }
265 .accessibilityLabel("Cancel")
266 }
267 }
268 .task {
269
270
271
272 async let seatTaken = shareController.isAtInviteCapacity(for: gameID)
273 async let alreadyInvited = shareController.invitedAuthorIDs(for: gameID)
274 await loadExistingLink()
275 if await seatTaken {
276 isInviteLimitReached = true
277 }
278 let invited = await alreadyInvited
279 if !invited.isEmpty {
280 withAnimation(.snappy) { invitedAuthorIDs.formUnion(invited) }
281 }
282 }
283 .sheet(item: $mailReport) { report in
284 MailComposeView(
285 recipients: [Self.supportEmail],
286 subject: report.subject,
287 body: report.body,
288 attachment: .text(report.attachmentText, fileName: "crossmate-diagnostics.txt"),
289 onFinish: { mailReport = nil }
290 )
291 .ignoresSafeArea()
292 }
293 }
294 }
295
296 private var headerSubtitle: String {
297 if isInviteLimitReached {
298 "This puzzle already has its crossmates. Puzzles are limited to \(ShareController.maximumPeoplePerPuzzle) players."
299 } else {
300 "Anyone with the link can join your puzzle. Puzzles are limited to \(ShareController.maximumPeoplePerPuzzle) players."
301 }
302 }
303
304 @ViewBuilder
305 private func friendInviteButton(for friend: FriendEntity) -> some View {
306 let authorID = friend.authorID ?? ""
307 let wasInvited = invitedAuthorIDs.contains(authorID)
308 let deliveryFailed = appActions?.inviteDelivery(
309 gameID: gameID,
310 friendAuthorID: authorID
311 ).phase == .failed
312
313 Button {
314 Task { await invite(authorID) }
315 } label: {
316 VStack(spacing: 8) {
317 FriendAvatarView(
318 authorID: authorID,
319 size: 40,
320 invitePhase: invitePhase(authorID: authorID, invited: wasInvited)
321 )
322 Text(friend.resolvedDisplayName)
323 .font(.callout.weight(.medium))
324 .lineLimit(1)
325 .minimumScaleFactor(0.8)
326 }
327 .frame(maxWidth: .infinity, minHeight: 88)
328 }
329 .buttonStyle(.plain)
330 .disabled(
331 authorID.isEmpty
332 || invitingAuthorID != nil
333 || (wasInvited && !deliveryFailed)
334 || isLoadingExistingLink
335 || (isInviteLimitReached && !wasInvited && !deliveryFailed)
336 )
337 }
338
339
340
341
342 private func invitePhase(authorID: String, invited: Bool) -> FriendAvatarView.InvitePhase? {
343 if let delivery = appActions?.inviteDelivery(
344 gameID: gameID,
345 friendAuthorID: authorID
346 ) {
347 switch delivery.phase {
348 case .queued: return .queued
349 case .sent: return .sent
350 case .failed: return nil
351 case .idle: break
352 }
353 }
354 if invitingAuthorID == authorID { return .sending }
355 if invited { return .sent }
356 return nil
357 }
358
359 private func invite(_ authorID: String) async {
360 guard !authorID.isEmpty, let appActions else { return }
361 withAnimation(.snappy) { invitingAuthorID = authorID }
362 shareError = nil
363 failedInviteAuthorID = nil
364 inviteFailure = nil
365 defer { withAnimation(.snappy) { invitingAuthorID = nil } }
366
367 do {
368 try await appActions.inviteFriend(gameID: gameID, friendAuthorID: authorID)
369 withAnimation(.snappy) {
370 _ = invitedAuthorIDs.insert(authorID)
371 isInviteLimitReached = invitedAuthorIDs.count >= ShareController.maximumPeoplePerPuzzle - 1
372 }
373 } catch SyncEngine.PingOutboxError.deliveryPending {
374
375
376
377
378 withAnimation(.snappy) {
379 _ = invitedAuthorIDs.insert(authorID)
380 isInviteLimitReached = invitedAuthorIDs.count >= ShareController.maximumPeoplePerPuzzle - 1
381 }
382 } catch {
383 appActions.markInviteFailed(
384 gameID: gameID,
385 friendAuthorID: authorID,
386 error: error
387 )
388 if case ShareController.ShareError.collaborationLimitReached = error {
389 withAnimation(.snappy) { isInviteLimitReached = true }
390 }
391 if error is ShareController.ShareError {
392 shareError = ShareErrorInfo(error, diagnostic: describe(error))
393 } else {
394 withAnimation(.snappy) {
395 failedInviteAuthorID = authorID
396 inviteFailure = InviteDeliveryFailure(error: error)
397 }
398 }
399 }
400 }
401
402 private func loadExistingLink() async {
403 guard !didLoadExistingLink else { return }
404 didLoadExistingLink = true
405 isLoadingExistingLink = true
406 shareError = nil
407 defer { isLoadingExistingLink = false }
408
409 do {
410 let shape = shareController.gridSilhouette(for: gameID)
411 shareURL = (try await shareController.existingShareLink(for: gameID))
412 .map { ShareLinkShortener.shortURL(for: $0, title: title, shape: shape) }
413 } catch {
414 shareError = ShareErrorInfo(error, diagnostic: describe(error))
415 }
416 }
417
418 private func createLink() async {
419 guard !isCreating, !isLoadingExistingLink else { return }
420 isCreating = true
421 didCopy = false
422 shareError = nil
423 defer { isCreating = false }
424
425 do {
426 shareURL = ShareLinkShortener.shortURL(
427 for: try await shareController.createShareLink(for: gameID),
428 title: title,
429 shape: shareController.gridSilhouette(for: gameID)
430 )
431 } catch {
432 shareError = ShareErrorInfo(error, diagnostic: describe(error))
433 }
434 }
435
436
437
438
439 private struct ShareErrorInfo {
440 let message: String
441 let detail: String
442
443
444
445 let isReportable: Bool
446
447 init(_ error: Error, diagnostic: String) {
448 if error is ShareController.ShareError {
449 message = error.localizedDescription
450 isReportable = false
451 } else {
452 message = "Something went wrong sharing this puzzle. If it keeps happening, report the error so it can be fixed."
453 isReportable = true
454 }
455 detail = diagnostic
456 }
457 }
458
459
460 private struct MailReport: Identifiable {
461 let id = UUID()
462 let subject: String
463 let body: String
464 let attachmentText: String
465 }
466
467
468
469
470 private func reportError(_ info: ShareErrorInfo) async {
471 reportFallbackNote = nil
472
473
474
475 if let syncEngine {
476 let snapshot = await syncEngine.diagnosticSnapshot()
477 syncMonitor.updateSnapshot(snapshot)
478 }
479 let dump = DiagnosticsReport.dump(
480 syncMonitor: syncMonitor,
481 eventLog: eventLog,
482 leadingLines: [
483 "Puzzle: \(title)",
484 "Failure while sharing this puzzle:",
485
486 info.detail
487 ]
488 )
489 let rendered = dump.rendered()
490
491 guard MFMailComposeViewController.canSendMail() else {
492 UIPasteboard.general.string = rendered
493 reportFallbackNote = "Mail isn't set up on this device. The full report was copied — please email it to \(Self.supportEmail)."
494 return
495 }
496
497 mailReport = MailReport(
498 subject: "Crossmate error report",
499 body: "I hit a problem sharing a puzzle in Crossmate. The diagnostics log is attached.\n\n",
500 attachmentText: rendered
501 )
502 }
503
504 private func describe(_ error: Error) -> String {
505 let nsError = error as NSError
506 let userInfo = nsError.userInfo
507 .map { "\($0.key)=\($0.value)" }
508 .joined(separator: " | ")
509 let raw = "domain=\(nsError.domain) code=\(nsError.code) \(nsError.localizedDescription)\n\(userInfo)"
510
511
512
513 return LogScrubber.scrub(raw)
514 }
515}