package mem_test

import (
	"testing"
	"unsafe"

	"git.brut.systems/judah/xx/mem"
	"git.brut.systems/judah/xx/testx"
)

func TestBitCast(t *testing.T) {
	a := uint32(0xFFFF_FFFF)
	b := mem.BitCast[float32](&a)
	c := mem.BitCast[uint32](&b)
	if a != c {
		t.Fail()
	}

	v := uint8(0xFF)
	d := mem.BitCast[int8](&v)
	if d != -1 {
		t.Fail()
	}
	e := mem.BitCast[uint8](&d)
	if e != 255 {
		t.Fail()
	}
}

func TestMemoryPrimitives(t *testing.T) {
	t.Run("copy", func(t *testing.T) {
		{ // non-overlapping
			a := []int{1, 2, 3, 4, 5, 6}
			b := make([]int, 3)
			mem.Copy(unsafe.Pointer(&b[0]), unsafe.Pointer(&a[0]), uintptr(len(b))*unsafe.Sizeof(int(0)))

			for i := range len(b) {
				testx.Expect(t, a[i] == b[i], "%d != %d [%d]", a[i], b[i], i)
			}
		}

		{ // overlapping
			a := []int{1, 2, 3, 4, 5}
			b := &a[0]
			mem.Copy(unsafe.Pointer(b), unsafe.Pointer(&a[0]), uintptr(len(a))*unsafe.Sizeof(int(0)))

			for i := range len(a) {
				testx.Expect(t, a[i] == i+1, "[%d] %d != %d", i, a[i], i+1)
			}
		}
	})

	t.Run("clear", func(t *testing.T) {
		{ // zero
			v := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
			mem.Clear(unsafe.Pointer(&v[0]), 0, uintptr(len(v))*unsafe.Sizeof(int(0)))

			for i := range len(v) {
				testx.Expect(t, v[i] == 0, "[%d] %d != 0", i, v[i])
			}
		}

		{ // fill
			v := []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
			mem.Clear(unsafe.Pointer(&v[0]), 0xFF, uintptr(len(v))*unsafe.Sizeof(int(0)))

			for i := range len(v) {
				testx.Expect(t, v[i] == 0xFF, "[%d] %d != 0xFF", i, v[i])
			}
		}
	})
}

func TestAllocationPrimitives(t *testing.T) {
	t.Run("reserve, unreserve", func(t *testing.T) {
		data, err := mem.Reserve(1 * mem.Gigabyte)
		testx.Expect(t, err == nil, "mem.Reserve returned an error - %s", err)

		testx.Expect(t, len(data) == 1*mem.Gigabyte, "len was %d", len(data))
		testx.Expect(t, cap(data) == 1*mem.Gigabyte, "len was %d", cap(data))

		err = mem.Release(data)
		testx.Expect(t, err == nil, "mem.Unreserve returned an error - %s", err)
	})

	t.Run("commit", func(t *testing.T) {
		data, err := mem.Reserve(1 * mem.Gigabyte)
		testx.Expect(t, err == nil, "mem.Reserve returned an error - %s", err)

		err = mem.Commit(data, mem.AccessRead|mem.AccessWrite)
		testx.Expect(t, err == nil, "mem.Commit returned an error - %s", err)

		for i := range data {
			data[i] = byte(i * i)
		}
	})

	t.Run("decommit", func(t *testing.T) {
		data, err := mem.Reserve(1 * mem.Gigabyte)
		testx.Expect(t, err == nil, "mem.Reserve returned an error - %s", err)

		err = mem.Commit(data, mem.AccessRead|mem.AccessWrite)
		testx.Expect(t, err == nil, "mem.Commit returned an error - %s", err)

		before := uintptr(unsafe.Pointer(&data[0]))

		err = mem.Decommit(data)
		testx.Expect(t, err == nil, "mem.Decommit returned an error - %s", err)

		// accessing data before recommitting it will fail

		err = mem.Commit(data, mem.AccessRead|mem.AccessWrite)
		testx.Expect(t, err == nil, "mem.Commit returned an error - %s", err)

		after := uintptr(unsafe.Pointer(&data[0]))
		testx.Expect(t, before == after, "base pointers did not match between after recommit %d != %d", before, after)

		for i := range data {
			data[i] = byte(i * i)
		}
	})
}