File Browser

private var iconsView: some View {
    ScrollView {
        LazyVGrid(
            columns: [GridItem(.adaptive(minimum: 120, maximum: 140), spacing: 12)],
            spacing: 12
        ) {
            ForEach(viewModel.allBrowserItems) { item in
                FinderIconCell(
                    object: item,
                    credentials: viewModel.credentials ?? .empty,
                    isSelected: viewModel.selectedObjectIDs.contains(item.id)
                )
                .onTapGesture(count: 2) {
                    if item.isFolder {
                        viewModel.navigateToFolder(item)
                    } else {
                        QuickLookCoordinator.shared.preview(
                            item,
                            credentials: viewModel.credentials ?? .empty
                        )
                    }
                }
                .onTapGesture(count: 1) {
                    toggleSelection(item)
                }
                .contextMenu { rowContextMenu(for: item) }
            }
        }
        .padding(16)
    }
}

private var listView: some View {
    VStack(spacing: 0) {
        listHeader
        Divider()
        List {
            ForEach(viewModel.allBrowserItems) { item in
                R2ObjectRow(
                    object: item,
                    credentials: viewModel.credentials ?? .empty,
                    isSelected: viewModel.selectedObjectIDs.contains(item.id),
                    onNavigate: { viewModel.navigateToFolder($0) },
                    onCopyURL: { viewModel.copyToClipboard($0) },
                    onPreview: { QuickLookCoordinator.shared.preview($0, credentials: viewModel.credentials ?? .empty) },
                    onDownload: { viewModel.downloadToDestination(from: $0, dest: $1) },
                    onDelete: { item in Task { await viewModel.deleteObject(item) } }
                )
                .onTapGesture { toggleSelection(item) }
                .contextMenu { rowContextMenu(for: item) }
            }
        }
        .listStyle(.inset)
    }
}

private var pathBar: some View {
    ScrollView(.horizontal, showsIndicators: false) {
        HStack(spacing: 2) {
            pathCrumb(
                label: viewModel.credentials?.bucketName ?? "Bucket",
                systemImage: "externaldrive.fill",
                isCurrent: viewModel.pathSegments.isEmpty
            ) { viewModel.navigateToRoot() }

            ForEach(Array(viewModel.pathSegments.enumerated()), id: \.offset) { idx, segment in
                Image(systemName: "chevron.right")
                    .font(.system(size: 9, weight: .semibold))
                    .foregroundStyle(.tertiary)
                pathCrumb(
                    label: segment,
                    systemImage: "folder.fill",
                    isCurrent: idx == viewModel.pathSegments.count - 1
                ) { viewModel.navigateToSegment(idx) }
            }
        }
        .padding(.horizontal, 14)
        .animation(.spring(response: 0.3, dampingFraction: 0.85), value: viewModel.pathSegments)
    }
    .frame(height: 30)
    .background(.regularMaterial)
}

.searchable(text: $vm.filterText, placement: .toolbar, prompt: "Search")

var allBrowserItems: [R2Object] {
    let combined = browserFolders + browserObjects
    let filtered: [R2Object]
    if filterText.isEmpty {
        filtered = combined
    } else {
        filtered = combined.filter { $0.name.localizedCaseInsensitiveContains(filterText) }
    }
    return filtered.sorted { a, b in
        // Folders always sort before files when sorting by name/date/kind
        if sortKey != .size && a.isFolder != b.isFolder {
            return a.isFolder
        }
        let result: Bool
        switch sortKey {
        case .name:
            result = a.name.localizedCompare(b.name) == .orderedAscending
        case .size:
            result = a.size < b.size
        case .date:
            let aDate = a.lastModified ?? .distantPast
            let bDate = b.lastModified ?? .distantPast
            result = aDate < bDate
        case .kind:
            result = a.isFolder == b.isFolder
                ? a.name.localizedCompare(b.name) == .orderedAscending
                : a.isFolder
        }
        return sortAscending ? result : !result
    }
}

func preview(_ object: R2Object, credentials: R2Credentials) {
    let panel = QLPreviewPanel.shared()!

    // Toggle: if already visible for same coordinator, close it
    if panel.isVisible && panel.dataSource === self {
        panel.close()
        return
    }

    // Generate a presigned URL and pass it directly to Quick Look — no download needed.
    // previewItemTitle supplies the filename so QL picks the right previewer plugin.
    guard let presignedURL = AWSV4Signer.presignedURL(for: object.key, credentials: credentials) else { return }
    previewItem = PreviewItem(url: presignedURL, title: object.name)

    panel.dataSource = self
    panel.delegate  = self
    panel.makeKeyAndOrderFront(nil)
    panel.reloadData()
}

