func (r *RateLimit) HandleResponse(key string, res *http.Response, content []byte) {
    var err error
    var global bool
    var limit uint64
    var remaining uint64
    var reset int64
    var body *ratelimitBody
    var noBody bool

    // read body as well
    if len(content) == 0 {
        noBody = true
    } else {
        err = json.Unmarshal(content, body)
        if err != nil {
            return
        }
    }

    // global?
    if res.Header.Get(XRateLimitGlobal) == "true" || (!noBody && body.Global) {
        global = true
    }

    // max number of request before reset
    if res.Header.Get(XRateLimitLimit) != "" || (!noBody && body.Global) {
        limit, err = strconv.ParseUint(res.Header.Get(XRateLimitLimit), 10, 64)
        if err != nil {
            // TODO: logging
        }
    }

    // remaining requests before reset
    remainingStr := res.Header.Get(XRateLimitRemaining)
    if remainingStr != "" {
        remaining, err = strconv.ParseUint(remainingStr, 10, 64)
        if err != nil {
            // TODO: logging
        }
    }

    // reset unix timestamp
    resetStr := res.Header.Get(XRateLimitReset)
    if resetStr != "" {
        // here we get a unix timestamp in seconds, which we convert to milliseconds
        reset, err = strconv.ParseInt(remainingStr, 10, 64)
        if err == nil {
            reset *= 1000 // => milliseconds
        } else {
            // TODO: logging
        }
    } else if res.Header.Get(RateLimitRetryAfter) != "" || (!noBody && body.RetryAfter > 0) {
        // here we are given a delay in millisecond, which we need to convert into a timestamp
        if res.Header.Get(RateLimitRetryAfter) != "" {
            reset, err = strconv.ParseInt(res.Header.Get(RateLimitRetryAfter), 10, 64)
            if err != nil {
                reset = 0
            }
        } else if !noBody && body.RetryAfter > 0 {
            reset = body.RetryAfter
        }

        // convert diff to timestamp
        reset += time.Now().UnixNano() / 1000
    }

    if global {
        r.global.mu.Lock()
        defer r.global.mu.Unlock()

        if limit != 0 {
            r.global.limit = limit
        }
        if remaining != 0 {
            r.global.remaining = remaining
        }
        if reset != 0 {
            r.global.reset = reset
        }
    } else {
        bucket := r.Bucket(key)
        bucket.mu.Lock()
        defer bucket.mu.Unlock()

        if limit != 0 {
            bucket.limit = limit
        }
        if remaining != 0 {
            bucket.remaining = remaining
        }
        if reset != 0 {
            bucket.reset = reset
        }
    }
}