crossmate

NewGameSheet.swift (5078B)

---

 import SwiftUI
 
 struct NewGameSheet: View {
     let store: GameStore
     var inviteTargetName: String? = nil
     var onCreated: (UUID) -> Void = { _ in }
 
     @Environment(\.dismiss) private var dismiss
     @Environment(EventLog.self) private var eventLog
     @AppStorage("lastPuzzleSource") private var selection: PuzzleSource = .bundles
     @State private var duplicateSource: String?
     @State private var createError: CreateError?
     /// Loaded once when the sheet appears rather than read inside `body`,
     /// which would re-run the fetch on every body evaluation.
     @State private var libraryDates: Set<Date> = []
 
     private struct CreateError: Identifiable {
         let id = UUID()
         let title: String
         let message: String
     }
 
     var body: some View {
         NavigationStack {
             VStack(spacing: 0) {
                 Picker("Source", selection: $selection) {
                     ForEach(PuzzleSource.allCases) { source in
                         Text(source.title).tag(source)
                     }
                 }
                 .pickerStyle(.segmented)
                 .padding()
 
                 Group {
                     switch selection {
                     case .bundles:
                         BundledBrowseView(onSelected: handleSelected)
                     case .imported:
                         ImportedBrowseView(onSelected: handleSelected)
                     case .external:
                         ExternalBrowseView(
                             onSelected: handleSelected,
                             libraryDates: libraryDates
                         )
                     }
                 }
             }
             .navigationTitle(navigationTitle)
             .navigationBarTitleDisplayMode(.inline)
             .onAppear {
                 libraryDates = store.nytPuzzleDatesInLibrary()
             }
             .toolbar {
                 ToolbarItem(placement: .cancellationAction) {
                     Button {
                         dismiss()
                     } label: {
                         Image(systemName: "xmark")
                     }
                     .accessibilityLabel("Cancel")
                 }
             }
         }
         .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 var navigationTitle: String {
         if let inviteTargetName, !inviteTargetName.isEmpty {
             "New Puzzle with \(inviteTargetName)"
         } else {
             "New Puzzle"
         }
     }
 
     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: " · ")
     }
 }