Lists, Tables and Collections

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

struct NotebookList: View {
    @Environment(NoteStore.self) private var store
    @Binding var selection: Notebook.ID?

    var body: some View {
        List(store.notebooks, selection: $selection) { notebook in
            Label(notebook.name, systemImage: notebook.symbolName)
                .badge(store.notes.count { $0.notebookID == notebook.id })
        }
        .navigationTitle("Notebooks")
    }
}

// FieldNotes/Views/NoteTagsSection.swift
Section("Tags") {
    ForEach(note.tags, id: \.self) { tag in
        TagChip(tag)
    }
}

// FieldNotes/Views/NoteList.swift (multi-selection variant)
@State private var selectedNotes: Set<Note.ID> = []

List(selection: $selectedNotes) {
    ForEach(notesInNotebook) { note in
        NoteRow(note: note)
    }
}
.contextMenu(forSelectionType: Note.ID.self) { ids in
    Button("Pin", systemImage: "pin") {
        for note in store.notes where ids.contains(note.id) { store.togglePin(note) }
    }
    Button("Delete", systemImage: "trash", role: .destructive) {
        for note in store.notes where ids.contains(note.id) { store.delete(note) }
    }
} primaryAction: { ids in
    // Double-click on macOS, or Return on a selection: open the note.
    if let first = ids.first { selection = first }
}

// FieldNotes/Views/NoteList.swift (row with swipe actions)
NoteRow(note: note)
    .swipeActions(edge: .leading) {
        Button {
            store.togglePin(note)
        } label: {
            Label(note.isPinned ? "Unpin" : "Pin",
                  systemImage: note.isPinned ? "pin.slash" : "pin")
        }
        .tint(.orange)
    }
    .swipeActions(edge: .trailing, allowsFullSwipe: false) {
        Button(role: .destructive) {
            store.delete(note)
        } label: {
            Label("Delete", systemImage: "trash")
        }
    }

// FieldNotes/Views/NoteStore+Reorder.swift
import SwiftUI
import FieldNotesModel
import FieldNotesServices

@available(iOS 27, macOS 27, watchOS 27, visionOS 27, *)
extension NoteStore {
    func apply<C>(_ difference: ReorderDifference<Note.ID, C>) {
        let moving = difference.sources.compactMap { id in notes.first { $0.id == id } }
        notes.removeAll { difference.sources.contains($0.id) }

        switch difference.destination.position {
        case .before(let targetID):
            let index = notes.firstIndex { $0.id == targetID } ?? notes.endIndex
            notes.insert(contentsOf: moving, at: index)
        case .end:
            notes.append(contentsOf: moving)
        }
    }
}

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

@available(iOS 27, macOS 27, watchOS 27, visionOS 27, *)
struct PinnedNotesList: View {
    @Environment(NoteStore.self) private var store
    let pinned: [Note]
    let isReorderingEnabled: Bool
    @Binding var selection: Note.ID?

    var body: some View {
        List(selection: $selection) {
            Section("Pinned") {
                ForEach(pinned) { note in
                    NoteRow(note: note)
                }
                .reorderable()
            }
        }
        .reorderContainer(for: Note.self, isEnabled: isReorderingEnabled) { difference in
            withAnimation { store.apply(difference) }
        }
    }
}

// In NoteList.body:
if #available(iOS 27, macOS 27, watchOS 27, visionOS 27, *) {
    PinnedNotesList(pinned: pinned, isReorderingEnabled: searchText.isEmpty, selection: $selection)
} else {
    List(pinned, selection: $selection) { NoteRow(note: $0) }
}

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

struct NotesTable: View {
    @Environment(NoteStore.self) private var store
    @State private var selection: Set<Note.ID> = []
    @State private var sortOrder = [KeyPathComparator(\Note.createdAt, order: .reverse)]

    private var rows: [Note] {
        store.notes.sorted(using: sortOrder)
    }

    var body: some View {
        Table(rows, selection: $selection, sortOrder: $sortOrder) {
            TableColumn("Title", value: \.title) { note in
                Label(note.title, systemImage: note.isPinned ? "pin.fill" : "note.text")
            }
            TableColumn("Notebook") { note in
                Text(notebookName(for: note))
            }
            .width(min: 100, ideal: 140)
            TableColumn("Created", value: \.createdAt) { note in
                Text(note.createdAt, format: .dateTime.day().month().year())
            }
            .width(ideal: 110)
            TableColumn("Tags") { note in
                Text(note.tags.joined(separator: ", "))
                    .foregroundStyle(.secondary)
            }
        }
        .contextMenu(forSelectionType: Note.ID.self) { ids in
            Button("Delete", systemImage: "trash", role: .destructive) {
                for note in store.notes where ids.contains(note.id) { store.delete(note) }
            }
        }
    }

    private func notebookName(for note: Note) -> String {
        store.notebooks.first { $0.id == note.notebookID }?.name ?? "None"
    }
}

// FieldNotes/Views/AllNotesView.swift
struct AllNotesView: View {
    @Environment(\.horizontalSizeClass) private var sizeClass
    @State private var selection: Note.ID?

