lanework/KanbanMobile/Screens/BoardScreen.swift

import SwiftUI

/// The lane list for one board — `BoardRoute.lanes`'s destination.
///
/// Holds only `boardRoot`, never a `BoardSummary`/`BoardModel` value: the session and its
/// snapshot are pulled from the environment's index store fresh on every body evaluation, so a
/// write from anywhere in the stack (a lane created, a card moved) reaches this screen the moment
/// the session's reload lands.
struct BoardScreen: View {
    let boardRoot: URL

    @Environment(BoardIndexStore.self) private var index
    @State private var isPresentingNewLane = false

    private var session: BoardSession { index.session(forBoardAt: boardRoot) }

    var body: some View {
        content
            .navigationTitle(title)
            .toolbar {
                if case .ready = session.phase {
                    Button("New Lane", systemImage: "plus") {
                        isPresentingNewLane = true
                    }
                }
            }
            .task { session.open() }
            .onDisappear {
                // Stops the materializing/downloading retry timer. In practice a no-op here: a
                // lane row (the only thing on this screen that pushes forward) only renders in
                // `.ready`, the one phase where `close()`'s `cancelRetry()` has nothing to cancel —
                // so pushing deeper into the board costs nothing, and popping back out to the
                // board list is where this actually stops the timer.
                session.close()
            }
            .titlePromptAlert("New Lane", isPresented: $isPresentingNewLane, placeholder: "Lane Title") { title in
                let newTitle: String? = title.isEmpty ? nil : title
                Task {
                    // The closure's throws type must be spelled out — a trailing closure literal
                    // does not pick up `perform`'s `throws(BoardWriteError)` from context alone.
                    await session.perform { (root: URL) throws(BoardWriteError) -> ItemID in
                        try BoardWriter.createLane(inBoard: root, title: newTitle)
                    }
                }
            }
    }

    private var title: String {
        // The same fallback `BoardSummaryScanner` uses — the folder name minus `.kanban` — so the
        // title never blanks out while the session is still opening.
        session.snapshot?.title.value ?? boardRoot.deletingPathExtension().lastPathComponent
    }

    @ViewBuilder
    private var content: some View {
        switch session.phase {
        case .idle, .loading:
            ProgressView("Opening board")

        case let .materializing(progress):
            ProgressView(value: progress.fractionMaterialized) {
                Text("Downloading board")
            }
            .padding()

        case let .failed(error):
            ContentUnavailableView {
                Label("Can't Open Board", systemImage: "exclamationmark.triangle")
            } description: {
                Text(error.description)
            } actions: {
                Button("Try Again") { session.reload() }
            }

        case .ready:
            if let snapshot = session.snapshot {
                laneList(snapshot)
            } else {
                // Unreachable in practice — `.ready` is only ever set alongside a landed load,
                // which sets `snapshot` in the same step (`BoardSession.apply`). Kept so the
                // switch is exhaustive without a force-unwrap.
                ProgressView("Opening board")
            }
        }
    }

    @ViewBuilder
    private func laneList(_ snapshot: BoardModel) -> some View {
        List {
            if session.lastError != nil {
                Section {
                    Label("Showing the last saved version — a recent update didn't load.", systemImage: "exclamationmark.triangle")
                        .font(.footnote)
                        .foregroundStyle(.secondary)
                }
            }
            if snapshot.lanes.isEmpty {
                ContentUnavailableView(
                    "No Lanes Yet",
                    systemImage: "rectangle.split.3x1",
                    description: Text("Add a lane to start organizing cards.")
                )
            } else {
                // Already in display order (`BoardModel.lanes`'s own contract) — the loader's
                // `Ranks.sortedForDisplay` is trusted rather than re-sorted here.
                ForEach(snapshot.lanes) { lane in
                    NavigationLink(value: BoardRoute.cards(boardRoot: boardRoot, laneID: lane.id)) {
                        LaneSummaryRow(lane: lane)
                    }
                }
            }
        }
        .refreshable { session.reload() }
    }
}

/// One lane row: title, and its card count.
private struct LaneSummaryRow: View {
    let lane: Lane

    var body: some View {
        VStack(alignment: .leading, spacing: 2) {
            Text(displayTitle)
            Text("\(lane.cards.count) card\(lane.cards.count == 1 ? "" : "s")")
                .font(.caption)
                .foregroundStyle(.secondary)
        }
    }

    private var displayTitle: String {
        guard let title = lane.title.value, !title.isEmpty else { return "Untitled Lane" }
        return title
    }
}