// MARK: - Running
extension EventsWorker {

    func run() -> Promise<()> {
        guard !inProgress else { log.info("New start call aborted, service already in proggres"); return Promise(value: ()) }
        guard !queue.isEmpty else { log.info("Nothing to send."); return Promise(value: ()) }
        log.info("Start")

        inProgress = true

        return executeNextTask()
            .then {
                log.info("Finish")
                return Promise(value: ())
            }
            .always {
                self.inProgress = false
            }
    }

    private func executeNextTask() -> Promise<()> {
        guard let task = queue.get() else { return Promise(value: ()) }

        log.info("Start new task")

        return task.resume()
            .then { result -> Promise<()> in
                switch result {
                case .completed:

                    log.info("Task completed")
                    self.queue.pop()
                    return self.executeNextTask()

                case .gatewayUnreachable:

                    log.info("Gateway Unreachable")
                    self.queue.save()
                    return Promise(error: Errors.gatewayUnreachable)

                case .gatewayError(let type, let message, let debugInfo):

                    //TODO: save error in ERROR LOG
                    log.warning("(type) (message) (debugInfo)")
                    self.queue.pop()
                    return self.executeNextTask()

                }
            }
            .recover { error -> Promise<()> in
                switch error {
                case Errors.gatewayUnreachable:
                    throw error
                default:
                    log.error(error)
                    self.queue.pop()
                    return self.executeNextTask()
                }
            }
    }
}

// MARK: - Error
extension EventsWorker {

    enum Errors: Error {
        case gatewayUnreachable
    }
}

func resume() -> Promise<EventsWorkerTaskResult> {
    //stuff
}

enum EventsWorkerTaskResult {
    case completed
    case gatewayUnreachable
    case gatewayError(type: String, message: String, debugInfo: String)
}