// Copyright (c) Tailscale Inc & AUTHORS
// SPDX-License-Identifier: BSD-3-Clause

package tstest

import (
	"slices"
	"sync/atomic"
	"testing"
	"time"

	"tailscale.com/tstime"
)

func TestClockWithDefinedStartTime(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name  string
		start time.Time
		step  time.Duration
		wants []time.Time // The return values of sequential calls to Now().
	}{
		{
			name:  "increment ms",
			start: time.Unix(12345, 1000),
			step:  1000,
			wants: []time.Time{
				time.Unix(12345, 1000),
				time.Unix(12345, 2000),
				time.Unix(12345, 3000),
				time.Unix(12345, 4000),
			},
		},
		{
			name:  "increment second",
			start: time.Unix(12345, 1000),
			step:  time.Second,
			wants: []time.Time{
				time.Unix(12345, 1000),
				time.Unix(12346, 1000),
				time.Unix(12347, 1000),
				time.Unix(12348, 1000),
			},
		},
		{
			name:  "no increment",
			start: time.Unix(12345, 1000),
			wants: []time.Time{
				time.Unix(12345, 1000),
				time.Unix(12345, 1000),
				time.Unix(12345, 1000),
				time.Unix(12345, 1000),
			},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			clock := NewClock(ClockOpts{
				Start: tt.start,
				Step:  tt.step,
			})

			if start := clock.GetStart(); !start.Equal(tt.start) {
				t.Errorf("clock has start %v, want %v", start, tt.start)
			}
			if step := clock.GetStep(); step != tt.step {
				t.Errorf("clock has step %v, want %v", step, tt.step)
			}

			for i := range tt.wants {
				if got := clock.Now(); !got.Equal(tt.wants[i]) {
					t.Errorf("step %v: clock.Now() = %v, want %v", i, got, tt.wants[i])
				}
				if got := clock.PeekNow(); !got.Equal(tt.wants[i]) {
					t.Errorf("step %v: clock.PeekNow() = %v, want %v", i, got, tt.wants[i])
				}
			}
		})
	}
}

func TestClockWithDefaultStartTime(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name  string
		step  time.Duration
		wants []time.Duration // The return values of sequential calls to Now() after added to Start()
	}{
		{
			name: "increment ms",
			step: 1000,
			wants: []time.Duration{
				0,
				1000,
				2000,
				3000,
			},
		},
		{
			name: "increment second",
			step: time.Second,
			wants: []time.Duration{
				0 * time.Second,
				1 * time.Second,
				2 * time.Second,
				3 * time.Second,
			},
		},
		{
			name:  "no increment",
			wants: []time.Duration{0, 0, 0, 0},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			clock := NewClock(ClockOpts{
				Step: tt.step,
			})
			start := clock.GetStart()

			if step := clock.GetStep(); step != tt.step {
				t.Errorf("clock has step %v, want %v", step, tt.step)
			}

			for i := range tt.wants {
				want := start.Add(tt.wants[i])
				if got := clock.Now(); !got.Equal(want) {
					t.Errorf("step %v: clock.Now() = %v, want %v", i, got, tt.wants[i])
				}
				if got := clock.PeekNow(); !got.Equal(want) {
					t.Errorf("step %v: clock.PeekNow() = %v, want %v", i, got, tt.wants[i])
				}
			}
		})
	}
}

func TestZeroInitClock(t *testing.T) {
	t.Parallel()

	var clock Clock
	start := clock.GetStart()

	if step := clock.GetStep(); step != 0 {
		t.Errorf("clock has step %v, want 0", step)
	}

	for i := range 10 {
		if got := clock.Now(); !got.Equal(start) {
			t.Errorf("step %v: clock.Now() = %v, want %v", i, got, start)
		}
		if got := clock.PeekNow(); !got.Equal(start) {
			t.Errorf("step %v: clock.PeekNow() = %v, want %v", i, got, start)
		}
	}
}

func TestClockSetStep(t *testing.T) {
	t.Parallel()

	type stepInfo struct {
		when int
		step time.Duration
	}

	tests := []struct {
		name        string
		start       time.Time
		step        time.Duration
		stepChanges []stepInfo
		wants       []time.Time // The return values of sequential calls to Now().
	}{
		{
			name:  "increment ms then s",
			start: time.Unix(12345, 1000),
			step:  1000,
			stepChanges: []stepInfo{
				{
					when: 4,
					step: time.Second,
				},
			},
			wants: []time.Time{
				time.Unix(12345, 1000),
				time.Unix(12345, 2000),
				time.Unix(12345, 3000),
				time.Unix(12345, 4000),
				time.Unix(12346, 4000),
				time.Unix(12347, 4000),
				time.Unix(12348, 4000),
				time.Unix(12349, 4000),
			},
		},
		{
			name:  "multiple changes over time",
			start: time.Unix(12345, 1000),
			step:  1,
			stepChanges: []stepInfo{
				{
					when: 2,
					step: time.Second,
				},
				{
					when: 4,
					step: 0,
				},
				{
					when: 6,
					step: 1000,
				},
			},
			wants: []time.Time{
				time.Unix(12345, 1000),
				time.Unix(12345, 1001),
				time.Unix(12346, 1001),
				time.Unix(12347, 1001),
				time.Unix(12347, 1001),
				time.Unix(12347, 1001),
				time.Unix(12347, 2001),
				time.Unix(12347, 3001),
			},
		},
		{
			name:  "multiple changes at once",
			start: time.Unix(12345, 1000),
			step:  1,
			stepChanges: []stepInfo{
				{
					when: 2,
					step: time.Second,
				},
				{
					when: 2,
					step: 0,
				},
				{
					when: 2,
					step: 1000,
				},
			},
			wants: []time.Time{
				time.Unix(12345, 1000),
				time.Unix(12345, 1001),
				time.Unix(12345, 2001),
				time.Unix(12345, 3001),
			},
		},
		{
			name:  "changes at start",
			start: time.Unix(12345, 1000),
			step:  0,
			stepChanges: []stepInfo{
				{
					when: 0,
					step: time.Second,
				},
				{
					when: 0,
					step: 1000,
				},
			},
			wants: []time.Time{
				time.Unix(12345, 1000),
				time.Unix(12345, 2000),
				time.Unix(12345, 3000),
				time.Unix(12345, 4000),
			},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			clock := NewClock(ClockOpts{
				Start: tt.start,
				Step:  tt.step,
			})
			wantStep := tt.step
			changeIndex := 0

			for i := range tt.wants {
				for len(tt.stepChanges) > changeIndex && tt.stepChanges[changeIndex].when == i {
					wantStep = tt.stepChanges[changeIndex].step
					clock.SetStep(wantStep)
					changeIndex++
				}

				if start := clock.GetStart(); !start.Equal(tt.start) {
					t.Errorf("clock has start %v, want %v", start, tt.start)
				}
				if step := clock.GetStep(); step != wantStep {
					t.Errorf("clock has step %v, want %v", step, tt.step)
				}

				if got := clock.Now(); !got.Equal(tt.wants[i]) {
					t.Errorf("step %v: clock.Now() = %v, want %v", i, got, tt.wants[i])
				}
				if got := clock.PeekNow(); !got.Equal(tt.wants[i]) {
					t.Errorf("step %v: clock.PeekNow() = %v, want %v", i, got, tt.wants[i])
				}
			}
		})
	}
}

