package stable_test

import (
	"runtime"
	"testing"

	"git.brut.systems/judah/xx/stable"
)

func TestXar_StableWithGC(t *testing.T) {
	type valuewithptr struct {
		value int
		ptr   *int
	}

	var xar stable.Xar[valuewithptr]
	xar.InitWithSize(8)

	aptr := xar.Append(valuewithptr{value: 10, ptr: nil})
	bptr := xar.Append(valuewithptr{value: 20, ptr: &aptr.value})

	const N = 1000
	for i := range N {
		xar.Append(valuewithptr{value: i})
		runtime.GC()
	}

	expect(t, xar.Get(0) == aptr)
	expect(t, xar.Get(1) == bptr)
	expect(t, xar.Len() == N+2, "len was %d", xar.Len())
	expect(t, bptr.ptr != nil && bptr.value == 20)
	expect(t, bptr.ptr == &aptr.value, "%p vs. %p", bptr.ptr, &aptr.value)
}

func TestXar_ResetAndReuse(t *testing.T) {
	var xar stable.Xar[int]
	start := xar.Append(60)
	xar.AppendMany(10, 20, 30, 40, 50)

	xar.Reset()
	runtime.GC()

	expect(t, xar.Cap() != 0)
	expect(t, xar.Len() == 0)

	xar.Append(0xFF)
	xar.Append(0xFC)
	xar.Append(0xFB)

	expect(t, xar.Get(0) == start)
	expect(t, xar.Len() == 3)
}

func TestXar_Iterators(t *testing.T) {
	var xar stable.Xar[int]
	xar.AppendMany(0, 1, 2, 3, 4, 5)

	iterations := 0
	for i, v := range xar.Values() {
		iterations += 1
		expect(t, v == i, "v: %d, i: %d", v, i)
	}

	expect(t, iterations == xar.Len())
}

func BenchmarkXar_Append(b *testing.B) {
	var xar stable.Xar[int]
	for i := range b.N {
		xar.Append(i * i)
	}

	xar.Reset()
	for i := range b.N {
		xar.Append(i * i)
	}
}

func BenchmarkXar_RandomAccess(b *testing.B) {
	var xar stable.Xar[int]
	for i := range b.N {
		xar.Append(i * i)
	}

	b.ResetTimer()

	for i := range b.N {
		xar.Get(i % 10000)
	}
}

func BenchmarkXar_Iteration(b *testing.B) {
	var xar stable.Xar[int]
	for i := range b.N {
		xar.Append(i * i)
	}

	b.ResetTimer()

	sum := 0
	for _, v := range xar.Values() {
		sum += v
	}
}