crossmate

SuccessPanel.swift (17492B)

---

 import SwiftUI
 
 struct SuccessPanel: View {
     let session: PlayerSession
     let roster: PlayerRoster
     /// Drives the finish-banner replay scrubber and the grid override above.
     var replay: ReplayControls? = nil
     /// Loads the merged journal (Phase 2b). Called once when the banner appears
     /// (and again on "check again" while waiting on a peer's upload).
     var loadReplay: (() async -> JournalReplayResult)? = nil
     @Environment(PlayerPreferences.self) private var preferences
 
     private struct Contribution: Identifiable {
         let authorID: String?
         let name: String
         let color: PlayerColor?
         let count: Int
 
         var id: String { authorID ?? "unattributed" }
     }
 
     private var revealedSquareCount: Int {
         let replayCells = replay?.frame?.cells
         var count = 0
         for r in 0..<session.puzzle.height {
             for c in 0..<session.puzzle.width {
                 let cell = session.puzzle.cells[r][c]
                 guard !cell.isBlock else { continue }
                 if displayedCellState(row: r, col: c, replayCells: replayCells).mark.isRevealed {
                     count += 1
                 }
             }
         }
         return count
     }
 
     private var revealedSquaresText: String {
         switch revealedSquareCount {
         case 0:
             return "No squares revealed"
         case 1:
             return "1 square revealed"
         default:
             return "\(revealedSquareCount) squares revealed"
         }
     }
 
     /// Total active solve time, frozen at completion (`roster.solveTime` bounds
     /// the union at `completedAt`). "Finished" rather than "Solved" so it reads
     /// correctly for a resignation too — and because an offline solo win carries
     /// no `completedBy`, so a win and a resign aren't reliably distinguishable
     /// here anyway. `nil` when there is no time to show — an archive made before
     /// the clock existed — so the line is omitted rather than reading 0:00.
     private var finishedInText: String? {
         let seconds = roster.solveTime()
         guard seconds > 0 else { return nil }
         return "Finished in \(TimeLog.clockString(seconds))"
     }
 
     private var contributions: [Contribution] {
         let replayCells = replay?.frame?.cells
         var counts: [String?: Int] = [:]
         for r in 0..<session.puzzle.height {
             for c in 0..<session.puzzle.width {
                 let cell = session.puzzle.cells[r][c]
                 guard !cell.isBlock else { continue }
                 let state = displayedCellState(row: r, col: c, replayCells: replayCells)
                 guard !state.mark.isRevealed else { continue }
                 let entry = state.letter
                 guard !entry.isEmpty else { continue }
                 if cell.solution != nil, !cell.accepts(entry) { continue }
                 counts[normalizedAuthorID(state.cellAuthorID), default: 0] += 1
             }
         }
 
         let entries = roster.entries
         let entryByAuthorID = Dictionary(uniqueKeysWithValues: entries.map { ($0.authorID, $0) })
         let hasRemotePlayers = entries.contains { !$0.isLocal }
         let usesLocalFallback = entries.isEmpty
         let rosterContributions: [Contribution]
         if usesLocalFallback {
             rosterContributions = [
                 Contribution(
                     authorID: nil,
                     name: preferences.name,
                     color: preferences.color,
                     count: counts[nil] ?? 0
                 )
             ]
         } else {
             rosterContributions = entries.map { entry in
                 Contribution(
                     authorID: entry.authorID,
                     name: entry.name,
                     color: entry.color,
                     count: counts[entry.authorID] ?? 0
                 )
             }
         }
         let rosterAuthorIDs = Set(entries.map(\.authorID))
 
         let countedContributions = counts.compactMap { authorID, count -> Contribution? in
             if let authorID, rosterAuthorIDs.contains(authorID) {
                 return nil
             }
             if authorID == nil && usesLocalFallback {
                 return nil
             }
             if let authorID, let entry = entryByAuthorID[authorID] {
                 return Contribution(authorID: authorID, name: entry.name, color: entry.color, count: count)
             }
             if authorID == nil && !hasRemotePlayers {
                 return Contribution(authorID: nil, name: preferences.name, color: preferences.color, count: count)
             }
             if authorID == nil {
                 // A `nil` author key only arises with remote players present
                 // (see `normalizedAuthorID`): an authorless square, e.g. a cell
                 // sealed to the solution at completion before its author's
                 // letter arrived. It belongs to no player, so drop it rather
                 // than surfacing a phantom "Player".
                 return nil
             }
             return Contribution(authorID: authorID, name: "Player", color: nil, count: count)
         }
 
         return (rosterContributions + countedContributions)
         .sorted {
             if $0.count != $1.count { return $0.count > $1.count }
             return $0.name < $1.name
         }
     }
 
     private func displayedCellState(
         row: Int,
         col: Int,
         replayCells: [GridPosition: JournalCellState]?
     ) -> JournalCellState {
         let position = GridPosition(row: row, col: col)
         if let replayCells {
             return replayCells[position] ?? .empty
         }
 
         let square = session.game.squares[row][col]
         return JournalCellState(
             letter: square.entry,
             mark: square.mark,
             cellAuthorID: square.letterAuthorID
         )
     }
 
     private func normalizedAuthorID(_ authorID: String?) -> String? {
         guard let authorID else {
             return roster.entries.contains(where: { !$0.isLocal }) ? nil : roster.localAuthorID
         }
         return authorID
     }
 
     var body: some View {
         VStack(spacing: 0) {
             if let replay {
                 ReplayScrubber(replay: replay, fillColor: preferences.color.tint)
             }
             scoreboard
         }
         .frame(maxWidth: .infinity, maxHeight: .infinity)
         // Drive the load from the panel itself, not the scrubber subview: the
         // scrubber renders `EmptyView` until a timeline loads, and SwiftUI skips
         // a non-rendering view's `.task`. Keyed on `reloadToken` so "check
         // again" re-fires it.
         .task(id: replay?.reloadToken) {
             guard let replay, let loadReplay else { return }
             await replay.load(loadReplay)
         }
         // A contributor's journal just synced — re-check completeness so a
         // waiting scrubber flips to ready without polling. Same async-sequence
         // idiom PlayerRoster uses for `.playerRosterShouldRefresh`.
         .task {
             let gameID = session.mutator.gameID
             for await note in NotificationCenter.default.notifications(named: .replayJournalDidSync) {
                 guard let replay, case .waiting = replay.status,
                       let gameIDs = note.userInfo?["gameIDs"] as? Set<UUID>,
                       gameIDs.contains(gameID)
                 else { continue }
                 replay.retry()
             }
         }
     }
 
     private var scoreboard: some View {
         HStack(alignment: .center, spacing: 16) {
             VStack(alignment: .center, spacing: 8) {
                 Image(systemName: "checkmark.seal.fill")
                     .font(.system(size: 44))
                     .foregroundStyle(.tint)
 
                 VStack(alignment: .center, spacing: 2) {
                     Text(session.puzzle.title)
                         .font(.subheadline.weight(.semibold))
                         .lineLimit(1)
                     if let date = session.puzzle.date {
                         Text(date, format: .dateTime.day().month(.abbreviated).year())
                             .font(.caption)
                             .foregroundStyle(.secondary)
                             .lineLimit(1)
                     }
                     if let author = session.puzzle.author {
                         Text(author)
                             .font(.caption)
                             .foregroundStyle(.secondary)
                             .lineLimit(1)
                     }
                     if let publisher = session.puzzle.publisher {
                         Text(publisher)
                             .font(.caption)
                             .foregroundStyle(.secondary)
                             .lineLimit(1)
                     }
                 }
                 .multilineTextAlignment(.center)
                 .frame(maxWidth: .infinity, alignment: .center)
             }
             .frame(maxWidth: .infinity, alignment: .center)
 
             VStack(alignment: .leading, spacing: 12) {
                 Text("Players")
                     .font(.headline)
 
                 ScrollView {
                     VStack(alignment: .leading, spacing: 6) {
                         ForEach(contributions) { contribution in
                             HStack(spacing: 8) {
                                 Circle()
                                     .fill(contribution.color?.tint ?? Color.secondary)
                                     .frame(width: 8, height: 8)
                                 Text(contribution.name)
                                     .font(.subheadline)
                                     .lineLimit(1)
                                 Spacer(minLength: 8)
                                 Text("\(contribution.count)")
                                     .font(.subheadline.monospacedDigit().weight(.semibold))
                             }
                         }
 
                         VStack(spacing: 4) {
                             if let finishedInText {
                                 Text(finishedInText)
                             }
                             Text(revealedSquaresText)
                         }
                         .font(.footnote)
                         .foregroundStyle(.secondary)
                         .padding(.top, 16)
                         .frame(maxWidth: .infinity, alignment: .center)
                     }
                 }
                 .scrollIndicators(.hidden)
             }
             // Cap the list width so a wide iPad column doesn't strand each
             // name far from its count, then expand-to-fill and centre that
             // capped block within the column.
             .frame(maxWidth: 320, alignment: .leading)
             .frame(maxWidth: .infinity)
             .padding(.top, 8)
         }
         .padding(.leading, 18)
         .padding(.trailing, 24)
         .padding(.top, 8)
         .padding(.bottom, 4)
         .frame(maxWidth: .infinity, maxHeight: .infinity)
     }
 }
 
 /// The replay scrubber that sits atop the finish banner. The thumb starts at
 /// the far right (the finished grid) and dragging left rewinds the puzzle grid
 /// above through its move history. Disabled with a sync caption while a
 /// contributing device's journal is still missing (strict completeness).
 private struct ReplayScrubber: View {
     @Bindable var replay: ReplayControls
     /// The local player's accent colour, for the filled track.
     var fillColor: Color
 
     /// Shared height for every scrubber state (slider, waiting, loading) so the
     /// banner doesn't change height as it loads, and captions sit vertically
     /// centred in the same space the slider occupies.
     private static let rowHeight: CGFloat = 24
 
     var body: some View {
         Group {
             switch replay.status {
             case .ready(let timeline) where timeline.count > 0:
                 slider(count: timeline.count)
             case .waiting:
                 waiting
             case .loading:
                 caption {
                     ProgressView().controlSize(.small)
                     Text("Loading replay…")
                 }
             case .idle, .ready, .unavailable:
                 // Not started yet (`.idle`), nothing to replay (empty log), or
                 // no reachable history. Hold the row's height anyway so the
                 // banner doesn't change size as the load resolves — otherwise
                 // the scoreboard below hitches up and down as the scrubber
                 // appears then collapses.
                 Color.clear.frame(height: Self.rowHeight)
             }
         }
         .padding(.horizontal, 18)
         .padding(.top, 14)
     }
 
     private func slider(count: Int) -> some View {
         HStack(spacing: 10) {
             historyOrSpeedControl
             CompactSlider(
                 value: $replay.position,
                 range: 0...count,
                 fillColor: UIColor(fillColor),
                 // A manual scrub always wins: cancel autoplay the moment the
                 // user grabs the thumb, while preserving the selected speed.
                 onUserScrub: { replay.pausePlayback() }
             )
             PlaybackControl(
                 isPlaying: replay.isPlaybackActive,
                 selectedSpeed: replay.selectedPlaybackSpeed,
                 onTap: { replay.togglePlayback() }
             )
         }
         .frame(height: Self.rowHeight)
         // Drive autoplay: play/pause and speed changes restart the loop with
         // the current interval. A paused replay yields a `nil` interval, so the
         // task exits and the grid rests.
         .task(id: "\(replay.isPlaybackActive)-\(replay.selectedPlaybackSpeed)") {
             guard let interval = replay.playbackStepInterval else { return }
             while !Task.isCancelled {
                 try? await Task.sleep(for: interval)
                 if Task.isCancelled { break }
                 replay.advancePlayback()
             }
         }
     }
 
     private var historyOrSpeedControl: some View {
         ZStack {
             Image(systemName: "clock.arrow.circlepath")
                 .font(.footnote)
                 .foregroundStyle(.secondary)
                 .opacity(replay.isPlaybackActive ? 0 : 1)
                 .scaleEffect(replay.isPlaybackActive ? 0.75 : 1)
                 .blur(radius: replay.isPlaybackActive ? 2 : 0)
                 .accessibilityHidden(replay.isPlaybackActive)
 
             Button {
                 replay.cycleSelectedPlaybackSpeed()
             } label: {
                 Text("\(replay.selectedPlaybackSpeed)x")
                     .font(.caption2.monospacedDigit().weight(.semibold))
                     .contentTransition(.numericText())
                     .frame(width: 28, height: 18)
                     .replayGlass()
                     .animation(.easeInOut(duration: 0.16), value: replay.selectedPlaybackSpeed)
             }
             .foregroundStyle(.secondary)
             .buttonStyle(.plain)
             .opacity(replay.isPlaybackActive ? 1 : 0)
             .scaleEffect(replay.isPlaybackActive ? 1 : 1.35)
             .blur(radius: replay.isPlaybackActive ? 0 : 2)
             .allowsHitTesting(replay.isPlaybackActive)
             .accessibilityHidden(!replay.isPlaybackActive)
             .accessibilityLabel("Replay speed")
             .accessibilityValue("Speed \(replay.selectedPlaybackSpeed) of \(ReplayControls.maxPlaybackSpeed)")
         }
         .frame(width: 30, height: 22)
         // The symbol/speed glyphs read a touch high against the slider track;
         // nudge the pair down a point to sit centred on it.
         .offset(y: 1)
         .animation(.spring(response: 0.34, dampingFraction: 0.62), value: replay.isPlaybackActive)
     }
 
     private var waiting: some View {
         caption {
             Image(systemName: "arrow.triangle.2.circlepath")
                 .font(.footnote)
             if case .waiting(let missing) = replay.status {
                 Text("Waiting for \(missing) device\(missing == 1 ? "" : "s") to sync history")
                     .lineLimit(1)
             }
             Spacer(minLength: 8)
             Button("Check again") { replay.retry() }
                 .font(.caption.weight(.semibold))
                 .buttonStyle(.borderless)
         }
     }
 
     private func caption<Content: View>(@ViewBuilder _ content: () -> Content) -> some View {
         HStack(spacing: 8, content: content)
             .font(.caption)
             .foregroundStyle(.secondary)
             .frame(height: Self.rowHeight)
             .frame(maxWidth: .infinity, alignment: .leading)
     }
 }
 
 /// A shaped play/pause control for replay autoplay.
 private struct PlaybackControl: View {
     let isPlaying: Bool
     let selectedSpeed: Int
     let onTap: () -> Void
 
     var body: some View {
         Button(action: onTap) {
             Image(systemName: isPlaying ? "pause.fill" : "play.fill")
                 .font(.caption2.weight(.heavy))
                 .frame(width: 26, height: 18)
                 .padding(.horizontal, 7)
                 .padding(.vertical, 4)
                 .replayGlass()
             .animation(.easeInOut(duration: 0.18), value: isPlaying)
         }
         .buttonStyle(.plain)
         .accessibilityLabel(isPlaying ? "Pause replay" : "Play replay")
         .accessibilityValue(isPlaying ? "Playing at speed \(selectedSpeed)" : "Paused")
     }
 }