package registry

import (
	"path/filepath"
	"sync"
	"testing"
	"time"
)

// A generation is never handed out twice by one registry file, across a
// close and reopen (an agent restart) and whatever the clock says: a
// rollback resumed after a restart compares and lifts by the generation it
// stored before it, so a later fence must never carry the same number.
func TestNextFenceGenerationIsUniqueAcrossRestarts(t *testing.T) {
	path := filepath.Join(t.TempDir(), "registry.db")
	reg, err := Open(path)
	if err != nil {
		t.Fatal(err)
	}
	now := time.Unix(1_800_000_000, 0)
	before := map[uint64]bool{}
	var last uint64
	for i := 0; i < 5; i++ {
		g, err := reg.NextFenceGeneration(now) // the same instant: still distinct
		if err != nil {
			t.Fatal(err)
		}
		if g == 0 || g <= last {
			t.Fatalf("generation %d after %d: want nonzero and rising", g, last)
		}
		before[g], last = true, g
	}
	if err := reg.Close(); err != nil {
		t.Fatal(err)
	}

	reg, err = Open(path)
	if err != nil {
		t.Fatal(err)
	}
	defer reg.Close()
	// The clock went back across the restart (a box that booted before NTP
	// synced): the generations still rise past every one handed out before.
	for _, at := range []time.Time{now.Add(-time.Hour), now, time.Unix(0, 0), now.Add(-time.Nanosecond)} {
		g, err := reg.NextFenceGeneration(at)
		if err != nil {
			t.Fatal(err)
		}
		if before[g] || g <= last {
			t.Fatalf("after the restart, at %v: generation %d (last before %d)", at, g, last)
		}
		last = g
	}
	// A clock ahead of every earlier generation is followed: generations
	// stay in wall-clock nanoseconds, the space the layout pass and the
	// moves cut draw theirs from.
	later := now.Add(time.Hour)
	if g, err := reg.NextFenceGeneration(later); err != nil || g != uint64(later.UnixNano()) {
		t.Fatalf("a clock ahead: generation %d, %v; want %d", g, err, later.UnixNano())
	}
}

func TestNextFenceGenerationConcurrentCallersNeverShare(t *testing.T) {
	reg := openTestRegistry(t)
	now := time.Unix(1_800_000_000, 0)
	const n = 40
	gens := make(chan uint64, n)
	var wg sync.WaitGroup
	for i := 0; i < n; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			g, err := reg.NextFenceGeneration(now)
			if err != nil {
				t.Error(err)
				return
			}
			gens <- g
		}()
	}
	wg.Wait()
	close(gens)
	seen := map[uint64]bool{}
	for g := range gens {
		if seen[g] {
			t.Fatalf("generation %d handed out twice", g)
		}
		seen[g] = true
	}
}