package main

import (
	"crypto/rand"
	"encoding/binary"
	"fmt"
	mrand "math/rand"
	"testing"
)

// TestEncodeDecodeBase62RoundTrip verifies encodeBase62/decodeBase62 are inverse.
func TestEncodeDecodeBase62RoundTrip(t *testing.T) {
	mrand.Seed(42)
	for i := 0; i < 1000; i++ {
		// Random 64-bit value
		v := mrand.Uint64()
		s := encodeBase62(v)
		dec, ok := decodeBase62(s)
		if !ok {
			t.Fatalf("decodeBase62 failed for %d encoded=%s", v, s)
		}
		if dec != v {
			t.Fatalf("round trip mismatch: have %d got %d (encoded=%s)", v, dec, s)
		}
	}
	// Explicit zero test
	if s := encodeBase62(0); s != "0" {
		t.Fatalf("expected encodeBase62(0) == \"0\", got %q", s)
	}
	if v, ok := decodeBase62("0"); !ok || v != 0 {
		t.Fatalf("decodeBase62(0) unexpected result v=%d ok=%v", v, ok)
	}
}

// TestNewCartIDUniqueness generates a number of IDs and checks for duplicates.
func TestNewCartIDUniqueness(t *testing.T) {
	const n = 10000
	seen := make(map[string]struct{}, n)
	for i := 0; i < n; i++ {
		id, err := NewCartID()
		if err != nil {
			t.Fatalf("NewCartID error: %v", err)
		}
		s := id.String()
		if _, exists := seen[s]; exists {
			t.Fatalf("duplicate CartID generated: %s", s)
		}
		seen[s] = struct{}{}
		if id.IsZero() {
			t.Fatalf("NewCartID returned zero value")
		}
	}
}

// TestParseCartIDValidation tests parsing of valid and invalid base62 strings.
func TestParseCartIDValidation(t *testing.T) {
	id, err := NewCartID()
	if err != nil {
		t.Fatalf("NewCartID error: %v", err)
	}
	parsed, ok := ParseCartID(id.String())
	if !ok {
		t.Fatalf("ParseCartID failed for valid id %s", id)
	}
	if parsed.raw != id.raw {
		t.Fatalf("parsed raw mismatch: %d vs %d", parsed.raw, id.raw)
	}

	if _, ok := ParseCartID(""); ok {
		t.Fatalf("expected empty string to be invalid")
	}
	// Invalid char ('-')
	if _, ok := ParseCartID("abc-123"); ok {
		t.Fatalf("expected invalid chars to fail parse")
	}
	// Overly long ( >16 )
	if _, ok := ParseCartID("1234567890abcdefg"); ok {
		t.Fatalf("expected overly long string to fail parse")
	}
}

// TestFallbackDeterminism ensures fallback hashing is deterministic.
func TestFallbackDeterminism(t *testing.T) {
	inputs := []string{
		"legacy-cart-1",
		"legacy-cart-2",
		"UPPER_lower_123",
		"🚀unicode", // unicode bytes (will hash byte sequence)
	}
	for _, in := range inputs {
		a := FallbackFromString(in)
		b := FallbackFromString(in)
		if a.raw != b.raw || a.String() != b.String() {
			t.Fatalf("fallback mismatch for %q: %+v vs %+v", in, a, b)
		}
	}
	// Distinct inputs should almost always differ; sample check
	a := FallbackFromString("distinct-A")
	b := FallbackFromString("distinct-B")
	if a.raw == b.raw {
		t.Fatalf("unexpected identical fallback hashes for distinct inputs")
	}
}

// TestCanonicalizeIncomingBehavior covers main control flow branches.
func TestCanonicalizeIncomingBehavior(t *testing.T) {
	// Empty => new id
	id1, generated, err := CanonicalizeIncoming("")
	if err != nil || !generated || id1.IsZero() {
		t.Fatalf("CanonicalizeIncoming empty failed: id=%v gen=%v err=%v", id1, generated, err)
	}

	// Valid base62 => parse; no generation
	id2, gen2, err := CanonicalizeIncoming(id1.String())
	if err != nil || gen2 || id2.raw != id1.raw {
		t.Fatalf("CanonicalizeIncoming parse mismatch: id2=%v gen2=%v err=%v", id2, gen2, err)
	}

	// Legacy-like random containing invalid chars -> fallback
	fallbackInput := "legacy\x00\x00padding"
	id3, gen3, err := CanonicalizeIncoming(fallbackInput)
	if err != nil || gen3 {
		t.Fatalf("CanonicalizeIncoming fallback unexpected: id3=%v gen3=%v err=%v", id3, gen3, err)
	}

	// Deterministic fallback
	id4, _, _ := CanonicalizeIncoming(fallbackInput)
	if id3.raw != id4.raw {
		t.Fatalf("fallback canonicalization not deterministic")
	}
}

