Потоки и задачи в Swift Concurrency

// Старый подход с GCD
DispatchQueue.global().async {
    let data = loadDataFromNetwork()
    DispatchQueue.main.async {
        self.updateUI(with: data)
    }
}
 
// Новый подход с Swift Concurrency
Task {
    let data = try await loadDataFromNetwork()
    await MainActor.run {
        self.updateUI(with: data)
    }
}

let thread = Thread {
    let image = self.processLargeImage()
    Thread.main.execute {
        self.imageView.image = image
    }
}
thread.start()

// Выполнить тяжелую задачу в фоне
DispatchQueue.global(qos: .userInitiated).async {
    let result = heavyComputation()
    
    // Обновить UI в главном потоке
    DispatchQueue.main.async {
        self.updateUI(with: result)
    }
}

DispatchQueue.global().async {
    // Загружаем данные пользователя
    self.loadUserData { userData in
        // Загружаем список друзей
        self.loadFriends(for: userData) { friends in
            // Загружаем фото друзей
            self.loadPhotos(for: friends) { photos in
                // Обрабатываем фото
                let processedPhotos = self.processPhotos(photos)
                
                // Обновляем UI
                DispatchQueue.main.async {
                    self.updateUI(with: processedPhotos)
                }
            }
        }
    }
}

class NetworkManager {
    func fetchData() {
        DispatchQueue.global().async {
            // Долгая операция
            let data = self.heavyNetworkRequest()
            
            DispatchQueue.main.async {
                self.processData(data)
            }
        }
    }
}

DispatchQueue.global().async { [weak self] in
    guard let self = self else { return }
    let data = self.heavyNetworkRequest()
    
    DispatchQueue.main.async { [weak self] in
        guard let self = self else { return }
        self.processData(data)
    }
}

firstly {
    fetchUserProfile()
}.then { profile in
    fetchUserFriends(profile.id)
}.then { friends in
    fetchFriendsPhotos(friends)
}.done { photos in
    self.updateUI(with: photos)
}.catch { error in
    self.handleError(error)
}

fetchUser()
    .flatMap { user in fetchFriends(for: user) }
    .flatMap { friends in fetchPhotos(for: friends) }
    .observeOn(MainScheduler.instance)
    .subscribe(
        onNext: { photos in self.updateUI(with: photos) },
        onError: { error in self.handleError(error) }
    )
    .disposed(by: disposeBag)

class ImageDownloader {
    var onComplete: ((UIImage) -> Void)?
    
    func downloadImage() {
        // self захватывается сильно внутри замыкания
        networkService.fetchImage { image in
            self.processImage(image)
            self.onComplete?(image)
        }
    }
}

// Создание потока напрямую - дорогая операция
let thread = Thread {
    performHeavyCalculation()
    print("Расчет завершен")
}
thread.start()

// Создание задачи - легковесная операция
Task {
    let result = await performHeavyCalculation()
    print("Расчет завершен с результатом: \(result)")
}

func processUserData() async throws {
    // Создаем группу дочерних задач
    try await withThrowingTaskGroup(of: Void.self) { group in
        // Добавляем задачу загрузки профиля
        group.addTask {
            try await self.downloadUserProfile()
        }
        
        // Добавляем задачу загрузки настроек
        group.addTask {
            try await self.downloadUserSettings()
        }
        
        // Ждем завершения всех задач или первой ошибки
        try await group.waitForAll()
    }
    
    // Код здесь выполнится только после завершения всех задач выше
    print("Все данные пользователя загружены")
}

someQueue.async { [weak self] in
    guard let self = self else { return }
    // Использование self
}

Task {
    // self захватывается не сильно, а соответствующим образом
    let result = await processData()
    updateUI(with: result)
}

let task = Task {
    try await performLongOperation()
}
 
// Где-то в другом месте кода
task.cancel()

func performLongOperation() async throws {
    for i in 1...1000 {
        try Task.checkCancellation() // Бросает CancellationError если задача отменена
        
        // Или
        if Task.isCancelled {
            // Обработка отмены
            return
        }
        
        // Выполнение части работы
        await processChunk(i)
    }
}

func fetchAndProcessData() async throws {
    let data = try await fetchDataFromServer() // Точка приостановки
    let processedData = processData(data)
    try await saveToDatabase(processedData) // Еще одна точка приостановки
    return processedData
}

