HTTPSession.swift

import Foundation
import BrightFutures

public enum HTTPSessionError: Error {
    case urlSessionError(Error)
    case badResponse
    case redirection(Int)
    case clientError(Int)
    case serverError(Int)

    case other(Error)

    init(httpErrorStatusCode code: Int) {
        switch code {
        case 0..<300:
            fatalError()
        case 300..<400:
            self = .redirection(code)
        case 400..<500:
            self = .clientError(code)
        case 500..<600:
            self = .serverError(code)
        default:
            self = .badResponse
        }
    }
}

public struct HTTPSession {
    public static func perform(httpRequest: URLRequest, with session: URLSession)
        -> Future<(data: Data, response: HTTPURLResponse), HTTPSessionError> {
            let promise = Promise<(data: Data, response: HTTPURLResponse), HTTPSessionError>()

            let task = session.dataTask(with: httpRequest) { data, response, error in
                guard error == nil else {
                    promise.failure(.urlSessionError(error!))
                    return
                }

                guard let data = data, let response = response as? HTTPURLResponse else {
                    promise.failure(.badResponse)
                    return
                }

                guard 200..<300 ~= response.statusCode else {
                    promise.failure(HTTPSessionError(httpErrorStatusCode: response.statusCode))
                    return
                }

                promise.success((data, response))
            }

            task.resume()
            
            return promise.future
    }
}