15. Swift Concurrency: withCheckedContinuation — Bridge Delegate

// Simpan continuation sebagai property — harus @unchecked Sendable karena
// UIImagePickerControllerDelegate callback datang dari main thread,
// dan continuation sendiri adalah Sendable.
@MainActor
final class UserListViewController: UIViewController {
    // ...existing code...

    // Menyimpan continuation di antara method pickImage() dan delegate callback.
    // CheckedContinuation tidak boleh diakses dari banyak thread, tapi karena
    // kita di @MainActor, ini aman.
    private var imageContinuation: CheckedContinuation<UIImage?, Never>?

    // API lama (UIImagePickerController) dibungkus menjadi async.
    // Caller cukup: let image = await pickAvatarImage()
    func pickAvatarImage() async -> UIImage? {
        // withCheckedContinuation menangguhkan eksekusi di sini.
        // Eksekusi dilanjutkan ketika imageContinuation.resume() dipanggil.
        await withCheckedContinuation { continuation in
            self.imageContinuation = continuation

            let picker = UIImagePickerController()
            picker.sourceType = .photoLibrary
            picker.delegate = self
            present(picker, animated: true)
        }
    }
}

// MARK: - UIImagePickerControllerDelegate

extension UserListViewController: UIImagePickerControllerDelegate, UINavigationControllerDelegate {

    func imagePickerController(
        _ picker: UIImagePickerController,
        didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey: Any]
    ) {
        let image = info[.originalImage] as? UIImage
        dismiss(animated: true)

        // Resume continuation dengan hasil — eksekusi di 'await withCheckedContinuation'
        // dilanjutkan, dan 'image' menjadi return value dari pickAvatarImage().
        imageContinuation?.resume(returning: image)
        imageContinuation = nil    // WAJIB: nil-kan setelah resume untuk mencegah double-resume
    }

    func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
        dismiss(animated: true)

        // User cancel — resume dengan nil. Continuation HARUS di-resume
        // dalam semua code path, jika tidak caller akan hang selamanya.
        imageContinuation?.resume(returning: nil)
        imageContinuation = nil
    }
}

// Dari action button "Ganti Avatar" — ini async yang bersih, tidak ada callback nesting.
@objc private func handleChangeAvatar() {
    Task {
        guard let image = await pickAvatarImage() else { return }
        // Lanjutkan dengan image yang dipilih user
        await interactor?.uploadAvatar(image: image)
    }
}

import CoreLocation

// Wrapper CLLocationManager yang mengubah delegate pattern menjadi async.
// Menggunakan 'withCheckedThrowingContinuation' karena lokasi bisa gagal (denied, timeout).
final class LocationService: NSObject, CLLocationManagerDelegate {

    private let manager = CLLocationManager()
    private var locationContinuation: CheckedContinuation<CLLocationCoordinate2D, Error>?

    func requestCurrentLocation() async throws -> CLLocationCoordinate2D {
        try await withCheckedThrowingContinuation { continuation in
            self.locationContinuation = continuation
            manager.delegate = self
            manager.requestWhenInUseAuthorization()
            manager.requestLocation()    // Single location request, calls delegate once
        }
    }

    // MARK: - CLLocationManagerDelegate

    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
        guard let location = locations.first else { return }
        locationContinuation?.resume(returning: location.coordinate)
        locationContinuation = nil
    }

    func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
        // Resume dengan error — caller akan catch ini.
        locationContinuation?.resume(throwing: error)
        locationContinuation = nil
    }
}

// Penggunaan di Interactor:
actor UserListInteractor: UserListBusinessLogic, UserListDataStore {
    private let locationService = LocationService()

    func fetchNearbyUsers() async {
        do {
            let coordinate = try await locationService.requestCurrentLocation()
            let users = try await worker.fetchUsers(near: coordinate)
            cachedUsers = users
            await presenter?.presentUsers(UserList.FetchUsers.Response(users: users, stats: nil, featuredUser: nil))
        } catch {
            await presenter?.presentError(error)
        }
    }
}

// Ketika butuh upload progress — URLSession.upload(for:from:) tidak memberikan progress.
// Kita harus pakai delegate, lalu bridge ke async.
actor UploadService: NSObject, URLSessionTaskDelegate {

    private var progressContinuation: AsyncStream<Double>.Continuation?

    func uploadWithProgress(data: Data, to url: URL) -> (
        progress: AsyncStream<Double>,
        result: Task<Data, Error>
    ) {
        let (stream, continuation) = AsyncStream.makeStream(of: Double.self)
        self.progressContinuation = continuation

        let task = Task {
            try await withCheckedThrowingContinuation { (cont: CheckedContinuation<Data, Error>) in
                var request = URLRequest(url: url)
                request.httpMethod = "POST"
                request.httpBody = data

                let session = URLSession(configuration: .default, delegate: self, delegateQueue: nil)
                session.uploadTask(with: request, from: data) { data, _, error in
                    if let error {
                        cont.resume(throwing: error)
                    } else {
                        cont.resume(returning: data ?? Data())
                    }
                    continuation.finish()
                }.resume()
            }
        }

        return (progress: stream, result: task)
    }

    // Delegate untuk progress — dipanggil oleh URLSession
    nonisolated func urlSession(
        _ session: URLSession,
        task: URLSessionTask,
        didSendBodyData bytesSent: Int64,
        totalBytesSent: Int64,
        totalBytesExpectedToSend: Int64
    ) {
        let progress = Double(totalBytesSent) / Double(totalBytesExpectedToSend)
        Task { await updateProgress(progress) }
    }

    private func updateProgress(_ progress: Double) {
        progressContinuation?.yield(progress)
    }
}

// Penggunaan:
func uploadAvatar() async {
    guard let imageData = UIImage(named: "avatar")?.jpegData(compressionQuality: 0.8) else { return }
    let uploadService = UploadService()
    let url = URL(string: "https://api.example.com/avatar")!

    let (progressStream, resultTask) = uploadService.uploadWithProgress(data: imageData, to: url)

    // Pantau progress di Task terpisah
    Task {
        for await progress in progressStream {
            await MainActor.run {
                print("Upload progress: \(Int(progress * 100))%")
                // Update progress bar di UI
            }
        }
    }

    // Tunggu hasil upload
    do {
        let responseData = try await resultTask.value
        print("Upload berhasil: \(responseData.count) bytes response")
    } catch {
        print("Upload gagal: \(error)")
    }
}