func TestClockAdvance(t *testing.T) {
	t.Parallel()

	type advanceInfo struct {
		when    int
		advance time.Duration
	}

	tests := []struct {
		name     string
		start    time.Time
		step     time.Duration
		advances []advanceInfo
		wants    []time.Time // The return values of sequential calls to Now().
	}{
		{
			name:  "increment ms then advance 1s",
			start: time.Unix(12345, 1000),
			step:  1000,
			advances: []advanceInfo{
				{
					when:    4,
					advance: time.Second,
				},
			},
			wants: []time.Time{
				time.Unix(12345, 1000),
				time.Unix(12345, 2000),
				time.Unix(12345, 3000),
				time.Unix(12345, 4000),
				time.Unix(12346, 4000),
				time.Unix(12346, 5000),
				time.Unix(12346, 6000),
				time.Unix(12346, 7000),
			},
		},
		{
			name:  "multiple advances over time",
			start: time.Unix(12345, 1000),
			step:  1,
			advances: []advanceInfo{
				{
					when:    2,
					advance: time.Second,
				},
				{
					when:    4,
					advance: 0,
				},
				{
					when:    6,
					advance: 1000,
				},
			},
			wants: []time.Time{
				time.Unix(12345, 1000),
				time.Unix(12345, 1001),
				time.Unix(12346, 1001),
				time.Unix(12346, 1002),
				time.Unix(12346, 1002),
				time.Unix(12346, 1003),
				time.Unix(12346, 2003),
				time.Unix(12346, 2004),
			},
		},
		{
			name:  "multiple advances at once",
			start: time.Unix(12345, 1000),
			step:  1,
			advances: []advanceInfo{
				{
					when:    2,
					advance: time.Second,
				},
				{
					when:    2,
					advance: 0,
				},
				{
					when:    2,
					advance: 1000,
				},
			},
			wants: []time.Time{
				time.Unix(12345, 1000),
				time.Unix(12345, 1001),
				time.Unix(12346, 2001),
				time.Unix(12346, 2002),
			},
		},
		{
			name:  "changes at start",
			start: time.Unix(12345, 1000),
			step:  5,
			advances: []advanceInfo{
				{
					when:    0,
					advance: time.Second,
				},
				{
					when:    0,
					advance: 1000,
				},
			},
			wants: []time.Time{
				time.Unix(12346, 2000),
				time.Unix(12346, 2005),
				time.Unix(12346, 2010),
				time.Unix(12346, 2015),
			},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			clock := NewClock(ClockOpts{
				Start: tt.start,
				Step:  tt.step,
			})
			wantStep := tt.step
			changeIndex := 0

			for i := range tt.wants {
				for len(tt.advances) > changeIndex && tt.advances[changeIndex].when == i {
					clock.Advance(tt.advances[changeIndex].advance)
					changeIndex++
				}

				if start := clock.GetStart(); !start.Equal(tt.start) {
					t.Errorf("clock has start %v, want %v", start, tt.start)
				}
				if step := clock.GetStep(); step != wantStep {
					t.Errorf("clock has step %v, want %v", step, tt.step)
				}

				if got := clock.Now(); !got.Equal(tt.wants[i]) {
					t.Errorf("step %v: clock.Now() = %v, want %v", i, got, tt.wants[i])
				}
				if got := clock.PeekNow(); !got.Equal(tt.wants[i]) {
					t.Errorf("step %v: clock.PeekNow() = %v, want %v", i, got, tt.wants[i])
				}
			}
		})
	}
}

func expectNoTicks(t *testing.T, tickC <-chan time.Time) {
	t.Helper()
	select {
	case tick := <-tickC:
		t.Errorf("wanted no ticks, got %v", tick)
	default:
	}
}