// TestUpgradeLegacyCartId ensures mapping of old CartId is stable.
func TestUpgradeLegacyCartId(t *testing.T) {
	var legacy CartId
	copy(legacy[:], []byte("legacy-123456789")) // 15 bytes + padding
	up1 := UpgradeLegacyCartId(legacy)
	up2 := UpgradeLegacyCartId(legacy)
	if up1.raw != up2.raw {
		t.Fatalf("UpgradeLegacyCartId not deterministic: %v vs %v", up1, up2)
	}
	if up1.String() != up2.String() {
		t.Fatalf("UpgradeLegacyCartId string mismatch: %s vs %s", up1, up2)
	}
}

// BenchmarkNewCartID gives a rough idea of generation cost.
func BenchmarkNewCartID(b *testing.B) {
	for i := 0; i < b.N; i++ {
		if _, err := NewCartID(); err != nil {
			b.Fatalf("error: %v", err)
		}
	}
}

// BenchmarkEncodeBase62 measures encode speed in isolation.
func BenchmarkEncodeBase62(b *testing.B) {
	// Random sample of values
	samples := make([]uint64, 1024)
	for i := range samples {
		var buf [8]byte
		if _, err := rand.Read(buf[:]); err != nil {
			b.Fatalf("rand: %v", err)
		}
		samples[i] = binary.BigEndian.Uint64(buf[:])
	}
	b.ResetTimer()
	var sink string
	for i := 0; i < b.N; i++ {
		sink = encodeBase62(samples[i%len(samples)])
	}
	_ = sink
}

// BenchmarkDecodeBase62 measures decode speed.
func BenchmarkDecodeBase62(b *testing.B) {
	// Pre-encode
	encoded := make([]string, 1024)
	for i := range encoded {
		encoded[i] = encodeBase62(uint64(i)<<32 | uint64(i))
	}
	b.ResetTimer()
	var sum uint64
	for i := 0; i < b.N; i++ {
		v, ok := decodeBase62(encoded[i%len(encoded)])
		if !ok {
			b.Fatalf("decode failed")
		}
		sum ^= v
	}
	_ = sum
}

// TestLookupNDeterminism (ring integration smoke test) ensures LookupN
// returns distinct hosts and stable ordering for a fixed ring.
func TestLookupNDeterminism(t *testing.T) {
	rb := NewRingBuilder().WithEpoch(1).WithVnodesPerHost(8).WithHosts([]string{"a", "b", "c"})
	ring := rb.Build()
	if ring.Empty() {
		t.Fatalf("expected non-empty ring")
	}
	id := MustNewCartID()
	owners1 := ring.LookupN(id.Raw(), 3)
	owners2 := ring.LookupN(id.Raw(), 3)
	if len(owners1) != len(owners2) {
		t.Fatalf("LookupN length mismatch")
	}
	for i := range owners1 {
		if owners1[i].Host != owners2[i].Host {
			t.Fatalf("LookupN ordering instability at %d: %v vs %v", i, owners1[i], owners2[i])
		}
	}
	// Distinct host constraint
	seen := map[string]struct{}{}
	for _, v := range owners1 {
		if _, ok := seen[v.Host]; ok {
			t.Fatalf("duplicate host in LookupN result: %v", owners1)
		}
		seen[v.Host] = struct{}{}
	}
}

// TestRingFingerprintChanges ensures fingerprint updates with membership changes.
func TestRingFingerprintChanges(t *testing.T) {
	b1 := NewRingBuilder().WithEpoch(1).WithHosts([]string{"node1", "node2"})
	r1 := b1.Build()
	b2 := NewRingBuilder().WithEpoch(2).WithHosts([]string{"node1", "node2", "node3"})
	r2 := b2.Build()
	if r1.Fingerprint() == r2.Fingerprint() {
		t.Fatalf("expected differing fingerprints after host set change")
	}
}

// TestRingDiffHosts verifies added/removed host detection.
func TestRingDiffHosts(t *testing.T) {
	r1 := NewRingBuilder().WithEpoch(1).WithHosts([]string{"a", "b"}).Build()
	r2 := NewRingBuilder().WithEpoch(2).WithHosts([]string{"b", "c"}).Build()
	added, removed := r1.DiffHosts(r2)
	if fmt.Sprintf("%v", added) != "[c]" {
		t.Fatalf("expected added [c], got %v", added)
	}
	if fmt.Sprintf("%v", removed) != "[a]" {
		t.Fatalf("expected removed [a], got %v", removed)
	}
}

// TestRingLookupConsistency ensures direct Lookup and LookupID are aligned.
func TestRingLookupConsistency(t *testing.T) {
	ring := NewRingBuilder().WithEpoch(1).WithHosts([]string{"alpha", "beta"}).WithVnodesPerHost(4).Build()
	id, _ := ParseCartID("1")
	if id.IsZero() {
		t.Fatalf("expected parsed id non-zero")
	}
	v1 := ring.Lookup(id.Raw())
	v2 := ring.LookupID(id)
	if v1.Host != v2.Host || v1.Hash != v2.Hash {
		t.Fatalf("Lookup vs LookupID mismatch: %+v vs %+v", v1, v2)
	}
}