struct ThreadingDemonstrator {
    private func firstTask() async throws {
        print("Задача 1 началась на потоке: \(Thread.current)")
        try await Task.sleep(for: .seconds(2))
        print("Задача 1 возобновилась на потоке: \(Thread.current)")
    }
 
    private func secondTask() async {
        print("Задача 2 началась на потоке: \(Thread.current)")
    }
 
    func demonstrate() {
        Task {
            try? await firstTask()
        }
        Task {
            await secondTask()
        }
    }
}

Задача 1 началась на потоке: <NSThread: 0x600001752200>{number = 3, name = (null)}
Задача 2 началась на потоке: <NSThread: 0x6000017b03c0>{number = 8, name = (null)}
Задача 1 возобновилась на потоке: <NSThread: 0x60000176ecc0>{number = 7, name = (null)}

// Задача с высоким приоритетом
Task(priority: .high) {
    await highPriorityWork()
}
 
// Задача со стандартным приоритетом
Task {
    await standardPriorityWork()
}

func processImage() async throws -> UIImage {
    let data = try await downloadImageData() // Точка приостановки 1
    let image = try await decodeImage(data) // Точка приостановки 2
    let processedImage = try await applyFilters(to: image) // Точка приостановки 3
    return processedImage
}

// Старый подход с GCD
DispatchQueue.global().async {
    let data = processData()
    DispatchQueue.main.async {
        self.updateUI(with: data)
    }
}

// Современный подход с MainActor
Task {
    let data = await processData()
    await MainActor.run {
        updateUI(with: data)
    }
}
 
// Или с использованием аннотации
@MainActor
func updateUserInterface() {
    // Этот код всегда выполняется в главном потоке
}

// Запуск асинхронного кода из синхронного контекста
Task {
    let result = await performAsyncOperation()
    print(result)
}
 
// Интеграция колбек-API с async/await
func fetchData() async throws -> Data {
    return try await withCheckedThrowingContinuation { continuation in
        oldFashionedAPI.fetchData { result, error in
            if let error = error {
                continuation.resume(throwing: error)
            } else if let result = result {
                continuation.resume(returning: result)
            } else {
                continuation.resume(throwing: NSError(domain: "Unknown", code: -1))
            }
        }
    }
}
 
// Запуск кода в конкретной GCD-очереди
await withUnsafeContinuation { continuation in
    DispatchQueue.global(qos: .utility).async {
        let result = performWorkInSpecificQueue()
        continuation.resume(returning: result)
    }
}

// Классический пример, создающий потенциально сотни потоков
for item in hugeArray {
    DispatchQueue.global().async {
        processItem(item) // Долгая блокирующая операция
    }
}

// Современный подход с ограниченным количеством потоков
await withTaskGroup(of: Void.self) { group in
    for item in hugeArray {
        group.addTask {
            await processItem(item)
        }
    }
}

Task(priority: .high) {
    // Высокоприоритетная задача
    await performCriticalOperation()
}
 
Task(priority: .low) {
    // Низкоприоритетная задача
    await performBackgroundIndexing()
}

let task = Task {
    for i in 1...1000 {
        if Task.isCancelled {
            print("Задача отменена на шаге \(i)")
            break
        }
        await processBatch(i)
    }
}
 
// Где-то в другом месте кода
task.cancel()

// Пример кода с использованием Task Detached для отладки
Task.detached(priority: .high) {
    print("Начало выполнения задачи: \(Date())")
    await someAsyncOperation()
    print("Завершение задачи: \(Date())")
}

// Неправильный подход: мышление в стиле GCD
Task {
    // "Фоновая" работа
    let data = await fetchData()
    
    // Обновление UI
    await MainActor.run {
        // Но зачем? Мы ведь уже в асинхронном контексте!
        Task { @MainActor in
            self.updateUI(with: data)
        }
    }
}

// Правильный подход
Task {
    let data = await fetchData()
    
    await MainActor.run {
        self.updateUI(with: data)
    }
}

// Задача создается, но нигде не сохраняется
func loadData() {
    Task {
        let data = try? await networkService.fetchData()
        // Обработка данных
    }
}

// Правильное управление жизненным циклом задач
class DataLoader {
    private var loadingTask: Task<Void, Error>?
    
