type Limiter struct {
	mu        sync.Mutex // 互斥鎖（排他鎖）
	limit     Limit      // 放入桶的頻率  float64 類型
	burst     int        // 桶的大小
	tokens    float64    // 令牌 token 當(dāng)前剩余的數(shù)量
	last      time.Time  // 最近取走 token 的時間
	lastEvent time.Time  // 最近限流事件的時間
}

type Reservation struct {
	ok        bool      // 是否滿足條件分配了 token
	lim       *Limiter  // 發(fā)送令牌的限流器
	tokens    int       // 發(fā)送 token 令牌的數(shù)量
	timeToAct time.Time // 滿足令牌發(fā)放的時間
	limit     Limit     // 令牌發(fā)放速度
}

func (lim *Limiter) Wait(ctx context.Context) (err error)
func (lim *Limiter) WaitN(ctx context.Context, n int) (err error)

func (lim *Limiter) Allow() bool
func (lim *Limiter) AllowN(now time.Time, n int) bool 

func (lim *Limiter) Reserve() *Reservation
func (lim *Limiter) ReserveN(now time.Time, n int) *Reservation

func (lim *Limiter) reserveN(now time.Time, n int, maxFutureReserve time.Duration) Reservation {
	lim.mu.Lock()

	// 首先判斷是否放入頻率是否為無窮大
	// 如果為無窮大，說明暫時不限流
	if lim.limit == Inf {
		lim.mu.Unlock()
		return Reservation{
			ok:        true,
			lim:       lim,
			tokens:    n,
			timeToAct: now,
		}
	}

	// 拿到截至 now 時間時
	// 可以獲取的令牌 tokens 數(shù)量及上一次拿走令牌的時間 last
	now, last, tokens := lim.advance(now)

	// 更新 tokens 數(shù)量
	tokens -= float64(n)

	// 如果 tokens 為負(fù)數(shù)，代表當(dāng)前沒有 token 放入桶中
	// 說明需要等待，計算等待的時間
	var waitDuration time.Duration
	if tokens < 0 {
		waitDuration = lim.limit.durationFromTokens(-tokens)
	}

	// 計算是否滿足分配條件
	// 1、需要分配的大小不超過桶的大小
	// 2、等待時間不超過設(shè)定的等待時長
	ok := n <= lim.burst && waitDuration <= maxFutureReserve

	// 預(yù)處理 reservation
	r := Reservation{
		ok:    ok,
		lim:   lim,
		limit: lim.limit,
	}
	// 若當(dāng)前滿足分配條件
	// 1、設(shè)置分配大小
	// 2、滿足令牌發(fā)放的時間 = 當(dāng)前時間 + 等待時長
	if ok {
		r.tokens = n
		r.timeToAct = now.Add(waitDuration)
	}

	// 更新 limiter 的值，并返回
	if ok {
		lim.last = now
		lim.tokens = tokens
		lim.lastEvent = r.timeToAct
	} else {
		lim.last = last
	}

	lim.mu.Unlock()
	return r
}

func NewLimiter(r Limit, b int) *Limiter {
	return &Limiter{
		limit: r, // 放入桶的頻率
		burst: b, // 桶的大小
	}
}

func main() {
	r := rate.Every(1 * time.Millisecond)
	limit := rate.NewLimiter(r, 10)
	http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
		if limit.Allow() {
			fmt.Printf("請求成功，當(dāng)前時間：%s\n", time.Now().Format("2006-01-02 15:04:05"))
		} else {
			fmt.Printf("請求成功，但是被限流了。。。\n")
		}
	})

	_ = http.ListenAndServe(":8081", nil)
}

func GetApi() {
	api := "http://localhost:8081/"
	res, err := http.Get(api)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	if res.StatusCode == http.StatusOK {
		fmt.Printf("get api success\n")
	}
}

func Benchmark_Main(b *testing.B) {
	for i := 0; i < b.N; i++ {
		GetApi()
	}
}