func TestSingleTicker(t *testing.T) {
	t.Parallel()

	type testStep struct {
		stop            bool
		reset           time.Duration
		resetAbsolute   time.Time
		setStep         time.Duration
		advance         time.Duration
		advanceRealTime time.Duration
		wantTime        time.Time
		wantTicks       []time.Time
	}

	tests := []struct {
		name         string
		realTimeOpts *ClockOpts
		start        time.Time
		step         time.Duration
		period       time.Duration
		channelSize  int
		steps        []testStep
	}{
		{
			name:   "no tick advance",
			start:  time.Unix(12345, 0),
			period: time.Second,
			steps: []testStep{
				{
					advance:  time.Second - 1,
					wantTime: time.Unix(12345, 999_999_999),
				},
			},
		},
		{
			name:   "no tick step",
			start:  time.Unix(12345, 0),
			step:   time.Second - 1,
			period: time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime: time.Unix(12345, 999_999_999),
				},
			},
		},
		{
			name:   "single tick advance exact",
			start:  time.Unix(12345, 0),
			period: time.Second,
			steps: []testStep{
				{
					advance:   time.Second,
					wantTime:  time.Unix(12346, 0),
					wantTicks: []time.Time{time.Unix(12346, 0)},
				},
			},
		},
		{
			name:   "single tick advance extra",
			start:  time.Unix(12345, 0),
			period: time.Second,
			steps: []testStep{
				{
					advance:   time.Second + 1,
					wantTime:  time.Unix(12346, 1),
					wantTicks: []time.Time{time.Unix(12346, 0)},
				},
			},
		},
		{
			name:   "single tick step exact",
			start:  time.Unix(12345, 0),
			step:   time.Second,
			period: time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime:  time.Unix(12346, 0),
					wantTicks: []time.Time{time.Unix(12346, 0)},
				},
			},
		},
		{
			name:   "single tick step extra",
			start:  time.Unix(12345, 0),
			step:   time.Second + 1,
			period: time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime:  time.Unix(12346, 1),
					wantTicks: []time.Time{time.Unix(12346, 0)},
				},
			},
		},
		{
			name:   "single tick per advance",
			start:  time.Unix(12345, 0),
			period: 3 * time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					advance:   4 * time.Second,
					wantTime:  time.Unix(12349, 0),
					wantTicks: []time.Time{time.Unix(12348, 0)},
				},
				{
					advance:   2 * time.Second,
					wantTime:  time.Unix(12351, 0),
					wantTicks: []time.Time{time.Unix(12351, 0)},
				},
				{
					advance:  2 * time.Second,
					wantTime: time.Unix(12353, 0),
				},
				{
					advance:   2 * time.Second,
					wantTime:  time.Unix(12355, 0),
					wantTicks: []time.Time{time.Unix(12354, 0)},
				},
			},
		},
		{
			name:   "single tick per step",
			start:  time.Unix(12345, 0),
			step:   2 * time.Second,
			period: 3 * time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime: time.Unix(12347, 0),
				},
				{
					wantTime:  time.Unix(12349, 0),
					wantTicks: []time.Time{time.Unix(12348, 0)},
				},
				{
					wantTime:  time.Unix(12351, 0),
					wantTicks: []time.Time{time.Unix(12351, 0)},
				},
				{
					wantTime: time.Unix(12353, 0),
				},
				{
					wantTime:  time.Unix(12355, 0),
					wantTicks: []time.Time{time.Unix(12354, 0)},
				},
			},
		},
		{
			name:        "multiple tick per advance",
			start:       time.Unix(12345, 0),
			period:      time.Second,
			channelSize: 3,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					advance:  2 * time.Second,
					wantTime: time.Unix(12347, 0),
					wantTicks: []time.Time{
						time.Unix(12346, 0),
						time.Unix(12347, 0),
					},
				},
				{
					advance:  4 * time.Second,
					wantTime: time.Unix(12351, 0),
					wantTicks: []time.Time{
						time.Unix(12348, 0),
						time.Unix(12349, 0),
						time.Unix(12350, 0),
						// fourth tick dropped due to channel size
					},
				},
			},
		},
		{
			name:        "multiple tick per step",
			start:       time.Unix(12345, 0),
			step:        3 * time.Second,
			period:      2 * time.Second,
			channelSize: 3,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime: time.Unix(12348, 0),
					wantTicks: []time.Time{
						time.Unix(12347, 0),
					},
				},
				{
					wantTime: time.Unix(12351, 0),
					wantTicks: []time.Time{
						time.Unix(12349, 0),
						time.Unix(12351, 0),
					},
				},
				{
					wantTime: time.Unix(12354, 0),
					wantTicks: []time.Time{
						time.Unix(12353, 0),
					},
				},
				{
					wantTime: time.Unix(12357, 0),
					wantTicks: []time.Time{
						time.Unix(12355, 0),
						time.Unix(12357, 0),
					},
				},
			},
		},
		{
			name:        "stop",
			start:       time.Unix(12345, 0),
			step:        2 * time.Second,
			period:      time.Second,
			channelSize: 3,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime: time.Unix(12347, 0),
					wantTicks: []time.Time{
						time.Unix(12346, 0),
						time.Unix(12347, 0),
					},
				},
				{
					stop:     true,
					wantTime: time.Unix(12349, 0),
				},
				{
					wantTime: time.Unix(12351, 0),
				},
				{
					advance:  10 * time.Second,
					wantTime: time.Unix(12361, 0),
				},
			},
		},
		{
			name:   "reset while running",
			start:  time.Unix(12345, 0),
			period: 2 * time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					advance:  time.Second,
					wantTime: time.Unix(12346, 0),
				},
				{
					advance:  time.Second,
					wantTime: time.Unix(12347, 0),
					wantTicks: []time.Time{
						time.Unix(12347, 0),
					},
				},
				{
					advance:  time.Second,
					reset:    time.Second,
					wantTime: time.Unix(12348, 0),
					wantTicks: []time.Time{
						time.Unix(12348, 0),
					},
				},
				{
					setStep:  5 * time.Second,
					reset:    10 * time.Second,
					wantTime: time.Unix(12353, 0),
				},
				{
					wantTime: time.Unix(12358, 0),
					wantTicks: []time.Time{
						time.Unix(12358, 0),
					},
				},
			},
		},
		{
			name:   "reset while stopped",
			start:  time.Unix(12345, 0),
			step:   time.Second,
			period: 2 * time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime: time.Unix(12346, 0),
				},
				{
					wantTime: time.Unix(12347, 0),
					wantTicks: []time.Time{
						time.Unix(12347, 0),
					},
				},
				{
					stop:     true,
					wantTime: time.Unix(12348, 0),
				},
				{
					wantTime: time.Unix(12349, 0),
				},
				{
					reset:    time.Second,
					wantTime: time.Unix(12350, 0),
					wantTicks: []time.Time{
						time.Unix(12350, 0),
					},
				},
				{
					wantTime: time.Unix(12351, 0),
					wantTicks: []time.Time{
						time.Unix(12351, 0),
					},
				},
			},
		},
		{
			name:   "reset absolute",
			start:  time.Unix(12345, 0),
			step:   time.Second,
			period: 2 * time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime: time.Unix(12346, 0),
				},
				{
					wantTime: time.Unix(12347, 0),
					wantTicks: []time.Time{
						time.Unix(12347, 0),
					},
				},
				{
					reset:         time.Second,
					resetAbsolute: time.Unix(12354, 50),
					advance:       7 * time.Second,
					wantTime:      time.Unix(12354, 0),
				},
				{
					wantTime: time.Unix(12355, 0),
					wantTicks: []time.Time{
						time.Unix(12354, 50),
					},
				},
				{
					wantTime: time.Unix(12356, 0),
					wantTicks: []time.Time{
						time.Unix(12355, 50),
					},
				},
			},
		},
		{
			name:         "follow real time",
			realTimeOpts: new(ClockOpts),
			start:        time.Unix(12345, 0),
			period:       2 * time.Second,
			channelSize:  3,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					advanceRealTime: 5 * time.Second,
					wantTime:        time.Unix(12350, 0),
					wantTicks: []time.Time{
						time.Unix(12347, 0),
						time.Unix(12349, 0),
					},
				},
				{
					advance:  5 * time.Second,
					wantTime: time.Unix(12355, 0),
					wantTicks: []time.Time{
						time.Unix(12351, 0),
						time.Unix(12353, 0),
						time.Unix(12355, 0),
					},
				},
			},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			var realTimeClockForTestClock tstime.Clock
			var realTimeClock *Clock
			if tt.realTimeOpts != nil {
				realTimeClock = NewClock(*tt.realTimeOpts)
				// Passing realTimeClock into newClockInternal results in a
				// non-nil interface with a nil pointer, so this is necessary.
				realTimeClockForTestClock = realTimeClock
			}

			clock := newClockInternal(ClockOpts{
				Start:            tt.start,
				Step:             tt.step,
				TimerChannelSize: tt.channelSize,
				FollowRealTime:   realTimeClock != nil,
			}, realTimeClockForTestClock)
			tc, tickC := clock.NewTicker(tt.period)
			tickControl := tc.(*Ticker)

			t.Cleanup(tickControl.Stop)

			expectNoTicks(t, tickC)

			for i, step := range tt.steps {
				if step.stop {
					tickControl.Stop()
				}

				if !step.resetAbsolute.IsZero() {
					tickControl.ResetAbsolute(step.resetAbsolute, step.reset)
				} else if step.reset > 0 {
					tickControl.Reset(step.reset)
				}

				if step.setStep > 0 {
					clock.SetStep(step.setStep)
				}

				if step.advance > 0 {
					clock.Advance(step.advance)
				}
				if step.advanceRealTime > 0 {
					realTimeClock.Advance(step.advanceRealTime)
				}

				if now := clock.Now(); !step.wantTime.IsZero() && !now.Equal(step.wantTime) {
					t.Errorf("step %v now = %v, want %v", i, now, step.wantTime)
				}

				for j, want := range step.wantTicks {
					select {
					case tick := <-tickC:
						if tick.Equal(want) {
							continue
						}
						t.Errorf("step %v tick %v = %v, want %v", i, j, tick, want)
					default:
						t.Errorf("step %v tick %v missing", i, j)
					}
				}

				expectNoTicks(t, tickC)
			}
		})
	}
}

