package limiter
import (
 "fmt"
 "testing"
 "time"
 "golang.org/x/time/rate"
)
func TestLimter(t *testing.T) {
	limiter := rate.NewLimiter(rate.Every(time.Millisecond*10), 2)
	for i := 0; i < 10; i++ {
		var ok bool
		if limiter.Allow() {
			ok = true
		}
		time.Sleep(time.Millisecond * 3)
		fmt.Println(ok, limiter.Burst())
	}
}

func NewLimiter(r Limit, b int) *Limiter {
	return &Limiter{
		limit: r,
		burst: b,
	}
}
type Limiter struct {
	mu     sync.Mutex
	limit  Limit
	burst  int
	tokens float64
	// last is the last time the limiter's tokens field was updated
	last time.Time
	// lastEvent is the latest time of a rate-limited event (past or future)
	lastEvent time.Time
}

// 判斷是否滿足條件
func (lim *Limiter) Allow() bool {
	return lim.AllowN(time.Now(), 1)
}
func (lim *Limiter) AllowN(now time.Time, n int) bool {
	return lim.reserveN(now, n, 0).ok
}
func (lim *Limiter) reserveN(now time.Time, n int, maxFutureReserve time.Duration) Reservation {
  // 加鎖防止并發(fā)
	lim.mu.Lock()
	defer lim.mu.Unlock()
	// 邊界處理，都是一些異常設置，設置最大值，或沒有設置的場景
	if lim.limit == Inf {
		return Reservation{
			ok:        true,
			lim:       lim,
			tokens:    n,
			timeToAct: now,
		}
	} else if lim.limit == 0 {
		var ok bool
		if lim.burst >= n {
			ok = true
			lim.burst -= n
		}
		return Reservation{
			ok:        ok,
			lim:       lim,
			tokens:    lim.burst,
			timeToAct: now,
		}
	}
	 // 從上次獲取令牌到當前時間，共產(chǎn)生的令牌數(shù)tokens
	now, last, tokens := lim.advance(now)
	// 減去需要的令牌數(shù)據(jù)
	tokens -= float64(n)
	var waitDuration time.Duration
  // 如果需要的令牌數(shù)tokens 為負數(shù)，則計算需要等待的 WaitDuration時間
	if tokens < 0 {
		waitDuration = lim.limit.durationFromTokens(-tokens)
	}
	// 獲取需要的令牌數(shù)如果大于桶的容量  或者 等待時間大于設置的maxFutureReserve
	ok := n <= lim.burst && waitDuration <= maxFutureReserve
	// 構造一個Reservation對象，后續(xù)結果返回該對象
	r := Reservation{
		ok:    ok,
		lim:   lim,
		limit: lim.limit,
	}
  // 成功才更新該對象
	if ok {
		r.tokens = n
		r.timeToAct = now.Add(waitDuration)
	}
	// 成功了，才把上次時間和tokens數(shù)更新
	if ok {
		lim.last = now
		lim.tokens = tokens
		lim.lastEvent = r.timeToAct
	} else {
    // 這里因為鎖并發(fā)的問題，所以才回導致last會有更新
		lim.last = last
	}
	return r
}

func (lim *Limiter) advance(now time.Time) (newNow time.Time, newLast time.Time, newTokens float64) {
	last := lim.last
  // 因為加鎖的原因，所以出現(xiàn)這種情況
	if now.Before(last) {
		last = now
	}
	// （當前時間-上次時間）* 速率 = 產(chǎn)生的令牌數(shù)
	elapsed := now.Sub(last)
	delta := lim.limit.tokensFromDuration(elapsed)
	tokens := lim.tokens + delta
	if burst := float64(lim.burst); tokens > burst {
		tokens = burst
	}
	return now, last, tokens
}