crossmate

PuzzleHeader.swift (11336B)

---

 import SwiftUI
 
 /// Swipeable header that sits above the grid. Page 1 is the title, the
 /// last page is the credits, and on iPhone a scoreboard page sits between
 /// them (iPad shows the scoreboard permanently in the side panel, so it is
 /// omitted here). A fixed height is required because `.page` style fills
 /// its container rather than sizing to content.
 struct PuzzleHeader: View {
     @Bindable var session: PlayerSession
     let roster: PlayerRoster
     let title: String
     let subtitle: String?
     let showsScoreboard: Bool
     let shouldAutoRevealScoreboard: Bool
     let gameID: UUID
     let isEngagementLive: Bool
     var onNudge: (() async -> Void)? = nil
     var nudgeReadyAt: () -> Date? = { nil }
     /// The shared open "arm" beat, owned by `PuzzleView` so the banner and the
     /// grid's "changed while you were away" borders reveal together. Until it
     /// flips (a moment after open), the title is the only thing on screen;
     /// then banner posts — including a session summary that arrived during the
     /// hold — animate in.
     let isArmed: Bool
     @Environment(AnnouncementCenter.self) private var announcements
     @Environment(\.dynamicTypeSize) private var dynamicTypeSize
     @State private var selection: Page = .title
     @State private var userSelectedPage = false
     @State private var isSelectingPageProgrammatically = false
     @State private var didAutoRevealScoreboard = false
 
     private enum Page: Hashable {
         case title
         case scoreboard
         case clock
         case credits
     }
 
     /// Reconstructed as "© <year> <publisher>" from the puzzle's date and
     /// publisher, falling back to whatever pieces exist, and finally to the
     /// raw copyright string parsed from the source.
     private var copyrightLine: String? {
         let year = session.puzzle.date.map {
             Calendar.current.component(.year, from: $0)
         }
         switch (year, session.puzzle.publisher) {
         case let (year?, publisher?):
             return "© \(year) \(publisher)"
         case let (year?, nil):
             return "© \(year)"
         case let (nil, publisher?):
             return "© \(publisher)"
         case (nil, nil):
             return session.puzzle.copyright
         }
     }
 
     private var hasCredits: Bool {
         session.puzzle.author != nil || copyrightLine != nil
     }
 
     private var pages: [Page] {
         var result: [Page] = [.title]
         if showsScoreboard { result.append(.scoreboard) }
         result.append(.clock)
         if hasCredits { result.append(.credits) }
         return result
     }
 
     /// Above the default text size the clue bar below the grid grows to fit
     /// the (must-read) clue, squeezing the grid. The title/scoreboard/credits
     /// shown here are the least important text on screen, so the header yields
     /// its own height as type scales up — shedding a few points per step down
     /// to a legible-enough floor — and hands that space back to the grid. The
     /// text inside just truncates within the smaller box. At or below the
     /// default size the comfortable full height is preserved.
     private var headerHeight: CGFloat {
         let sizes = DynamicTypeSize.allCases
         guard let current = sizes.firstIndex(of: dynamicTypeSize),
               let baseline = sizes.firstIndex(of: .large)
         else { return 80 }
         let stepsAboveDefault = max(0, current - baseline)
         return max(48, 80 - CGFloat(stepsAboveDefault) * 6)
     }
 
     var body: some View {
         let visibleAnnouncement = isArmed
             ? announcements.current(forGame: gameID)
             : nil
         Group {
             // Title/scoreboard/credits is the baseline — it renders
             // immediately on open and stays put. After the open beat we
             // start reacting to announcements: the banner slides down
             // over the title and slides back out on dismissal. Both
             // branches occupy the same fixed-height frame so the grid
             // below doesn't jump.
             if let announcement = visibleAnnouncement {
                 AnnouncementBanner(
                     announcement: announcement,
                     fillsAvailableHeight: true,
                     // Over the puzzle grid the frosted material reads better than
                     // the solid grouped fill the Game List and archive use.
                     background: AnyShapeStyle(.regularMaterial)
                 ) {
                     announcements.dismiss(id: announcement.id)
                 }
                 .padding(.horizontal, 12)
                 .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .bottom)
                 .transition(.move(edge: .bottom).combined(with: .opacity))
             } else {
                 headerPages
                     .transition(.move(edge: .bottom).combined(with: .opacity))
             }
         }
         .frame(height: headerHeight)
         .padding(.bottom, 14)
         .animation(.easeInOut(duration: 0.3), value: visibleAnnouncement)
         .animation(.easeInOut(duration: 0.2), value: isEngagementLive)
         .onChange(of: selection) { _, _ in
             guard !isSelectingPageProgrammatically else { return }
             userSelectedPage = true
         }
         .task(id: autoRevealTaskID) {
             guard let autoRevealTaskID, autoRevealTaskID.shouldReveal else {
                 return
             }
             didAutoRevealScoreboard = false
             userSelectedPage = false
             try? await Task.sleep(for: .seconds(30))
             guard !Task.isCancelled,
                   showsScoreboard,
                   shouldAutoRevealScoreboard,
                   !userSelectedPage,
                   !didAutoRevealScoreboard
             else { return }
 
             isSelectingPageProgrammatically = true
             withAnimation(.easeInOut(duration: 0.35)) {
                 selection = .scoreboard
             }
             didAutoRevealScoreboard = true
             await Task.yield()
             isSelectingPageProgrammatically = false
         }
     }
 
     private struct AutoRevealTaskID: Equatable {
         let gameID: UUID
         let shouldReveal: Bool
     }
 
     private var autoRevealTaskID: AutoRevealTaskID? {
         AutoRevealTaskID(
             gameID: gameID,
             shouldReveal: showsScoreboard && shouldAutoRevealScoreboard
         )
     }
 
     private var headerPages: some View {
         VStack(spacing: 10) {
             TabView(selection: $selection) {
                 ForEach(pages, id: \.self) { page in
                     pageContent(page)
                         .tag(page)
                 }
             }
             .tabViewStyle(.page(indexDisplayMode: .never))
 
             if pages.count > 1 {
                 HStack(spacing: 6) {
                     ForEach(pages, id: \.self) { page in
                         Circle()
                             .fill(page == selection ? Color.secondary : Color.secondary.opacity(0.3))
                             .frame(width: 6, height: 6)
                     }
                 }
                 .animation(.easeInOut(duration: 0.2), value: selection)
             }
         }
     }
 
     @ViewBuilder
     private func pageContent(_ page: Page) -> some View {
         switch page {
         case .title:
             PuzzleTitle(title: title, subtitle: subtitle, isEngagementLive: isEngagementLive)
                 .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .bottom)
         case .scoreboard:
             PuzzleScoreboard(
                 session: session,
                 roster: roster,
                 layout: .horizontal,
                 onNudge: onNudge,
                 nudgeReadyAt: nudgeReadyAt
             )
                 .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .bottom)
         case .clock:
             PuzzleClock(roster: roster)
                 .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .bottom)
         case .credits:
             PuzzleCredits(author: session.puzzle.author, copyright: copyrightLine)
                 .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .bottom)
         }
     }
 }
 
 /// The solve-time clock page. Ticks once a second off `TimelineView`, re-reading
 /// the union of every player's active intervals so it counts up live and shows a
 /// co-solver's already-elapsed time the moment you join. Freezes automatically
 /// once the game is solved (the roster bounds the union at `completedAt`).
 private struct PuzzleClock: View {
     let roster: PlayerRoster
 
     var body: some View {
         TimelineView(.periodic(from: .now, by: 1)) { context in
             VStack(spacing: 2) {
                 Text(TimeLog.clockString(roster.solveTime(asOf: context.date)))
                     .font(.headline)
                     .monospacedDigit()
                     .contentTransition(.numericText())
                 Text("Solving Time")
                     .font(.footnote)
                     .foregroundStyle(.secondary)
             }
             .multilineTextAlignment(.center)
             .frame(maxWidth: .infinity)
             .padding(.horizontal)
         }
     }
 }
 
 private struct PuzzleTitle: View {
     let title: String
     let subtitle: String?
     let isEngagementLive: Bool
     @State private var showsEngagementIcon = false
 
     var body: some View {
         VStack(spacing: 2) {
             Text(title)
                 .font(.headline)
                 .lineLimit(2)
                 .overlay(alignment: .trailing) {
                     engagementIcon
                         .offset(x: 28)
                         .opacity(showsEngagementIcon ? 1 : 0)
                         .accessibilityLabel("Engagement live")
                         .accessibilityHidden(!showsEngagementIcon)
                 }
             if let subtitle {
                 Text(subtitle)
                     .font(.subheadline)
                     .foregroundStyle(.secondary)
                     .lineLimit(1)
             }
         }
         .multilineTextAlignment(.center)
         .frame(maxWidth: .infinity)
         .padding(.horizontal)
         .animation(.easeInOut(duration: 0.2), value: showsEngagementIcon)
         .onAppear {
             showsEngagementIcon = isEngagementLive
         }
         .onChange(of: isEngagementLive) { _, isLive in
             withAnimation(.easeInOut(duration: 0.2)) {
                 showsEngagementIcon = isLive
             }
         }
     }
 
     private var engagementIcon: some View {
         Image(systemName: "bolt.circle")
             .font(.headline)
             .foregroundStyle(.green)
             .symbolRenderingMode(.monochrome)
     }
 }
 
 private struct PuzzleCredits: View {
     let author: String?
     let copyright: String?
 
     var body: some View {
         VStack(spacing: 2) {
             if let author, !author.isEmpty {
                 Text("By \(author)")
                     .font(.subheadline)
                     .lineLimit(2)
             }
             if let copyright {
                 Text(copyright)
                     .font(.footnote)
                     .foregroundStyle(.secondary)
                     .lineLimit(2)
             }
         }
         .multilineTextAlignment(.center)
         .frame(maxWidth: .infinity)
         .padding(.horizontal)
     }
 }