crossmate

NYTBrowseView.swift (8135B)

---

 import SwiftUI
 
 struct NYTBrowseView: View {
     let onSelected: (String) -> Void
 
     @Environment(\.nytPuzzleFetcher) private var fetcher
     @Environment(NYTAuthService.self) private var nytAuth
     @State private var displayedMonth: Date = NYTBrowseView.startOfCurrentMonth()
     @State private var selectedDate: Date?
     @State private var isLoading = false
     @State private var errorMessage: String?
     @State private var sessionExpired = false
 
     private static let nytTimeZone = TimeZone(identifier: "America/New_York")!
 
     private static var nytCalendar: Calendar {
         var cal = Calendar(identifier: .gregorian)
         cal.timeZone = nytTimeZone
         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 let columns: [GridItem] = Array(repeating: GridItem(.flexible(), spacing: 4), count: 7)
     private let weekdaySymbols = ["S", "M", "T", "W", "T", "F", "S"]
 
     var body: some View {
         VStack(spacing: 16) {
             monthHeader
             weekdayHeader
             dayGrid
             Spacer()
             confirmButton
         }
         .padding()
         .disabled(isLoading)
         .overlay {
             if isLoading {
                 ProgressView("Fetching puzzle…")
                     .padding()
                     .background(.regularMaterial, in: .rect(cornerRadius: 12))
             }
         }
         .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 monthHeader: some View {
         HStack {
             Button {
                 shiftMonth(by: -1)
             } label: {
                 Image(systemName: "chevron.left")
                     .font(.title3)
             }
             .disabled(!canGoBack)
 
             Spacer()
 
             Text(monthTitle)
                 .font(.headline)
 
             Spacer()
 
             Button {
                 shiftMonth(by: 1)
             } label: {
                 Image(systemName: "chevron.right")
                     .font(.title3)
             }
             .disabled(!canGoForward)
         }
     }
 
     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)
             }
         }
     }
 
     private var dayGrid: some View {
         LazyVGrid(columns: columns, spacing: 4) {
             ForEach(Array(gridCells.enumerated()), id: \.offset) { _, cell in
                 if let date = cell {
                     let cal = Self.nytCalendar
                     let dayNumber = cal.component(.day, from: date)
                     CalendarDayCell(
                         dayNumber: dayNumber,
                         isEnabled: isEnabled(date),
                         isToday: cal.isDateInToday(date),
                         isSelected: isSelected(date),
                         onTap: { selectedDate = date }
                     )
                 } else {
                     Color.clear.frame(minHeight: 44)
                 }
             }
         }
     }
 
     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 func isSelected(_ date: Date) -> Bool {
         guard let selectedDate else { return false }
         return Self.nytCalendar.isDate(date, inSameDayAs: selectedDate)
     }
 
     // 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 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?] {
         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 cells
         }
         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 % 7 != 0 { cells.append(nil) }
         return cells
     }
 
     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
             }
         }
     }
 }