type result struct {
	v interface {}
	err error
}
type RetryableSource interface {
    // ask the source for a result, and assumes the source will perform the necessary 
    // cancellation procedure
	Request()
    // where the source puts the result: we only care about the first one
	ResponseC() chan result
}
type backoffRequesterImpl struct {
	source RetryableSource
	stopC concurrency.ErrorSignal
	backoff wait.Backoff
}

func (r *backoffRequesterImpl) Request(parentCtx context.Context, timeout time.Duration, errReporter errorReporter) (interface{}, error) {
	r.source.Request()
	ctx, cancel := context.WithTimeout(parentCtx, timeout)
	defer cancel()
	for {
		select {
		case <-r.stopC.Done():
			return nil, errors.New("request cancelled")
		case <-ctx.Done():
			// FIXME retry
			return nil, errors.New("timeout")
		case response := <-r.source.ResponseC():
			if response.err != nil {
				if errReporter != nil {
					errReporter.Report(response.err)
				}
				time.AfterFunc(r.backoff.Step(), func() {
					r.source.Request()
				})
			} else {
				return response.v, nil
			}
		}
	}
}

// NOTE BLOCKING: loops forever or until you cancel
func (r *backoffRequesterImpl) Request(parentCtx context.Context, timeout time.Duration) (interface{}, error) {
	r.source.Request()
	cancelCtx, cancel := context.WithCancel(parentCtx)
	defer cancel()
	timeoutCtx, _ := context.WithTimeout(cancelCtx, timeout)
	for {
		select {
		case <-r.cancelC.Done():
			return nil, errors.New("request cancelled")
		case <-timeoutCtx.Done():
			r.handleError(errors.New("timeout"))
			timeoutCtx, _ = context.WithTimeout(cancelCtx, timeout)
		case response := <-r.source.ResponseC():
			err := response.err
			if err != nil {
				r.handleError(err)
			} else {
				return response.v, nil
			}
		}
	}
}

func (r *backoffRequesterImpl) handleError(err error) {
	time.AfterFunc(r.backoff.Step(), func() {
		r.source.Request()
	})
}

func (r *backoffRequesterImpl) Cancel() {
	r.cancelC.SignalWithError(errors.New("stop"))
}

type backoffRequesterImpl struct {
	source RetryableSource
	cancelC concurrency.ErrorSignal
	backoff wait.Backoff
	timeoutCtx context.Context
}

// NOTE BLOCKING: loops forever or until you cancel
func (r *backoffRequesterImpl) Request(parentCtx context.Context, timeout time.Duration) (interface{}, error) {
	r.source.Request()
	cancelCtx, cancel := context.WithCancel(parentCtx)
	defer cancel()
	r.timeoutCtx, _ = context.WithTimeout(cancelCtx, timeout)
	for {
		select {
		case <-r.cancelC.Done():
      // assume request will never come. We take first value in `r.source.ResponseC()` as
			// the response, assume `r.source.Request()` does any cancellation required.
			return nil, errors.New("request cancelled")
		case <-r.timeoutCtx.Done():
			r.handleError(cancelCtx, timeout, errors.New("timeout"))
			// r.timeoutCtx, _ = context.WithTimeout(cancelCtx, timeout)
		case response := <-r.source.ResponseC():
			err := response.err
			if err != nil {
				r.handleError(cancelCtx, timeout, err)
			} else {
				return response.v, nil
			}
		}
	}
    // TODO wait for parentCtx and Cancel if done: consider that the way to cancel instead,so no `cancelC concurrency.ErrorSignal`
}

func (r *backoffRequesterImpl) handleError(cancelCtx context.Context, timeout time.Duration, err error) {
	// BAD: starts timeout before request: `r.timeoutCtx, _ = context.WithTimeout(cancelCtx, timeout)`
    r.timeoutCtx = cancelCtx
	time.AfterFunc(r.backoff.Step(), func() {
		r.source.Request()
		// BAD: concurrently modifies timeout, Request loop might not catch it
		r.timeoutCtx, _ = context.WithTimeout(cancelCtx, timeout)
	})
}

func (r *backoffRequesterImpl) Cancel() {
	r.cancelC.SignalWithError(errors.New("stop"))
}