Mastering Swift Concurrency: A Deep Dive into async/await

func fetchDataOld(completion: @escaping (Result<Data, Error>) -> Void) {
    DispatchQueue.global().async {
        // Simulate a network request
        Thread.sleep(forTimeInterval: 2)
        if Bool.random() {
            completion(.success(Data("Hello, Async!".utf8)))
        } else {
            completion(.failure(URLError(.notConnectedToInternet)))
        }
    }
}

enum DataError: Error {
    case networkError
    case decodingError
}

func fetchData() async throws -> Data {
    // Simulate a network request
    try await Task.sleep(nanoseconds: 2 * 1_000_000_000) // Sleep for 2 seconds
    if Bool.random() {
        return Data("Hello, Async Await!".utf8)
    } else {
        throw DataError.networkError
    }
}

// How to call an async function from a synchronous context (e.g., a button tap)
@MainActor
func someAction() {
    Task {
        do {
            let data = try await fetchData()
            let message = String(decoding: data, as: UTF8.self)
            print("Fetched data: \(message)")
        } catch {
            print("Failed to fetch data: \(error.localizedDescription)")
        }
    }
}

func fetchUserProfile() async throws -> String {
    try await Task.sleep(nanoseconds: 1 * 1_000_000_000)
    return "User Profile Data"
}

func fetchUserFeed() async throws -> String {
    try await Task.sleep(nanoseconds: 3 * 1_000_000_000)
    return "User Feed Data (heavy operation)"
}

func loadUserDataConcurrently() async {
    print("Loading user data concurrently...")
    do {
        async let profile = fetchUserProfile()
        async let feed = fetchUserFeed()

        let userProfileData = try await profile // Waits for profile to complete
        let userFeedData = try await feed     // Waits for feed to complete

        print("\n--- Concurrency Results ---")
        print("Profile: \(userProfileData)")
        print("Feed: \(userFeedData)")
        print("---------------------------")

    } catch {
        print("Error loading user data: \(error.localizedDescription)")
    }
}

// Call from a synchronous context
Task {
    await loadUserDataConcurrently()
}

import SwiftUI

enum UserServiceError: Error, LocalizedError {
    case userNotFound
    case networkError(String)

    var errorDescription: String? {
        switch self {
        case .userNotFound: return "User not found."
        case .networkError(let msg): return "Network error: \(msg)"
        }
    }
}

@MainActor
class UserViewModel: ObservableObject {
    @Published var userName: String = "Loading..."
    @Published var errorMessage: String? = nil

    func fetchUserDetails() async {
        errorMessage = nil // Clear previous errors
        do {
            let fetchedName = try await simulateNetworkFetchUserName()
            self.userName = fetchedName
        } catch let error as UserServiceError {
            self.errorMessage = error.localizedDescription
        } catch {
            self.errorMessage = "An unexpected error occurred: \(error.localizedDescription)"
        }
    }

    private func simulateNetworkFetchUserName() async throws -> String {
        try await Task.sleep(nanoseconds: 1 * 1_000_000_000)
        if Bool.random() {
            return "Alice Smith"
        } else {
            throw UserServiceError.networkError("Server unavailable")
        }
    }
}

struct UserProfileView: View {
    @StateObject private var viewModel = UserViewModel()

    var body: some View {
        VStack {
            Text("User Name: \(viewModel.userName)")
                .font(.title)
            if let error = viewModel.errorMessage {
                Text(error)
                    .foregroundColor(.red)
            }
            Button("Refresh User") {
                Task {
                    await viewModel.fetchUserDetails()
                }
            }
        }
        .onAppear {
            if viewModel.userName == "Loading..." { // Fetch on initial load
                Task {
                    await viewModel.fetchUserDetails()
                }
            }
        }
    }
}