func TestSingleTimer(t *testing.T) {
	t.Parallel()

	type testStep struct {
		stop            bool
		stopReturn      bool // The expected return value for Stop() if stop is true.
		reset           time.Duration
		resetAbsolute   time.Time
		resetReturn     bool // The expected return value for Reset() or ResetAbsolute().
		setStep         time.Duration
		advance         time.Duration
		advanceRealTime time.Duration
		wantTime        time.Time
		wantTicks       []time.Time
	}

	tests := []struct {
		name         string
		realTimeOpts *ClockOpts
		start        time.Time
		step         time.Duration
		delay        time.Duration
		steps        []testStep
	}{
		{
			name:  "no tick advance",
			start: time.Unix(12345, 0),
			delay: time.Second,
			steps: []testStep{
				{
					advance:  time.Second - 1,
					wantTime: time.Unix(12345, 999_999_999),
				},
			},
		},
		{
			name:  "no tick step",
			start: time.Unix(12345, 0),
			step:  time.Second - 1,
			delay: time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime: time.Unix(12345, 999_999_999),
				},
			},
		},
		{
			name:  "single tick advance exact",
			start: time.Unix(12345, 0),
			delay: time.Second,
			steps: []testStep{
				{
					advance:   time.Second,
					wantTime:  time.Unix(12346, 0),
					wantTicks: []time.Time{time.Unix(12346, 0)},
				},
				{
					advance:  time.Second,
					wantTime: time.Unix(12347, 0),
				},
			},
		},
		{
			name:  "single tick advance extra",
			start: time.Unix(12345, 0),
			delay: time.Second,
			steps: []testStep{
				{
					advance:   time.Second + 1,
					wantTime:  time.Unix(12346, 1),
					wantTicks: []time.Time{time.Unix(12346, 0)},
				},
				{
					advance:  time.Second,
					wantTime: time.Unix(12347, 1),
				},
			},
		},
		{
			name:  "single tick step exact",
			start: time.Unix(12345, 0),
			step:  time.Second,
			delay: time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime:  time.Unix(12346, 0),
					wantTicks: []time.Time{time.Unix(12346, 0)},
				},
				{
					wantTime: time.Unix(12347, 0),
				},
			},
		},
		{
			name:  "single tick step extra",
			start: time.Unix(12345, 0),
			step:  time.Second + 1,
			delay: time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime:  time.Unix(12346, 1),
					wantTicks: []time.Time{time.Unix(12346, 0)},
				},
				{
					wantTime: time.Unix(12347, 2),
				},
			},
		},
		{
			name:  "reset for single tick per advance",
			start: time.Unix(12345, 0),
			delay: 3 * time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					advance:   4 * time.Second,
					wantTime:  time.Unix(12349, 0),
					wantTicks: []time.Time{time.Unix(12348, 0)},
				},
				{
					resetAbsolute: time.Unix(12351, 0),
					advance:       2 * time.Second,
					wantTime:      time.Unix(12351, 0),
					wantTicks:     []time.Time{time.Unix(12351, 0)},
				},
				{
					reset:    3 * time.Second,
					advance:  2 * time.Second,
					wantTime: time.Unix(12353, 0),
				},
				{
					advance:   2 * time.Second,
					wantTime:  time.Unix(12355, 0),
					wantTicks: []time.Time{time.Unix(12354, 0)},
				},
				{
					advance:  10 * time.Second,
					wantTime: time.Unix(12365, 0),
				},
			},
		},
		{
			name:  "reset for single tick per step",
			start: time.Unix(12345, 0),
			step:  2 * time.Second,
			delay: 3 * time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime: time.Unix(12347, 0),
				},
				{
					wantTime:  time.Unix(12349, 0),
					wantTicks: []time.Time{time.Unix(12348, 0)},
				},
				{
					reset:     time.Second,
					wantTime:  time.Unix(12351, 0),
					wantTicks: []time.Time{time.Unix(12350, 0)},
				},
				{
					resetAbsolute: time.Unix(12354, 0),
					wantTime:      time.Unix(12353, 0),
				},
				{
					wantTime:  time.Unix(12355, 0),
					wantTicks: []time.Time{time.Unix(12354, 0)},
				},
			},
		},
		{
			name:  "reset while active",
			start: time.Unix(12345, 0),
			step:  2 * time.Second,
			delay: 3 * time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime: time.Unix(12347, 0),
				},
				{
					reset:       3 * time.Second,
					resetReturn: true,
					wantTime:    time.Unix(12349, 0),
				},
				{
					resetAbsolute: time.Unix(12354, 0),
					resetReturn:   true,
					wantTime:      time.Unix(12351, 0),
				},
				{
					wantTime: time.Unix(12353, 0),
				},
				{
					wantTime:  time.Unix(12355, 0),
					wantTicks: []time.Time{time.Unix(12354, 0)},
				},
			},
		},
		{
			name:  "stop after fire",
			start: time.Unix(12345, 0),
			step:  2 * time.Second,
			delay: time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime:  time.Unix(12347, 0),
					wantTicks: []time.Time{time.Unix(12346, 0)},
				},
				{
					stop:     true,
					wantTime: time.Unix(12349, 0),
				},
				{
					wantTime: time.Unix(12351, 0),
				},
				{
					advance:  10 * time.Second,
					wantTime: time.Unix(12361, 0),
				},
			},
		},
		{
			name:  "stop before fire",
			start: time.Unix(12345, 0),
			step:  2 * time.Second,
			delay: time.Second,
			steps: []testStep{
				{
					stop:       true,
					stopReturn: true,
					wantTime:   time.Unix(12345, 0),
				},
				{
					wantTime: time.Unix(12347, 0),
				},
				{
					wantTime: time.Unix(12349, 0),
				},
				{
					wantTime: time.Unix(12351, 0),
				},
				{
					advance:  10 * time.Second,
					wantTime: time.Unix(12361, 0),
				},
			},
		},
		{
			name:  "stop after reset",
			start: time.Unix(12345, 0),
			step:  2 * time.Second,
			delay: time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime:  time.Unix(12347, 0),
					wantTicks: []time.Time{time.Unix(12346, 0)},
				},
				{
					reset:    10 * time.Second,
					wantTime: time.Unix(12349, 0),
				},
				{
					stop:       true,
					stopReturn: true,
					wantTime:   time.Unix(12351, 0),
				},
				{
					advance:  10 * time.Second,
					wantTime: time.Unix(12361, 0),
				},
			},
		},
		{
			name:  "reset while running",
			start: time.Unix(12345, 0),
			delay: 2 * time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					advance:  time.Second,
					wantTime: time.Unix(12346, 0),
				},
				{
					advance:  time.Second,
					wantTime: time.Unix(12347, 0),
					wantTicks: []time.Time{
						time.Unix(12347, 0),
					},
				},
				{
					advance:  time.Second,
					reset:    time.Second,
					wantTime: time.Unix(12348, 0),
					wantTicks: []time.Time{
						time.Unix(12348, 0),
					},
				},
				{
					setStep:  5 * time.Second,
					reset:    10 * time.Second,
					wantTime: time.Unix(12353, 0),
				},
				{
					wantTime: time.Unix(12358, 0),
					wantTicks: []time.Time{
						time.Unix(12358, 0),
					},
				},
			},
		},
		{
			name:  "reset while stopped",
			start: time.Unix(12345, 0),
			step:  time.Second,
			delay: 2 * time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime: time.Unix(12346, 0),
				},
				{
					stop:       true,
					stopReturn: true,
					wantTime:   time.Unix(12347, 0),
				},
				{
					wantTime: time.Unix(12348, 0),
				},
				{
					wantTime: time.Unix(12349, 0),
				},
				{
					reset:    time.Second,
					wantTime: time.Unix(12350, 0),
					wantTicks: []time.Time{
						time.Unix(12350, 0),
					},
				},
				{
					wantTime: time.Unix(12351, 0),
				},
			},
		},
		{
			name:  "reset absolute",
			start: time.Unix(12345, 0),
			step:  time.Second,
			delay: 2 * time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime: time.Unix(12346, 0),
				},
				{
					wantTime: time.Unix(12347, 0),
					wantTicks: []time.Time{
						time.Unix(12347, 0),
					},
				},
				{
					resetAbsolute: time.Unix(12354, 50),
					advance:       7 * time.Second,
					wantTime:      time.Unix(12354, 0),
				},
				{
					wantTime: time.Unix(12355, 0),
					wantTicks: []time.Time{
						time.Unix(12354, 50),
					},
				},
				{
					wantTime: time.Unix(12356, 0),
				},
			},
		},
		{
			name:         "follow real time",
			realTimeOpts: new(ClockOpts),
			start:        time.Unix(12345, 0),
			delay:        2 * time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					advanceRealTime: 5 * time.Second,
					wantTime:        time.Unix(12350, 0),
					wantTicks: []time.Time{
						time.Unix(12347, 0),
					},
				},
				{
					reset:    2 * time.Second,
					advance:  5 * time.Second,
					wantTime: time.Unix(12355, 0),
					wantTicks: []time.Time{
						time.Unix(12352, 0),
					},
				},
			},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			var realTimeClockForTestClock tstime.Clock
			var realTimeClock *Clock
			if tt.realTimeOpts != nil {
				realTimeClock = NewClock(*tt.realTimeOpts)
				// Passing realTimeClock into newClockInternal results in a
				// non-nil interface with a nil pointer, so this is necessary.
				realTimeClockForTestClock = realTimeClock
			}

			clock := newClockInternal(ClockOpts{
				Start:          tt.start,
				Step:           tt.step,
				FollowRealTime: realTimeClock != nil,
			}, realTimeClockForTestClock)
			tc, tickC := clock.NewTimer(tt.delay)
			timerControl := tc.(*Timer)

			t.Cleanup(func() { timerControl.Stop() })

			expectNoTicks(t, tickC)

			for i, step := range tt.steps {
				if step.stop {
					if got := timerControl.Stop(); got != step.stopReturn {
						t.Errorf("step %v Stop returned %v, want %v", i, got, step.stopReturn)
					}
				}

				if !step.resetAbsolute.IsZero() {
					if got := timerControl.ResetAbsolute(step.resetAbsolute); got != step.resetReturn {
						t.Errorf("step %v Reset returned %v, want %v", i, got, step.resetReturn)
					}
				}

				if step.reset > 0 {
					if got := timerControl.Reset(step.reset); got != step.resetReturn {
						t.Errorf("step %v Reset returned %v, want %v", i, got, step.resetReturn)
					}
				}

				if step.setStep > 0 {
					clock.SetStep(step.setStep)
				}

				if step.advance > 0 {
					clock.Advance(step.advance)
				}
				if step.advanceRealTime > 0 {
					realTimeClock.Advance(step.advanceRealTime)
				}

				if now := clock.Now(); !step.wantTime.IsZero() && !now.Equal(step.wantTime) {
					t.Errorf("step %v now = %v, want %v", i, now, step.wantTime)
				}

				for j, want := range step.wantTicks {
					select {
					case tick := <-tickC:
						if tick.Equal(want) {
							continue
						}
						t.Errorf("step %v tick %v = %v, want %v", i, j, tick, want)
					default:
						t.Errorf("step %v tick %v missing", i, j)
					}
				}

				expectNoTicks(t, tickC)
			}
		})
	}
}

