Navigation and Presentation

// FieldNotes/Views/ContentView.swift
import SwiftUI
import FieldNotesModel
import FieldNotesServices

struct ContentView: View {
    @Environment(NoteStore.self) private var store
    @State private var selectedNotebook: Notebook.ID?
    @State private var selectedNote: Note.ID?
    @State private var columnVisibility = NavigationSplitViewVisibility.automatic
    @State private var compactColumn = NavigationSplitViewColumn.sidebar

    var body: some View {
        NavigationSplitView(
            columnVisibility: $columnVisibility,
            preferredCompactColumn: $compactColumn
        ) {
            NotebookList(selection: $selectedNotebook)
                .navigationSplitViewColumnWidth(min: 180, ideal: 220, max: 300)
        } content: {
            NoteList(notebookID: selectedNotebook, selection: $selectedNote)
                .navigationSplitViewColumnWidth(min: 260, ideal: 320)
        } detail: {
            NoteDetailStack(noteID: selectedNote)
        }
        .navigationSplitViewStyle(.balanced)
    }
}

// Distraction-free writing: hide the sidebar and the note list.
Button("Focus", systemImage: "arrow.up.left.and.arrow.down.right") {
    withAnimation { columnVisibility = .detailOnly }
}

// After a deep link, make sure the collapsed stack shows the note on iPhone.
compactColumn = .detail

// FieldNotes/Views/NoteDetailStack.swift
struct NoteDetailStack: View {
    @Environment(NoteStore.self) private var store
    let noteID: Note.ID?

    var body: some View {
        NavigationStack {
            Group {
                if let note = store.notes.first(where: { $0.id == noteID }) {
                    NoteDetail(note: note)
                } else {
                    ContentUnavailableView("No Note Selected", systemImage: "note.text")
                }
            }
            .navigationDestination(for: Note.self) { note in
                NoteDetail(note: note)
            }
            .navigationDestination(for: String.self) { tag in
                TaggedNotesList(tag: tag)
            }
        }
    }
}

// Inside NoteDetail: each tag chip is a link that pushes a String value.
ForEach(note.tags, id: \.self) { tag in
    NavigationLink(value: tag) {
        Text(tag)
    }
    .buttonStyle(.plain)
}

// Inside TaggedNotesList: each row pushes a Note value.
List(notes) { note in
    NavigationLink(value: note) {
        NoteRow(note: note)
    }
}

@State private var suggestedNote: Note?

NoteDetail(note: note)
    .navigationDestination(item: $suggestedNote) { note in
        NoteDetail(note: note)
    }

// FieldNotes/Navigation/DeepLink.swift
enum DeepLink {
    case note(Note.ID)
    case notebook(Notebook.ID)

    init?(url: URL) {
        let parts = url.pathComponents.filter { $0 != "/" }
        // fieldnotes://note/<uuid> has host "note"; the https form has it as the first path component.
        let kind = url.scheme == "fieldnotes" ? url.host() : parts.first
        guard let idString = parts.last, let id = UUID(uuidString: idString) else { return nil }
        switch kind {
        case "note": self = .note(id)
        case "notebook": self = .notebook(id)
        default: return nil
        }
    }
}

// In ContentView: translate the link into selection and column state.
.onOpenURL { url in
    guard let link = DeepLink(url: url) else { return }
    switch link {
    case .note(let id):
        guard let note = store.notes.first(where: { $0.id == id }) else { return }
        selectedNotebook = note.notebookID
        selectedNote = note.id
        router.popToRoot()
        compactColumn = .detail
    case .notebook(let id):
        selectedNotebook = id
        selectedNote = nil
        compactColumn = .content
    }
}

{
  "applinks": {
    "details": [
      {
        "appIDs": ["ABCDE12345.com.example.fieldnotes"],
        "components": [ { "/": "/note/*" }, { "/": "/notebook/*" } ]
      }
    ]
  }
}

// FieldNotes/Views/FieldNotesTabs.swift
enum AppTab: Hashable {
    case notes, map, capture, search
    case notebook(Notebook.ID)
}

