package stario

import (
	"bytes"
	"testing"
)

func TestNewStarRingRejectsInvalidCapacity(t *testing.T) {
	ring, err := NewStarRing(0)
	if err != ErrStarRingInvalidCapacity {
		t.Fatalf("unexpected error: %v", err)
	}
	if ring != nil {
		t.Fatal("expected nil ring when capacity is invalid")
	}
}

func TestStarRingWriteAndSnapshot(t *testing.T) {
	ring, err := NewStarRing(16)
	if err != nil {
		t.Fatal(err)
	}
	if n, err := ring.Write([]byte("abc")); err != nil || n != 3 {
		t.Fatalf("write failed: n=%d err=%v", n, err)
	}
	if n, err := ring.WriteString("def"); err != nil || n != 3 {
		t.Fatalf("write string failed: n=%d err=%v", n, err)
	}

	got := ring.Snapshot()
	if !bytes.Equal(got, []byte("abcdef")) {
		t.Fatalf("unexpected snapshot: %q", got)
	}
	if ring.Len() != 6 {
		t.Fatalf("unexpected ring len: %d", ring.Len())
	}
	if ring.Capacity() != 16 {
		t.Fatalf("unexpected ring capacity: %d", ring.Capacity())
	}
}

func TestStarRingOverflowDropsOldestBytesPrecisely(t *testing.T) {
	ring, err := NewStarRing(10)
	if err != nil {
		t.Fatal(err)
	}
	_, _ = ring.WriteString("abcde")
	_, _ = ring.WriteString("fghij")
	_, _ = ring.WriteString("kl")

	got := ring.Snapshot()
	want := []byte("cdefghijkl")
	if !bytes.Equal(got, want) {
		t.Fatalf("unexpected snapshot after overflow: got %q want %q", got, want)
	}
	if ring.Len() != len(want) {
		t.Fatalf("unexpected ring len after overflow: %d", ring.Len())
	}
}

func TestStarRingLargeWriteKeepsTail(t *testing.T) {
	ring, err := NewStarRing(5)
	if err != nil {
		t.Fatal(err)
	}
	_, _ = ring.WriteString("123")
	_, _ = ring.WriteString("456789")

	got := ring.Snapshot()
	want := []byte("56789")
	if !bytes.Equal(got, want) {
		t.Fatalf("unexpected snapshot after large write: got %q want %q", got, want)
	}
}

func TestStarRingSnapshotIsCopy(t *testing.T) {
	ring, err := NewStarRing(8)
	if err != nil {
		t.Fatal(err)
	}
	_, _ = ring.WriteString("hello")

	first := ring.Snapshot()
	first[0] = 'H'
	second := ring.Snapshot()
	if !bytes.Equal(second, []byte("hello")) {
		t.Fatalf("snapshot should not expose internal storage: %q", second)
	}
}

func TestStarRingReset(t *testing.T) {
	ring, err := NewStarRing(8)
	if err != nil {
		t.Fatal(err)
	}
	_, _ = ring.WriteString("hello")
	ring.Reset()
	if ring.Len() != 0 {
		t.Fatalf("expected len=0 after reset, got %d", ring.Len())
	}
	if got := ring.Snapshot(); len(got) != 0 {
		t.Fatalf("expected empty snapshot after reset, got %q", got)
	}
}