class ApiRequest<ResponseModel: AbstractModel> {
    private let afRequest: DataRequest
    init(_ httpMethod: Alamofire.HTTPMethod, _ apiMethod: String, parameters: [String: Any]? = nil, asJSON: Bool? = nil) {
        var encoding: ParameterEncoding = Alamofire.URLEncoding.default
        if asJSON ?? false {
            encoding = Alamofire.JSONEncoding.default
        }

        var headers = []

        afRequest = Alamofire.request(RestApi.server + apiMethod, method: httpMethod, parameters: parameters, encoding: encoding, headers: headers)

        afRequest.validate().responseJSON { (response) in
            self.debugCallbacks.forEach { $0(response.request!, response.response, response.error) }
            switch response.result {
            case .success(let value):
                if let errorMessage = (value as? [String: AnyObject])?["errors_string"] as? String {
                    self.apiErrorCallbacks.forEach { $0(errorMessage) }
                } else {
                    self.successCallbacks.forEach { $0() }
                    let decoder = JSONDecoder()
                    decoder.keyDecodingStrategy = .convertFromSnakeCase
                    do {
                        let model = try decoder.decode(ResponseModel.self, from: response.data!)
                        self.successCallbacks2.forEach { $0(model) }
                    } catch {
                        self.serverErrorCallbacks.forEach { $0() }
                    }
                }
            case .failure(let error):
                if let error = error as? URLError {
                    switch error.code {
                    case .notConnectedToInternet:
                        self.networkErrorCallbacks.forEach { $0() }
                    case .cancelled:
                        // nothing
                        break;
                    default:
                        break;
                    }
                } else {
                    self.serverErrorCallbacks.forEach { $0() }
                }
            }
        }
    }

    func cancel() {
        afRequest.cancel()
    }

    private var debugCallbacks: [(URLRequest, HTTPURLResponse?, Error?) -> ()] = []
    private var successCallbacks: [() -> ()] = []
    private var successCallbacks2: [(ResponseModel) -> ()] = []
    private var apiErrorCallbacks: [(String) -> ()] = []
    private var serverErrorCallbacks: [() -> ()] = []
    private var networkErrorCallbacks: [() -> ()] = []

    func debug(_ callback: @escaping (_ request: URLRequest, _ response: HTTPURLResponse?, _ error: Error?) -> ()) -> Self {
        debugCallbacks.append(callback)
        return self
    }
    func success(_ callback: @escaping () -> ()) -> Self {
        successCallbacks.append(callback)
        return self
    }
    func success(_ callback: @escaping (ResponseModel) -> ()) -> Self {
        successCallbacks2.append(callback)
        return self
    }
    func apiError(_ callback: @escaping (String) -> ()) -> Self {
        apiErrorCallbacks.append(callback)
        return self
    }
    func serverError(_ callback: @escaping () -> ()) -> Self {
        serverErrorCallbacks.append(callback)
        return self
    }
    func networkError(_ callback: @escaping () -> ()) -> Self {
        networkErrorCallbacks.append(callback)
        return self
    }
}

class AbstractModel: Decodable {
    init() {
        fatalError()
    }
}

class Page<Model: AbstractModel>: AbstractModel {
    var results: [Model]
    var pagesCount: Int

    enum CodingKeys: String, CodingKey {
        case results
        case pagesCount = "pages"
    }

    required init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.results = try container.decode([Model].self, forKey: .results)
        self.pagesCount = try container.decode(Int.self, forKey: .pagesCount)
        try super.init(from: decoder)
    }
}