response.swift

//: Playground - noun: a place where people can play

import UIKit

class Response {
    
    typealias Headers = [String : String]
    
    enum ResponseError: Error {
        case badInput
        case noData
        case noResponseReceived
        case unacceptableResponse(Int)
    }
    
    enum Result<T> {
        case success(T)
        case error(Error)
    }
    
    let response: HTTPURLResponse?
    let error: Error?
    let data: Data?
    
    init(data: Data?, response: HTTPURLResponse?, error: Error?) {
        self.data = data
        self.error = error
        self.response = response
    }
    
    var jsonResult: Result<Any> { return result(type: Any.self) }
    
    var dataResult: Result<Data> { return result(type: Data.self) }
    
    var headersResult: Result<Headers> { return result(type: Headers.self) }
    
    private func result<T>(type: T.Type) -> Result<T> {
        guard error != nil else { return .error(error!) }
        guard let r = response else { return .error(ResponseError.noResponseReceived) }
        let statusCode = r.statusCode
        guard Array(200...220).contains(statusCode) else { return .error(ResponseError.unacceptableResponse(statusCode)) }
        guard let _data = data else { return .error(ResponseError.noData) }
        
        switch type {
        case Data.self: return Result<Data>.success(_data)
        case Any.self:
            do {
                let json = try JSONSerialization.jsonObject(with: _data, options: [])
                return Result<Any>.success(json)
            } catch let parsingError {
                return .error(parsingError)
            }
        case Headers.self: return Result<Headers>.success(r.allHeaderFields as! Headers)
        default: fatalError("Type \(type) not allowed")
        }
    }
}