crossmate

GameListView.swift (13624B)

---

 import CoreData
 import SwiftUI
 
 struct GameListView: View {
     let store: GameStore
     let shareController: ShareController
     let onRefresh: () async -> Void
     @Binding var navigationPath: NavigationPath
 
     @Environment(\.managedObjectContext) private var viewContext
     @Environment(\.dynamicTypeSize) private var dynamicTypeSize
     @FetchRequest(
         sortDescriptors: [],
         animation: .default
     )
     private var games: FetchedResults<GameEntity>
 
     @State private var showingNewGame = false
     @State private var showingSettings = false
     @State private var deleteTarget: GameSummary?
     @State private var resignTarget: GameSummary?
     @State private var leaveTarget: GameSummary?
     @State private var leaveError: Error?
     @State private var summaryCache = GameSummaryCache()
 
     var body: some View {
         GeometryReader { geometry in
             content(usesRoomierType: usesRoomierType(for: geometry.size))
         }
         .navigationTitle("")
         .navigationBarTitleDisplayMode(.inline)
         .toolbar {
             ToolbarItem(placement: .topBarLeading) {
                 Button {
                     showingSettings = true
                 } label: {
                     Image(systemName: "gearshape")
                 }
             }
             ToolbarItem(placement: .topBarTrailing) {
                 Button {
                     showingNewGame = true
                 } label: {
                     Image(systemName: "plus")
                 }
             }
         }
         .sheet(isPresented: $showingSettings) {
             SettingsView()
         }
         .sheet(isPresented: $showingNewGame) {
             NewGameSheet(store: store)
         }
         .alert("Resign Puzzle?", isPresented: .init(
             get: { resignTarget != nil },
             set: { if !$0 { resignTarget = nil } }
         )) {
             Button("Resign", role: .destructive) {
                 if let target = resignTarget {
                     try? store.resignGame(id: target.id)
                 }
             }
             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 {
                     try? store.deleteGame(id: target.id)
                 }
             }
             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.")
                 }
             }
         }
     }
 
     @ViewBuilder
     private func content(usesRoomierType: Bool) -> some View {
         let summaries = games.compactMap { summaryCache.summary(for: $0) }
         let inProgress = summaries
             .filter { $0.completedAt == nil }
             .sorted { ($0.updatedAt ?? .distantPast) > ($1.updatedAt ?? .distantPast) }
         let completed = summaries
             .filter { $0.completedAt != nil }
             .sorted { ($0.completedAt ?? .distantPast) > ($1.completedAt ?? .distantPast) }
 
         Group {
             List {
                 if !inProgress.isEmpty {
                     Section {
                         ForEach(inProgress) { game in
                             rowView(for: game, usesRoomierType: usesRoomierType)
                         }
                     } header: {
                         Text("In Progress")
                     }
                 }
 
                 if !completed.isEmpty {
                     Section {
                         ForEach(completed) { game in
                             rowView(for: game, usesRoomierType: usesRoomierType)
                         }
                     } header: {
                         Text("Completed")
                     }
                 }
             }
             .overlay {
                 if games.isEmpty {
                     ContentUnavailableView {
                         Label("No Puzzles", systemImage: "square.grid.3x3")
                     } description: {
                         Text("Tap the + button to start a new puzzle, or pull down to refresh.")
                     }
                 }
             }
             .refreshable {
                 await onRefresh()
             }
         }
     }
 
     @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 showsUnseenBadge = game.hasUnseenOtherMoves
 
         HStack(spacing: 12) {
             GridThumbnailView(
                 width: game.gridWidth,
                 height: game.gridHeight,
                 cells: game.thumbnailCells
             )
             .overlay(alignment: .topTrailing) {
                 if showsUnseenBadge {
                     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()
             Menu {
                 Button {
                     isShowingShareSheet = true
                 } 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()
         }
         .padding(.vertical, 4)
         .sheet(isPresented: $isShowingShareSheet) {
             GameShareSheet(
                 gameID: game.id,
                 title: game.title,
                 shareController: shareController
             )
         }
     }
 }
 
 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)
     }
 }