package buffer

import (
	"io"
	"testing"
)

func TestWrite(t *testing.T) {
	t.Parallel()
	b := Buffer{}
	data := []byte("test")

	n, err := b.Write(data)
	if n != len(data) || err != nil {
		t.Errorf("Write failed: expected %d bytes, got %d, error: %v", len(data), n, err)
	}

	if b.Len() != len(data) {
		t.Errorf("Len is incorrect after write: expected %d, got %d", len(data), b.Len())
	}

	if string(b.Bytes()) != "test" {
		t.Error("Bytes returned after write do not match written data")
	}
}

func TestRead(t *testing.T) {
	t.Parallel()
	b := NewBuffer([]byte("testdata"))
	p := make([]byte, 3)
	n, err := b.Read(p)

	if n != 3 || string(p[:n]) != "tes" || err != nil {
		t.Errorf("Read returned incorrect data: expected 'tes', got '%s', error: %v", p[:n], err)
	}

	b.Reset()
	data := []byte("abc")
	n, err = b.Write(data)
	if n != 3 || err != nil {
		t.Errorf("Write failed: expected %d bytes, got %d, error: %v", len(data), n, err)
	}

	p = make([]byte, 2)
	n, err = b.Read(p)

	if n != 2 || string(p) != "ab" || err != nil {
		t.Errorf("Read after reset failed: expected 'ab', got '%s', error: %v", p, err)
	}

	b.pos = b.len
	n, err = b.Read(p)
	if n != 0 || err != io.EOF {
		t.Errorf("Reading beyond buffer did not return EOF: n=%d, err=%v", n, err)
	}
}

func TestReset(t *testing.T) {
	t.Parallel()
	b := NewBuffer([]byte("test"))
	data := []byte("data")
	n, err := b.Write(data)
	if n != 4 || err != nil {
		t.Errorf("Write failed: expected %d bytes, got %d, error: %v", len(data), n, err)
	}

	if b.Len() != 8 || b.pos != 0 {
		t.Errorf("Initial buffer state incorrect: len=%d, pos=%d", b.Len(), b.pos)
	}

	b.Reset()
	if b.Len() != 0 || b.pos != 0 {
		t.Errorf("Reset did not clear buffer correctly: len=%d, pos=%d", b.Len(), b.pos)
	}
}

func TestSeek(t *testing.T) {
	t.Parallel()
	b := NewBuffer([]byte("test"))
	tests := []struct {
		offset int64
		whence int
		expect int64
		err    error
	}{
		{2, io.SeekStart, 2, nil},
		{-1, io.SeekCurrent, 1, nil},
		{-2, io.SeekEnd, int64(len("test") - 2), nil},
		{5, io.SeekStart, int64(len("test")), nil},
		{-10, io.SeekEnd, 0, nil},
		{0, 999, 0, io.EOF}, // Invalid whence test
	}

	for _, tt := range tests {
		pos, err := b.Seek(tt.offset, tt.whence)
		if pos != tt.expect || (err != tt.err && !((err == nil) && (tt.err == nil))) {
			t.Errorf("Seek(%d, %d): expected %d with error %v, got %d and %v",
				tt.offset, tt.whence, tt.expect, tt.err, pos, err)
		}
	}
}