crossmate

ClueList.swift (8808B)

---

 import SwiftUI
 
 struct ClueList: View {
     @Bindable var session: PlayerSession
     var presentation: Presentation = .sheet
     var replayFrame: ReplayFrame?
     @Environment(PlayerPreferences.self) private var preferences
     @Environment(\.dismiss) private var dismiss
     @Environment(\.scenePhase) private var scenePhase
 
     enum Presentation {
         case sheet
         case sidebar
     }
 
     private var currentClueBackground: Color {
         preferences.color.authorTintFill
     }
 
     var body: some View {
         switch presentation {
         case .sheet:
             NavigationStack {
                 clueList
                     .navigationTitle("Clues")
                     .navigationBarTitleDisplayMode(.inline)
                     .toolbar {
                         ToolbarItem(placement: .cancellationAction) {
                             Button {
                                 dismiss()
                             } label: {
                                 Image(systemName: "xmark")
                             }
                             .accessibilityLabel("Cancel")
                         }
                     }
             }
         case .sidebar:
             clueList
         }
     }
 
     @ViewBuilder
     private var clueList: some View {
         let currentDisplay = Self.currentDisplay(session: session, replayFrame: replayFrame)
         let current = currentDisplay.clue
         let currentDirection = currentDisplay.direction
         let currentID = currentDisplay.currentID
 
         if presentation == .sheet {
             list(
                 current: current,
                 currentDirection: currentDirection,
                 currentID: currentID
             )
             .listStyle(.plain)
         } else {
             sidebarList(
                 current: current,
                 currentDirection: currentDirection,
                 currentID: currentID
             )
         }
     }
 
     private func list(
         current: Puzzle.Clue?,
         currentDirection: Puzzle.Direction,
         currentID: String?
     ) -> some View {
         ScrollViewReader { proxy in
             List {
                 ClueSectionHeader(title: "Across", presentation: .sheet)
                 ForEach(session.puzzle.acrossClues) { clue in
                     rowButton(for: clue, direction: .across, current: current, currentDirection: currentDirection)
                         .id(rowID(direction: .across, number: clue.number))
                 }
 
                 ClueSectionHeader(title: "Down", presentation: .sheet)
                 ForEach(session.puzzle.downClues) { clue in
                     rowButton(for: clue, direction: .down, current: current, currentDirection: currentDirection)
                         .id(rowID(direction: .down, number: clue.number))
                 }
             }
             .onAppear {
                 guard let currentID else { return }
                 proxy.scrollTo(currentID, anchor: .center)
             }
             .onChange(of: currentID) { _, newID in
                 guard let newID else { return }
                 withAnimation(.easeInOut(duration: 0.2)) {
                     proxy.scrollTo(newID, anchor: .center)
                 }
             }
             .onChange(of: scenePhase) { _, newPhase in
                 guard newPhase == .active, let currentID else { return }
                 proxy.scrollTo(currentID, anchor: .center)
             }
         }
     }
 
     private func sidebarList(
         current: Puzzle.Clue?,
         currentDirection: Puzzle.Direction,
         currentID: String?
     ) -> some View {
         ScrollViewReader { proxy in
             ScrollView {
                 VStack(alignment: .leading, spacing: 0) {
                     ClueSectionHeader(title: "Across", presentation: .sidebar)
                     ForEach(session.puzzle.acrossClues) { clue in
                         rowButton(for: clue, direction: .across, current: current, currentDirection: currentDirection)
                             .id(rowID(direction: .across, number: clue.number))
                     }
 
                     ClueSectionHeader(title: "Down", presentation: .sidebar)
                         .padding(.top, 12)
                     ForEach(session.puzzle.downClues) { clue in
                         rowButton(for: clue, direction: .down, current: current, currentDirection: currentDirection)
                             .id(rowID(direction: .down, number: clue.number))
                     }
                 }
                 .padding(.vertical, 10)
             }
             .onAppear {
                 guard let currentID else { return }
                 proxy.scrollTo(currentID, anchor: .center)
             }
             .onChange(of: currentID) { _, newID in
                 guard let newID else { return }
                 withAnimation(.easeInOut(duration: 0.2)) {
                     proxy.scrollTo(newID, anchor: .center)
                 }
             }
         }
     }
 
     private func rowID(direction: Puzzle.Direction, number: Int) -> String {
         "\(direction == .across ? "A" : "D")-\(number)"
     }
 
     private static func currentDisplay(session: PlayerSession, replayFrame: ReplayFrame?) -> ClueDisplay {
         if let position = replayFrame?.cursor,
            let direction = replayFrame?.cursorDirection {
             return ClueDisplay(
                 clue: session.puzzle.clue(atRow: position.row, col: position.col, direction: direction),
                 direction: direction
             )
         }
         return ClueDisplay(clue: session.currentClue(), direction: session.direction)
     }
 
     private struct ClueDisplay {
         let clue: Puzzle.Clue?
         let direction: Puzzle.Direction
 
         var currentID: String? {
             clue.map { "\(direction == .across ? "A" : "D")-\($0.number)" }
         }
     }
 
     @ViewBuilder
     private func rowButton(
         for clue: Puzzle.Clue,
         direction: Puzzle.Direction,
         current: Puzzle.Clue?,
         currentDirection: Puzzle.Direction
     ) -> some View {
         let isCurrent = current?.number == clue.number && currentDirection == direction
         Button {
             session.selectClue(direction: direction, number: clue.number)
             if presentation == .sheet {
                 dismiss()
             }
         } label: {
             ClueRow(
                 number: clue.number,
                 text: clue.attributedText,
                 isCurrent: isCurrent,
                 currentBackground: currentClueBackground,
                 presentation: presentation
             )
         }
         .buttonStyle(.plain)
         .modifier(SheetClueListRowChrome(
             isActive: presentation == .sheet,
             background: isCurrent ? currentClueBackground : .clear
         ))
     }
 }
 
 private struct ClueSectionHeader: View {
     let title: String
     let presentation: ClueList.Presentation
 
     var body: some View {
         Text(title)
             .font(.footnote.weight(.semibold))
             .foregroundStyle(.secondary)
             .textCase(.uppercase)
             .frame(maxWidth: .infinity, alignment: .leading)
             .padding(.leading, presentation == .sheet ? 12 : 18)
             .padding(.trailing, presentation == .sheet ? 0 : 18)
             .padding(.vertical, 6)
             .modifier(SheetClueListRowChrome(isActive: presentation == .sheet, background: .clear))
     }
 }
 
 private struct ClueRow: View {
     let number: Int
     let text: AttributedString
     let isCurrent: Bool
     let currentBackground: Color
     let presentation: ClueList.Presentation
 
     private var background: Color {
         isCurrent ? currentBackground : .clear
     }
 
     var body: some View {
         HStack(alignment: .firstTextBaseline, spacing: 10) {
             Text("\(number)")
                 .font(.subheadline.weight(.semibold))
                 .foregroundStyle(.secondary)
                 .frame(minWidth: 28, alignment: .trailing)
             Text(text)
                 .font(.body)
                 .foregroundStyle(.primary)
                 .frame(maxWidth: .infinity, alignment: .leading)
         }
         .padding(.leading, presentation == .sheet ? 12 : 18)
         .padding(.trailing, presentation == .sheet ? 0 : 18)
         .padding(.vertical, presentation == .sheet ? 10 : 8)
         .contentShape(Rectangle())
         .background(presentation == .sidebar ? background : .clear)
     }
 }
 
 private struct SheetClueListRowChrome: ViewModifier {
     let isActive: Bool
     let background: Color
 
     func body(content: Content) -> some View {
         if isActive {
             content
                 .listRowInsets(EdgeInsets(top: 0, leading: 0, bottom: 0, trailing: 0))
                 .listRowBackground(background)
         } else {
             content
         }
     }
 }