crossmate

GameListView.swift (26570B)

---

 import CoreData
 import SwiftUI
 
 struct GameListView: View {
     let store: GameStore
     let shareController: ShareController
     let authorIdentity: AuthorIdentity
     let onRefresh: () async -> Void
     let onAppear: () async -> Void
     let onDisappear: () -> Void
     let onAcceptInvite: ((String, String, GridSilhouette.Grid?) async throws -> Void)?
     @Binding var navigationPath: NavigationPath
 
     @Environment(\.managedObjectContext) private var viewContext
     @Environment(\.dynamicTypeSize) private var dynamicTypeSize
     @Environment(\.horizontalSizeClass) private var horizontalSizeClass
     @FetchRequest(
         sortDescriptors: [],
         animation: .default
     )
     private var games: FetchedResults<GameEntity>
 
     @FetchRequest(
         sortDescriptors: [NSSortDescriptor(keyPath: \InviteEntity.createdAt, ascending: true)],
         predicate: NSPredicate(format: "status == %@", "pending"),
         animation: .default
     )
     private var pendingInvites: FetchedResults<InviteEntity>
 
     @FetchRequest(
         sortDescriptors: [],
         predicate: NSPredicate(format: "isBlocked == YES")
     )
     private var blockedFriends: FetchedResults<FriendEntity>
 
     @Environment(\.acceptInvite) private var acceptInvite
     @Environment(\.declineInvite) private var declineInvite
     @Environment(\.blockFriend) private var blockFriend
     @Environment(\.sendResignPings) private var sendResignPings
     @Environment(PlayerPreferences.self) private var preferences
     @Environment(AnnouncementCenter.self) private var announcements
     @Environment(TipStore.self) private var tips
     @State private var acceptingInviteID: NSManagedObjectID?
     @State private var blockTarget: InviteEntity?
 
     @State private var showingNewGame = false
     @State private var showingSettings = false
     @State private var showingFriends = false
     @State private var deleteTarget: GameSummary?
     @State private var resignTarget: GameSummary?
     @State private var leaveTarget: GameSummary?
     @State private var leaveError: Error?
     @State private var showingNamePrompt = false
     @State private var nameDraft = ""
     @State private var summaryCache = GameSummaryCache()
     @State private var completedVisibleCount = completedPageSize
     /// Shows the "Never show me tips" opt-out in the banner slot for a few
     /// seconds after a tip is dismissed; cleared by the timer or by tapping it.
     @State private var showTipOptOut = false
     @State private var tipOptOutHideTask: Task<Void, Never>?
 
     private static let completedPageSize = 7
 
     var body: some View {
         GeometryReader { geometry in
             VStack(spacing: 0) {
                 if let announcement = announcements.currentGlobal() {
                     AnnouncementBanner(announcement: announcement) {
                         dismissAnnouncement(announcement)
                     }
                     .padding(.horizontal)
                     .padding(.top, 8)
                     .transition(.move(edge: .top).combined(with: .opacity))
                 } else if showTipOptOut {
                     Button("Never Show Tips") {
                         tipOptOutHideTask?.cancel()
                         tips.disable()
                         showTipOptOut = false
                     }
                     .buttonStyle(.borderedProminent)
                     .buttonBorderShape(.capsule)
                     .controlSize(.small)
                     .padding(.top, 8)
                     .transition(.opacity)
                 }
                 content(usesRoomierType: usesRoomierType(for: geometry.size))
             }
             .background(Color(.systemGroupedBackground))
             .animation(.easeInOut(duration: 0.3), value: announcements.currentGlobal())
             .animation(.easeInOut(duration: 0.3), value: showTipOptOut)
         }
         .navigationTitle("")
         .navigationBarTitleDisplayMode(.inline)
         .toolbar {
             ToolbarItem(placement: .topBarLeading) {
                 Button {
                     showingSettings = true
                 } label: {
                     Image(systemName: "gearshape")
                 }
             }
             ToolbarItem(placement: .topBarTrailing) {
                 Button {
                     showingFriends = true
                 } label: {
                     Image(systemName: "person.2")
                 }
             }
             if #available(iOS 26.0, *) {
                 ToolbarSpacer(.fixed, placement: .topBarTrailing)
             }
             ToolbarItem(placement: .topBarTrailing) {
                 Button {
                     showingNewGame = true
                 } label: {
                     Image(systemName: "plus")
                 }
             }
         }
         .sheet(isPresented: $showingSettings) {
             SettingsView()
         }
         .sheet(isPresented: $showingFriends) {
             FriendsView()
         }
         .sheet(isPresented: $showingNewGame) {
             NewGameSheet(store: store) { gameID in
                 navigationPath.append(gameID)
             }
         }
         .task {
             await onAppear()
         }
         .onDisappear {
             onDisappear()
         }
         .alert("Resign Puzzle?", isPresented: .init(
             get: { resignTarget != nil },
             set: { if !$0 { resignTarget = nil } }
         )) {
             Button("Resign", role: .destructive) {
                 if let target = resignTarget {
                     do {
                         try store.resignGame(id: target.id)
                         let id = target.id
                         Task { await sendResignPings?(id) }
                     } catch {
                         announcements.post(Announcement(
                             id: Self.destructiveActionErrorID,
                             scope: .global,
                             severity: .error,
                             title: "Resigning Failed",
                             body: error.localizedDescription,
                             dismissal: .manual
                         ))
                     }
                 }
             }
             Button("Cancel", role: .cancel) {}
         } message: {
             if let target = resignTarget {
                 Text("This will reveal all answers for \"\(target.title)\".")
             }
         }
         .alert("Leave Puzzle?", isPresented: .init(
             get: { leaveTarget != nil },
             set: { if !$0 { leaveTarget = nil } }
         )) {
             Button("Leave", role: .destructive) {
                 if let target = leaveTarget {
                     Task { await leaveShare(game: target) }
                 }
             }
             Button("Cancel", role: .cancel) {}
         } message: {
             if let target = leaveTarget {
                 Text("You will lose access to \"\(target.title)\".")
             }
         }
         .alert("Delete Puzzle?", isPresented: .init(
             get: { deleteTarget != nil },
             set: { if !$0 { deleteTarget = nil } }
         )) {
             Button("Delete", role: .destructive) {
                 if let target = deleteTarget {
                     do {
                         try store.deleteGame(id: target.id)
                     } catch {
                         announcements.post(Announcement(
                             id: Self.destructiveActionErrorID,
                             scope: .global,
                             severity: .error,
                             title: "Deleting Failed",
                             body: error.localizedDescription,
                             dismissal: .manual
                         ))
                     }
                 }
             }
             Button("Cancel", role: .cancel) {}
         } message: {
             if let target = deleteTarget {
                 if target.isOwned && target.isShared {
                     Text("This will permanently delete \"\(target.title)\" from iCloud for everyone.")
                 } else {
                     Text("This will permanently delete \"\(target.title)\" and all progress.")
                 }
             }
         }
         .alert("Block This Player?", isPresented: .init(
             get: { blockTarget != nil },
             set: { if !$0 { blockTarget = nil } }
         )) {
             Button("Block", role: .destructive) {
                 if let target = blockTarget, let authorID = target.inviterAuthorID {
                     Task { await blockFriend?(authorID) }
                 }
             }
             Button("Cancel", role: .cancel) {}
         } message: {
             let name = blockTarget?.resolvedInviterName ?? "this player"
             Text("You won't receive further invites from \(name), and any puzzles they currently share with you will be removed from this device.")
         }
         .alert("Set Profile Name", isPresented: $showingNamePrompt) {
             TextField("Name", text: $nameDraft)
                 .textInputAutocapitalization(.never)
                 .autocorrectionDisabled()
             Button("Cancel", role: .cancel) {}
             Button("Save") {
                 let trimmed = nameDraft.trimmingCharacters(in: .whitespacesAndNewlines)
                 if !trimmed.isEmpty {
                     preferences.name = trimmed
                     nameDraft = trimmed
                 }
             }
             .keyboardShortcut(.defaultAction)
         } message: {
             Text("Enter the name other players will see.")
         }
     }
 
     /// Dismisses the banner's announcement. For a tip, also records it as
     /// dismissed so it never returns, and surfaces the "Never show me tips"
     /// opt-out in its place for a few seconds.
     private func dismissAnnouncement(_ announcement: Announcement) {
         announcements.dismiss(id: announcement.id)
         guard let tipID = Tip.tipID(fromAnnouncementID: announcement.id) else { return }
         tips.markDismissed(tipID)
         showTipOptOut = true
         tipOptOutHideTask?.cancel()
         tipOptOutHideTask = Task { @MainActor in
             try? await Task.sleep(for: .seconds(6))
             guard !Task.isCancelled else { return }
             showTipOptOut = false
         }
     }
 
     @ViewBuilder
     private func content(usesRoomierType: Bool) -> some View {
         let summaries = games.compactMap {
             summaryCache.summary(
                 for: $0,
                 localAuthorID: authorIdentity.currentID,
                 localName: preferences.name,
                 localColor: preferences.color
             )
         }
         let inProgress = summaries
             .filter { $0.completedAt == nil && !$0.isAccessRevoked }
             .sorted { ($0.updatedAt ?? .distantPast) > ($1.updatedAt ?? .distantPast) }
         let revoked = summaries
             .filter { $0.isAccessRevoked }
             .sorted { ($0.updatedAt ?? .distantPast) > ($1.updatedAt ?? .distantPast) }
         let completed = summaries
             .filter { $0.completedAt != nil && !$0.isAccessRevoked }
             .sorted { ($0.completedAt ?? .distantPast) > ($1.completedAt ?? .distantPast) }
         let visibleCount = min(completedVisibleCount, completed.count)
         let visibleCompleted = Array(completed.prefix(visibleCount))
         let hasMore = visibleCount < completed.count
 
         let blockedIDs = Set(blockedFriends.compactMap { $0.authorID })
         let visibleInvites = pendingInvites.filter {
             guard let inviter = $0.inviterAuthorID else { return true }
             return !blockedIDs.contains(inviter)
         }
 
         Group {
             if horizontalSizeClass == .regular {
                 gridLayout(
                     invites: visibleInvites,
                     inProgress: inProgress,
                     revoked: revoked,
                     completed: visibleCompleted,
                     hasMore: hasMore,
                     usesRoomierType: usesRoomierType
                 )
             } else {
                 listLayout(
                     invites: visibleInvites,
                     inProgress: inProgress,
                     revoked: revoked,
                     completed: visibleCompleted,
                     hasMore: hasMore,
                     usesRoomierType: usesRoomierType
                 )
             }
         }
         .overlay {
             if games.isEmpty {
                 if preferences.hasName {
                     ContentUnavailableView {
                         Label("No Puzzles", systemImage: "square.grid.3x3")
                     } description: {
                         Text("Tap the + button to start a new puzzle, or pull down to refresh.")
                     }
                 } else {
                     ContentUnavailableView {
                         Label("Set Your Profile Name", systemImage: "person.text.rectangle")
                     } description: {
                         Text("Choose the name other players will see.")
                     } actions: {
                         Button {
                             nameDraft = ""
                             showingNamePrompt = true
                         } label: { Text("Set Profile Name") }
                         .buttonStyle(.borderedProminent)
                     }
                 }
             }
         }
         .onChange(of: completed.count) { oldCount, newCount in
             if newCount > oldCount {
                 completedVisibleCount += (newCount - oldCount)
             }
         }
     }
 
     // MARK: - List layout (compact width / iPhone)
 
     @ViewBuilder
     private func listLayout(
         invites: [InviteEntity],
         inProgress: [GameSummary],
         revoked: [GameSummary],
         completed: [GameSummary],
         hasMore: Bool,
         usesRoomierType: Bool
     ) -> some View {
         List {
             if !invites.isEmpty {
                 Section {
                     ForEach(invites, id: \.objectID) { invite in
                         inviteRow(for: invite)
                     }
                 } header: {
                     Text("Invited")
                 }
             }
 
             if !inProgress.isEmpty {
                 Section {
                     ForEach(inProgress) { game in
                         rowView(for: game, usesRoomierType: usesRoomierType)
                     }
                 } header: {
                     Text("In Progress")
                 }
             }
 
             if !revoked.isEmpty {
                 Section {
                     ForEach(revoked) { game in
                         rowView(for: game, usesRoomierType: usesRoomierType)
                     }
                 } header: {
                     Text("Revoked")
                 }
             }
 
             if !completed.isEmpty {
                 Section {
                     ForEach(completed) { game in
                         rowView(for: game, usesRoomierType: usesRoomierType)
                     }
                 } header: {
                     Text("Completed")
                 } footer: {
                     if hasMore {
                         loadMoreButton
                     }
                 }
             }
         }
         .refreshable {
             await onRefresh()
         }
     }
 
     // MARK: - Grid layout (regular width / iPad)
 
     private var gridColumns: [GridItem] {
         [GridItem(.adaptive(minimum: 320), spacing: 12)]
     }
 
     @ViewBuilder
     private func gridLayout(
         invites: [InviteEntity],
         inProgress: [GameSummary],
         revoked: [GameSummary],
         completed: [GameSummary],
         hasMore: Bool,
         usesRoomierType: Bool
     ) -> some View {
         ScrollView {
             LazyVStack(spacing: 8) {
                 if !invites.isEmpty {
                     Section {
                         LazyVGrid(columns: gridColumns, spacing: 12) {
                             ForEach(invites, id: \.objectID) { invite in
                                 inviteCard(for: invite)
                             }
                         }
                         .padding(.horizontal)
                     } header: {
                         gridSectionHeader("Invited")
                     }
                 }
 
                 if !inProgress.isEmpty {
                     Section {
                         LazyVGrid(columns: gridColumns, spacing: 12) {
                             ForEach(inProgress) { game in
                                 gameCard(for: game, usesRoomierType: usesRoomierType)
                             }
                         }
                         .padding(.horizontal)
                     } header: {
                         gridSectionHeader("In Progress")
                     }
                 }
 
                 if !revoked.isEmpty {
                     Section {
                         LazyVGrid(columns: gridColumns, spacing: 12) {
                             ForEach(revoked) { game in
                                 gameCard(for: game, usesRoomierType: usesRoomierType)
                             }
                         }
                         .padding(.horizontal)
                     } header: {
                         gridSectionHeader("Revoked")
                     }
                 }
 
                 if !completed.isEmpty {
                     Section {
                         LazyVGrid(columns: gridColumns, spacing: 12) {
                             ForEach(completed) { game in
                                 gameCard(for: game, usesRoomierType: usesRoomierType)
                             }
                         }
                         .padding(.horizontal)
 
                         if hasMore {
                             loadMoreButton
                                 .padding(.horizontal)
                         }
                     } header: {
                         gridSectionHeader("Completed")
                     }
                 }
             }
             .padding(.vertical, 8)
         }
         .background(Color(.systemGroupedBackground))
         .refreshable {
             await onRefresh()
         }
     }
 
     private func gridSectionHeader(_ title: String) -> some View {
         Text(title)
             .font(.footnote.weight(.semibold))
             .foregroundStyle(.secondary)
             .frame(maxWidth: .infinity, alignment: .leading)
             .padding(.horizontal, 16)
             .padding(.vertical, 8)
             .background(Color(.systemGroupedBackground))
     }
 
     private var loadMoreButton: some View {
         HStack {
             Spacer()
             Button {
                 withAnimation(.easeInOut(duration: 0.25)) {
                     completedVisibleCount += Self.completedPageSize
                 }
             } label: {
                 Text("Load More")
                     .font(.subheadline.weight(.semibold))
                     .foregroundColor(.secondary)
                     .padding(.horizontal, 18)
                     .padding(.vertical, 8)
                     .background(Color(.tertiarySystemFill), in: Capsule())
             }
             .buttonStyle(.plain)
             .textCase(nil)
             Spacer()
         }
         .padding(.top, 8)
     }
 
     private func gameCard(for game: GameSummary, usesRoomierType: Bool) -> some View {
         GameCardView(
             game: game,
             shareController: shareController,
             usesRoomierType: usesRoomierType,
             onResume: { navigationPath.append(game.id) },
             onLeave: { leaveTarget = game },
             onResign: { resignTarget = game },
             onDelete: { deleteTarget = game }
         )
     }
 
     /// The puzzle-shape preview for an invite, decoded from the silhouette
     /// segment the inviter sent. Open cells render grey (`.filled`) to read as
     /// "not yet playable", matching the link-tap placeholder in
     /// `JoiningPuzzleView`. An absent or undecodable grid gets no thumbnail.
     @ViewBuilder
     private func inviteThumbnail(for invite: InviteEntity) -> some View {
         if let segment = invite.gridSilhouette,
            let shape = GridSilhouette.decode(segment) {
             GridThumbnailView(
                 width: shape.width,
                 height: shape.height,
                 cells: shape.blocks.map { $0 ? .block : .filled }
             )
         }
     }
 
     @ViewBuilder
     private func inviteCard(for invite: InviteEntity) -> some View {
         let inviter = invite.resolvedInviterName ?? "A player"
         let title = (invite.gameTitle?.isEmpty == false) ? invite.gameTitle! : "a puzzle"
         HStack(spacing: 12) {
             inviteThumbnail(for: invite)
             VStack(alignment: .leading, spacing: 2) {
                 Text(title)
                     .font(.subheadline.weight(.semibold))
                     .lineLimit(1)
                     .truncationMode(.tail)
                 Text("Invited by \(inviter)")
                     .font(.footnote)
                     .foregroundStyle(.secondary)
                     .lineLimit(1)
             }
             Spacer(minLength: 0)
             if acceptingInviteID == invite.objectID {
                 ProgressView()
             } else {
                 Button("Accept") { Task { await accept(invite) } }
                     .buttonStyle(.borderedProminent)
                     .controlSize(.small)
             }
             inviteMenu(for: invite)
         }
         .padding(12)
         .frame(maxWidth: .infinity)
         .frame(height: CardMetrics.height)
         .background(
             Color(.secondarySystemGroupedBackground),
             in: RoundedRectangle(cornerRadius: CardMetrics.cornerRadius)
         )
     }
 
     private func inviteMenu(for invite: InviteEntity) -> some View {
         Menu {
             Button { Task { await decline(invite) } } label: {
                 Label("Decline", systemImage: "xmark")
             }
             Button(role: .destructive) { blockTarget = invite } label: {
                 Label("Block", systemImage: "hand.raised")
             }
         } label: {
             Text("More")
                 .foregroundStyle(.primary)
         }
         .buttonStyle(.bordered)
         .controlSize(.small)
         .tint(.secondary)
         .compositingGroup()
     }
 
     @ViewBuilder
     private func inviteRow(for invite: InviteEntity) -> some View {
         let inviter = invite.resolvedInviterName ?? "A player"
         let title = (invite.gameTitle?.isEmpty == false) ? invite.gameTitle! : "a puzzle"
         HStack {
             inviteThumbnail(for: invite)
             VStack(alignment: .leading, spacing: 2) {
                 Text(title).font(.body.weight(.medium))
                 Text("Invited by \(inviter)")
                     .font(.caption)
                     .foregroundStyle(.secondary)
             }
             Spacer()
             if acceptingInviteID == invite.objectID {
                 ProgressView()
             } else {
                 Button("Accept") { Task { await accept(invite) } }
                     .buttonStyle(.borderedProminent)
                     .controlSize(.small)
             }
             inviteMenu(for: invite)
         }
         .swipeActions(edge: .trailing) {
             Button("Decline") { Task { await decline(invite) } }
                 .tint(.gray)
             Button("Block", role: .destructive) { blockTarget = invite }
         }
     }
 
     private func accept(_ invite: InviteEntity) async {
         guard let url = invite.shareURL,
               let ping = invite.pingRecordName
         else { return }
         let shape = invite.gridSilhouette.flatMap(GridSilhouette.decode)
         acceptingInviteID = invite.objectID
         announcements.dismiss(id: Self.inviteErrorID)
         defer { acceptingInviteID = nil }
         do {
             if let onAcceptInvite {
                 try await onAcceptInvite(url, ping, shape)
             } else if let acceptInvite {
                 try await acceptInvite(url, ping)
             }
         } catch {
             announcements.post(Announcement(
                 id: Self.inviteErrorID,
                 scope: .global,
                 severity: .error,
                 title: "Accepting Failed",
                 body: error.localizedDescription,
                 dismissal: .manual
             ))
         }
     }
 
     /// Single-slot id for the invite-accept failure banner — a fresh
     /// failure replaces the prior one rather than stacking.
     private static let inviteErrorID = "invite-accept-error"
 
     /// Single-slot id for game-list destructive-action failures (decline,
     /// resign, delete) — a fresh failure replaces the prior one.
     private static let destructiveActionErrorID = "game-list-destructive-action-error"
 
     private func decline(_ invite: InviteEntity) async {
         guard let declineInvite, let gameID = invite.gameID else { return }
         do {
             try await declineInvite(gameID)
         } catch {
             announcements.post(Announcement(
                 id: Self.destructiveActionErrorID,
                 scope: .global,
                 severity: .error,
                 title: "Declining Failed",
                 body: error.localizedDescription,
                 dismissal: .manual
             ))
         }
     }
 
     @ViewBuilder
     private func rowView(for game: GameSummary, usesRoomierType: Bool) -> some View {
         GameRowView(
             game: game,
             shareController: shareController,
             usesRoomierType: usesRoomierType,
             onResume: { navigationPath.append(game.id) },
             onLeave: { leaveTarget = game },
             onResign: { resignTarget = game },
             onDelete: { deleteTarget = game }
         )
         .background(
             NavigationLink(value: game.id) { EmptyView() }
                 .opacity(0)
         )
         .swipeActions(edge: .trailing, allowsFullSwipe: false) {
             if !game.isOwned && game.isShared {
                 Button("Leave", role: .destructive) {
                     leaveTarget = game
                 }
             } else {
                 Button("Delete", role: .destructive) {
                     deleteTarget = game
                 }
             }
         }
     }
 
     private func leaveShare(game: GameSummary) async {
         do {
             try await shareController.leaveShare(gameID: game.id)
             leaveTarget = nil
         } catch {
             leaveError = error
             leaveTarget = nil
         }
     }
 
     private func usesRoomierType(for size: CGSize) -> Bool {
         size.height >= 760 && dynamicTypeSize <= .medium
     }
 }