type testEvent struct {
	fireTimes     []time.Time
	scheduleTimes []time.Time
}

func (te *testEvent) Fire(t time.Time) time.Time {
	var ret time.Time

	te.fireTimes = append(te.fireTimes, t)
	if len(te.scheduleTimes) > 0 {
		ret = te.scheduleTimes[0]
		te.scheduleTimes = te.scheduleTimes[1:]
	}
	return ret
}

func TestEventManager(t *testing.T) {
	t.Parallel()

	var em eventManager

	testEvents := []testEvent{
		{
			scheduleTimes: []time.Time{
				time.Unix(12300, 0), // step 1
				time.Unix(12340, 0), // step 1
				time.Unix(12345, 0), // step 1
				time.Unix(12346, 0), // step 1
				time.Unix(12347, 0), // step 3
				time.Unix(12348, 0), // step 4
				time.Unix(12349, 0), // step 4
			},
		},
		{
			scheduleTimes: []time.Time{
				time.Unix(12350, 0), // step 4
				time.Unix(12360, 0), // step 5
				time.Unix(12370, 0), // rescheduled
				time.Unix(12380, 0), // step 6
				time.Unix(12381, 0), // step 6
				time.Unix(12382, 0), // step 6
				time.Unix(12393, 0), // stopped
			},
		},
		{
			scheduleTimes: []time.Time{
				time.Unix(12350, 1), // step 4
				time.Unix(12360, 1), // rescheduled
				time.Unix(12370, 1), // step 6
				time.Unix(12380, 1), // step 6
				time.Unix(12381, 1), // step 6
				time.Unix(12382, 1), // step 6
				time.Unix(12383, 1), // step 6
			},
		},
		{
			scheduleTimes: []time.Time{
				time.Unix(12355, 0), // step 5
				time.Unix(12365, 0), // step 5
				time.Unix(12370, 0), // step 6
				time.Unix(12390, 0), // step 6
				time.Unix(12391, 0), // step 7
				time.Unix(12392, 0), // step 7
				time.Unix(12393, 0), // step 7
			},
		},
		{
			scheduleTimes: []time.Time{
				time.Unix(100000, 0), // step 7
			},
		},
		{
			scheduleTimes: []time.Time{
				time.Unix(12346, 0), // step 1
			},
		},
		{
			scheduleTimes: []time.Time{
				time.Unix(12305, 0), // step 5
			},
		},
		{
			scheduleTimes: []time.Time{
				time.Unix(12372, 0), // step 6
				time.Unix(12374, 0), // step 6
				time.Unix(12376, 0), // step 6
				time.Unix(12386, 0), // step 6
				time.Unix(12396, 0), // step 7
			},
		},
	}

	steps := []struct {
		reschedule    []int
		stop          []int
		advanceTo     time.Time
		want          map[int][]time.Time
		waitingEvents int
	}{
		{
			advanceTo: time.Unix(12345, 0),
		},
		{
			reschedule: []int{0, 1, 2, 3, 4, 5}, // add 0, 1, 2, 3, 4, 5
			advanceTo:  time.Unix(12346, 0),
			want: map[int][]time.Time{
				0: {
					time.Unix(12300, 0),
					time.Unix(12340, 0),
					time.Unix(12345, 0),
					time.Unix(12346, 0),
				},
				5: {
					time.Unix(12346, 0),
				},
			},
			waitingEvents: 5, // scheduled 0, 1, 2, 3, 4, 5; retired 5
		},
		{
			advanceTo:     time.Unix(12346, 50),
			waitingEvents: 5, // no change
		},
		{
			advanceTo: time.Unix(12347, 50),
			want: map[int][]time.Time{
				0: {
					time.Unix(12347, 0),
				},
			},
			waitingEvents: 5, // no change
		},
		{
			advanceTo: time.Unix(12350, 50),
			want: map[int][]time.Time{
				0: {
					time.Unix(12348, 0),
					time.Unix(12349, 0),
				},
				1: {
					time.Unix(12350, 0),
				},
				2: {
					time.Unix(12350, 1),
				},
			},
			waitingEvents: 4, // retired 0
		},
		{
			reschedule: []int{6, 7}, // add 6, 7
			stop:       []int{2},
			advanceTo:  time.Unix(12365, 0),
			want: map[int][]time.Time{
				1: {
					time.Unix(12360, 0),
				},
				3: {
					time.Unix(12355, 0),
					time.Unix(12365, 0),
				},
				6: {
					time.Unix(12305, 0),
				},
			},
			waitingEvents: 4, // scheduled 6, 7; retired 2, 5
		},
		{
			reschedule: []int{1, 2}, // update 1; add 2
			stop:       []int{6},
			advanceTo:  time.Unix(12390, 0),
			want: map[int][]time.Time{
				1: {
					time.Unix(12380, 0),
					time.Unix(12381, 0),
					time.Unix(12382, 0),
				},
				2: {
					time.Unix(12370, 1),
					time.Unix(12380, 1),
					time.Unix(12381, 1),
					time.Unix(12382, 1),
					time.Unix(12383, 1),
				},
				3: {
					time.Unix(12370, 0),
					time.Unix(12390, 0),
				},
				7: {
					time.Unix(12372, 0),
					time.Unix(12374, 0),
					time.Unix(12376, 0),
					time.Unix(12386, 0),
				},
			},
			waitingEvents: 3, // scheduled 2, retired 2, stopped 6
		},
		{
			stop:      []int{1}, // no-op: already stopped
			advanceTo: time.Unix(200000, 0),
			want: map[int][]time.Time{
				3: {
					time.Unix(12391, 0),
					time.Unix(12392, 0),
					time.Unix(12393, 0),
				},
				4: {
					time.Unix(100000, 0),
				},
				7: {
					time.Unix(12396, 0),
				},
			},
			waitingEvents: 0, // retired 3, 4, 7
		},
		{
			advanceTo: time.Unix(300000, 0),
		},
	}

	for i, step := range steps {
		for _, idx := range step.reschedule {
			ev := &testEvents[idx]
			t := ev.scheduleTimes[0]
			ev.scheduleTimes = ev.scheduleTimes[1:]
			em.Reschedule(ev, t)
		}
		for _, idx := range step.stop {
			ev := &testEvents[idx]
			em.Reschedule(ev, time.Time{})
		}
		em.AdvanceTo(step.advanceTo)
		for j := range testEvents {
			if !slices.Equal(testEvents[j].fireTimes, step.want[j]) {
				t.Errorf("step %v event %v fire times = %v, want %v", i, j, testEvents[j].fireTimes, step.want[j])
			}
			testEvents[j].fireTimes = nil
		}
	}
}