    func loadData() {
        // Отменяем предыдущую задачу, если она существует
        loadingTask?.cancel()
        
        loadingTask = Task {
            do {
                let data = try await networkService.fetchData()
                // Обработка данных
            } catch {
                // Обработка ошибки
            }
        }
    }
    
    deinit {
        loadingTask?.cancel()
    }
}

// Ненужное создание задачи
func processImage() async throws -> UIImage {
    // Зачем создавать новую задачу? Мы уже в асинхронном контексте!
    return try await Task {
        let data = try await downloadImageData()
        return try await processData(data)
    }.value
}

// Простой асинхронный поток
func processImage() async throws -> UIImage {
    let data = try await downloadImageData()
    return try await processData(data)
}

// Игнорирование отмены
func processLargeDataSet() async throws -> [Result] {
    var results = [Result]()
    for item in largeDataSet {
        // Если задача отменена, мы всё равно продолжаем работу!
        let result = try await processItem(item)
        results.append(result)
    }
    return results
}
 
// Корректная обработка отмены
func processLargeDataSet() async throws -> [Result] {
    var results = [Result]()
    for item in largeDataSet {
        try Task.checkCancellation() // Бросает ошибку, если задача отменена
        let result = try await processItem(item)
        results.append(result)
    }
    return results
}

// Глубокий колбек-ад
networkService.fetchUser(id: userId) { user, error in
    guard let user = user, error == nil else {
        self.handleError(error!)
        return
    }
    
    self.databaseService.loadUserSettings(for: user) { settings, error in
        guard let settings = settings, error == nil else {
            self.handleError(error!)
            return
        }
        
        self.analyticsService.trackUserActivity(user, settings) { success, error in
            guard success, error == nil else {
                self.handleError(error!)
                return
            }
            
            DispatchQueue.main.async {
                self.updateUI(with: user, settings)
            }
        }
    }
}

// Шаг 1: Преобразование отдельных методов в асинхронные
extension NetworkService {
    func fetchUser(id: String) async throws -> User {
        try await withCheckedThrowingContinuation { continuation in
            fetchUser(id: id) { user, error in
                if let user = user {
                    continuation.resume(returning: user)
                } else {
                    continuation.resume(throwing: error ?? UnknownError())
                }
            }
        }
    }
}
 
// Аналогично для других сервисов...

// Шаг 2: Использование преобразованных методов
async func handleUserFlow() async throws {
    do {
        let user = try await networkService.fetchUser(id: userId)
        let settings = try await databaseService.loadUserSettings(for: user)
        let success = try await analyticsService.trackUserActivity(user, settings)
        
        await MainActor.run {
            self.updateUI(with: user, settings)
        }
    } catch {
        await MainActor.run {
            self.handleError(error)
        }
    }
}

// Мост от GCD к async/await
extension LegacyService {
    func modernFetch() async throws -> Data {
        try await withCheckedThrowingContinuation { continuation in
            legacyFetch { result, error in
                if let error = error {
                    continuation.resume(throwing: error)
                } else {
                    continuation.resume(returning: result ?? Data())
                }
            }
        }
    }
}
 
// Мост от async/await к GCD
func legacyInterface(completion: @escaping (Result<Data, Error>) -> Void) {
    Task {
        do {
            let data = try await modernAsyncFunction()
            completion(.success(data))
        } catch {
            completion(.failure(error))
        }
    }
}

// Старый подход с GCD-барьером
class UserCache {
    private let queue = DispatchQueue(label: "com.app.usercache", attributes: .concurrent)
    private var cache: [String: User] = [:]
    
    func getUser(id: String) -> User? {
        var result: User?
        queue.sync {
            result = cache[id]
        }
        return result
    }
    
    func setUser(_ user: User, forId id: String) {
        queue.async(flags: .barrier) {
            self.cache[id] = user
        }
    }
}
 
// Новый подход с актором
actor UserCache {
    private var cache: [String: User] = [:]
    
    func getUser(id: String) -> User? {
        return cache[id]
    }
    
    func setUser(_ user: User, forId id: String) {
        cache[id] = user
    }
}

// Создание таймера через AsyncSequence
func timer(interval: TimeInterval) -> AsyncStream<Date> {
    AsyncStream { continuation in
        let timer = Timer.scheduledTimer(withTimeInterval: interval, repeats: true) { timer in
            continuation.yield(Date())
        }
        
        continuation.onTermination = { _ in
            timer.invalidate()
        }
    }
}
 
