linkding-ios/Marks/Views/SearchView.swift

import SwiftUI

struct SearchView: View {
    @Bindable var viewModel: BookmarksViewModel

    @State private var searchText = ""
    @State private var useSemanticSearch = false
    @State private var semanticResults: [Bookmark]? = nil
    @State private var searchTask: Task<Void, Never>?
    @State private var browsingBookmark: Bookmark?

    var body: some View {
        NavigationStack {
            List {
                ForEach(results) { bookmark in
                    BookmarkListRow(
                        bookmark: bookmark,
                        viewModel: viewModel,
                        onOpen: { browsingBookmark = bookmark }
                    )
                }
            }
            .listStyle(.plain)
            .paperSurface()
            .navigationTitle("Search")
            .toolbar {
                ToolbarItem(placement: .topBarTrailing) {
                    Toggle(isOn: $useSemanticSearch) {
                        Label("Semantic", systemImage: "sparkles")
                    }
                    .toggleStyle(.button)
                    .onChange(of: useSemanticSearch) { _, _ in scheduleSearch() }
                }
            }
            .overlay {
                if searchText.isEmpty {
                    PaperEmptyState(title: "Search Bookmarks", systemImage: "magnifyingglass", message: "Search by title, URL, or tag.")
                } else if results.isEmpty && !viewModel.isLoading {
                    PaperEmptyState(title: "No Results", systemImage: "magnifyingglass", message: "Nothing matches \u{201C}\(searchText)\u{201D}.")
                }
                if viewModel.isLoading {
                    ProgressView()
                }
            }
            .sensoryFeedback(.selection, trigger: browsingBookmark?.id)
            .sheet(item: $browsingBookmark) { bookmark in
                if let url = URL(string: bookmark.url) {
                    BrowserView(
                        url: url,
                        title: bookmark.displayTitle,
                        claude: viewModel.claude,
                        podcastPlayer: viewModel.podcastPlayer,
                        podcastGenerator: viewModel.podcastGenerator
                    ) {
                        await viewModel.archive(bookmark)
                    }
                    .bookmarkOnscreen(bookmark)
                }
            }
        }
        .searchable(text: $searchText, prompt: "Titles, URLs, tags…")
        .onChange(of: searchText) { _, _ in scheduleSearch() }
        .onAppear { consumeIntentSearch() }
        .onChange(of: IntentRouter.shared.searchRequest) { _, _ in consumeIntentSearch() }
    }

    /// Pulls a query handed over by `SearchMarksIntent` into the search field.
    private func consumeIntentSearch() {
        guard let query = IntentRouter.shared.searchRequest else { return }
        searchText = query
        IntentRouter.shared.searchRequest = nil
    }

    private var results: [Bookmark] {
        if let semantic = semanticResults { return semantic }
        guard !searchText.isEmpty else { return [] }
        let q = searchText.lowercased()
        return viewModel.bookmarks.filter { b in
            b.displayTitle.lowercased().contains(q) ||
            b.url.lowercased().contains(q) ||
            b.tagNames.contains { $0.lowercased().contains(q) } ||
            (b.aiTags ?? []).contains { $0.lowercased().contains(q) } ||
            (b.aiSummary ?? "").lowercased().contains(q)
        }
    }

    private func scheduleSearch() {
        semanticResults = nil
        searchTask?.cancel()
        guard !searchText.isEmpty, useSemanticSearch else { return }
        let claude = viewModel.claude
        searchTask = Task {
            try? await Task.sleep(for: .milliseconds(500))
            guard !Task.isCancelled else { return }
            let q = searchText
            let all = viewModel.bookmarks
            do {
                let ranked = try await claude.semanticSearch(query: q, in: all)
                await MainActor.run { semanticResults = ranked }
            } catch {}
        }
    }
}