// Package throttle begrenst de leessnelheid met een token bucket.
package throttle

import (
	"context"
	"io"
	"sync"
	"time"
)

// Limiter is een token bucket in bytes per seconde, gedeeld door alle
// downloads van één server.
type Limiter struct {
	mu     sync.Mutex
	rate   float64 // bytes/s; 0 = onbegrensd
	burst  float64
	tokens float64
	last   time.Time
	now    func() time.Time
	sleep  func(context.Context, time.Duration) error
}

// New maakt een limiter. bytesPerSec 0 = geen limiet. De burst is een
// kwart seconde, minstens 16 KiB.
func New(bytesPerSec int64) *Limiter {
	l := &Limiter{rate: float64(bytesPerSec), now: time.Now, sleep: sleepCtx}
	l.burst = l.rate / 4
	if l.burst < 16<<10 {
		l.burst = 16 << 10
	}
	l.tokens = l.burst
	l.last = l.now()
	return l
}

func sleepCtx(ctx context.Context, d time.Duration) error {
	t := time.NewTimer(d)
	defer t.Stop()
	select {
	case <-ctx.Done():
		return ctx.Err()
	case <-t.C:
		return nil
	}
}

// Rate is de ingestelde snelheid in bytes/s.
func (l *Limiter) Rate() int64 {
	if l == nil {
		return 0
	}
	return int64(l.rate)
}

// Wait blokkeert tot n bytes gelezen mogen worden.
func (l *Limiter) Wait(ctx context.Context, n int) error {
	if l == nil || l.rate <= 0 || n <= 0 {
		return nil
	}
	l.mu.Lock()
	now := l.now()
	l.tokens += now.Sub(l.last).Seconds() * l.rate
	if l.tokens > l.burst {
		l.tokens = l.burst
	}
	l.last = now
	l.tokens -= float64(n)
	var wait time.Duration
	if l.tokens < 0 {
		wait = time.Duration(-l.tokens / l.rate * float64(time.Second))
	}
	l.mu.Unlock()
	if wait > 0 {
		return l.sleep(ctx, wait)
	}
	return nil
}

// Reader begrenst r met l.
func (l *Limiter) Reader(ctx context.Context, r io.Reader) io.Reader {
	if l == nil || l.rate <= 0 {
		return r
	}
	return &reader{ctx: ctx, r: r, l: l}
}

type reader struct {
	ctx context.Context
	r   io.Reader
	l   *Limiter
}

func (t *reader) Read(p []byte) (int, error) {
	if max := int(t.l.burst); len(p) > max {
		p = p[:max]
	}
	n, err := t.r.Read(p)
	if n > 0 {
		if werr := t.l.Wait(t.ctx, n); werr != nil {
			return n, werr
		}
	}
	return n, err
}
