import Foundation

func main() {
    // First we'll look at basic rate limiting. Suppose
    // we want to limit our handling of incoming requests.
    // We'll serve these requests off a DispatchQueue.
    let requests = DispatchQueue(label: "com.example.requests")
    for i in 1...5 {
        requests.async {
            print("Enqueueing request", i)
        }
    }

    // This timer will fire every 200 milliseconds.
    // This is the regulator in our rate limiting scheme.
    let limiter = DispatchSource.makeTimerSource()
    limiter.schedule(deadline: .now(), repeating: .milliseconds(200))
    
    // By waiting for the timer to fire before serving each request,
    // we limit ourselves to 1 request every 200 milliseconds.
    limiter.setEventHandler {
        requests.async {
            if let req = requests.sync(execute: { return requests.label }) {
                print("request", req, Date())
            }
        }
    }
    limiter.resume()

    // We may want to allow short bursts of requests in
    // our rate limiting scheme while preserving the
    // overall rate limit. We can accomplish this by
    // using a semaphore. This burstyLimiter
    // will allow bursts of up to 3 events.
    let burstyLimiter = DispatchSemaphore(value: 3)

    // Every 200 milliseconds we'll try to add a new
    // value to burstyLimiter, up to its limit of 3.
    let burstyTimer = DispatchSource.makeTimerSource()
    burstyTimer.schedule(deadline: .now(), repeating: .milliseconds(200))
    burstyTimer.setEventHandler {
        burstyLimiter.signal()
    }
    burstyTimer.resume()

    // Now simulate 5 more incoming requests. The first
    // 3 of these will benefit from the burst capability
    // of burstyLimiter.
    let burstyRequests = DispatchQueue(label: "com.example.burstyRequests")
    for i in 1...5 {
        burstyRequests.async {
            burstyLimiter.wait()
            print("bursty request", i, Date())
        }
    }

    // Keep the program running
    RunLoop.main.run()
}

main()