Swift Concurrency

import Foundation

let apiURL = "https://my.api.mockaroo.com/movie_ticket.json?key=8795e870"

struct MovieTicket: Codable {
    let movieTitle, movieGenre: String
    let movieTicketPrice: Float
    let movieDuration: Int
}

enum TicketError: Error {
    case urlError
    case invalidServerResponse
}

func getDataFromClosure(completionHandler: @escaping (Result<[MovieTicket], Error>) -> Void) {
    guard let url = URL(string: apiURL) else {
        completionHandler(.failure(TicketError.urlError))
        return
    }
    
    URLSession.shared.dataTask(with: URLRequest(url: url)) { data, response, error in
        if let error = error {
            completionHandler(.failure(error))
        }
        
        guard let response = response as? HTTPURLResponse,
              response.statusCode == 200,
              let data = data
        else {
            completionHandler(.failure(TicketError.invalidServerResponse))
            return
        }
        
        do {
            let tickets = try JSONDecoder().decode([MovieTicket].self, from: data)
            completionHandler(.success(tickets))
        } catch {
            completionHandler(.failure(error))
        }
    }.resume()
}

getDataFromClosure { result in
    switch result {
    case .success(let tickets):
        for (index, ticket) in tickets.enumerated() {
            print("\(index): \(ticket.movieTitle) [genre] - \(ticket.movieGenre)")
        }
    case .failure(let failure):
        print(failure.localizedDescription)
    }
    exit(0)
}

// https://developer.apple.com/forums/thread/713085
// The standard workaround is to add a call to dispatchMain() which ‘parks’ the main thread,
// preventing the tool from exiting. If you then want to exit after your network request is complete, call exit(_:) directly.
dispatchMain()

func getDataFromConcurrency() async throws -> [MovieTicket] {
    guard let url = URL(string: apiURL) else { throw TicketError.urlError }

    let (data, response) = try await URLSession.shared.data(from: url)

    guard let response = response as? HTTPURLResponse,
          response.statusCode == 200
    else { throw TicketError.invalidServerResponse }

    let tickets = try JSONDecoder().decode([MovieTicket].self, from: data)

    return tickets
}

do {
    let tickets = try await getDataFromConcurrency()
    for (index, ticket) in tickets.enumerated() {
        print("\(index): \(ticket.movieTitle) [genre] - \(ticket.movieGenre)")
    }
} catch {
    print(error.localizedDescription)
}