Upload System

private func uploadPendingTasks() async {
    guard let credentials else {
        showError("Please configure R2 credentials in Settings first (Cmd+,).")
        return
    }

    let pending = uploadTasks.filter { $0.status == .pending }
    await withTaskGroup(of: Void.self) { group in
        for uploadTask in pending {
            // Create and store the task handle on MainActor before it runs,
            // so the cancel button can reach it immediately.
            let handle = Task {
                await self.uploadSingleFile(uploadTask, credentials: credentials)
            }
            await MainActor.run { uploadTask.uploadTask = handle }
            group.addTask {
                await handle.value
                await MainActor.run { uploadTask.uploadTask = nil }
            }
        }
    }
}

static func upload(
    fileURL: URL,
    credentials: R2Credentials,
    key: String,
    contentType: String,
    onProgress: @MainActor @escaping @Sendable (Int64, Int64) -> Void
) async throws -> UploadResult {
    let url = await credentials.endpoint
        .appendingPathComponent(credentials.bucketName)
        .appendingPathComponent(key)

    var request = URLRequest(url: url)
    request.httpMethod = "PUT"
    request.setValue(contentType, forHTTPHeaderField: "Content-Type")

    let fileSize = (try? FileManager.default.attributesOfItem(atPath: fileURL.path)[.size] as? Int64) ?? 0
    request.setValue("\(fileSize)", forHTTPHeaderField: "Content-Length")

    let signedRequest = AWSV4Signer.sign(
        request: request,
        credentials: credentials,
        payloadHash: "UNSIGNED-PAYLOAD"
    )

    let delegate = UploadProgressDelegate(onProgress: onProgress)
    let session = URLSession(configuration: .default, delegate: delegate, delegateQueue: nil)
    defer { session.finishTasksAndInvalidate() }

    let (data, response) = try await session.upload(for: signedRequest, fromFile: fileURL)
    let statusCode = (response as? HTTPURLResponse)?.statusCode ?? 0
    return UploadResult(httpStatusCode: statusCode, responseBody: data)
}

private final class UploadProgressDelegate: NSObject, URLSessionTaskDelegate, @unchecked Sendable {
    private let onProgress: @MainActor @Sendable (Int64, Int64) -> Void

    init(onProgress: @MainActor @escaping @Sendable (Int64, Int64) -> Void) {
        self.onProgress = onProgress
    }

    nonisolated func urlSession(
        _ session: URLSession,
        task: URLSessionTask,
        didSendBodyData bytesSent: Int64,
        totalBytesSent: Int64,
        totalBytesExpectedToSend: Int64
    ) {
        let handler = onProgress
        let sent = totalBytesSent
        let total = totalBytesExpectedToSend
        Task { @MainActor in
            handler(sent, total)
        }
    }
}

let result = try await R2UploadService.upload(
    fileURL: resolvedFileURL,
    credentials: credentials,
    key: key,
    contentType: contentType,
    onProgress: { [weak uploadTask] sent, total in
        guard let uploadTask else { return }
        uploadTask.progress = total > 0 ? Double(sent) / Double(total) : 0
    }
)

@Observable
final class FileUploadTask: Identifiable {
    let id: UUID
    let fileName: String
    let fileSize: Int64
    let fileURL: URL

    var progress: Double = 0  // 0.0 – 1.0
    var status: Status = .pending
    var errorMessage: String?
    var resultURL: URL?
    /// When set, used as the full R2 key instead of generating a random-prefix key.
    /// Used for folder-aware uploads from the browser.
    var uploadKey: String?
    /// Security-scoped bookmark for a parent folder (used when uploading folders).
    var parentFolderBookmark: Data?
    /// Security-scoped bookmark for the file itself (used when uploading individual files via file picker).
    var fileBookmark: Data?

    enum Status: Sendable {
        case pending
        case uploading
        case completed
        case failed
        case cancelled
    }

    /// The running upload task — held so it can be cancelled.
    var uploadTask: Task<Void, Never>?

