package idgen

import (
	"testing"
	"testing/synctest"
	"time"
)

func TestNewToken_length(t *testing.T) {
	tok := NewToken()
	if len(tok) != 32 {
		t.Fatalf("expected 32 chars, got %d: %q", len(tok), tok)
	}
}

func TestNewToken_validBase32(t *testing.T) {
	tok := NewToken()
	if _, err := encoding.DecodeString(tok); err != nil {
		t.Fatalf("invalid base32: %v", err)
	}
}

func TestNewToken_unique(t *testing.T) {
	seen := make(map[string]bool, 100)
	for range 100 {
		tok := NewToken()
		if seen[tok] {
			t.Fatal("duplicate token generated")
		}
		seen[tok] = true
	}
}

func TestNextID_roundtrip(t *testing.T) {
	const nodeID = 42
	before := time.Now().Unix()
	id := NextID(nodeID)
	after := time.Now().Unix()

	gotTime, gotNode, gotSeq := SplitID(id)
	if gotNode != nodeID {
		t.Errorf("nodeID: got %d, want %d", gotNode, nodeID)
	}
	if gotTime < before || gotTime > after {
		t.Errorf("timestamp %d out of range [%d, %d]", gotTime, before, after)
	}
	if gotSeq < 1 {
		t.Errorf("seq should be >= 1, got %d", gotSeq)
	}
}

func TestNextID_allNodeIDs(t *testing.T) {
	for nodeID := int64(0); nodeID < 64; nodeID++ {
		id := NextID(nodeID)
		_, got, _ := SplitID(id)
		if got != nodeID {
			t.Errorf("nodeID %d: SplitID returned %d", nodeID, got)
		}
	}
}

func TestNextID_monotonic(t *testing.T) {
	prev := NextID(0)
	for range 1000 {
		id := NextID(0)
		if id <= prev {
			t.Fatalf("not monotonically increasing: %d <= %d", id, prev)
		}
		prev = id
	}
}

func TestNextID_unique(t *testing.T) {
	seen := make(map[int64]bool, 1000)
	for i := range 1000 {
		id := NextID(0)
		if seen[id] {
			t.Fatalf("duplicate ID at i=%d", i)
		}
		seen[id] = true
	}
}

func TestNextID_invalidNodeID(t *testing.T) {
	for _, bad := range []int64{-1, 64, 100} {
		func() {
			defer func() {
				if recover() == nil {
					t.Errorf("NextID(%d) should have panicked", bad)
				}
			}()
			NextID(bad)
		}()
	}
}

func TestNextID_timestampAdvances(t *testing.T) {
	synctest.Test(t, func(t *testing.T) {
		// synctest's synthetic clock starts at 2000-01-01 00:00:00 UTC.
		// Prime ts to one second before that so the first NextID call
		// enters the new-second branch and records the synthetic start time.
		lock.Lock()
		ts = time.Now().Unix() - 1
		seq = 0
		lock.Unlock()

		id1 := NextID(0)
		t1, _, _ := SplitID(id1)

		time.Sleep(2 * time.Second)

		id2 := NextID(0)
		t2, _, _ := SplitID(id2)

		if t2 <= t1 {
			t.Errorf("timestamp did not advance: %d -> %d", t1, t2)
		}
	})
}

func BenchmarkNextID(b *testing.B) {
	for b.Loop() {
		NextID(0)
	}
}