crossmate

SettingsView.swift (14404B)

---

 import CoreData
 import SwiftUI
 
 struct SettingsView: View {
     @Environment(NYTAuthService.self) private var nytAuth
     @Environment(PlayerPreferences.self) private var preferences
     @Environment(\.dismiss) private var dismiss
     @Environment(\.appActions) private var appActions
 
     @AppStorage("debugMode") private var debugMode = false
     @State private var showingNYTLogin = false
     @State private var showResetConfirmation = false
     @State private var externalSource: ExternalSource?
     @State private var easterEggTaps = 0
 
     var body: some View {
         @Bindable var preferences = preferences
         NavigationStack {
             Form {
                 Section {
                     NavigationLink {
                         ProfileNameEditView()
                     } label: {
                         HStack {
                             Text("Name")
                             Spacer()
                             Text(preferences.name)
                                 .foregroundStyle(.secondary)
                                 .lineLimit(1)
                         }
                     }
 
                     NavigationLink {
                         ProfileColorEditView()
                     } label: {
                         HStack {
                             Text("Colour")
                             Spacer()
                             colorSwatch(preferences.color)
                         }
                     }
                 } header: {
                     Text("Profile")
                 }
 
                 Section("External Source") {
                     Picker("Publisher", selection: $externalSource) {
                         Text("None").tag(nil as ExternalSource?)
                         ForEach(ExternalSource.allCases) { source in
                             Text(source.title).tag(source as ExternalSource?)
                         }
                     }
                     .pickerStyle(.menu)
 
                     switch externalSource {
                     case nil:
                         EmptyView()
                     case .newYorkTimes:
                         switch nytAuth.sessionState {
                         case .signedIn:
                             signedInView
                         case .signedOut:
                             signInView
                         case .unknown:
                             unknownSessionView
                         }
                     }
                 }
 
                 MovementSettingsSection(preferences: preferences)
 
                 Section {
                     Toggle("Nudges", isOn: $preferences.notifiesNudges)
                     Toggle("Pauses", isOn: $preferences.notifiesPauses)
                     Toggle("Invitations", isOn: $preferences.notifiesInvitations)
                     Toggle("Joins", isOn: $preferences.notifiesJoins)
                     Toggle("Completions", isOn: $preferences.notifiesCompletions)
                 } header: {
                     Text("Notifications")
                 } footer: {
                     Text("Notification settings apply only to this device.")
                 }
 
                 Section("Sharing") {
                     NavigationLink("Blocked Users") {
                         BlockedUsersView()
                     }
                 }
 
                 if debugMode {
                     Section("Debugging") {
                         Toggle("Enable iCloud Sync", isOn: $preferences.isICloudSyncEnabled)
 
                         NavigationLink("Diagnostics Log") {
                             DiagnosticsView()
                         }
 
                         Button("Reset Database", role: .destructive) {
                             showResetConfirmation = true
                         }
                         .alert(
                             "Delete All Puzzles?",
                             isPresented: $showResetConfirmation
                         ) {
                             Button("Delete All Puzzles", role: .destructive) {
                                 Task { await appActions?.resetDatabase() }
                             }
                             Button("Cancel", role: .cancel) {}
                         } message: {
                             Text("This removes every puzzle and clears the sync state on this device. Puzzles on other devices and in iCloud are not affected.")
                         }
                     }
                 }
 
                 Section {
                     NavigationLink("Tips") {
                         TipsArchive()
                     }
                     NavigationLink("About") {
                         AboutView()
                     }
                 } footer: {
                     Text("Made in Tokyo from natural ones and zeros")
                         .frame(maxWidth: .infinity)
                         .multilineTextAlignment(.center)
                         .padding(.vertical, 24)
                         .onTapGesture {
                             easterEggTaps += 1
                             if easterEggTaps >= 4 {
                                 debugMode.toggle()
                                 easterEggTaps = 0
                             }
                         }
                 }
             }
             .navigationTitle("Settings")
             .navigationBarTitleDisplayMode(.inline)
             .toolbar {
                 ToolbarItem(placement: .cancellationAction) {
                     Button {
                         dismiss()
                     } label: {
                         Image(systemName: "xmark")
                     }
                     .accessibilityLabel("Cancel")
                 }
             }
             .sheet(isPresented: $showingNYTLogin) {
                 NYTLoginView()
             }
             .onAppear {
                 if externalSource == nil, nytAuth.canAttemptNYTFetch {
                     externalSource = .newYorkTimes
                 }
             }
         }
     }
 
     // MARK: - Subviews
 
     private func colorSwatch(_ color: PlayerColor) -> some View {
         Circle()
             .fill(color.tint)
             .frame(width: 20, height: 20)
     }
 
     private enum ExternalSource: String, CaseIterable, Identifiable {
         case newYorkTimes
 
         var id: String { rawValue }
 
         var title: String {
             switch self {
             case .newYorkTimes: "New York Times"
             }
         }
     }
 
     @ViewBuilder
     private var signedInView: some View {
         if let email = nytAuth.signedInEmail {
             LabeledContent("E-mail", value: email)
         } else {
             LabeledContent("Status", value: "Signed in")
         }
         Button("Sign Out", role: .destructive) {
             nytAuth.signOut()
         }
     }
 
     @ViewBuilder
     private var signInView: some View {
         if let errorMessage = nytAuth.errorMessage {
             Text(errorMessage)
                 .foregroundStyle(.red)
                 .font(.caption)
         }
         Button("Sign In with NYT") {
             showingNYTLogin = true
         }
     }
 
     @ViewBuilder
     private var unknownSessionView: some View {
         if let message = nytAuth.sessionStatusMessage {
             Text(message)
                 .foregroundStyle(.secondary)
                 .font(.caption)
         }
         Button {
             nytAuth.loadStoredSession()
         } label: {
             Label("Try Again", systemImage: "arrow.clockwise")
         }
     }
 }
 
 private struct MovementSettingsSection: View {
     @Bindable var preferences: PlayerPreferences
 
     var body: some View {
         Section {
             Toggle("Skip Filled Squares", isOn: $preferences.skipsFilledCells)
             VStack(alignment: .leading, spacing: 2) {
                 HStack(alignment: .firstTextBaseline, spacing: 12) {
                     Text("After Last Fill")
                         .frame(maxWidth: .infinity, alignment: .leading)
                         .fixedSize(horizontal: false, vertical: true)
 
                     Picker("After Last Fill", selection: $preferences.answerEndMovement) {
                         Text("Do Nothing")
                             .tag(PlayerPreferences.AnswerEndMovement.doNothing)
                         Text("Wrap in Current Answer")
                             .tag(PlayerPreferences.AnswerEndMovement.wrapInCurrentAnswer)
                         Text("Move to Next Answer")
                             .tag(PlayerPreferences.AnswerEndMovement.moveToNextAnswer)
                     }
                     .labelsHidden()
                     .pickerStyle(.menu)
                     .fixedSize(horizontal: true, vertical: false)
                 }
 
                 Text("Sets behaviour after filling in the last square in an answer.")
                     .font(.footnote)
                     .foregroundStyle(.secondary)
             }
         } header: {
             Text("Movement")
         }
     }
 }
 
 private struct BlockedUsersView: View {
     @Environment(\.appActions) private var appActions
 
     @FetchRequest(
         sortDescriptors: [NSSortDescriptor(keyPath: \FriendEntity.createdAt, ascending: true)],
         predicate: NSPredicate(format: "isBlocked == YES"),
         animation: .default
     )
     private var blockedFriends: FetchedResults<FriendEntity>
 
     @State private var unblockTarget: FriendEntity?
 
     var body: some View {
         List {
             ForEach(blockedFriends, id: \.authorID) { friend in
                 blockedFriendRow(for: friend)
             }
         }
         .overlay {
             if blockedFriends.isEmpty {
                 ContentUnavailableView {
                     Label("No Blocked Users", systemImage: "person.crop.circle.badge.xmark")
                 } description: {
                     Text("Blocked crossmates will appear here.")
                 }
             }
         }
         .navigationTitle("Blocked Users")
         .navigationBarTitleDisplayMode(.inline)
         .alert("Unblock This Player?", isPresented: .init(
             get: { unblockTarget != nil },
             set: { if !$0 { unblockTarget = nil } }
         )) {
             Button("Unblock") {
                 guard let authorID = unblockTarget?.authorID, !authorID.isEmpty else { return }
                 Task { await appActions?.unblockFriend(authorID: authorID) }
             }
             Button("Cancel", role: .cancel) {}
         } message: {
             let name = unblockTarget?.resolvedDisplayName ?? "this player"
             Text("\(name) will be able to invite you again, and any puzzles hidden when you blocked them will return to your list.")
         }
     }
 
     @ViewBuilder
     private func blockedFriendRow(for friend: FriendEntity) -> some View {
         let authorID = friend.authorID ?? ""
 
         HStack {
             FriendAvatarView(authorID: authorID)
                 .padding(.trailing, 8)
             Text(friend.resolvedDisplayName)
                 .foregroundStyle(.primary)
             Spacer()
             Button("Unblock") {
                 unblockTarget = friend
             }
             .disabled(authorID.isEmpty)
         }
         .swipeActions(edge: .trailing) {
             Button("Unblock") { unblockTarget = friend }
                 .tint(.blue)
         }
     }
 }
 
 private struct ProfileColorEditView: View {
     @Environment(PlayerPreferences.self) private var preferences
     @Environment(\.dismiss) private var dismiss
 
     var body: some View {
         @Bindable var preferences = preferences
         Form {
             Section {
                 Picker("Colour", selection: $preferences.color) {
                     ForEach(PlayerColor.palette) { color in
                         Label {
                             Text(color.name)
                         } icon: {
                             Circle()
                                 .fill(color.tint)
                                 .frame(width: 20, height: 20)
                         }
                         .tag(color)
                     }
                 }
                 .pickerStyle(.inline)
                 .labelsHidden()
             } footer: {
                 Text("This is the colour other players will see for your letters.")
             }
         }
         .navigationTitle("Colour")
         .navigationBarTitleDisplayMode(.inline)
         // Mimic the native navigation-link picker, which pops back as soon as a
         // colour is chosen.
         .onChange(of: preferences.color) {
             dismiss()
         }
     }
 }
 
 private struct ProfileNameEditView: View {
     @Environment(PlayerPreferences.self) private var preferences
     @State private var nameDraft = ""
     @FocusState private var isNameFocused: Bool
 
     var body: some View {
         Form {
             Section {
                 HStack {
                     TextField("Name", text: $nameDraft)
                         .textInputAutocapitalization(.never)
                         .autocorrectionDisabled()
                         .focused($isNameFocused)
                         .onSubmit(commitName)
 
                     if !nameDraft.isEmpty {
                         Button {
                             nameDraft = ""
                             isNameFocused = true
                         } label: {
                             Image(systemName: "xmark.circle.fill")
                                 .foregroundStyle(.secondary)
                         }
                         .buttonStyle(.plain)
                         .accessibilityLabel("Clear Name")
                     }
                 }
             } footer: {
                 Text("This is the name other players will see.")
             }
         }
         .navigationTitle("Name")
         .navigationBarTitleDisplayMode(.inline)
         .onAppear {
             nameDraft = preferences.name
         }
         .onChange(of: isNameFocused) { _, isFocused in
             if !isFocused {
                 commitName()
             }
         }
         .onDisappear {
             commitName()
         }
     }
 
     private var trimmedName: String {
         nameDraft.trimmingCharacters(in: .whitespacesAndNewlines)
     }
 
     private var canCommitName: Bool {
         !trimmedName.isEmpty && trimmedName != preferences.name
     }
 
     private func commitName() {
         guard canCommitName else { return }
         preferences.name = trimmedName
         nameDraft = trimmedName
     }
 }