crossmate

NYTBrowseView.swift (21009B)

---

 import SwiftUI
 
 struct NYTBrowseView: View {
     let onSelected: (String) -> Void
     /// NYT publication dates already in the local library. Marks those days in
     /// the grid, and keeps the random picker off puzzles already held.
     var libraryDates: Set<Date> = []
 
     @Environment(\.nytPuzzleFetcher) private var fetcher
     @Environment(NYTAuthService.self) private var nytAuth
     @State private var displayedMonth: Date = NYTBrowseView.startOfCurrentMonth()
     @State private var selectedDate: Date? = NYTBrowseView.today()
     @State private var isLoading = false
     @State private var errorMessage: String?
     @State private var sessionExpired = false
     @State private var showingMonthPicker = false
     @State private var pickerDate: Date = NYTBrowseView.startOfCurrentMonth()
     @State private var randomWeekday: Int? = nil
     @State private var randomYear: Int = NYTBrowseView.currentYear()
 
     private static let nytTimeZone = TimeZone(identifier: "America/New_York")!
 
     private static var nytCalendar: Calendar {
         var cal = Calendar(identifier: .gregorian)
         cal.timeZone = nytTimeZone
         // Without an explicit locale the calendar uses a "fixed" locale whose
         // weekdaySymbols are abbreviated ("Mon"); set the current locale so the
         // weekday menu shows full names.
         cal.locale = .current
         return cal
     }
 
     private static let minDate: Date = {
         var comps = DateComponents()
         comps.year = 2001
         comps.month = 1
         comps.day = 1
         return nytCalendar.date(from: comps)!
     }()
 
     private static func startOfCurrentMonth() -> Date {
         let cal = nytCalendar
         let comps = cal.dateComponents([.year, .month], from: Date())
         return cal.date(from: comps) ?? Date()
     }
 
     private static func today() -> Date {
         nytCalendar.startOfDay(for: Date())
     }
 
     private static func currentYear() -> Int {
         nytCalendar.component(.year, from: Date())
     }
 
     private static let selectableYears: [Int] = {
         let start = nytCalendar.component(.year, from: minDate)
         let end = nytCalendar.component(.year, from: Date())
         return Array(start...end)
     }()
 
     // Full weekday names (index 0 = Sunday) in the user's locale. Sourced from a
     // DateFormatter rather than nytCalendar, whose unset "fixed" locale yields
     // abbreviated symbols ("Mon").
     private static let fullWeekdaySymbols: [String] = {
         let formatter = DateFormatter()
         formatter.locale = .current
         return formatter.weekdaySymbols
     }()
 
     private static func weekdayName(_ weekday: Int) -> String {
         // weekday uses Gregorian numbering: 1 = Sunday … 7 = Saturday
         fullWeekdaySymbols[(weekday - 1) % fullWeekdaySymbols.count]
     }
 
     private static let shortWeekdaySymbols: [String] = {
         let formatter = DateFormatter()
         formatter.locale = .current
         return formatter.shortWeekdaySymbols
     }()
 
     private static func shortWeekdayName(_ weekday: Int) -> String {
         // weekday uses Gregorian numbering: 1 = Sunday … 7 = Saturday
         shortWeekdaySymbols[(weekday - 1) % shortWeekdaySymbols.count]
     }
 
     // Gregorian weekday numbers. The menu opens upward from the bottom-anchored
     // button, so the first declared item lands nearest the button (visually at
     // the bottom). Declaring Sunday → Monday here yields a top-to-bottom reading
     // of Monday … Sunday, with "Any Day" (declared first) pinned to the bottom.
     private static let weekdayMenuOrder = [1, 7, 6, 5, 4, 3, 2]
 
     private let weekdaySymbols = ["S", "M", "T", "W", "T", "F", "S"]
 
     /// Every month is laid out over six rows, so the grid neither jumps height
     /// as you page months nor overflows a fixed-height iPad form sheet in the
     /// months that genuinely need six.
     private static let gridRowCount = 6
 
     var body: some View {
         Group {
             switch nytAuth.sessionState {
             case .unknown:
                 unavailableSessionView
             case .signedIn:
                 browserView
             case .signedOut:
                 signedOutView
             }
         }
         .alert(
             "Couldn't Fetch Puzzle",
             isPresented: .init(
                 get: { errorMessage != nil },
                 set: { if !$0 { errorMessage = nil } }
             ),
             presenting: errorMessage
         ) { _ in
             Button("OK", role: .cancel) {}
         } message: { message in
             Text(message)
         }
         .alert("NYT Session Expired", isPresented: $sessionExpired) {
             Button("OK", role: .cancel) {
                 nytAuth.signOut()
             }
         } message: {
             Text("Your NYT session has expired. Sign in again from Settings to resume fetching puzzles.")
         }
     }
 
     private var browserView: some View {
         VStack(spacing: 16) {
             monthHeader
             weekdayHeader
             dayGrid
             confirmButton
             randomButton
         }
         .padding()
         .disabled(isLoading)
         .overlay {
             if isLoading {
                 ProgressView("Fetching puzzle…")
                     .padding()
                     .background(.regularMaterial, in: .rect(cornerRadius: 12))
             }
         }
     }
 
     private var unavailableSessionView: some View {
         VStack(spacing: 16) {
             Spacer()
             Image(systemName: "lock.rotation")
                 .font(.largeTitle)
                 .foregroundStyle(.secondary)
             Text(nytAuth.sessionStatusMessage ?? "Crossmate could not determine whether you are signed in to NYT.")
                 .font(.body)
                 .foregroundStyle(.secondary)
                 .multilineTextAlignment(.center)
             Button {
                 nytAuth.loadStoredSession()
             } label: {
                 Label("Try Again", systemImage: "arrow.clockwise")
                     .frame(maxWidth: .infinity)
             }
             .buttonStyle(.borderedProminent)
             .controlSize(.large)
             Spacer()
         }
         .padding()
     }
 
     private var signedOutView: some View {
         VStack(spacing: 16) {
             Spacer()
             Image(systemName: "person.crop.circle.badge.exclamationmark")
                 .font(.largeTitle)
                 .foregroundStyle(.secondary)
             Text("Set up an external puzzle provider in Settings to fetch crossword puzzles.")
                 .font(.body)
                 .foregroundStyle(.secondary)
                 .multilineTextAlignment(.center)
             Spacer()
         }
         .padding()
     }
 
     private var monthHeader: some View {
         HStack {
             Button {
                 shiftMonth(by: -1)
             } label: {
                 Image(systemName: "chevron.left")
                     .font(.title3)
             }
             .disabled(!canGoBack)
             .accessibilityLabel("Previous Month")
 
             Spacer()
 
             Button {
                 pickerDate = selectedDate ?? displayedMonth
                 showingMonthPicker = true
             } label: {
                 HStack(spacing: 4) {
                     Text(monthTitle)
                     Image(systemName: "chevron.down")
                         .font(.caption.weight(.semibold))
                 }
                 .font(.headline)
             }
             .buttonStyle(.plain)
             .accessibilityLabel("Choose Month")
             .accessibilityValue(monthTitle)
             .popover(isPresented: $showingMonthPicker) {
                 dateWheelPopover
                     .presentationCompactAdaptation(.popover)
             }
 
             Spacer()
 
             Button {
                 shiftMonth(by: 1)
             } label: {
                 Image(systemName: "chevron.right")
                     .font(.title3)
             }
             .disabled(!canGoForward)
             .accessibilityLabel("Next Month")
         }
     }
 
     private var weekdayHeader: some View {
         HStack(spacing: 0) {
             ForEach(Array(weekdaySymbols.enumerated()), id: \.offset) { _, symbol in
                 Text(symbol)
                     .font(.caption)
                     .foregroundStyle(.secondary)
                     .frame(maxWidth: .infinity)
             }
         }
     }
 
     /// The rows share whatever vertical space the sheet has left over, rather
     /// than each claiming a fixed height: on a roomy layout they sit at their
     /// natural size, and in a 620pt iPad form sheet they compress instead of
     /// pushing the buttons off the bottom.
     private var dayGrid: some View {
         Grid(horizontalSpacing: 4, verticalSpacing: 4) {
             ForEach(Array(gridRows.enumerated()), id: \.offset) { _, row in
                 GridRow {
                     ForEach(Array(row.enumerated()), id: \.offset) { _, cell in
                         if let date = cell {
                             let cal = Self.nytCalendar
                             let dayNumber = cal.component(.day, from: date)
                             CalendarDayCell(
                                 date: date,
                                 dayNumber: dayNumber,
                                 isEnabled: isEnabled(date),
                                 isToday: cal.isDateInToday(date),
                                 isSelected: isSelected(date),
                                 isInLibrary: isInLibrary(date),
                                 onTap: { selectedDate = date }
                             )
                         } else {
                             Color.clear
                         }
                     }
                 }
                 .frame(maxHeight: .infinity)
             }
         }
         .frame(maxHeight: .infinity)
     }
 
     private var confirmButton: some View {
         Button {
             if let selectedDate {
                 fetch(selectedDate)
             }
         } label: {
             Text(confirmButtonTitle)
                 .font(.headline)
                 .frame(maxWidth: .infinity)
         }
         .buttonStyle(.borderedProminent)
         .controlSize(.large)
         .disabled(selectedDate == nil)
     }
 
     private var confirmButtonTitle: String {
         guard let selectedDate else { return "Select a Date" }
         let style = Date.FormatStyle(
             date: .complete,
             time: .omitted,
             locale: .current,
             calendar: Self.nytCalendar,
             timeZone: Self.nytTimeZone
         )
         return "Start \(selectedDate.formatted(style))"
     }
 
     private var randomButton: some View {
         HStack(spacing: 12) {
             HStack(spacing: 4) {
                 Text("Random")
                     .accessibilityHidden(true)
                 weekdayMenu
                 Text("in")
                     .accessibilityHidden(true)
                 yearMenu
             }
             .font(.headline)
             .lineLimit(1)
             .minimumScaleFactor(0.7)
             .foregroundStyle(Self.randomButtonForeground)
             .frame(maxWidth: .infinity)
             .padding(.vertical, 14)
             .padding(.horizontal, 16)
             .background(Self.randomButtonConfigTint, in: .capsule)
 
             Button {
                 if let date = randomDate() {
                     fetch(date)
                 }
             } label: {
                 Image(systemName: "shuffle")
                     .font(.title3)
                     .foregroundStyle(Color.accentColor)
                     .frame(width: 52, height: 52)
                     .background(Self.randomButtonTint, in: .circle)
                     .contentShape(.circle)
             }
             .buttonStyle(.plain)
             .accessibilityLabel("Fetch Random Puzzle")
             .accessibilityValue(randomSelectionAccessibilityValue)
             .accessibilityHint("Creates a random puzzle using the selected day and year")
         }
     }
 
     private var randomSelectionAccessibilityValue: String {
         let day = randomWeekday.map(Self.weekdayName) ?? "Any Day"
         return "\(day), \(randomYear)"
     }
 
     private static let randomButtonTint = Color.accentColor.opacity(0.15)
     private static let randomButtonConfigTint = Color(.tertiarySystemFill)
     private static let randomButtonForeground = Color.primary
 
     private var weekdayMenu: some View {
         Menu {
             Button("Any Day") { randomWeekday = nil }
             ForEach(Self.weekdayMenuOrder, id: \.self) { weekday in
                 Button(Self.weekdayName(weekday)) { randomWeekday = weekday }
             }
         } label: {
             menuLabel(
                 randomWeekday.map(Self.shortWeekdayName) ?? "day",
                 reservingWidthFor: Self.weekdayMenuLabelOptions
             )
         }
         .accessibilityLabel("Random Day")
         .accessibilityValue(randomWeekday.map(Self.weekdayName) ?? "Any Day")
         .accessibilityHint("Chooses the weekday for random puzzles")
     }
 
     private var yearMenu: some View {
         Menu {
             ForEach(Self.selectableYears.reversed(), id: \.self) { year in
                 Button(String(year)) { randomYear = year }
             }
         } label: {
             menuLabel(String(randomYear))
         }
         .accessibilityLabel("Random Year")
         .accessibilityValue(String(randomYear))
         .accessibilityHint("Chooses the year for random puzzles")
     }
 
     private static var weekdayMenuLabelOptions: [String] {
         ["day"] + weekdayMenuOrder.map(shortWeekdayName)
     }
 
     private func menuLabel(_ text: String, reservingWidthFor options: [String] = []) -> some View {
         HStack(spacing: 2) {
             ZStack {
                 ForEach(options, id: \.self) { option in
                     Text(option)
                         .hidden()
                 }
                 Text(text)
             }
             Image(systemName: "chevron.down")
                 .font(.caption2.weight(.bold))
                 .foregroundStyle(Color.accentColor)
         }
         .foregroundStyle(Self.randomButtonForeground)
     }
 
     /// Picks a random valid puzzle date in `randomYear`, optionally constrained to
     /// `randomWeekday`, clamped to the supported range (>= minDate, <= today).
     private func randomDate() -> Date? {
         let cal = Self.nytCalendar
         let minStart = cal.startOfDay(for: Self.minDate)
         let todayStart = cal.startOfDay(for: Date())
 
         var startComps = DateComponents()
         startComps.year = randomYear
         startComps.month = 1
         startComps.day = 1
         var endComps = DateComponents()
         endComps.year = randomYear
         endComps.month = 12
         endComps.day = 31
         guard let yearStart = cal.date(from: startComps),
               let yearEnd = cal.date(from: endComps) else { return nil }
 
         let lower = max(cal.startOfDay(for: yearStart), minStart)
         let upper = min(cal.startOfDay(for: yearEnd), todayStart)
         guard lower <= upper else { return nil }
 
         var candidates: [Date] = []
         var day = lower
         while day <= upper {
             let matchesWeekday = randomWeekday.map { cal.component(.weekday, from: day) == $0 } ?? true
             if matchesWeekday {
                 let dayStart = cal.startOfDay(for: day)
                 if !libraryDates.contains(dayStart) {
                     candidates.append(dayStart)
                 }
             }
             guard let next = cal.date(byAdding: .day, value: 1, to: day) else { break }
             day = next
         }
         return candidates.randomElement()
     }
 
     private var dateWheelPopover: some View {
         VStack(spacing: 28) {
             HStack {
                 Button(role: .cancel) {
                     showingMonthPicker = false
                 } label: {
                     Image(systemName: "xmark")
                 }
                 .accessibilityLabel("Cancel")
 
                 Spacer()
 
                 Button {
                     selectedDate = pickerDate
                     displayedMonth = startOfMonth(for: pickerDate)
                     showingMonthPicker = false
                 } label: {
                     Image(systemName: "checkmark")
                 }
                 .buttonStyle(.borderedProminent)
                 .accessibilityLabel("Done")
             }
 
             DatePicker(
                 "Puzzle Date",
                 selection: $pickerDate,
                 in: Self.minDate...Date(),
                 displayedComponents: .date
             )
             .datePickerStyle(.wheel)
             .labelsHidden()
             .environment(\.calendar, Self.nytCalendar)
             .environment(\.timeZone, Self.nytTimeZone)
             .frame(width: 320, height: 160)
             .clipped()
         }
         .padding(.horizontal)
         .padding(.vertical, 8)
     }
 
     private func isSelected(_ date: Date) -> Bool {
         guard let selectedDate else { return false }
         return Self.nytCalendar.isDate(date, inSameDayAs: selectedDate)
     }
 
     /// Grid cells are already NY midnight, as are the stored publication dates
     /// the set is built from, but normalise anyway so the lookup can't be
     /// broken by a legacy row that landed on some other time of day.
     private func isInLibrary(_ date: Date) -> Bool {
         libraryDates.contains(Self.nytCalendar.startOfDay(for: date))
     }
 
     // MARK: - Month navigation
 
     private func shiftMonth(by delta: Int) {
         let cal = Self.nytCalendar
         if let next = cal.date(byAdding: .month, value: delta, to: displayedMonth) {
             displayedMonth = next
         }
     }
 
     private func startOfMonth(for date: Date) -> Date {
         let cal = Self.nytCalendar
         let components = cal.dateComponents([.year, .month], from: date)
         return cal.date(from: components) ?? date
     }
 
     private var monthTitle: String {
         let formatter = DateFormatter()
         formatter.calendar = Self.nytCalendar
         formatter.timeZone = Self.nytTimeZone
         formatter.dateFormat = "MMMM yyyy"
         return formatter.string(from: displayedMonth)
     }
 
     private var canGoBack: Bool {
         let cal = Self.nytCalendar
         let minMonth = cal.dateComponents([.year, .month], from: Self.minDate)
         let current = cal.dateComponents([.year, .month], from: displayedMonth)
         guard let cy = current.year, let cm = current.month,
               let my = minMonth.year, let mm = minMonth.month else { return false }
         return (cy, cm) > (my, mm)
     }
 
     private var canGoForward: Bool {
         let cal = Self.nytCalendar
         let today = cal.dateComponents([.year, .month], from: Date())
         let current = cal.dateComponents([.year, .month], from: displayedMonth)
         guard let cy = current.year, let cm = current.month,
               let ty = today.year, let tm = today.month else { return false }
         return (cy, cm) < (ty, tm)
     }
 
     // MARK: - Grid
 
     private var gridCells: [Date?] {
         let cellCount = Self.gridRowCount * 7
         var cells: [Date?] = []
         let cal = Self.nytCalendar
         let monthComps = cal.dateComponents([.year, .month], from: displayedMonth)
         guard let firstOfMonth = cal.date(from: monthComps),
               let range = cal.range(of: .day, in: .month, for: firstOfMonth) else {
             return Array(repeating: nil, count: cellCount)
         }
         let firstWeekday = cal.component(.weekday, from: firstOfMonth)
         let leadingBlanks = firstWeekday - 1
         for _ in 0..<leadingBlanks { cells.append(nil) }
         for day in range {
             cells.append(cal.date(byAdding: .day, value: day - 1, to: firstOfMonth))
         }
         while cells.count < cellCount { cells.append(nil) }
         return cells
     }
 
     private var gridRows: [[Date?]] {
         let cells = gridCells
         return stride(from: 0, to: cells.count, by: 7).map { start in
             Array(cells[start..<(start + 7)])
         }
     }
 
     private func isEnabled(_ date: Date) -> Bool {
         let cal = Self.nytCalendar
         let dayStart = cal.startOfDay(for: date)
         let minDayStart = cal.startOfDay(for: Self.minDate)
         let todayStart = cal.startOfDay(for: Date())
         return dayStart >= minDayStart && dayStart <= todayStart
     }
 
     // MARK: - Fetch
 
     private func fetch(_ date: Date) {
         guard let fetcher else {
             errorMessage = "Puzzle fetcher unavailable."
             return
         }
         isLoading = true
         Task { @MainActor in
             defer { isLoading = false }
             do {
                 let source = try await fetcher.fetchPuzzle(for: date)
                 onSelected(source)
             } catch NYTFetchError.unauthorized {
                 sessionExpired = true
             } catch {
                 errorMessage = error.localizedDescription
             }
         }
     }
 }