    var body: some View {
        if sizeClass == .compact {
            NoteList(notebookID: nil, selection: $selection)
        } else {
            NotesTable()
        }
    }
}

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

struct NotebookGrid: View {
    @Environment(NoteStore.self) private var store
    @Binding var selection: Notebook.ID?

    private let columns = [GridItem(.adaptive(minimum: 150), spacing: 16)]

    var body: some View {
        ScrollView {
            LazyVGrid(columns: columns, spacing: 16) {
                ForEach(store.notebooks) { notebook in
                    Button {
                        selection = notebook.id
                    } label: {
                        NotebookCover(notebook: notebook,
                                      count: store.notes.count { $0.notebookID == notebook.id })
                    }
                    .buttonStyle(.plain)
                }
            }
            .padding()
        }
    }
}

ScrollView {
    LazyVStack(alignment: .leading, pinnedViews: [.sectionHeaders]) {
        ForEach(notesByDay, id: \.day) { group in
            Section {
                ForEach(group.notes) { NoteCard(note: $0) }
            } header: {
                Text(group.day, format: .dateTime.weekday(.wide).day().month())
                    .font(.headline)
                    .padding(.vertical, 4)
                    .frame(maxWidth: .infinity, alignment: .leading)
                    .background(.bar)
            }
        }
    }
    .padding(.horizontal)
}

// FieldNotes/Views/NoteList.swift (search)
@State private var searchText = ""

private var notesInNotebook: [Note] {
    store.notes.filter { note in
        note.notebookID == notebookID
            && (searchText.isEmpty
                || note.title.localizedStandardContains(searchText)
                || note.body.localizedStandardContains(searchText))
    }
}

var body: some View {
    List(selection: $selection) {
        // Pinned and Notes sections as above
    }
    .searchable(text: $searchText, prompt: "Search notes")
    .overlay {
        if notesInNotebook.isEmpty && !searchText.isEmpty {
            ContentUnavailableView.search(text: searchText)
        }
    }
}

struct TagToken: Identifiable, Hashable {
    let name: String
    var id: String { name }
}

@State private var tokens: [TagToken] = []
@State private var suggestedTokens: [TagToken] = []

List(selection: $selection) { /* ... */ }
    .searchable(text: $searchText, tokens: $tokens, suggestedTokens: $suggestedTokens,
                prompt: "Search notes or tags") { token in
        Label(token.name, systemImage: "tag")
    }
    .onAppear {
        suggestedTokens = Set(store.notes.flatMap(\.tags)).sorted().map(TagToken.init)
    }

// FieldNotes/Views/NoteList.swift (refresh)
List(selection: $selection) {
    // sections
}
.refreshable {
    do {
        try await store.refresh()
    } catch {
        syncError = error
    }
}

struct RefreshToolbarButton: View {
    @Environment(\.refresh) private var refresh

    var body: some View {
        if let refresh {
            Button("Refresh", systemImage: "arrow.clockwise") {
                Task { await refresh() }
            }
            .keyboardShortcut("r")
        }
    }
}

// Packages/FieldNotesUI/Sources/FieldNotesUI/TagCloud.swift
import SwiftUI

public struct TagCloud<Content: View>: View {
    private let limit: Int
    private let content: Content

    public init(limit: Int = 5, @ContentBuilder content: () -> Content) {
        self.limit = limit
        self.content = content()
    }

    public var body: some View {
        Group(subviews: content) { subviews in
            HStack(spacing: 6) {
                ForEach(subviews.prefix(limit)) { subview in
                    subview
                        .padding(.horizontal, 8)
                        .padding(.vertical, 4)
                        .background(.tint.opacity(subview.containerValues.isHighlighted ? 0.35 : 0.12),
                                    in: .capsule)
                }
                if subviews.count > limit {
                    Text("+\(subviews.count - limit)")
                        .foregroundStyle(.secondary)
                }
            }
        }
    }
}

extension ContainerValues {
    @Entry public var isHighlighted: Bool = false
}

public extension View {
    func tagHighlighted(_ highlighted: Bool = true) -> some View {
        containerValue(\.isHighlighted, highlighted)
    }
}

TagCloud {
    ForEach(note.tags, id: \.self) { tag in
        Text(tag)
            .tagHighlighted(tag == activeTag)
    }
    Text("field")   // a static extra chip
}

// A card-style list that keeps the caller's sections.
public struct CardList<Content: View>: View {
    private let content: Content

    public init(@ContentBuilder content: () -> Content) {
        self.content = content()
    }

    public var body: some View {
        ScrollView {
            LazyVStack(alignment: .leading, spacing: 20) {
                ForEach(sections: content) { section in
                    section.header.font(.headline)
                    ForEach(section.content) { subview in
                        subview
                            .padding()
                            .frame(maxWidth: .infinity, alignment: .leading)
                            .background(.background.secondary, in: .rect(cornerRadius: 12))
                    }
                }
            }
            .padding()
        }
    }
}