crossmate

NewGameSheet.swift (5592B)

---

 import SwiftUI
 
 struct NewGameSheet: View {
     let store: GameStore
     var onCreated: (UUID) -> Void = { _ in }
 
     @Environment(\.dismiss) private var dismiss
     @Environment(NYTAuthService.self) private var nytAuth
     @Environment(EventLog.self) private var eventLog
     @AppStorage("lastPuzzleSource") private var storedSourceRaw = PuzzleSource.bundles.rawValue
     @AppStorage("debugMode") private var debugMode = false
     @State private var selection: PuzzleSource = .bundles
     @State private var duplicateSource: String?
     @State private var createError: CreateError?
 
     private struct CreateError: Identifiable {
         let id = UUID()
         let title: String
         let message: String
     }
 
     private var availableSources: [PuzzleSource] {
         var sources: [PuzzleSource] = [.bundles]
         if debugMode {
             sources.append(.debug)
         }
         sources.append(.imported)
         if nytAuth.canAttemptNYTFetch {
             sources.append(.nyt)
         }
         return sources
     }
 
     var body: some View {
         NavigationStack {
             VStack(spacing: 0) {
                 Picker("Source", selection: $selection) {
                     ForEach(availableSources) { source in
                         Text(source.title).tag(source)
                     }
                 }
                 .pickerStyle(.segmented)
                 .padding()
 
                 Group {
                     switch selection {
                     case .bundles:
                         BundledBrowseView(onSelected: handleSelected)
                     case .debug:
                         DebugBrowseView(onSelected: handleSelected)
                     case .imported:
                         ImportedBrowseView(onSelected: handleSelected)
                     case .nyt:
                         NYTBrowseView(
                             onSelected: handleSelected,
                             excludedDates: store.nytPuzzleDatesInLibrary()
                         )
                     }
                 }
             }
             .navigationTitle("New Puzzle")
             .navigationBarTitleDisplayMode(.inline)
             .toolbar {
                 ToolbarItem(placement: .cancellationAction) {
                     Button {
                         dismiss()
                     } label: {
                         Image(systemName: "xmark")
                     }
                     .accessibilityLabel("Cancel")
                 }
             }
         }
         .onAppear {
             // Fall back to .bundles if the stored raw value is missing or no
             // longer maps to a case (e.g. the renamed "bundled" -> "bundles").
             let stored = PuzzleSource(rawValue: storedSourceRaw) ?? .bundles
             selection = availableSources.contains(stored) ? stored : .bundles
         }
         .onChange(of: selection) { _, newValue in
             storedSourceRaw = newValue.rawValue
         }
         .alert(
             "Puzzle Already in Library",
             isPresented: .init(
                 get: { duplicateSource != nil },
                 set: { if !$0 { duplicateSource = nil } }
             ),
             presenting: duplicateSource
         ) { source in
             Button("Create Copy") {
                 create(from: source)
             }
             Button("Cancel", role: .cancel) {}
         } message: { _ in
             Text("You already have a copy of this puzzle in your library. Do you want to create a new copy?")
         }
         .alert(
             createError?.title ?? "Couldn't Create Puzzle",
             isPresented: .init(
                 get: { createError != nil },
                 set: { if !$0 { createError = nil } }
             ),
             presenting: createError
         ) { _ in
             Button("OK", role: .cancel) {}
         } message: { error in
             Text(error.message)
         }
     }
 
     private func handleSelected(_ source: String) {
         if store.findGameID(matching: source) != nil {
             duplicateSource = source
         } else {
             create(from: source)
         }
     }
 
     private func create(from source: String) {
         do {
             let gameID = try store.createGame(from: source)
             dismiss()
             onCreated(gameID)
         } catch let parseError as XD.ParseError {
             // Keep the alert plain-language and date-stamped; the specifics that
             // pin down the converter bug — which character, which clue — go to
             // the diagnostic log, which is what a tester actually shares back.
             let lead = XD.metadataValue("Date", in: source).map { "The puzzle for \($0)" } ?? "This puzzle"
             createError = CreateError(
                 title: "Could Not Parse Puzzle",
                 message: "\(lead) \(parseError.userFacingReason)."
             )
             eventLog.note(
                 "new puzzle parse failed [\(Self.puzzleDescriptor(from: source))]: \(parseError.description)",
                 level: "error"
             )
         } catch {
             createError = CreateError(title: "Couldn't Create Puzzle", message: error.localizedDescription)
         }
     }
 
     /// A compact one-line identification of the puzzle for the diagnostic log,
     /// built from whatever metadata headers survived in the raw source.
     private static func puzzleDescriptor(from source: String) -> String {
         let parts = ["Publisher", "Title", "Date"].compactMap { XD.metadataValue($0, in: source) }
         return parts.isEmpty ? "unknown puzzle" : parts.joined(separator: " · ")
     }
 }