// Использование
Task {
    for await date in timer(interval: 1.0) {
        // Обработка каждого тика таймера
        print("Timer tick at \(date)")
    }
}

// Бенчмарк для GCD
func benchmarkGCD(iterations: Int, completion: @escaping (TimeInterval) -> Void) {
    let startTime = CFAbsoluteTimeGetCurrent()
    let group = DispatchGroup()
    
    for _ in 0..<iterations {
        group.enter()
        DispatchQueue.global().async {
            // Имитация работы
            Thread.sleep(forTimeInterval: 0.01)
            group.leave()
        }
    }
    
    group.notify(queue: .main) {
        let timeElapsed = CFAbsoluteTimeGetCurrent() - startTime
        completion(timeElapsed)
    }
}
 
// Бенчмарк для Swift Concurrency
func benchmarkSwiftConcurrency(iterations: Int) async -> TimeInterval {
    let startTime = CFAbsoluteTimeGetCurrent()
    
    await withTaskGroup(of: Void.self) { group in
        for _ in 0..<iterations {
            group.addTask {
                // Имитация той же работы
                try? await Task.sleep(nanoseconds: 10_000_000) // 0.01 секунды
            }
        }
    }
    
    return CFAbsoluteTimeGetCurrent() - startTime
}

// Неоптимальный подход: слишком много точек приостановки
func processItems(_ items: [Item]) async throws -> [Result] {
    var results = [Result]()
    for item in items {
        // Каждая итерация содержит точку приостановки
        let result = try await processItem(item)
        results.append(result)
    }
    return results
}
 
// Оптимизированный подход: параллельная обработка с одной точкой ожидания
func processItems(_ items: [Item]) async throws -> [Result] {
    try await withThrowingTaskGroup(of: (Int, Result).self) { group in
        for (index, item) in items.enumerated() {
            group.addTask {
                let result = try await processItem(item)
                return (index, result)
            }
        }
        
        // Только одна точка ожидания для всех задач
        var indexedResults = [(Int, Result)]()
        for try await result in group {
            indexedResults.append(result)
        }
        
        // Восстановление порядка результатов
        return indexedResults.sorted { $0.0 < $1.0 }.map { $0.1 }
    }
}

// Традиционный подход с GCD
let backgroundContext = persistentContainer.newBackgroundContext()
backgroundContext.perform {
    // Операции с базой данных в фоновом контексте
    try? backgroundContext.save()
    
    // Обновление UI в главном потоке
    DispatchQueue.main.async {
        self.updateUI()
    }
}

// Современный подход с Core Data и Swift Concurrency
actor CoreDataController {
    let container: NSPersistentContainer
    
    init() {
        container = NSPersistentContainer(name: "MyModel")
        container.loadPersistentStores { _, error in
            if let error = error {
                fatalError("Failed to load Core Data stack: \(error)")
            }
        }
    }
    
    func performBackgroundTask<T>(_ task: @escaping (NSManagedObjectContext) throws -> T) async throws -> T {
        let context = container.newBackgroundContext()
        return try await withCheckedThrowingContinuation { continuation in
            context.perform {
                do {
                    let result = try task(context)
                    continuation.resume(returning: result)
                } catch {
                    continuation.resume(throwing: error)
                }
            }
        }
    }
    
    func saveEntities<T: NSManagedObject>(of type: T.Type, with data: [Any]) async throws -> [T] {
        try await performBackgroundTask { context in
            var entities = [T]()
            
            // Создание и настройка сущностей...
            
            try context.save()
            return entities
        }
    }
}
 
// Использование
let coreDataController = CoreDataController()
 
Task {
    do {
        let entities = try await coreDataController.saveEntities(of: MyEntity.self, with: data)
        await MainActor.run {
            updateUI(with: entities)
        }
    } catch {
        print("Error: \(error)")
    }
}

// Старый подход с GCD
class WebSocketManager {
private let queue = DispatchQueue(label: "com.app.websocket", qos: .userInitiated)
private var webSocket: WebSocket?
private var isConnected = false
 
func connect() {
    queue.async {
        self.webSocket = WebSocket(url: self.serverURL)
        self.webSocket?.connect()
    }
}
 
func sendMessage(_ message: String) {
    queue.async {
        guard self.isConnected else {
            self.messageBuffer.append(message)
            return
        }
        self.webSocket?.send(message)
    }
}
 
// ...и много другого кода для обработки сообщений и ошибок
}

