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

package verify

import (
	"testing"
	"unsafe"
)

func TestBlocks(t *testing.T) {
	k := loadBasic(t)

	// The "sum" function has labels: sum_done, sum_loop.
	blocks, err := k.Blocks("sum")
	if err != nil {
		t.Fatalf("Blocks(sum): %v", err)
	}
	if len(blocks) < 3 {
		t.Errorf("sum: expected at least 3 blocks (entry + 2 labels), got %d", len(blocks))
	}
	if blocks[0].Offset != 0 {
		t.Errorf("first block offset = %d, want 0", blocks[0].Offset)
	}
	t.Logf("sum blocks: %v", blocks)
}

func TestBlockCount(t *testing.T) {
	k := loadLZ4Kernel(t)

	n, err := k.BlockCount("decodeBlockAVX2")
	if err != nil {
		t.Fatalf("BlockCount: %v", err)
	}
	// The decoder has many labels (dec_loop, dec_malformed, etc.).
	if n < 10 {
		t.Errorf("decodeBlockAVX2: expected at least 10 blocks, got %d", n)
	}
	t.Logf("decodeBlockAVX2: %d basic blocks", n)
}

func TestProfilePaths(t *testing.T) {
	k := loadLZ4Kernel(t)

	// Build a corpus of varied LZ4 blocks.
	var argSets [][]byte
	blocks := []struct {
		src     []byte
		dstSize int
	}{
		{[]byte{0x00}, 16},                          // empty
		{[]byte{0x50, 'H', 'e', 'l', 'l', 'o'}, 16}, // literals only
		{[]byte{0x54, 'A', 'A', 'A', 'A', 'A', 5, 0, 0x30, 'B', 'B', 'B'}, 32}, // match
		{[]byte{0x14, 'X', 1, 0, 0x10, 'Y'}, 16},                               // overlapping
		{[]byte{0x50, 'H'}, 16},                                                // malformed
		{[]byte{0x14, 'X', 0, 0}, 16},                                          // zero offset
	}
	for _, b := range blocks {
		args := make([]byte, 64)
		if len(b.src) > 0 {
			PutPtr(args, 0, unsafe.Pointer(&b.src[0]))
		}
		PutUint64(args, 8, uint64(len(b.src)))
		PutUint64(args, 16, uint64(cap(b.src)))
		dst := make([]byte, b.dstSize)
		if len(dst) > 0 {
			PutPtr(args, 24, unsafe.Pointer(&dst[0]))
		}
		PutUint64(args, 32, uint64(len(dst)))
		PutUint64(args, 40, uint64(cap(dst)))
		argSets = append(argSets, args)
	}

	// Result offsets: n+48 and code+56.
	paths, err := k.ProfilePaths("decodeBlockAVX2", argSets, []int{48, 56})
	if err != nil {
		t.Fatalf("ProfilePaths: %v", err)
	}

	// We expect at least 3 distinct paths: success (various n), malformed, zero offset.
	if len(paths) < 3 {
		t.Errorf("expected at least 3 distinct paths, got %d", len(paths))
	}
	t.Logf("decodeBlockAVX2: %d distinct output paths from %d inputs", len(paths), len(argSets))
}