crossmate

GameListView.swift (36224B)

---

 import CoreData
 import SwiftUI
 
 struct GameListView: View {
     let store: GameStore
     let shareController: ShareController
     let onRefresh: () async -> Void
     let onAppear: () async -> Void
     let onDisappear: () -> 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
     @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
 
     private static let completedPageSize = 7
 
     var body: some View {
         GeometryReader { geometry in
             VStack(spacing: 0) {
                 if let announcement = announcements.currentGlobal() {
                     AnnouncementBanner(announcement: announcement) {
                         announcements.dismiss(id: announcement.id)
                     }
                     .padding(.horizontal)
                     .padding(.top, 8)
                     .transition(.move(edge: .top).combined(with: .opacity))
                 }
                 content(usesRoomierType: usesRoomierType(for: geometry.size))
             }
             .animation(.easeInOut(duration: 0.3), value: announcements.currentGlobal())
         }
         .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")
                 }
             }
             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 games 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.")
         }
     }
 
     @ViewBuilder
     private func content(usesRoomierType: Bool) -> some View {
         let summaries = games.compactMap { summaryCache.summary(for: $0) }
         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`. Absent or non-square grids get no thumbnail.
     @ViewBuilder
     private func inviteThumbnail(for invite: InviteEntity) -> some View {
         if let segment = invite.gridSilhouette,
            let shape = GridSilhouette.decode(segment) {
             GridThumbnailView(
                 width: shape.side,
                 height: shape.side,
                 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 acceptInvite,
               let url = invite.shareURL,
               let ping = invite.pingRecordName
         else { return }
         acceptingInviteID = invite.objectID
         announcements.dismiss(id: Self.inviteErrorID)
         defer { acceptingInviteID = nil }
         do {
             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
     }
 }
 
 // MARK: - Row
 
 private struct GameRowView: View {
     let game: GameSummary
     let shareController: ShareController
     let usesRoomierType: Bool
     var onResume: () -> Void = {}
     var onLeave: () -> Void = {}
     var onResign: () -> Void = {}
     var onDelete: () -> Void = {}
     @State private var isShowingShareSheet = false
 
     var body: some View {
         let showsUnreadBadge = game.hasUnreadOtherMoves
 
         HStack(spacing: 12) {
             GridThumbnailView(
                 width: game.gridWidth,
                 height: game.gridHeight,
                 cells: game.thumbnailCells
             )
             .overlay(alignment: .topTrailing) {
                 if showsUnreadBadge {
                     Circle()
                         .fill(.red)
                         .frame(width: 14, height: 14)
                         .overlay(
                             Circle()
                                 .stroke(.background, lineWidth: 2)
                         )
                         .offset(x: 5, y: -5)
                         .accessibilityLabel("Unseen changes")
                 }
             }
             VStack(alignment: .leading, spacing: 2) {
                 HStack(spacing: 4) {
                     Text(game.title)
                         .font((usesRoomierType ? Font.headline : .subheadline).weight(.semibold))
                         .lineLimit(1)
                         .minimumScaleFactor(0.8)
                         .truncationMode(.tail)
                     if game.isShared {
                         Image(systemName: "person.2.fill")
                             .font(.caption)
                             .foregroundStyle(.secondary)
                     }
                 }
                 GameMetadataView(
                     puzzleDate: game.puzzleDate,
                     publisher: game.publisher,
                     usesRoomierType: usesRoomierType
                 )
                 if let date = game.updatedAt {
                     LastUpdatedView(date: date, usesRoomierType: usesRoomierType)
                 }
             }
             Spacer()
             GameOverflowMenu(
                 game: game,
                 onShare: { isShowingShareSheet = true },
                 onResume: onResume,
                 onLeave: onLeave,
                 onResign: onResign,
                 onDelete: onDelete
             )
         }
         .padding(.vertical, 4)
         .sheet(isPresented: $isShowingShareSheet) {
             GameShareSheet(
                 gameID: game.id,
                 title: game.title,
                 shareController: shareController
             )
         }
     }
 }
 
 // MARK: - Card (regular width)
 
 private enum CardMetrics {
     static let height: CGFloat = 88
     static let cornerRadius: CGFloat = 12
 }
 
 /// Tappable card used in the iPad grid layout. The whole card is one
 /// `Button` (so the pressed-state highlight covers the full card), and the
 /// overflow `Menu` is layered as an `.overlay` rather than nested inside the
 /// button — keeping them siblings means tapping the ellipsis opens the menu
 /// instead of also firing the navigation action.
 private struct GameCardView: View {
     let game: GameSummary
     let shareController: ShareController
     let usesRoomierType: Bool
     var onResume: () -> Void = {}
     var onLeave: () -> Void = {}
     var onResign: () -> Void = {}
     var onDelete: () -> Void = {}
     @State private var isShowingShareSheet = false
 
     var body: some View {
         let showsUnreadBadge = game.hasUnreadOtherMoves
 
         Button(action: onResume) {
             HStack(spacing: 12) {
                 GridThumbnailView(
                     width: game.gridWidth,
                     height: game.gridHeight,
                     cells: game.thumbnailCells
                 )
                 .overlay(alignment: .topTrailing) {
                     if showsUnreadBadge {
                         Circle()
                             .fill(.red)
                             .frame(width: 14, height: 14)
                             .overlay(
                                 Circle()
                                     .stroke(.background, lineWidth: 2)
                             )
                             .offset(x: 5, y: -5)
                             .accessibilityLabel("Unseen changes")
                     }
                 }
                 VStack(alignment: .leading, spacing: 2) {
                     HStack(spacing: 4) {
                         Text(game.title)
                             .font((usesRoomierType ? Font.headline : .subheadline).weight(.semibold))
                             .lineLimit(1)
                             .minimumScaleFactor(0.8)
                             .truncationMode(.tail)
                         if game.isShared {
                             Image(systemName: "person.2.fill")
                                 .font(.caption)
                                 .foregroundStyle(.secondary)
                         }
                     }
                     GameMetadataView(
                         puzzleDate: game.puzzleDate,
                         publisher: game.publisher,
                         usesRoomierType: usesRoomierType
                     )
                     if let date = game.updatedAt {
                         LastUpdatedView(date: date, usesRoomierType: usesRoomierType)
                     }
                 }
                 Spacer(minLength: 0)
                 // Reserve room for the overflow menu, which is layered as an
                 // overlay so its taps don't fall through to this button.
                 Color.clear.frame(width: 32, height: 32)
             }
             .padding(12)
             .frame(maxWidth: .infinity)
             .frame(height: CardMetrics.height)
         }
         .buttonStyle(CardButtonStyle())
         .overlay(alignment: .trailing) {
             GameOverflowMenu(
                 game: game,
                 onShare: { isShowingShareSheet = true },
                 onResume: onResume,
                 onLeave: onLeave,
                 onResign: onResign,
                 onDelete: onDelete
             )
             .padding(.trailing, 12)
         }
         .sheet(isPresented: $isShowingShareSheet) {
             GameShareSheet(
                 gameID: game.id,
                 title: game.title,
                 shareController: shareController
             )
         }
     }
 }
 
 private struct CardButtonStyle: ButtonStyle {
     func makeBody(configuration: Configuration) -> some View {
         configuration.label
             .background(
                 Color(.secondarySystemGroupedBackground),
                 in: RoundedRectangle(cornerRadius: CardMetrics.cornerRadius)
             )
             .overlay {
                 if configuration.isPressed {
                     RoundedRectangle(cornerRadius: CardMetrics.cornerRadius)
                         .fill(Color.primary.opacity(0.06))
                 }
             }
             .contentShape(RoundedRectangle(cornerRadius: CardMetrics.cornerRadius))
     }
 }
 
 // MARK: - Shared overflow menu
 
 private struct GameOverflowMenu: View {
     let game: GameSummary
     var onShare: () -> Void
     var onResume: () -> Void
     var onLeave: () -> Void
     var onResign: () -> Void
     var onDelete: () -> Void
 
     var body: some View {
         Menu {
             Button { onShare() } label: {
                 Label("Share", systemImage: "square.and.arrow.up")
             }
             .disabled(!game.isOwned)
             Button { onResume() } label: {
                 Label("Resume", systemImage: "square.and.pencil")
             }
             Section {
                 Button(role: .destructive) { onResign() } label: {
                     Label("Resign", systemImage: "flag")
                 }
                 if !game.isOwned && game.isShared {
                     Button(role: .destructive) { onLeave() } label: {
                         Label("Leave", systemImage: "rectangle.portrait.and.arrow.right")
                     }
                 } else {
                     Button(role: .destructive) { onDelete() } label: {
                         Label("Delete", systemImage: "trash")
                     }
                 }
             }
         } label: {
             Image(systemName: "ellipsis")
                 .font(.body)
                 .frame(width: 32, height: 32)
                 .contentShape(Rectangle())
         }
         .tint(.secondary)
         .compositingGroup()
     }
 }
 
 private struct LastUpdatedView: View {
     let date: Date
     let usesRoomierType: Bool
 
     var body: some View {
         TimelineView(.lastUpdated(from: date)) { context in
             Text(text(now: context.date))
                 .font(usesRoomierType ? .footnote : .caption)
                 .foregroundStyle(.secondary)
         }
     }
 
     private func text(now: Date) -> String {
         let elapsed = max(0, now.timeIntervalSince(date))
         if elapsed < 60 {
             let seconds = max(1, Int(elapsed.rounded(.down)))
             return "Last updated \(seconds) \(seconds == 1 ? "second" : "seconds") ago"
         }
         if elapsed < 60 * 60 {
             let minutes = Int((elapsed / 60).rounded(.down))
             return "Last updated \(minutes) \(minutes == 1 ? "minute" : "minutes") ago"
         }
         if elapsed <= 48 * 60 * 60 {
             let hours = Int((elapsed / (60 * 60)).rounded(.down))
             return "Last updated \(hours) \(hours == 1 ? "hour" : "hours") ago"
         }
         return "Last updated on \(date.formatted(.dateTime.day().month(.abbreviated).year()))"
     }
 }
 
 private struct LastUpdatedSchedule: TimelineSchedule {
     let anchor: Date
 
     func entries(from startDate: Date, mode: TimelineScheduleMode) -> AnyIterator<Date> {
         var next = startDate
         return AnyIterator {
             let current = next
             let elapsed = max(0, current.timeIntervalSince(anchor))
             let step: TimeInterval
             if elapsed < 60 {
                 step = 1
             } else if elapsed < 60 * 60 {
                 step = 60
             } else if elapsed <= 48 * 60 * 60 {
                 step = 60 * 60
             } else {
                 return nil
             }
             next = current.addingTimeInterval(step)
             return current
         }
     }
 }
 
 extension TimelineSchedule where Self == LastUpdatedSchedule {
     static func lastUpdated(from date: Date) -> LastUpdatedSchedule {
         LastUpdatedSchedule(anchor: date)
     }
 }
 
 private struct GameMetadataView: View {
     let puzzleDate: Date?
     let publisher: String?
     let usesRoomierType: Bool
 
     private var font: Font {
         usesRoomierType ? .subheadline : .footnote
     }
 
     var body: some View {
         if let puzzleDate, let publisher {
             ViewThatFits(in: .horizontal) {
                 HStack(spacing: 0) {
                     Text(puzzleDate, format: .dateTime.day().month(.abbreviated).year())
                     Text(" • ")
                     Text(publisher)
                 }
                 .font(font)
                 .lineLimit(1)
 
                 VStack(alignment: .leading, spacing: 2) {
                     puzzleDateView(puzzleDate)
                     publisherView(publisher)
                 }
             }
         } else {
             if let puzzleDate {
                 puzzleDateView(puzzleDate)
             }
             if let publisher {
                 publisherView(publisher)
             }
         }
     }
 
     private func puzzleDateView(_ puzzleDate: Date) -> some View {
         Text(puzzleDate, format: .dateTime.day().month(.abbreviated).year())
             .font(font)
     }
 
     private func publisherView(_ publisher: String) -> some View {
         Text(publisher)
             .font(font)
             .lineLimit(1)
             .truncationMode(.tail)
     }
 }