mainContent
    .dropDestination(for: URL.self) { urls, _ in
        guard viewModel.hasCredentials else { return false }
        viewModel.handleDroppedURLs(urls)
        return true
    } isTargeted: { isDropTargeted = $0 }

func handleDroppedURLs(_ urls: [URL]) {
    var tasks: [FileUploadTask] = []

    for url in urls {
        let accessing = url.startAccessingSecurityScopedResource()
        defer { if accessing { url.stopAccessingSecurityScopedResource() } }

        var isDirectory: ObjCBool = false
        let exists = FileManager.default.fileExists(atPath: url.path, isDirectory: &isDirectory)
        guard exists else { continue }

        if isDirectory.boolValue {
            // Recursively enumerate directory contents
            let dirName = url.lastPathComponent
            let folderBookmark = try? url.bookmarkData(options: [.withSecurityScope],
                                                     includingResourceValuesForKeys: nil,
                                                     relativeTo: nil)
            guard let enumerator = FileManager.default.enumerator(
                at: url,
                includingPropertiesForKeys: [.fileSizeKey, .isDirectoryKey],
                options: [.skipsHiddenFiles]
            ) else { continue }

            for case let fileURL as URL in enumerator {
                // Process each file in the folder...
                let relativePath = fileURL.path.replacingOccurrences(
                    of: url.deletingLastPathComponent().path + "/",
                    with: ""
                )
                let r2Key = currentPrefix + relativePath
                let task = FileUploadTask(fileURL: fileURL, fileName: fileName, fileSize: fileSize)
                task.uploadKey = r2Key
                task.parentFolderBookmark = folderBookmark
                tasks.append(task)
            }
        } else {
            // Single file — upload into current prefix
            let task = FileUploadTask(fileURL: url, fileName: fileName, fileSize: fileSize)
            task.uploadKey = currentPrefix + fileName
            tasks.append(task)
        }
    }

    guard !tasks.isEmpty else { return }
    uploadTasks.append(contentsOf: tasks)
    Task { await uploadPendingTasks() }
}

@ViewBuilder
private func rowContextMenu(for item: R2Object) -> some View {
    if item.isFolder {
        Button { viewModel.navigateToFolder(item) } label: {
            Label("Open", systemImage: "arrow.right.circle")
        }
        Divider()
    } else {
        Button {
            QuickLookCoordinator.shared.preview(item, credentials: viewModel.credentials ?? .empty)
        } label: {
            Label("Preview", systemImage: "eye")
        }
        Button {
            let url = (viewModel.credentials ?? .empty).publicURL(forKey: item.key)
            viewModel.copyToClipboard(url.absoluteString)
        } label: {
            Label("Copy URL", systemImage: "doc.on.clipboard")
        }
        Divider()
    }
    Button { viewModel.selectedObjectIDs.insert(item.id) } label: {
        Label("Select", systemImage: "checkmark.circle")
    }
    Divider()
    Button(role: .destructive) { pendingDeleteItem = item } label: {
        Label(item.isFolder ? "Delete Folder & Contents" : "Delete", systemImage: "trash")
    }
}

private var statusBar: some View {
    let total = viewModel.allBrowserItems.count
    let sel   = viewModel.selectedObjectIDs.count
    return Group {
        if total > 0 || sel > 0 {
            HStack(spacing: 10) {
                if sel > 0 {
                    Text("\(sel) of \(total) selected").foregroundStyle(.secondary)
                    Spacer()
                    Button(role: .destructive) { showDeleteConfirm = true } label: {
                        Label("Delete Selected", systemImage: "trash")
                    }
                    .buttonStyle(.plain).foregroundStyle(.red)
                    Button { viewModel.clearSelection() } label: { Text("Deselect") }
                        .buttonStyle(.plain).foregroundStyle(Color.accentColor)
                } else {
                    Text("\(total) item\(total == 1 ? "" : "s")").foregroundStyle(.secondary)
                    Spacer()
                }
            }
            .font(.caption)
            .padding(.horizontal, 12).padding(.vertical, 5)
            .background(.bar)
            .overlay(alignment: .top) { Divider() }
        }
    }
}