OldNetworkManager.swift

struct NetworkManager {
    
    static let environment: NetworkEnvironment = .production
    private let keywordRouter = Router<KeywordAPI>()
    private let scryfallRouter = Router<ScryfallAPI>()
    
    enum NetworkReponse: String {
        case success
        case authenticationError = "You need to be authenticated first."
        case badRequest = "Bad Request"
        case outdated = "The url you requested is outdated."
        case failed = "Network request failed."
        case noData = "Response returned with no data to decode."
        case unableToDecode = "We could not decode the response."
    }
    
    enum Result<String> {
        case success
        case failure(String)
    }
    
    fileprivate func handleNetworkResponse(_ response: HTTPURLResponse) -> Result<String>{
        switch response.statusCode {
        case 200...299: return .success
        case 401...500: return .failure(NetworkReponse.authenticationError.rawValue)
        case 501...599: return .failure(NetworkReponse.badRequest.rawValue)
        case 600: return .failure(NetworkReponse.outdated.rawValue)
        default: return .failure(NetworkReponse.failed.rawValue)
        }
    }
    
    func getKeywords(completion: @escaping (_ keywords: [Keyword]?, _ error: String?) -> Void) {
        
        keywordRouter.request(.keywords) { (data, response, error) in
            
            if error != nil {
                completion(nil, "Please Check your network connection")
            }
            
            if let response = response as? HTTPURLResponse {
                
                let result = self.handleNetworkResponse(response)
                switch result {
                case .success:
                    guard let responseData = data else { completion(nil, NetworkReponse.noData.rawValue); return }
                    
                    do {
                        let apiResponse = try JSONDecoder().decode([Keyword].self, from: responseData)
                        completion(apiResponse, nil)
                    } catch {
                        completion(nil, NetworkReponse.unableToDecode.rawValue)
                    }
                    
                case .failure(let networkFailureError): completion(nil, networkFailureError)
                    
                }
            }
        }
    }
    
    ...
    
    }