// Copyright (c) 2026 Petr Balvín <opensource@petrbalvin.org> (https://petrbalvin.org)
// SPDX-License-Identifier: BSD-3-Clause

package verify

import (
	"bytes"
	"math/rand"
	"os"
	"runtime"
	"testing"
	"unsafe"
)

const lz4AVX512Path = "../../go-libraries/go-lz4/avx512_amd64.s"

func loadLZ4AVX512Kernel(t *testing.T) *Kernel {
	t.Helper()
	if _, err := os.Stat(lz4AVX512Path); err != nil {
		t.Skipf("sibling kernel not available: %v", err)
	}
	k, err := Load(lz4AVX512Path)
	if err != nil {
		t.Fatalf("Load(%s): %v", lz4AVX512Path, err)
	}
	t.Cleanup(k.Close)
	return k
}

func TestAVX512DecodeKnownAnswers(t *testing.T) {
	k := loadLZ4AVX512Kernel(t)

	tests := []struct {
		name     string
		src      []byte
		wantN    int
		wantCode int
	}{
		{"literals_only", []byte{0x50, 'H', 'e', 'l', 'l', 'o'}, 5, 0},
		{"literals_and_match", []byte{0x54, 'A', 'A', 'A', 'A', 'A', 0x05, 0x00, 0x30, 'B', 'B', 'B'}, 16, 0},
		{"overlapping", []byte{0x14, 'X', 0x01, 0x00, 0x10, 'Y'}, 10, 0},
		{"malformed", []byte{0x50, 'H', 'e'}, 0, 1},
		{"zero_offset", []byte{0x14, 'X', 0x00, 0x00}, 0, 2},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			dst := make([]byte, 64)
			args := make([]byte, 64)
			PutPtr(args, 0, unsafe.Pointer(&tt.src[0]))
			PutUint64(args, 8, uint64(len(tt.src)))
			PutUint64(args, 16, uint64(cap(tt.src)))
			PutPtr(args, 24, unsafe.Pointer(&dst[0]))
			PutUint64(args, 32, uint64(len(dst)))
			PutUint64(args, 40, uint64(cap(dst)))

			out, err := k.CallFunc("decodeBlockAVX512", args)
			runtime.KeepAlive(tt.src)
			runtime.KeepAlive(dst)
			if err != nil {
				t.Fatalf("CallFunc: %v", err)
			}
			n := int(GetUint64(out, 48))
			code := int(GetUint64(out, 56))
			if n != tt.wantN || code != tt.wantCode {
				t.Errorf("got (n=%d, code=%d), want (n=%d, code=%d)", n, code, tt.wantN, tt.wantCode)
			}
		})
	}
}

func TestAVX512DifferentialFuzz(t *testing.T) {
	k := loadLZ4AVX512Kernel(t)
	rng := rand.New(rand.NewSource(77))

	for i := 0; i < 3000; i++ {
		wantSize := 1 + rng.Intn(4096)
		src := genLZ4Block(rng, wantSize)
		dstSize := wantSize + 64

		goDst := make([]byte, dstSize)
		goN, goCode := decodeBlockGo(src, goDst)

		jitDst := make([]byte, dstSize)
		args := make([]byte, 64)
		if len(src) > 0 {
			PutPtr(args, 0, unsafe.Pointer(&src[0]))
		}
		PutUint64(args, 8, uint64(len(src)))
		PutUint64(args, 16, uint64(cap(src)))
		if dstSize > 0 {
			PutPtr(args, 24, unsafe.Pointer(&jitDst[0]))
		}
		PutUint64(args, 32, uint64(dstSize))
		PutUint64(args, 40, uint64(cap(jitDst)))

		out, err := k.CallFunc("decodeBlockAVX512", args)
		runtime.KeepAlive(src)
		runtime.KeepAlive(jitDst)
		if err != nil {
			t.Fatalf("iter %d: %v", i, err)
		}
		jitN := int(GetUint64(out, 48))
		jitCode := int(GetUint64(out, 56))

		if jitCode != goCode {
			t.Fatalf("iter %d: code mismatch: JIT=%d Go=%d", i, jitCode, goCode)
		}
		if jitCode != 0 {
			continue
		}
		if jitN != goN {
			t.Fatalf("iter %d: n mismatch: JIT=%d Go=%d", i, jitN, goN)
		}
		if !bytes.Equal(jitDst[:jitN], goDst[:goN]) {
			t.Fatalf("iter %d: output mismatch (n=%d)", i, jitN)
		}
	}
}

func TestAVX512WideCopy(t *testing.T) {
	k := loadLZ4AVX512Kernel(t)

	sizes := []int{0, 1, 31, 32, 63, 64, 65, 127, 128, 256, 1024}
	for _, n := range sizes {
		src := make([]byte, n)
		for i := range src {
			src[i] = byte(i*11 + 3)
		}
		dst := make([]byte, n)

		args := make([]byte, 48)
		if n > 0 {
			PutPtr(args, 0, unsafe.Pointer(&dst[0]))
			PutPtr(args, 24, unsafe.Pointer(&src[0]))
		}
		PutUint64(args, 8, uint64(n))
		PutUint64(args, 16, uint64(n))
		PutUint64(args, 32, uint64(n))
		PutUint64(args, 40, uint64(n))

		_, err := k.CallFunc("wideCopyAVX512", args)
		runtime.KeepAlive(dst)
		runtime.KeepAlive(src)
		if err != nil {
			t.Fatalf("wideCopyAVX512(n=%d): %v", n, err)
		}
		if !bytes.Equal(dst, src) {
			t.Errorf("wideCopyAVX512(n=%d): mismatch", n)
		}
	}
}