package varn_test

import (
	"io"
	"testing"

	"github.com/stretchr/testify/assert"

	"git.intruders.space/public/opentimestamps/varn"
)

func TestNewBuffer(t *testing.T) {
	data := []byte{0x01, 0x02, 0x03}
	buf := varn.NewBuffer(data)

	// Test the first byte to verify initialization
	b, err := buf.ReadByte()
	assert.NoError(t, err)
	assert.Equal(t, byte(0x01), b)

	// Test reading the second byte
	b, err = buf.ReadByte()
	assert.NoError(t, err)
	assert.Equal(t, byte(0x02), b)

	// Test reading the third byte
	b, err = buf.ReadByte()
	assert.NoError(t, err)
	assert.Equal(t, byte(0x03), b)

	// Test reading beyond the buffer
	_, err = buf.ReadByte()
	assert.ErrorIs(t, err, io.EOF)

	// Test reading from an empty buffer
	emptyBuf := varn.NewBuffer([]byte{})
	_, err = emptyBuf.ReadByte()
	assert.ErrorIs(t, err, io.EOF)

	// Test reading from a nil buffer
	nilBuf := varn.NewBuffer(nil)
	_, err = nilBuf.ReadByte()
	assert.ErrorIs(t, err, io.EOF)

	// Test reading from a buffer with a single byte
	singleByteBuf := varn.NewBuffer([]byte{0xFF})
	b, err = singleByteBuf.ReadByte()
	assert.NoError(t, err)
	assert.Equal(t, byte(0xFF), b)
}

func TestReadBytes(t *testing.T) {
	data := []byte{0x01, 0x02, 0x03, 0x04, 0x05}
	buf := varn.NewBuffer(data)

	// Read 3 bytes
	bytes, err := buf.ReadBytes(3)
	assert.NoError(t, err)
	assert.Equal(t, []byte{0x01, 0x02, 0x03}, bytes)

	// Read 2 more bytes
	bytes, err = buf.ReadBytes(2)
	assert.NoError(t, err)
	assert.Equal(t, []byte{0x04, 0x05}, bytes)

	// Try to read beyond the buffer
	_, err = buf.ReadBytes(1)
	assert.ErrorIs(t, err, io.EOF)
}

func TestReadByte(t *testing.T) {
	data := []byte{0x0A, 0x0B}
	buf := varn.NewBuffer(data)

	// Read first byte
	b, err := buf.ReadByte()
	assert.NoError(t, err)
	assert.Equal(t, byte(0x0A), b)

	// Read second byte
	b, err = buf.ReadByte()
	assert.NoError(t, err)
	assert.Equal(t, byte(0x0B), b)

	// Try to read beyond the buffer
	_, err = buf.ReadByte()
	assert.ErrorIs(t, err, io.EOF)
}

func TestReadVarUint(t *testing.T) {
	testCases := []struct {
		name     string
		input    []byte
		expected uint64
	}{
		{
			name:     "Single byte",
			input:    []byte{0x01},
			expected: 1,
		},
		{
			name:     "Two bytes",
			input:    []byte{0x81, 0x01}, // 129 in varint encoding
			expected: 129,
		},
		{
			name:     "Large number",
			input:    []byte{0xFF, 0xFF, 0xFF, 0xFF, 0x01}, // 536870911 in varint encoding
			expected: 536870911,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			buf := varn.NewBuffer(tc.input)
			val, err := buf.ReadVarUint()
			assert.NoError(t, err)
			assert.Equal(t, tc.expected, val)
		})
	}

	// Test EOF
	buf := varn.NewBuffer([]byte{0x81}) // Incomplete varint
	_, err := buf.ReadVarUint()
	assert.ErrorIs(t, err, io.EOF)
}

func TestReadVarBytes(t *testing.T) {
	// Test normal case: length followed by data
	data := []byte{0x03, 0x0A, 0x0B, 0x0C, 0x0D}
	buf := varn.NewBuffer(data)

	bytes, err := buf.ReadVarBytes()
	assert.NoError(t, err)
	assert.Equal(t, []byte{0x0A, 0x0B, 0x0C}, bytes)

	// Test empty array
	data = []byte{0x00, 0x01}
	buf = varn.NewBuffer(data)

	bytes, err = buf.ReadVarBytes()
	assert.NoError(t, err)
	assert.Equal(t, []byte{}, bytes)

	// Test EOF during length read
	buf = varn.NewBuffer([]byte{})
	_, err = buf.ReadVarBytes()
	assert.ErrorIs(t, err, io.EOF)

	// Test error during data read (insufficient bytes)
	data = []byte{0x03, 0x01}
	buf = varn.NewBuffer(data)
	_, err = buf.ReadVarBytes()
	assert.ErrorIs(t, err, io.ErrUnexpectedEOF)
}