func TestClockFollowRealTime(t *testing.T) {
	t.Parallel()

	type advanceInfo struct {
		when                 int
		advanceTestClock     time.Duration
		advanceTestClockTo   time.Time
		advanceRealTimeClock time.Duration
	}

	tests := []struct {
		name              string
		start             time.Time
		wantStart         time.Time // This may differ from start when start.IsZero().
		realTimeClockOpts ClockOpts
		advances          []advanceInfo
		wants             []time.Time // The return values of sequential calls to Now().
	}{
		{
			name:      "increment ms then advance 1s",
			start:     time.Unix(12345, 1000),
			wantStart: time.Unix(12345, 1000),
			advances: []advanceInfo{
				{
					when:                 1,
					advanceRealTimeClock: 1000,
				},
				{
					when:                 2,
					advanceRealTimeClock: 1000,
				},
				{
					when:                 3,
					advanceRealTimeClock: 1000,
				},
				{
					when:             4,
					advanceTestClock: time.Second,
				},
				{
					when:                 5,
					advanceRealTimeClock: 1000,
				},
				{
					when:                 6,
					advanceRealTimeClock: 1000,
				},
				{
					when:                 7,
					advanceRealTimeClock: 1000,
				},
			},
			wants: []time.Time{
				time.Unix(12345, 1000),
				time.Unix(12345, 2000),
				time.Unix(12345, 3000),
				time.Unix(12345, 4000),
				time.Unix(12346, 4000),
				time.Unix(12346, 5000),
				time.Unix(12346, 6000),
				time.Unix(12346, 7000),
			},
		},
		{
			name:      "multiple advances over time",
			start:     time.Unix(12345, 1000),
			wantStart: time.Unix(12345, 1000),
			advances: []advanceInfo{
				{
					when:                 1,
					advanceRealTimeClock: 1,
				},
				{
					when:             2,
					advanceTestClock: time.Second,
				},
				{
					when:                 3,
					advanceRealTimeClock: 1,
				},
				{
					when:             4,
					advanceTestClock: 0,
				},
				{
					when:                 5,
					advanceRealTimeClock: 1,
				},
				{
					when:             6,
					advanceTestClock: 1000,
				},
				{
					when:                 7,
					advanceRealTimeClock: 1,
				},
			},
			wants: []time.Time{
				time.Unix(12345, 1000),
				time.Unix(12345, 1001),
				time.Unix(12346, 1001),
				time.Unix(12346, 1002),
				time.Unix(12346, 1002),
				time.Unix(12346, 1003),
				time.Unix(12346, 2003),
				time.Unix(12346, 2004),
			},
		},
		{
			name:      "multiple advances at once",
			start:     time.Unix(12345, 1000),
			wantStart: time.Unix(12345, 1000),
			advances: []advanceInfo{
				{
					when:                 1,
					advanceRealTimeClock: 1,
				},
				{
					when:             2,
					advanceTestClock: time.Second,
				},
				{
					when:             2,
					advanceTestClock: 0,
				},
				{
					when:             2,
					advanceTestClock: 1000,
				},
				{
					when:                 3,
					advanceRealTimeClock: 1,
				},
			},
			wants: []time.Time{
				time.Unix(12345, 1000),
				time.Unix(12345, 1001),
				time.Unix(12346, 2001),
				time.Unix(12346, 2002),
			},
		},
		{
			name:      "changes at start",
			start:     time.Unix(12345, 1000),
			wantStart: time.Unix(12345, 1000),
			advances: []advanceInfo{
				{
					when:             0,
					advanceTestClock: time.Second,
				},
				{
					when:             0,
					advanceTestClock: 1000,
				},
				{
					when:                 1,
					advanceRealTimeClock: 5,
				},
				{
					when:                 2,
					advanceRealTimeClock: 5,
				},
				{
					when:                 3,
					advanceRealTimeClock: 5,
				},
			},
			wants: []time.Time{
				time.Unix(12346, 2000),
				time.Unix(12346, 2005),
				time.Unix(12346, 2010),
				time.Unix(12346, 2015),
			},
		},
		{
			name: "start from current time",
			realTimeClockOpts: ClockOpts{
				Start: time.Unix(12345, 0),
			},
			wantStart: time.Unix(12345, 0),
			advances: []advanceInfo{
				{
					when:             1,
					advanceTestClock: time.Second,
				},
				{
					when:                 2,
					advanceRealTimeClock: 10 * time.Second,
				},
				{
					when:             3,
					advanceTestClock: time.Minute,
				},
				{
					when:                 4,
					advanceRealTimeClock: time.Hour,
				},
				{
					when:               5,
					advanceTestClockTo: time.Unix(100, 0),
				},
				{
					when:                 6,
					advanceRealTimeClock: time.Hour,
				},
			},
			wants: []time.Time{
				time.Unix(12345, 0),
				time.Unix(12346, 0),
				time.Unix(12356, 0),
				time.Unix(12416, 0),
				time.Unix(16016, 0),
				time.Unix(100, 0),
				time.Unix(3700, 0),
			},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			realTimeClock := NewClock(tt.realTimeClockOpts)
			clock := newClockInternal(ClockOpts{
				Start:          tt.start,
				FollowRealTime: true,
			}, realTimeClock)
			changeIndex := 0

			for i := range tt.wants {
				for len(tt.advances) > changeIndex && tt.advances[changeIndex].when == i {
					advance := tt.advances[changeIndex]
					if advance.advanceTestClockTo.IsZero() {
						clock.Advance(advance.advanceTestClock)
					} else {
						clock.AdvanceTo(advance.advanceTestClockTo)
					}
					realTimeClock.Advance(advance.advanceRealTimeClock)
					changeIndex++
				}

				if start := clock.GetStart(); !start.Equal(tt.wantStart) {
					t.Errorf("clock has start %v, want %v", start, tt.wantStart)
				}

				if got := clock.Now(); !got.Equal(tt.wants[i]) {
					t.Errorf("step %v: clock.Now() = %v, want %v", i, got, tt.wants[i])
				}
				if got := clock.PeekNow(); !got.Equal(tt.wants[i]) {
					t.Errorf("step %v: clock.PeekNow() = %v, want %v", i, got, tt.wants[i])
				}
			}
		})
	}
}