actor WebSocketClient {
private var webSocket: WebSocket?
private var messageStream: AsyncStream<String>?
private var messageStreamContinuation: AsyncStream<String>.Continuation?
 
func connect() async throws {
    webSocket = WebSocket(url: serverURL)
    
    // Создаем AsyncStream для сообщений
    messageStream = AsyncStream { continuation in
        self.messageStreamContinuation = continuation
        
        webSocket?.onMessage = { message in
            continuation.yield(message)
        }
        
        webSocket?.onDisconnect = { error in
            continuation.finish()
        }
        
        continuation.onTermination = { _ in
            self.disconnect()
        }
    }
    
    try await webSocket?.connect()
}
 
func disconnect() {
    webSocket?.disconnect()
    messageStreamContinuation?.finish()
}
 
func sendMessage(_ message: String) async throws {
    guard let webSocket = webSocket else {
        throw WebSocketError.notConnected
    }
    
    try await webSocket.send(message)
}
 
func messages() -> AsyncStream<String>? {
    return messageStream
}
}
 
// Использование в реальном времени
Task {
let client = WebSocketClient()
try await client.connect()
 
// Слушаем сообщения
if let messageStream = client.messages() {
    for await message in messageStream {
        await MainActor.run {
            chatView.addMessage(message)
        }
    }
}
}
 
// Отправка сообщения
Task {
try await client.sendMessage("Hello!")
}

func fetchPatientData(completion: @escaping (Result<PatientData, Error>) -> Void) {
    let group = DispatchGroup()
    
    var medicalHistory: MedicalHistory?
    var medications: [Medication] = []
    var labResults: [LabResult] = []
    var errors: [Error] = []
    
    // Загрузка истории болезни
    group.enter()
    apiService.fetchMedicalHistory(patientId: patientId) { result in
        switch result {
        case .success(let history):
            medicalHistory = history
        case .failure(let error):
            errors.append(error)
        }
        group.leave()
    }
    
    // Загрузка списка лекарств
    group.enter()
    apiService.fetchMedications(patientId: patientId) { result in
        switch result {
        case .success(let meds):
            medications = meds
        case .failure(let error):
            errors.append(error)
        }
        group.leave()
    }
    
    // Загрузка результатов анализов
    group.enter()
    apiService.fetchLabResults(patientId: patientId) { result in
        switch result {
        case .success(let labs):
            labResults = labs
        case .failure(let error):
            errors.append(error)
        }
        group.leave()
    }
    
    group.notify(queue: .main) {
        if !errors.isEmpty {
            completion(.failure(PatientDataError.multipleFetchErrors(errors)))
            return
        }
        
        guard let history = medicalHistory else {
            completion(.failure(PatientDataError.missingCriticalData))
            return
        }
        
        let patientData = PatientData(
            medicalHistory: history,
            medications: medications,
            labResults: labResults
        )
        
        completion(.success(patientData))
    }
}

func fetchPatientData() async throws -> PatientData {
    async let historyTask = apiService.fetchMedicalHistory(patientId: patientId)
    async let medicationsTask = apiService.fetchMedications(patientId: patientId)
    async let labResultsTask = apiService.fetchLabResults(patientId: patientId)
    
    do {
        let history = try await historyTask
        let medications = try await medicationsTask
        let labResults = try await labResultsTask
        
        return PatientData(
            medicalHistory: history,
            medications: medications,
            labResults: labResults
        )
    } catch {
        throw PatientDataError.fetchFailed(error)
    }
}

class FeedLoader {
    private let operationQueue = OperationQueue()
    
