package xar_test

import (
	"runtime"
	"testing"

	"git.brut.systems/judah/xx/containerx/xar"
	"git.brut.systems/judah/xx/testx"
)

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

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

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

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

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

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

	x.Reset()
	runtime.GC()

	testx.Expect(t, x.Cap() != 0)
	testx.Expect(t, x.Len() == 0)

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

	testx.Expect(t, x.Get(0) == start)
	testx.Expect(t, x.Len() == 3)
}

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

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

	testx.Expect(t, iterations == x.Len())
}

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

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

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

	b.ResetTimer()

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

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

	b.ResetTimer()

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