Crossmate/Views/Browse/NYTBrowseView.swift (21009B)
1import SwiftUI
2
3struct NYTBrowseView: View {
4 let onSelected: (String) -> Void
5
6
7 var libraryDates: Set<Date> = []
8
9 @Environment(\.nytPuzzleFetcher) private var fetcher
10 @Environment(NYTAuthService.self) private var nytAuth
11 @State private var displayedMonth: Date = NYTBrowseView.startOfCurrentMonth()
12 @State private var selectedDate: Date? = NYTBrowseView.today()
13 @State private var isLoading = false
14 @State private var errorMessage: String?
15 @State private var sessionExpired = false
16 @State private var showingMonthPicker = false
17 @State private var pickerDate: Date = NYTBrowseView.startOfCurrentMonth()
18 @State private var randomWeekday: Int? = nil
19 @State private var randomYear: Int = NYTBrowseView.currentYear()
20
21 private static let nytTimeZone = TimeZone(identifier: "America/New_York")!
22
23 private static var nytCalendar: Calendar {
24 var cal = Calendar(identifier: .gregorian)
25 cal.timeZone = nytTimeZone
26
27
28
29 cal.locale = .current
30 return cal
31 }
32
33 private static let minDate: Date = {
34 var comps = DateComponents()
35 comps.year = 2001
36 comps.month = 1
37 comps.day = 1
38 return nytCalendar.date(from: comps)!
39 }()
40
41 private static func startOfCurrentMonth() -> Date {
42 let cal = nytCalendar
43 let comps = cal.dateComponents([.year, .month], from: Date())
44 return cal.date(from: comps) ?? Date()
45 }
46
47 private static func today() -> Date {
48 nytCalendar.startOfDay(for: Date())
49 }
50
51 private static func currentYear() -> Int {
52 nytCalendar.component(.year, from: Date())
53 }
54
55 private static let selectableYears: [Int] = {
56 let start = nytCalendar.component(.year, from: minDate)
57 let end = nytCalendar.component(.year, from: Date())
58 return Array(start...end)
59 }()
60
61
62
63
64 private static let fullWeekdaySymbols: [String] = {
65 let formatter = DateFormatter()
66 formatter.locale = .current
67 return formatter.weekdaySymbols
68 }()
69
70 private static func weekdayName(_ weekday: Int) -> String {
71
72 fullWeekdaySymbols[(weekday - 1) % fullWeekdaySymbols.count]
73 }
74
75 private static let shortWeekdaySymbols: [String] = {
76 let formatter = DateFormatter()
77 formatter.locale = .current
78 return formatter.shortWeekdaySymbols
79 }()
80
81 private static func shortWeekdayName(_ weekday: Int) -> String {
82
83 shortWeekdaySymbols[(weekday - 1) % shortWeekdaySymbols.count]
84 }
85
86
87
88
89
90 private static let weekdayMenuOrder = [1, 7, 6, 5, 4, 3, 2]
91
92 private let weekdaySymbols = ["S", "M", "T", "W", "T", "F", "S"]
93
94
95
96
97 private static let gridRowCount = 6
98
99 var body: some View {
100 Group {
101 switch nytAuth.sessionState {
102 case .unknown:
103 unavailableSessionView
104 case .signedIn:
105 browserView
106 case .signedOut:
107 signedOutView
108 }
109 }
110 .alert(
111 "Couldn't Fetch Puzzle",
112 isPresented: .init(
113 get: { errorMessage != nil },
114 set: { if !$0 { errorMessage = nil } }
115 ),
116 presenting: errorMessage
117 ) { _ in
118 Button("OK", role: .cancel) {}
119 } message: { message in
120 Text(message)
121 }
122 .alert("NYT Session Expired", isPresented: $sessionExpired) {
123 Button("OK", role: .cancel) {
124 nytAuth.signOut()
125 }
126 } message: {
127 Text("Your NYT session has expired. Sign in again from Settings to resume fetching puzzles.")
128 }
129 }
130
131 private var browserView: some View {
132 VStack(spacing: 16) {
133 monthHeader
134 weekdayHeader
135 dayGrid
136 confirmButton
137 randomButton
138 }
139 .padding()
140 .disabled(isLoading)
141 .overlay {
142 if isLoading {
143 ProgressView("Fetching puzzle…")
144 .padding()
145 .background(.regularMaterial, in: .rect(cornerRadius: 12))
146 }
147 }
148 }
149
150 private var unavailableSessionView: some View {
151 VStack(spacing: 16) {
152 Spacer()
153 Image(systemName: "lock.rotation")
154 .font(.largeTitle)
155 .foregroundStyle(.secondary)
156 Text(nytAuth.sessionStatusMessage ?? "Crossmate could not determine whether you are signed in to NYT.")
157 .font(.body)
158 .foregroundStyle(.secondary)
159 .multilineTextAlignment(.center)
160 Button {
161 nytAuth.loadStoredSession()
162 } label: {
163 Label("Try Again", systemImage: "arrow.clockwise")
164 .frame(maxWidth: .infinity)
165 }
166 .buttonStyle(.borderedProminent)
167 .controlSize(.large)
168 Spacer()
169 }
170 .padding()
171 }
172
173 private var signedOutView: some View {
174 VStack(spacing: 16) {
175 Spacer()
176 Image(systemName: "person.crop.circle.badge.exclamationmark")
177 .font(.largeTitle)
178 .foregroundStyle(.secondary)
179 Text("Set up an external puzzle provider in Settings to fetch crossword puzzles.")
180 .font(.body)
181 .foregroundStyle(.secondary)
182 .multilineTextAlignment(.center)
183 Spacer()
184 }
185 .padding()
186 }
187
188 private var monthHeader: some View {
189 HStack {
190 Button {
191 shiftMonth(by: -1)
192 } label: {
193 Image(systemName: "chevron.left")
194 .font(.title3)
195 }
196 .disabled(!canGoBack)
197 .accessibilityLabel("Previous Month")
198
199 Spacer()
200
201 Button {
202 pickerDate = selectedDate ?? displayedMonth
203 showingMonthPicker = true
204 } label: {
205 HStack(spacing: 4) {
206 Text(monthTitle)
207 Image(systemName: "chevron.down")
208 .font(.caption.weight(.semibold))
209 }
210 .font(.headline)
211 }
212 .buttonStyle(.plain)
213 .accessibilityLabel("Choose Month")
214 .accessibilityValue(monthTitle)
215 .popover(isPresented: $showingMonthPicker) {
216 dateWheelPopover
217 .presentationCompactAdaptation(.popover)
218 }
219
220 Spacer()
221
222 Button {
223 shiftMonth(by: 1)
224 } label: {
225 Image(systemName: "chevron.right")
226 .font(.title3)
227 }
228 .disabled(!canGoForward)
229 .accessibilityLabel("Next Month")
230 }
231 }
232
233 private var weekdayHeader: some View {
234 HStack(spacing: 0) {
235 ForEach(Array(weekdaySymbols.enumerated()), id: \.offset) { _, symbol in
236 Text(symbol)
237 .font(.caption)
238 .foregroundStyle(.secondary)
239 .frame(maxWidth: .infinity)
240 }
241 }
242 }
243
244
245
246
247
248 private var dayGrid: some View {
249 Grid(horizontalSpacing: 4, verticalSpacing: 4) {
250 ForEach(Array(gridRows.enumerated()), id: \.offset) { _, row in
251 GridRow {
252 ForEach(Array(row.enumerated()), id: \.offset) { _, cell in
253 if let date = cell {
254 let cal = Self.nytCalendar
255 let dayNumber = cal.component(.day, from: date)
256 CalendarDayCell(
257 date: date,
258 dayNumber: dayNumber,
259 isEnabled: isEnabled(date),
260 isToday: cal.isDateInToday(date),
261 isSelected: isSelected(date),
262 isInLibrary: isInLibrary(date),
263 onTap: { selectedDate = date }
264 )
265 } else {
266 Color.clear
267 }
268 }
269 }
270 .frame(maxHeight: .infinity)
271 }
272 }
273 .frame(maxHeight: .infinity)
274 }
275
276 private var confirmButton: some View {
277 Button {
278 if let selectedDate {
279 fetch(selectedDate)
280 }
281 } label: {
282 Text(confirmButtonTitle)
283 .font(.headline)
284 .frame(maxWidth: .infinity)
285 }
286 .buttonStyle(.borderedProminent)
287 .controlSize(.large)
288 .disabled(selectedDate == nil)
289 }
290
291 private var confirmButtonTitle: String {
292 guard let selectedDate else { return "Select a Date" }
293 let style = Date.FormatStyle(
294 date: .complete,
295 time: .omitted,
296 locale: .current,
297 calendar: Self.nytCalendar,
298 timeZone: Self.nytTimeZone
299 )
300 return "Start \(selectedDate.formatted(style))"
301 }
302
303 private var randomButton: some View {
304 HStack(spacing: 12) {
305 HStack(spacing: 4) {
306 Text("Random")
307 .accessibilityHidden(true)
308 weekdayMenu
309 Text("in")
310 .accessibilityHidden(true)
311 yearMenu
312 }
313 .font(.headline)
314 .lineLimit(1)
315 .minimumScaleFactor(0.7)
316 .foregroundStyle(Self.randomButtonForeground)
317 .frame(maxWidth: .infinity)
318 .padding(.vertical, 14)
319 .padding(.horizontal, 16)
320 .background(Self.randomButtonConfigTint, in: .capsule)
321
322 Button {
323 if let date = randomDate() {
324 fetch(date)
325 }
326 } label: {
327 Image(systemName: "shuffle")
328 .font(.title3)
329 .foregroundStyle(Color.accentColor)
330 .frame(width: 52, height: 52)
331 .background(Self.randomButtonTint, in: .circle)
332 .contentShape(.circle)
333 }
334 .buttonStyle(.plain)
335 .accessibilityLabel("Fetch Random Puzzle")
336 .accessibilityValue(randomSelectionAccessibilityValue)
337 .accessibilityHint("Creates a random puzzle using the selected day and year")
338 }
339 }
340
341 private var randomSelectionAccessibilityValue: String {
342 let day = randomWeekday.map(Self.weekdayName) ?? "Any Day"
343 return "\(day), \(randomYear)"
344 }
345
346 private static let randomButtonTint = Color.accentColor.opacity(0.15)
347 private static let randomButtonConfigTint = Color(.tertiarySystemFill)
348 private static let randomButtonForeground = Color.primary
349
350 private var weekdayMenu: some View {
351 Menu {
352 Button("Any Day") { randomWeekday = nil }
353 ForEach(Self.weekdayMenuOrder, id: \.self) { weekday in
354 Button(Self.weekdayName(weekday)) { randomWeekday = weekday }
355 }
356 } label: {
357 menuLabel(
358 randomWeekday.map(Self.shortWeekdayName) ?? "day",
359 reservingWidthFor: Self.weekdayMenuLabelOptions
360 )
361 }
362 .accessibilityLabel("Random Day")
363 .accessibilityValue(randomWeekday.map(Self.weekdayName) ?? "Any Day")
364 .accessibilityHint("Chooses the weekday for random puzzles")
365 }
366
367 private var yearMenu: some View {
368 Menu {
369 ForEach(Self.selectableYears.reversed(), id: \.self) { year in
370 Button(String(year)) { randomYear = year }
371 }
372 } label: {
373 menuLabel(String(randomYear))
374 }
375 .accessibilityLabel("Random Year")
376 .accessibilityValue(String(randomYear))
377 .accessibilityHint("Chooses the year for random puzzles")
378 }
379
380 private static var weekdayMenuLabelOptions: [String] {
381 ["day"] + weekdayMenuOrder.map(shortWeekdayName)
382 }
383
384 private func menuLabel(_ text: String, reservingWidthFor options: [String] = []) -> some View {
385 HStack(spacing: 2) {
386 ZStack {
387 ForEach(options, id: \.self) { option in
388 Text(option)
389 .hidden()
390 }
391 Text(text)
392 }
393 Image(systemName: "chevron.down")
394 .font(.caption2.weight(.bold))
395 .foregroundStyle(Color.accentColor)
396 }
397 .foregroundStyle(Self.randomButtonForeground)
398 }
399
400
401
402 private func randomDate() -> Date? {
403 let cal = Self.nytCalendar
404 let minStart = cal.startOfDay(for: Self.minDate)
405 let todayStart = cal.startOfDay(for: Date())
406
407 var startComps = DateComponents()
408 startComps.year = randomYear
409 startComps.month = 1
410 startComps.day = 1
411 var endComps = DateComponents()
412 endComps.year = randomYear
413 endComps.month = 12
414 endComps.day = 31
415 guard let yearStart = cal.date(from: startComps),
416 let yearEnd = cal.date(from: endComps) else { return nil }
417
418 let lower = max(cal.startOfDay(for: yearStart), minStart)
419 let upper = min(cal.startOfDay(for: yearEnd), todayStart)
420 guard lower <= upper else { return nil }
421
422 var candidates: [Date] = []
423 var day = lower
424 while day <= upper {
425 let matchesWeekday = randomWeekday.map { cal.component(.weekday, from: day) == $0 } ?? true
426 if matchesWeekday {
427 let dayStart = cal.startOfDay(for: day)
428 if !libraryDates.contains(dayStart) {
429 candidates.append(dayStart)
430 }
431 }
432 guard let next = cal.date(byAdding: .day, value: 1, to: day) else { break }
433 day = next
434 }
435 return candidates.randomElement()
436 }
437
438 private var dateWheelPopover: some View {
439 VStack(spacing: 28) {
440 HStack {
441 Button(role: .cancel) {
442 showingMonthPicker = false
443 } label: {
444 Image(systemName: "xmark")
445 }
446 .accessibilityLabel("Cancel")
447
448 Spacer()
449
450 Button {
451 selectedDate = pickerDate
452 displayedMonth = startOfMonth(for: pickerDate)
453 showingMonthPicker = false
454 } label: {
455 Image(systemName: "checkmark")
456 }
457 .buttonStyle(.borderedProminent)
458 .accessibilityLabel("Done")
459 }
460
461 DatePicker(
462 "Puzzle Date",
463 selection: $pickerDate,
464 in: Self.minDate...Date(),
465 displayedComponents: .date
466 )
467 .datePickerStyle(.wheel)
468 .labelsHidden()
469 .environment(\.calendar, Self.nytCalendar)
470 .environment(\.timeZone, Self.nytTimeZone)
471 .frame(width: 320, height: 160)
472 .clipped()
473 }
474 .padding(.horizontal)
475 .padding(.vertical, 8)
476 }
477
478 private func isSelected(_ date: Date) -> Bool {
479 guard let selectedDate else { return false }
480 return Self.nytCalendar.isDate(date, inSameDayAs: selectedDate)
481 }
482
483
484
485
486 private func isInLibrary(_ date: Date) -> Bool {
487 libraryDates.contains(Self.nytCalendar.startOfDay(for: date))
488 }
489
490
491
492 private func shiftMonth(by delta: Int) {
493 let cal = Self.nytCalendar
494 if let next = cal.date(byAdding: .month, value: delta, to: displayedMonth) {
495 displayedMonth = next
496 }
497 }
498
499 private func startOfMonth(for date: Date) -> Date {
500 let cal = Self.nytCalendar
501 let components = cal.dateComponents([.year, .month], from: date)
502 return cal.date(from: components) ?? date
503 }
504
505 private var monthTitle: String {
506 let formatter = DateFormatter()
507 formatter.calendar = Self.nytCalendar
508 formatter.timeZone = Self.nytTimeZone
509 formatter.dateFormat = "MMMM yyyy"
510 return formatter.string(from: displayedMonth)
511 }
512
513 private var canGoBack: Bool {
514 let cal = Self.nytCalendar
515 let minMonth = cal.dateComponents([.year, .month], from: Self.minDate)
516 let current = cal.dateComponents([.year, .month], from: displayedMonth)
517 guard let cy = current.year, let cm = current.month,
518 let my = minMonth.year, let mm = minMonth.month else { return false }
519 return (cy, cm) > (my, mm)
520 }
521
522 private var canGoForward: Bool {
523 let cal = Self.nytCalendar
524 let today = cal.dateComponents([.year, .month], from: Date())
525 let current = cal.dateComponents([.year, .month], from: displayedMonth)
526 guard let cy = current.year, let cm = current.month,
527 let ty = today.year, let tm = today.month else { return false }
528 return (cy, cm) < (ty, tm)
529 }
530
531
532
533 private var gridCells: [Date?] {
534 let cellCount = Self.gridRowCount * 7
535 var cells: [Date?] = []
536 let cal = Self.nytCalendar
537 let monthComps = cal.dateComponents([.year, .month], from: displayedMonth)
538 guard let firstOfMonth = cal.date(from: monthComps),
539 let range = cal.range(of: .day, in: .month, for: firstOfMonth) else {
540 return Array(repeating: nil, count: cellCount)
541 }
542 let firstWeekday = cal.component(.weekday, from: firstOfMonth)
543 let leadingBlanks = firstWeekday - 1
544 for _ in 0..<leadingBlanks { cells.append(nil) }
545 for day in range {
546 cells.append(cal.date(byAdding: .day, value: day - 1, to: firstOfMonth))
547 }
548 while cells.count < cellCount { cells.append(nil) }
549 return cells
550 }
551
552 private var gridRows: [[Date?]] {
553 let cells = gridCells
554 return stride(from: 0, to: cells.count, by: 7).map { start in
555 Array(cells[start..<(start + 7)])
556 }
557 }
558
559 private func isEnabled(_ date: Date) -> Bool {
560 let cal = Self.nytCalendar
561 let dayStart = cal.startOfDay(for: date)
562 let minDayStart = cal.startOfDay(for: Self.minDate)
563 let todayStart = cal.startOfDay(for: Date())
564 return dayStart >= minDayStart && dayStart <= todayStart
565 }
566
567
568
569 private func fetch(_ date: Date) {
570 guard let fetcher else {
571 errorMessage = "Puzzle fetcher unavailable."
572 return
573 }
574 isLoading = true
575 Task { @MainActor in
576 defer { isLoading = false }
577 do {
578 let source = try await fetcher.fetchPuzzle(for: date)
579 onSelected(source)
580 } catch NYTFetchError.unauthorized {
581 sessionExpired = true
582 } catch {
583 errorMessage = error.localizedDescription
584 }
585 }
586 }
587}