    func loadFeed(completion: @escaping (Result<[Post], Error>) -> Void) {
        // Загрузка базовых данных постов
        networkService.fetchPosts { [weak self] result in
            guard let self = self, let posts = try? result.get() else {
                completion(.failure(FeedError.unableToLoadPosts))
                return
            }
            
            // Если нет постов, сразу возвращаем пустой массив
            if posts.isEmpty {
                completion(.success([]))
                return
            }
            
            // Создаем операции для загрузки изображений
            let operations: [Operation] = posts.map { post in
                return ImageLoadOperation(post: post)
            }
            
            // Операция завершения
            let completionOperation = BlockOperation {
                // Получаем посты с изображениями
                let postsWithImages = posts.compactMap { post -> Post? in
                    if let op = operations.first(where: { ($0 as? ImageLoadOperation)?.post.id == post.id }),
                       let imageOp = op as? ImageLoadOperation {
                        var updatedPost = post
                        updatedPost.image = imageOp.loadedImage
                        return updatedPost
                    }
                    return post
                }
                
                DispatchQueue.main.async {
                    completion(.success(postsWithImages))
                }
            }
            
            // Устанавливаем зависимости
            for operation in operations {
                completionOperation.addDependency(operation)
            }
            
            // Запускаем операции
            self.operationQueue.addOperations(operations, waitUntilFinished: false)
            self.operationQueue.addOperation(completionOperation)
        }
    }
}

struct FeedLoader {
    func loadFeed() async throws -> [Post] {
        // Загрузка базовых данных постов
        let posts = try await networkService.fetchPosts()
        
        // Если нет постов, сразу возвращаем пустой массив
        if posts.isEmpty {
            return []
        }
        
        // Загружаем изображения параллельно с помощью TaskGroup
        return try await withThrowingTaskGroup(of: Post.self) { group in
            // Добавляем задачу для каждого поста
            for post in posts {
                group.addTask {
                    var updatedPost = post
                    if let imageURL = post.imageURL {
                        do {
                            let (imageData, _) = try await URLSession.shared.data(from: imageURL)
                            updatedPost.image = UIImage(data: imageData)
                        } catch {
                            print("Failed to load image for post \(post.id): \(error)")
                        }
                    }
                    return updatedPost
                }
            }
            
            // Собираем результаты
            var postsWithImages: [Post] = []
            for try await post in group {
                postsWithImages.append(post)
            }
            
            // Сортируем по оригинальному порядку
            return postsWithImages.sorted { posts.firstIndex(of: $0)! < posts.firstIndex(of: $1)! }
        }
    }
}

func applyFilters(to image: UIImage, filters: [ImageFilter], completion: @escaping (Result<UIImage, Error>) -> Void) {
    guard let ciImage = CIImage(image: image) else {
        completion(.failure(FilterError.invalidInputImage))
        return
    }
    
    let processingQueue = DispatchQueue(label: "image.processing", qos: .userInitiated)
    
    processingQueue.async {
        var currentImage = ciImage
        let context = CIContext(options: nil)
        
        for filter in filters {
            autoreleasepool {
                guard let filtered = filter.apply(to: currentImage) else {
                    DispatchQueue.main.async {
                        completion(.failure(FilterError.filterApplicationFailed))
                    }
                    return
                }
                currentImage = filtered
            }
        }
        
        guard let outputCGImage = context.createCGImage(currentImage, from: currentImage.extent) else {
            DispatchQueue.main.async {
                completion(.failure(FilterError.renderingFailed))
            }
            return
        }
        
        let outputImage = UIImage(cgImage: outputCGImage)
        
        DispatchQueue.main.async {
            completion(.success(outputImage))
        }
    }
}

func applyFilters(to image: UIImage, filters: [ImageFilter]) async throws -> UIImage {
    guard let ciImage = CIImage(image: image) else {
        throw FilterError.invalidInputImage
    }
    
    var currentImage = ciImage
    let context = CIContext(options: nil)
    
    for filter in filters {
        if Task.isCancelled {
            throw CancellationError()
        }
        
        // Некоторые фильтры могут быть асинхронными (например, фильтры с ML)
        if filter is AsyncImageFilter {
            currentImage = try await (filter as! AsyncImageFilter).applyAsync(to: currentImage)
        } else {
            guard let filtered = filter.apply(to: currentImage) else {
                throw FilterError.filterApplicationFailed
            }
            currentImage = filtered
        }
    }
    
    // Рендеринг может быть длительным, выполняем его в Task, чтобы можно было отменить
    guard let outputCGImage = try await Task {
        if Task.isCancelled { throw CancellationError() }
        return context.createCGImage(currentImage, from: currentImage.extent)
    }.value else {
        throw FilterError.renderingFailed
    }
    
    return UIImage(cgImage: outputCGImage)
}