    init(fileURL: URL, fileName: String, fileSize: Int64) {
        self.id = UUID()
        self.fileURL = fileURL
        self.fileName = fileName
        self.fileSize = fileSize
    }

    func cancel() {
        uploadTask?.cancel()
        uploadTask = nil
        status = .cancelled
    }
}

func cancel() {
    uploadTask?.cancel()
    uploadTask = nil
    status = .cancelled
}

catch is CancellationError {
    if uploadTask.status != .cancelled {
        uploadTask.status = .cancelled
    }
}

if (200...299).contains(result.httpStatusCode) {
    let publicURL = credentials.publicURL(forKey: key)
    uploadTask.resultURL = publicURL
    uploadTask.progress = 1.0
    uploadTask.status = .completed
    loadCurrentFolder()

    let item = UploadItem(
        fileName: uploadTask.fileName,
        fileSize: uploadTask.fileSize,
        r2Key: key,
        publicURL: publicURL
    )
    historyStore.add(item)
    copyToClipboard(publicURL.absoluteString)
    clipboardToastFileName = uploadTask.fileName
    Task { @MainActor in
        try? await Task.sleep(for: .seconds(2.5))
        if clipboardToastFileName == uploadTask.fileName {
            clipboardToastFileName = nil
        }
    }
}

// Save a security-scoped bookmark while we still have access,
// so uploadSingleFile can re-open the file later on a background task.
let bookmark = try? url.bookmarkData(options: [.withSecurityScope],
                                     includingResourceValuesForKeys: nil,
                                     relativeTo: nil)

let task = FileUploadTask(fileURL: url, fileName: fileName, fileSize: fileSize)
task.fileBookmark = bookmark
if !currentPrefix.isEmpty {
    task.uploadKey = currentPrefix + fileName
}
tasks.append(task)

var resolvedFileURL = fileURL
var fileAccessing = false
if let bookmark = uploadTask.fileBookmark {
    var isStale = false
    if let resolved = try? URL(resolvingBookmarkData: bookmark,
                               options: [.withSecurityScope],
                               relativeTo: nil,
                               bookmarkDataIsStale: &isStale) {
        resolvedFileURL = resolved
        fileAccessing = resolved.startAccessingSecurityScopedResource()
    }
} else {
    fileAccessing = fileURL.startAccessingSecurityScopedResource()
}
defer { if fileAccessing { resolvedFileURL.stopAccessingSecurityScopedResource() } }

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 {
        let fileAccessing = fileURL.startAccessingSecurityScopedResource()
        defer { if fileAccessing { fileURL.stopAccessingSecurityScopedResource() } }

        let values = try? fileURL.resourceValues(forKeys: [.isDirectoryKey, .fileSizeKey])
        guard values?.isDirectory == false else { continue }

        // Preserve relative path: dirName/relative/path/to/file
        let relativePath = fileURL.path.replacingOccurrences(
            of: url.deletingLastPathComponent().path + "/",
            with: ""
        )
        let r2Key = currentPrefix + relativePath
        let fileName = fileURL.lastPathComponent
        let fileSize = Int64(values?.fileSize ?? 0)

        let task = FileUploadTask(fileURL: fileURL, fileName: fileName, fileSize: fileSize)
        task.uploadKey = r2Key
        task.parentFolderBookmark = folderBookmark
        tasks.append(task)
    }
}

private func mimeType(for url: URL) -> String {
    if let type = UTType(filenameExtension: url.pathExtension) {
        return type.preferredMIMEType ?? "application/octet-stream"
    }
    return "application/octet-stream"
}

request.setValue(contentType, forHTTPHeaderField: "Content-Type")

if (200...299).contains(result.httpStatusCode) {
    // Success path...
} else {
    let body = String(data: result.responseBody, encoding: .utf8) ?? "Unknown error"
    uploadTask.status = .failed
    uploadTask.errorMessage = "HTTP \(result.httpStatusCode): \(body)"
}

// Handle other errors
catch is CancellationError {
    if uploadTask.status != .cancelled {
        uploadTask.status = .cancelled
    }
} catch {
    uploadTask.status = .failed
    uploadTask.errorMessage = error.localizedDescription
}