func TestAfterFunc(t *testing.T) {
	t.Parallel()

	type testStep struct {
		stop            bool
		stopReturn      bool // The expected return value for Stop() if stop is true.
		reset           time.Duration
		resetAbsolute   time.Time
		resetReturn     bool // The expected return value for Reset() or ResetAbsolute().
		setStep         time.Duration
		advance         time.Duration
		advanceRealTime time.Duration
		wantTime        time.Time
		wantTick        bool
	}

	tests := []struct {
		name         string
		realTimeOpts *ClockOpts
		start        time.Time
		step         time.Duration
		delay        time.Duration
		steps        []testStep
	}{
		{
			name:  "no tick advance",
			start: time.Unix(12345, 0),
			delay: time.Second,
			steps: []testStep{
				{
					advance:  time.Second - 1,
					wantTime: time.Unix(12345, 999_999_999),
				},
			},
		},
		{
			name:  "no tick step",
			start: time.Unix(12345, 0),
			step:  time.Second - 1,
			delay: time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime: time.Unix(12345, 999_999_999),
				},
			},
		},
		{
			name:  "single tick advance exact",
			start: time.Unix(12345, 0),
			delay: time.Second,
			steps: []testStep{
				{
					advance:  time.Second,
					wantTime: time.Unix(12346, 0),
					wantTick: true,
				},
				{
					advance:  time.Second,
					wantTime: time.Unix(12347, 0),
				},
			},
		},
		{
			name:  "single tick advance extra",
			start: time.Unix(12345, 0),
			delay: time.Second,
			steps: []testStep{
				{
					advance:  time.Second + 1,
					wantTime: time.Unix(12346, 1),
					wantTick: true,
				},
				{
					advance:  time.Second,
					wantTime: time.Unix(12347, 1),
				},
			},
		},
		{
			name:  "single tick step exact",
			start: time.Unix(12345, 0),
			step:  time.Second,
			delay: time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime: time.Unix(12346, 0),
					wantTick: true,
				},
				{
					wantTime: time.Unix(12347, 0),
				},
			},
		},
		{
			name:  "single tick step extra",
			start: time.Unix(12345, 0),
			step:  time.Second + 1,
			delay: time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime: time.Unix(12346, 1),
					wantTick: true,
				},
				{
					wantTime: time.Unix(12347, 2),
				},
			},
		},
		{
			name:  "reset for single tick per advance",
			start: time.Unix(12345, 0),
			delay: 3 * time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					advance:  4 * time.Second,
					wantTime: time.Unix(12349, 0),
					wantTick: true,
				},
				{
					resetAbsolute: time.Unix(12351, 0),
					advance:       2 * time.Second,
					wantTime:      time.Unix(12351, 0),
					wantTick:      true,
				},
				{
					reset:    3 * time.Second,
					advance:  2 * time.Second,
					wantTime: time.Unix(12353, 0),
				},
				{
					advance:  2 * time.Second,
					wantTime: time.Unix(12355, 0),
					wantTick: true,
				},
				{
					advance:  10 * time.Second,
					wantTime: time.Unix(12365, 0),
				},
			},
		},
		{
			name:  "reset for single tick per step",
			start: time.Unix(12345, 0),
			step:  2 * time.Second,
			delay: 3 * time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime: time.Unix(12347, 0),
				},
				{
					wantTime: time.Unix(12349, 0),
					wantTick: true,
				},
				{
					reset:    time.Second,
					wantTime: time.Unix(12351, 0),
					wantTick: true,
				},
				{
					resetAbsolute: time.Unix(12354, 0),
					wantTime:      time.Unix(12353, 0),
				},
				{
					wantTime: time.Unix(12355, 0),
					wantTick: true,
				},
			},
		},
		{
			name:  "reset while active",
			start: time.Unix(12345, 0),
			step:  2 * time.Second,
			delay: 3 * time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime: time.Unix(12347, 0),
				},
				{
					reset:       3 * time.Second,
					resetReturn: true,
					wantTime:    time.Unix(12349, 0),
				},
				{
					resetAbsolute: time.Unix(12354, 0),
					resetReturn:   true,
					wantTime:      time.Unix(12351, 0),
				},
				{
					wantTime: time.Unix(12353, 0),
				},
				{
					wantTime: time.Unix(12355, 0),
					wantTick: true,
				},
			},
		},
		{
			name:  "stop after fire",
			start: time.Unix(12345, 0),
			step:  2 * time.Second,
			delay: time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime: time.Unix(12347, 0),
					wantTick: true,
				},
				{
					stop:     true,
					wantTime: time.Unix(12349, 0),
				},
				{
					wantTime: time.Unix(12351, 0),
				},
				{
					advance:  10 * time.Second,
					wantTime: time.Unix(12361, 0),
				},
			},
		},
		{
			name:  "stop before fire",
			start: time.Unix(12345, 0),
			step:  2 * time.Second,
			delay: time.Second,
			steps: []testStep{
				{
					stop:       true,
					stopReturn: true,
					wantTime:   time.Unix(12345, 0),
				},
				{
					wantTime: time.Unix(12347, 0),
				},
				{
					wantTime: time.Unix(12349, 0),
				},
				{
					wantTime: time.Unix(12351, 0),
				},
				{
					advance:  10 * time.Second,
					wantTime: time.Unix(12361, 0),
				},
			},
		},
		{
			name:  "stop after reset",
			start: time.Unix(12345, 0),
			step:  2 * time.Second,
			delay: time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime: time.Unix(12347, 0),
					wantTick: true,
				},
				{
					reset:    10 * time.Second,
					wantTime: time.Unix(12349, 0),
				},
				{
					stop:       true,
					stopReturn: true,
					wantTime:   time.Unix(12351, 0),
				},
				{
					advance:  10 * time.Second,
					wantTime: time.Unix(12361, 0),
				},
			},
		},
		{
			name:  "reset while running",
			start: time.Unix(12345, 0),
			delay: 2 * time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					advance:  time.Second,
					wantTime: time.Unix(12346, 0),
				},
				{
					advance:  time.Second,
					wantTime: time.Unix(12347, 0),
					wantTick: true,
				},
				{
					advance:  time.Second,
					reset:    time.Second,
					wantTime: time.Unix(12348, 0),
					wantTick: true,
				},
				{
					setStep:  5 * time.Second,
					reset:    10 * time.Second,
					wantTime: time.Unix(12353, 0),
				},
				{
					wantTime: time.Unix(12358, 0),
					wantTick: true,
				},
			},
		},
		{
			name:  "reset while stopped",
			start: time.Unix(12345, 0),
			step:  time.Second,
			delay: 2 * time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime: time.Unix(12346, 0),
				},
				{
					stop:       true,
					stopReturn: true,
					wantTime:   time.Unix(12347, 0),
				},
				{
					wantTime: time.Unix(12348, 0),
				},
				{
					wantTime: time.Unix(12349, 0),
				},
				{
					reset:    time.Second,
					wantTime: time.Unix(12350, 0),
					wantTick: true,
				},
				{
					wantTime: time.Unix(12351, 0),
				},
			},
		},
		{
			name:  "reset absolute",
			start: time.Unix(12345, 0),
			step:  time.Second,
			delay: 2 * time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					wantTime: time.Unix(12346, 0),
				},
				{
					wantTime: time.Unix(12347, 0),
					wantTick: true,
				},
				{
					resetAbsolute: time.Unix(12354, 50),
					advance:       7 * time.Second,
					wantTime:      time.Unix(12354, 0),
				},
				{
					wantTime: time.Unix(12355, 0),
					wantTick: true,
				},
				{
					wantTime: time.Unix(12356, 0),
				},
			},
		},
		{
			name:         "follow real time",
			realTimeOpts: new(ClockOpts),
			start:        time.Unix(12345, 0),
			delay:        2 * time.Second,
			steps: []testStep{
				{
					wantTime: time.Unix(12345, 0),
				},
				{
					advanceRealTime: 5 * time.Second,
					wantTime:        time.Unix(12350, 0),
					wantTick:        true,
				},
				{
					reset:    2 * time.Second,
					advance:  5 * time.Second,
					wantTime: time.Unix(12355, 0),
					wantTick: true,
				},
			},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			var realTimeClockForTestClock tstime.Clock
			var realTimeClock *Clock
			if tt.realTimeOpts != nil {
				realTimeClock = NewClock(*tt.realTimeOpts)
				// Passing realTimeClock into newClockInternal results in a
				// non-nil interface with a nil pointer, so this is necessary.
				realTimeClockForTestClock = realTimeClock
			}

			var gotTick atomic.Bool

			clock := newClockInternal(ClockOpts{
				Start:          tt.start,
				Step:           tt.step,
				FollowRealTime: realTimeClock != nil,
			}, realTimeClockForTestClock)
			tc := clock.AfterFunc(tt.delay, func() {
				if gotTick.Swap(true) == true {
					t.Error("multiple ticks detected")
				}
			})
			timerControl := tc.(*Timer)

			t.Cleanup(func() { timerControl.Stop() })

			if gotTick.Load() {
				t.Error("initial tick detected, want none")
			}

			for i, step := range tt.steps {
				if step.stop {
					if got := timerControl.Stop(); got != step.stopReturn {
						t.Errorf("step %v Stop returned %v, want %v", i, got, step.stopReturn)
					}
				}

				if !step.resetAbsolute.IsZero() {
					if got := timerControl.ResetAbsolute(step.resetAbsolute); got != step.resetReturn {
						t.Errorf("step %v Reset returned %v, want %v", i, got, step.resetReturn)
					}
				}

				if step.reset > 0 {
					if got := timerControl.Reset(step.reset); got != step.resetReturn {
						t.Errorf("step %v Reset returned %v, want %v", i, got, step.resetReturn)
					}
				}

				if step.setStep > 0 {
					clock.SetStep(step.setStep)
				}

				if step.advance > 0 {
					clock.Advance(step.advance)
				}
				if step.advanceRealTime > 0 {
					realTimeClock.Advance(step.advanceRealTime)
				}

				if now := clock.Now(); !step.wantTime.IsZero() && !now.Equal(step.wantTime) {
					t.Errorf("step %v now = %v, want %v", i, now, step.wantTime)
				}

				if got := gotTick.Swap(false); got != step.wantTick {
					t.Errorf("step %v tick %v, want %v", i, got, step.wantTick)
				}
			}
		})
	}
}

func TestSince(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name  string
		start time.Time
		since time.Time
		want  time.Duration
	}{
		{
			name:  "positive",
			start: time.Unix(12345, 1000),
			since: time.Unix(11111, 1000),
			want:  1234 * time.Second,
		},
		{
			name:  "negative",
			start: time.Unix(12345, 1000),
			since: time.Unix(15436, 1000),
			want:  -3091 * time.Second,
		},
		{
			name:  "zero",
			start: time.Unix(12345, 1000),
			since: time.Unix(12345, 1000),
			want:  0,
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			clock := NewClock(ClockOpts{
				Start: tt.start,
			})
			got := clock.Since(tt.since)
			if got != tt.want {
				t.Errorf("Since duration %v, want %v", got, tt.want)
			}
		})
	}
}
