import (
	"context"
	"fmt"
	"time"

	"github.com/cenkalti/backoff/v4"
)

// BackOff is a backoff policy for retrying an operation.
type BackOff interface {
	// NextBackOff returns the duration to wait before retrying the next operation.
	NextBackOff() time.Duration
	// Reset to initial state.
	Reset()
	// RetryWithContext tries the operation until it does not return error,
	// or when the context expires, whichever happens first.

			if ctx.Err() != nil {
				// If there is context timeout, exit this loop.
				return nil, fmt.Errorf("wasm module download failed after %v attempts, last error: %v", attempts, lastError)
			}
			time.Sleep(b.NextBackOff())
			continue
		}
		if resp.StatusCode == http.StatusOK {
			// Limit wasm module to 256mb; in reality it must be much smaller
			body, err := io.ReadAll(io.LimitReader(resp.Body, 1024*1024*256))
			if err != nil {

		minInterval := expected - time.Duration(DefaultRandomizationFactor*float64(expected))
		maxInterval := expected + time.Duration(DefaultRandomizationFactor*float64(expected))
		actualInterval := exp.NextBackOff()
		if !(minInterval <= actualInterval && actualInterval <= maxInterval) {
			t.Error("error")
		}
	}
}

type TestClock struct {
	i     time.Duration
	start time.Time
}

	c.mutex.RLock()
	if c.closed {
		c.mutex.RUnlock()
		return
	}
	c.mutex.RUnlock()

	err := c.Run(context.Background())
	if err != nil {
		time.AfterFunc(c.cfg.BackoffPolicy.NextBackOff(), c.reconnect)
	} else if c.cfg.BackoffPolicy != nil {
		// We connected, so reset the backoff
		c.cfg.BackoffPolicy.Reset()
	}
}

type Option func(c *Client)

	a.mutex.RLock()
	if a.closed {
		a.mutex.RUnlock()
		return
	}
	a.mutex.RUnlock()

	err := a.Run()
	if err != nil {
		// TODO: fix reconnect
		time.AfterFunc(a.cfg.BackoffPolicy.NextBackOff(), a.reconnect)
	}
}

func (a *ADSC) handleRecv() {
	// We connected, so reset the backoff
	if a.cfg.BackoffPolicy != nil {
		a.cfg.BackoffPolicy.Reset()
	}
	for {
		var err error