struct FieldNotesTabs: View {
    @Environment(NoteStore.self) private var store
    @State private var selection: AppTab = .notes

    var body: some View {
        TabView(selection: $selection) {
            Tab("Notes", systemImage: "note.text", value: .notes) {
                ContentView()
            }
            Tab("Map", systemImage: "map", value: .map) {
                NotesMap()
            }
            Tab("Capture", systemImage: "plus", value: .capture, role: captureRole) {
                QuickCaptureView()
            }
            Tab(value: .search, role: .search) {
                NoteSearchView()
            }
            TabSection("Notebooks") {
                ForEach(store.notebooks) { notebook in
                    Tab(notebook.name, systemImage: notebook.symbolName,
                        value: AppTab.notebook(notebook.id)) {
                        NoteList(notebookID: notebook.id, selection: .constant(nil))
                    }
                }
            }
            .defaultVisibility(.hidden, for: .tabBar)
        }
        .tabViewStyle(.sidebarAdaptable)
        .tabBarMinimizeBehavior(.onScrollDown)
    }

    /// `TabRole.prominent` is new in 27; on 26 the Capture tab is an ordinary tab.
    private var captureRole: TabRole? {
        if #available(iOS 27, macOS 27, watchOS 27, visionOS 27, *) {
            return .prominent
        }
        return nil
    }
}

TabView(selection: $selection) { /* tabs as above */ }
    .tabViewBottomAccessory {
        SyncStatusView()   // "Synced 2 min ago", with a retry button
    }

// FieldNotes/Views/NotebookGrid.swift
struct NotebookGrid: View {
    @Environment(NoteStore.self) private var store
    @Namespace private var zoom

    var body: some View {
        NavigationStack {
            ScrollView {
                LazyVGrid(columns: [GridItem(.adaptive(minimum: 150))]) {
                    ForEach(store.notebooks) { notebook in
                        NavigationLink(value: notebook) {
                            NotebookCard(notebook: notebook)
                                .matchedTransitionSource(id: notebook.id, in: zoom)
                        }
                        .buttonStyle(.plain)
                    }
                }
                .padding()
            }
            .navigationDestination(for: Notebook.self) { notebook in
                NoteList(notebookID: notebook.id, selection: .constant(nil))
                    #if !os(macOS)
                    .navigationTransition(.zoom(sourceID: notebook.id, in: zoom))
                    #endif
            }
        }
    }
}

// NoteDetail
.toolbar {
    ToolbarItem(placement: .primaryAction) {
        Button("Tags", systemImage: "tag") { isPickingTags = true }
    }
    ToolbarItem(placement: .primaryAction) {
        Button("Info", systemImage: "info.circle") { showsInspector.toggle() }
    }

    #if !os(visionOS)
    ToolbarSpacer(.fixed, placement: .primaryAction)   // Share sits in its own glass group
    #endif

    if #available(iOS 27, macOS 26.1, visionOS 27, *) {
        ToolbarItem(placement: .primaryAction) {
            ShareLink(item: note.body, subject: Text(note.title))
        }
        .visibilityPriority(.high)                     // new in 27: overflows last
    } else {
        ToolbarItem(placement: .primaryAction) {
            ShareLink(item: note.body, subject: Text(note.title))
        }
    }

    #if os(iOS) || os(visionOS)
    if #available(iOS 27, visionOS 27, *) {
        ToolbarOverflowMenu {                          // new in 27: always in the "..." menu
            Button("Duplicate", systemImage: "plus.square.on.square") { duplicate(note) }
            Button("Archive", systemImage: "archivebox") { archive(note) }
        }
    }
    #endif
}

// ContentView: one search field for all columns.
NavigationSplitView { /* ... */ } content: { /* ... */ } detail: { /* ... */ }
    .searchable(text: $searchText, placement: .sidebar, prompt: "Search notes")

// FieldNotesTabs: the search tab's content.
Tab(value: .search, role: .search) {
    NavigationStack {
        NoteSearchResults(query: searchText)
            .searchable(text: $searchText, prompt: "Titles, tags and text")
            .searchToolbarBehavior(.minimize)
    }
}