package world

import (
	"errors"
	"fmt"
	"github.com/stretchr/testify/require"
	"image/color"
	"testing"
)

func newIndexedTestWorld() *World {
	w := NewWorld(10, 10)
	w.SetCircleRadiusScaleFp(SCALE)
	w.resetGrid(2 * SCALE) // 5x5 grid.
	return w
}

func cellHasOnlyID(t *testing.T, w *World, row, col int, want PrimitiveID) {
	t.Helper()

	cell := w.grid[row][col]
	if len(cell) != 1 {
		t.Fatalf("cell[%d][%d] len = %d, want 1", row, col, len(cell))
	}
	if got := cell[0].ID(); got != want {
		t.Fatalf("cell[%d][%d] item id = %v, want %v", row, col, got, want)
	}
}

func cellIsEmpty(t *testing.T, w *World, row, col int) {
	t.Helper()

	if got := len(w.grid[row][col]); got != 0 {
		t.Fatalf("cell[%d][%d] len = %d, want 0", row, col, got)
	}
}

func occupiedCellsByID(w *World, id PrimitiveID) map[[2]int]struct{} {
	result := make(map[[2]int]struct{})

	for row := range w.grid {
		for col := range w.grid[row] {
			for _, item := range w.grid[row][col] {
				if item.ID() == id {
					result[[2]int{row, col}] = struct{}{}
				}
			}
		}
	}

	return result
}

func assertOccupiedCells(t *testing.T, w *World, id PrimitiveID, want ...[2]int) {
	t.Helper()

	got := occupiedCellsByID(w, id)
	if len(got) != len(want) {
		t.Fatalf("occupied cell count = %d, want %d; got=%v want=%v", len(got), len(want), got, want)
	}

	for _, cell := range want {
		if _, ok := got[cell]; !ok {
			t.Fatalf("missing occupied cell row=%d col=%d; got=%v", cell[0], cell[1], got)
		}
	}
}

// TestNewWorld verifies new World.
func TestNewWorld(t *testing.T) {
	t.Parallel()

	w := NewWorld(12, 7)

	if w.W != 12*SCALE {
		t.Fatalf("W = %d, want %d", w.W, 12*SCALE)
	}
	if w.H != 7*SCALE {
		t.Fatalf("H = %d, want %d", w.H, 7*SCALE)
	}
	if w.cellSize != 1 {
		t.Fatalf("cellSize = %d, want 1", w.cellSize)
	}
	if w.objects == nil {
		t.Fatal("objects map is nil")
	}
}

// TestNewWorldPanicsOnInvalidSize verifies new World Panics On Invalid Size.
func TestNewWorldPanicsOnInvalidSize(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name   string
		width  int
		height int
	}{
		{name: "zero width", width: 0, height: 1},
		{name: "zero height", width: 1, height: 0},
		{name: "negative width", width: -1, height: 1},
		{name: "negative height", width: 1, height: -1},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			defer func() {
				if recover() == nil {
					t.Fatalf("NewWorld(%d, %d) did not panic", tt.width, tt.height)
				}
			}()

			_ = NewWorld(tt.width, tt.height)
		})
	}
}

// TestCheckCoordinate verifies check Coordinate.
func TestCheckCoordinate(t *testing.T) {
	t.Parallel()

	w := NewWorld(10, 10)

	tests := []struct {
		name string
		xf   int
		yf   int
		want bool
	}{
		{name: "origin", xf: 0, yf: 0, want: true},
		{name: "inside", xf: 5000, yf: 5000, want: true},
		{name: "last valid", xf: 9999, yf: 9999, want: true},
		{name: "x below", xf: -1, yf: 0, want: false},
		{name: "y below", xf: 0, yf: -1, want: false},
		{name: "x equal width", xf: 10000, yf: 0, want: false},
		{name: "y equal height", xf: 0, yf: 10000, want: false},
	}

	for _, tt := range tests {
		if got := w.checkCoordinate(tt.xf, tt.yf); got != tt.want {
			t.Fatalf("checkCoordinate(%d, %d) = %v, want %v", tt.xf, tt.yf, got, tt.want)
		}
	}
}

// TestAddPoint verifies add Point.
func TestAddPoint(t *testing.T) {
	t.Parallel()

	w := NewWorld(10, 10)

	id, err := w.AddPoint(1.25, 2.75)
	if err != nil {
		t.Fatalf("AddPoint returned error: %v", err)
	}

	item, ok := w.objects[id]
	if !ok {
		t.Fatalf("point with id %v was not stored", id)
	}

	p, ok := item.(Point)
	if !ok {
		t.Fatalf("stored item type = %T, want Point", item)
	}
	if p.X != 1250 || p.Y != 2750 {
		t.Fatalf("stored point = (%d, %d), want (1250, 2750)", p.X, p.Y)
	}
}

// TestAddPointRejectsOutOfBounds verifies add Point Rejects Out Of Bounds.
func TestAddPointRejectsOutOfBounds(t *testing.T) {
	t.Parallel()

	w := NewWorld(10, 10)

	tests := []struct {
		name string
		x    float64
		y    float64
	}{
		{name: "negative x", x: -0.001, y: 1},
		{name: "negative y", x: 1, y: -0.001},
		{name: "x rounds to width", x: 9.9995, y: 1},
		{name: "y rounds to height", x: 1, y: 9.9995},
		{name: "x clearly outside", x: 10, y: 1},
		{name: "y clearly outside", x: 1, y: 10},
	}

	for _, tt := range tests {
		_, err := w.AddPoint(tt.x, tt.y)
		if !errors.Is(err, errBadCoordinate) {
			t.Fatalf("%s: error = %v, want %v", tt.name, err, errBadCoordinate)
		}
	}
}

// TestAddPointAllowsLastRoundedInsideValue verifies add Point Allows Last Rounded Inside Value.
func TestAddPointAllowsLastRoundedInsideValue(t *testing.T) {
	t.Parallel()

	w := NewWorld(10, 10)

	id, err := w.AddPoint(9.9994, 9.9994)
	if err != nil {
		t.Fatalf("AddPoint returned error: %v", err)
	}

	p := w.objects[id].(Point)
	if p.X != 9999 || p.Y != 9999 {
		t.Fatalf("stored point = (%d, %d), want (9999, 9999)", p.X, p.Y)
	}
}

// TestAddCircle verifies add Circle.
func TestAddCircle(t *testing.T) {
	t.Parallel()

	w := NewWorld(10, 10)

	id, err := w.AddCircle(2.5, 3.5, 1.25)
	if err != nil {
		t.Fatalf("AddCircle returned error: %v", err)
	}

	item, ok := w.objects[id]
	if !ok {
		t.Fatalf("circle with id %v was not stored", id)
	}

	c, ok := item.(Circle)
	if !ok {
		t.Fatalf("stored item type = %T, want Circle", item)
	}
	if c.X != 2500 || c.Y != 3500 || c.Radius != 1250 {
		t.Fatalf("stored circle = (%d, %d, %d), want (2500, 3500, 1250)", c.X, c.Y, c.Radius)
	}
}

// TestAddCircleAllowsZeroRadius verifies add Circle Allows Zero Radius.
func TestAddCircleAllowsZeroRadius(t *testing.T) {
	t.Parallel()

	w := NewWorld(10, 10)

	id, err := w.AddCircle(2, 3, 0)
	if err != nil {
		t.Fatalf("AddCircle returned error: %v", err)
	}

	c := w.objects[id].(Circle)
	if c.Radius != 0 {
		t.Fatalf("radius = %d, want 0", c.Radius)
	}
}

// TestAddCircleRejectsInvalidInput verifies add Circle Rejects Invalid Input.
func TestAddCircleRejectsInvalidInput(t *testing.T) {
	t.Parallel()

	w := NewWorld(10, 10)

	if _, err := w.AddCircle(1, 1, -0.001); !errors.Is(err, errBadRadius) {
		t.Fatalf("negative radius error = %v, want %v", err, errBadRadius)
	}

	tests := []struct {
		name string
		x    float64
		y    float64
	}{
		{name: "negative x", x: -0.001, y: 1},
		{name: "negative y", x: 1, y: -0.001},
		{name: "x rounds to width", x: 9.9995, y: 1},
		{name: "y rounds to height", x: 1, y: 9.9995},
	}

	for _, tt := range tests {
		_, err := w.AddCircle(tt.x, tt.y, 1)
		if !errors.Is(err, errBadCoordinate) {
			t.Fatalf("%s: error = %v, want %v", tt.name, err, errBadCoordinate)
		}
	}
}

// TestAddLine verifies add Line.
func TestAddLine(t *testing.T) {
	t.Parallel()

	w := NewWorld(10, 10)

	id, err := w.AddLine(1.1, 2.2, 3.3, 4.4)
	if err != nil {
		t.Fatalf("AddLine returned error: %v", err)
	}

	item, ok := w.objects[id]
	if !ok {
		t.Fatalf("line with id %v was not stored", id)
	}

	l, ok := item.(Line)
	if !ok {
		t.Fatalf("stored item type = %T, want Line", item)
	}
	if l.X1 != 1100 || l.Y1 != 2200 || l.X2 != 3300 || l.Y2 != 4400 {
		t.Fatalf("stored line = (%d, %d) -> (%d, %d), want (1100, 2200) -> (3300, 4400)",
			l.X1, l.Y1, l.X2, l.Y2)
	}
}

// TestAddLineRejectsInvalidInput verifies add Line Rejects Invalid Input.
func TestAddLineRejectsInvalidInput(t *testing.T) {
	t.Parallel()

	w := NewWorld(10, 10)

	tests := []struct {
		name string
		x1   float64
		y1   float64
		x2   float64
		y2   float64
	}{
		{name: "first point x below", x1: -0.001, y1: 1, x2: 2, y2: 2},
		{name: "first point y below", x1: 1, y1: -0.001, x2: 2, y2: 2},
		{name: "second point x below", x1: 1, y1: 1, x2: -0.001, y2: 2},
		{name: "second point y below", x1: 1, y1: 1, x2: 2, y2: -0.001},
		{name: "first point x rounds to width", x1: 9.9995, y1: 1, x2: 2, y2: 2},
		{name: "second point y rounds to height", x1: 1, y1: 1, x2: 2, y2: 9.9995},
	}

	for _, tt := range tests {
		_, err := w.AddLine(tt.x1, tt.y1, tt.x2, tt.y2)
		if !errors.Is(err, errBadCoordinate) {
			t.Fatalf("%s: error = %v, want %v", tt.name, err, errBadCoordinate)
		}
	}
}

// TestResetGrid verifies reset Grid.
func TestResetGrid(t *testing.T) {
	t.Parallel()

	w := NewWorld(10, 6)
	w.resetGrid(2 * SCALE)

	if w.cellSize != 2*SCALE {
		t.Fatalf("cellSize = %d, want %d", w.cellSize, 2*SCALE)
	}
	if w.cols != 5 {
		t.Fatalf("cols = %d, want 5", w.cols)
	}
	if w.rows != 3 {
		t.Fatalf("rows = %d, want 3", w.rows)
	}
	if len(w.grid) != 3 {
		t.Fatalf("len(grid) = %d, want 3", len(w.grid))
	}
	for row := range w.grid {
		if len(w.grid[row]) != 5 {
			t.Fatalf("len(grid[%d]) = %d, want 5", row, len(w.grid[row]))
		}
	}
}

// TestWorldToCellXY verifies world To Cell XY.
func TestWorldToCellXY(t *testing.T) {
	t.Parallel()

	w := newIndexedTestWorld()

	if got := w.worldToCellX(2500); got != 1 {
		t.Fatalf("worldToCellX(2500) = %d, want 1", got)
	}
	if got := w.worldToCellY(4500); got != 2 {
		t.Fatalf("worldToCellY(4500) = %d, want 2", got)
	}
	if got := w.worldToCellX(-1); got != 4 {
		t.Fatalf("worldToCellX(-1) = %d, want 4", got)
	}
	if got := w.worldToCellY(10000); got != 0 {
		t.Fatalf("worldToCellY(10000) = %d, want 0", got)
	}
}

// TestIndexObjectPoint verifies index Object Point.
func TestIndexObjectPoint(t *testing.T) {
	t.Parallel()

	w := newIndexedTestWorld()
	id := PrimitiveID(1)

	p := Point{Id: id, X: 2500, Y: 4500}
	w.indexObject(p)

	cellHasOnlyID(t, w, 2, 1, id)
	cellIsEmpty(t, w, 0, 0)
	cellIsEmpty(t, w, 4, 4)
}

// TestIndexObjectCircleWithoutWrap verifies index Object Circle Without Wrap.
func TestIndexObjectCircleWithoutWrap(t *testing.T) {
	t.Parallel()

	w := newIndexedTestWorld()
	id := PrimitiveID(1)

	c := Circle{Id: id, X: 3000, Y: 2000, Radius: 900}
	w.indexObject(c)

	assertOccupiedCells(t, w, id,
		[2]int{0, 1},
		[2]int{1, 1},
	)
}

// TestIndexObjectCircleWrapsAcrossCorner verifies index Object Circle Wraps Across Corner.
func TestIndexObjectCircleWrapsAcrossCorner(t *testing.T) {
	t.Parallel()

	w := newIndexedTestWorld()
	id := PrimitiveID(1)

	c := Circle{Id: id, X: 500, Y: 500, Radius: 900}
	w.indexObject(c)

	assertOccupiedCells(t, w, id,
		[2]int{0, 0},
		[2]int{0, 4},
		[2]int{4, 0},
		[2]int{4, 4},
	)
}

// TestIndexObjectCircleCoversWholeWorld verifies index Object Circle Covers Whole World.
func TestIndexObjectCircleCoversWholeWorld(t *testing.T) {
	t.Parallel()

	w := newIndexedTestWorld()
	id := PrimitiveID(1)

	c := Circle{Id: id, X: 5000, Y: 5000, Radius: 6000}
	w.indexObject(c)

	want := make([][2]int, 0, 25)
	for row := 0; row < 5; row++ {
		for col := 0; col < 5; col++ {
			want = append(want, [2]int{row, col})
		}
	}

	assertOccupiedCells(t, w, id, want...)
}

// TestIndexObjectVerticalLineExpandsDegenerateX verifies index Object Vertical Line Expands Degenerate X.
func TestIndexObjectVerticalLineExpandsDegenerateX(t *testing.T) {
	t.Parallel()

	w := newIndexedTestWorld()
	id := PrimitiveID(1)

	l := Line{Id: id, X1: 3000, Y1: 1000, X2: 3000, Y2: 5000}
	w.indexObject(l)

	assertOccupiedCells(t, w, id,
		[2]int{0, 1},
		[2]int{1, 1},
		[2]int{2, 1},
	)
}

// TestIndexObjectHorizontalLineExpandsDegenerateY verifies index Object Horizontal Line Expands Degenerate Y.
func TestIndexObjectHorizontalLineExpandsDegenerateY(t *testing.T) {
	t.Parallel()

	w := newIndexedTestWorld()
	id := PrimitiveID(1)

	l := Line{Id: id, X1: 1000, Y1: 3000, X2: 5000, Y2: 3000}
	w.indexObject(l)

	assertOccupiedCells(t, w, id,
		[2]int{1, 0},
		[2]int{1, 1},
		[2]int{1, 2},
	)
}

// TestIndexObjectLineWrapsAcrossX verifies index Object Line Wraps Across X.
func TestIndexObjectLineWrapsAcrossX(t *testing.T) {
	t.Parallel()

	w := newIndexedTestWorld()
	id := PrimitiveID(1)

	l := Line{Id: id, X1: 9000, Y1: 3000, X2: 1000, Y2: 3000}
	w.indexObject(l)

	assertOccupiedCells(t, w, id,
		[2]int{1, 4},
		[2]int{1, 0},
	)
}

// TestIndexObjectLineWrapsAcrossY verifies index Object Line Wraps Across Y.
func TestIndexObjectLineWrapsAcrossY(t *testing.T) {
	t.Parallel()

	w := newIndexedTestWorld()
	id := PrimitiveID(1)

	l := Line{Id: id, X1: 3000, Y1: 9000, X2: 3000, Y2: 1000}
	w.indexObject(l)

	assertOccupiedCells(t, w, id,
		[2]int{4, 1},
		[2]int{0, 1},
	)
}

// TestIndexObjectLineTieCaseUsesDeterministicWrap verifies index Object Line Tie Case Uses Deterministic Wrap.
func TestIndexObjectLineTieCaseUsesDeterministicWrap(t *testing.T) {
	t.Parallel()

	w := newIndexedTestWorld()
	id := PrimitiveID(1)

	l := Line{Id: id, X1: 1000, Y1: 3000, X2: 6000, Y2: 3000}
	w.indexObject(l)

	assertOccupiedCells(t, w, id,
		[2]int{1, 3},
		[2]int{1, 4},
		[2]int{1, 0},
	)
}

type unknown struct {
	id PrimitiveID
}

func (u unknown) ID() PrimitiveID {
	return u.id
}

// TestIndexBBoxPanicsOnUnknownItemType verifies index B Box Panics On Unknown Item Type.
func TestIndexBBoxPanicsOnUnknownItemType(t *testing.T) {
	t.Parallel()

	w := newIndexedTestWorld()

	defer func() {
		if recover() == nil {
			t.Fatal("indexObject did not panic for unknown item type")
		}
	}()

	w.indexObject(unknown{id: PrimitiveID(1)})
}

// TestAddPoint_DefaultsPriorityAndStyle verifies add Point Defaults Priority And Style.
func TestAddPoint_DefaultsPriorityAndStyle(t *testing.T) {
	t.Parallel()

	w := NewWorld(10, 10)
	id, err := w.AddPoint(1, 1)
	require.NoError(t, err)

	obj := w.objects[id].(Point)
	require.Equal(t, DefaultPriorityPoint, obj.Priority)
	require.Equal(t, StyleIDDefaultPoint, obj.StyleID)
}

// TestAddCircle_DefaultsPriorityAndStyle verifies add Circle Defaults Priority And Style.
func TestAddCircle_DefaultsPriorityAndStyle(t *testing.T) {
	t.Parallel()

	w := NewWorld(10, 10)
	id, err := w.AddCircle(1, 1, 1)
	require.NoError(t, err)

	obj := w.objects[id].(Circle)
	require.Equal(t, DefaultPriorityCircle, obj.Priority)
	require.Equal(t, StyleIDDefaultCircle, obj.StyleID)
}

// TestAddLine_DefaultsPriorityAndStyle verifies add Line Defaults Priority And Style.
func TestAddLine_DefaultsPriorityAndStyle(t *testing.T) {
	t.Parallel()

	w := NewWorld(10, 10)
	id, err := w.AddLine(1, 1, 2, 2)
	require.NoError(t, err)

	obj := w.objects[id].(Line)
	require.Equal(t, DefaultPriorityLine, obj.Priority)
	require.Equal(t, StyleIDDefaultLine, obj.StyleID)
}

// TestAddStyleLine_ThenUseStyleID verifies add Style Line Then Use Style ID.
func TestAddStyleLine_ThenUseStyleID(t *testing.T) {
	t.Parallel()

	w := NewWorld(10, 10)

	width := 5.0
	ov := StyleOverride{StrokeWidthPx: &width}
	styleID := w.AddStyleLine(ov)

	id, err := w.AddLine(1, 1, 2, 2, LineWithStyleID(styleID), LineWithPriority(777))
	require.NoError(t, err)

	obj := w.objects[id].(Line)
	require.Equal(t, 777, obj.Priority)
	require.Equal(t, styleID, obj.StyleID)

	s, ok := w.styles.Get(styleID)
	require.True(t, ok)
	require.Equal(t, 5.0, s.StrokeWidthPx)
}

// TestAddPoint_WithOverride_CreatesDerivedStyle verifies add Point With Override Creates Derived Style.
func TestAddPoint_WithOverride_CreatesDerivedStyle(t *testing.T) {
	t.Parallel()

	w := NewWorld(10, 10)

	newRadius := 9.0
	ov := StyleOverride{PointRadiusPx: &newRadius}

	id, err := w.AddPoint(1, 1, PointWithStyleOverride(ov))
	require.NoError(t, err)

	obj := w.objects[id].(Point)
	require.NotEqual(t, StyleIDDefaultPoint, obj.StyleID)

	s, ok := w.styles.Get(obj.StyleID)
	require.True(t, ok)
	require.Equal(t, 9.0, s.PointRadiusPx)
}

// TestExplicitStyleID_WinsOverOverride verifies explicit Style ID Wins Over Override.
func TestExplicitStyleID_WinsOverOverride(t *testing.T) {
	t.Parallel()

	w := NewWorld(10, 10)

	red := color.RGBA{R: 255, A: 255}
	styleID := w.AddStyleCircle(StyleOverride{FillColor: red})

	// Try to override radius in options too; StyleID must win, override must be ignored.
	width := 123.0
	id, err := w.AddCircle(2, 2, 1,
		CircleWithStyleID(styleID),
		CircleWithStyleOverride(StyleOverride{StrokeWidthPx: &width}),
	)
	require.NoError(t, err)

	obj := w.objects[id].(Circle)
	require.Equal(t, styleID, obj.StyleID)

	s, ok := w.styles.Get(styleID)
	require.True(t, ok)
	require.Equal(t, red, s.FillColor)
	// width override must not affect styleID.
	require.NotEqual(t, 123.0, s.StrokeWidthPx)
}

// TestWorldPrimitiveID_ReusesFreedIDs verifies world Primitive ID Reuses Freed I Ds.
func TestWorldPrimitiveID_ReusesFreedIDs(t *testing.T) {
	t.Parallel()

	w := NewWorld(10, 10)

	id1, err := w.AddPoint(1, 1)
	require.NoError(t, err)

	id2, err := w.AddPoint(2, 2)
	require.NoError(t, err)

	require.NotEqual(t, id1, id2)

	require.NoError(t, w.Remove(id1))

	id3, err := w.AddPoint(3, 3)
	require.NoError(t, err)

	// LIFO free-list: id1 should be reused.
	require.Equal(t, id1, id3)
}

// TestWorldRemove_UnknownID verifies world Remove Unknown ID.
func TestWorldRemove_UnknownID(t *testing.T) {
	t.Parallel()

	w := NewWorld(10, 10)
	err := w.Remove(12345)
	require.ErrorIs(t, err, errNoSuchObject)
}

type gridCell struct {
	Row int
	Col int
}

func newTestWorld(wReal, hReal int) *World {
	w := NewWorld(wReal, hReal)
	w.SetCircleRadiusScaleFp(SCALE)
	return w
}

func countObjectInGrid(g *World, id PrimitiveID) int {
	count := 0
	for row := range g.grid {
		for col := range g.grid[row] {
			for _, item := range g.grid[row][col] {
				if item.ID() == id {
					count++
				}
			}
		}
	}
	return count
}

func hasObjectInCell(g *World, row, col int, id PrimitiveID) bool {
	for _, item := range g.grid[row][col] {
		if item.ID() == id {
			return true
		}
	}
	return false
}

// TestViewportPxToWorldFixed verifies viewport Px To World Fixed.
func TestViewportPxToWorldFixed(t *testing.T) {
	tests := []struct {
		name             string
		viewportWidthPx  int
		viewportHeightPx int
		cameraZoom       int
		wantWidth        int
		wantHeight       int
	}{
		{
			name:             "zoom 1.0",
			viewportWidthPx:  500,
			viewportHeightPx: 400,
			cameraZoom:       SCALE,
			wantWidth:        500 * SCALE,
			wantHeight:       400 * SCALE,
		},
		{
			name:             "zoom 2.0",
			viewportWidthPx:  500,
			viewportHeightPx: 400,
			cameraZoom:       2 * SCALE,
			wantWidth:        250 * SCALE,
			wantHeight:       200 * SCALE,
		},
		{
			name:             "zoom below 1.0",
			viewportWidthPx:  550,
			viewportHeightPx: 550,
			cameraZoom:       917,
			wantWidth:        599781,
			wantHeight:       599781,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotW, gotH := viewportPxToWorldFixed(tt.viewportWidthPx, tt.viewportHeightPx, tt.cameraZoom)
			require.Equal(t, tt.wantWidth, gotW)
			require.Equal(t, tt.wantHeight, gotH)
		})
	}
}

// TestSplitByWrap_ZeroOrNegativeSizeReturnsNil verifies split By Wrap Zero Or Negative Size Returns Nil.
func TestSplitByWrap_ZeroOrNegativeSizeReturnsNil(t *testing.T) {
	tests := []struct {
		name       string
		minX, maxX int
		minY, maxY int
	}{
		{
			name: "zero width",
			minX: 100, maxX: 100,
			minY: 50, maxY: 100,
		},
		{
			name: "zero height",
			minX: 100, maxX: 200,
			minY: 50, maxY: 50,
		},
		{
			name: "negative width",
			minX: 200, maxX: 100,
			minY: 50, maxY: 100,
		},
		{
			name: "negative height",
			minX: 100, maxX: 200,
			minY: 100, maxY: 50,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			rects := splitByWrap(600, 400, tt.minX, tt.maxX, tt.minY, tt.maxY)
			require.Nil(t, rects)
		})
	}
}

// TestSplitByWrap_XWrapUsesWorldWidth verifies split By Wrap X Wrap Uses World Width.
func TestSplitByWrap_XWrapUsesWorldWidth(t *testing.T) {
	rects := splitByWrap(
		600, 400,
		500, 650,
		50, 100,
	)

	require.Len(t, rects, 2)
	require.Equal(t, Rect{minX: 500, maxX: 600, minY: 50, maxY: 100}, rects[0])
	require.Equal(t, Rect{minX: 0, maxX: 50, minY: 50, maxY: 100}, rects[1])
}

// TestSplitByWrap_YWrapUsesWorldHeight verifies split By Wrap Y Wrap Uses World Height.
func TestSplitByWrap_YWrapUsesWorldHeight(t *testing.T) {
	rects := splitByWrap(
		600, 400,
		50, 100,
		350, 450,
	)

	require.Len(t, rects, 2)
	require.Equal(t, Rect{minX: 50, maxX: 100, minY: 350, maxY: 400}, rects[0])
	require.Equal(t, Rect{minX: 50, maxX: 100, minY: 0, maxY: 50}, rects[1])
}

// TestSplitByWrap_XAndYWrap verifies split By Wrap X And Y Wrap.
func TestSplitByWrap_XAndYWrap(t *testing.T) {
	rects := splitByWrap(
		600, 400,
		550, 650,
		350, 450,
	)

	require.Len(t, rects, 4)
	require.ElementsMatch(t, []Rect{
		{minX: 550, maxX: 600, minY: 350, maxY: 400},
		{minX: 550, maxX: 600, minY: 0, maxY: 50},
		{minX: 0, maxX: 50, minY: 350, maxY: 400},
		{minX: 0, maxX: 50, minY: 0, maxY: 50},
	}, rects)
}

// TestSplitByWrap_NoWrapInsideWorld verifies split By Wrap No Wrap Inside World.
func TestSplitByWrap_NoWrapInsideWorld(t *testing.T) {
	rects := splitByWrap(
		600, 400,
		100, 200,
		50, 100,
	)

	require.Len(t, rects, 1)
	require.Equal(t, Rect{minX: 100, maxX: 200, minY: 50, maxY: 100}, rects[0])
}

// TestSplitByWrap_FullWorldCoverageOnEqualWidth verifies split By Wrap Full World Coverage On Equal Width.
func TestSplitByWrap_FullWorldCoverageOnEqualWidth(t *testing.T) {
	rects := splitByWrap(
		600, 400,
		0, 600,
		50, 100,
	)

	require.Len(t, rects, 1)
	require.Equal(t, Rect{minX: 0, maxX: 600, minY: 50, maxY: 100}, rects[0])
}

// TestSplitByWrap_FullWorldCoverageOnEqualHeight verifies split By Wrap Full World Coverage On Equal Height.
func TestSplitByWrap_FullWorldCoverageOnEqualHeight(t *testing.T) {
	rects := splitByWrap(
		600, 400,
		50, 100,
		0, 400,
	)

	require.Len(t, rects, 1)
	require.Equal(t, Rect{minX: 50, maxX: 100, minY: 0, maxY: 400}, rects[0])
}

// TestSplitByWrap_FullWorldCoverageOnBothAxes verifies split By Wrap Full World Coverage On Both Axes.
func TestSplitByWrap_FullWorldCoverageOnBothAxes(t *testing.T) {
	rects := splitByWrap(
		600, 400,
		0, 600,
		0, 400,
	)

	require.Len(t, rects, 1)
	require.Equal(t, Rect{minX: 0, maxX: 600, minY: 0, maxY: 400}, rects[0])
}

// TestWorldToCell verifies world To Cell.
func TestWorldToCell(t *testing.T) {
	tests := []struct {
		name      string
		value     int
		worldSize int
		cells     int
		cellSize  int
		want      int
	}{
		{
			name:      "simple inside world",
			value:     150,
			worldSize: 600,
			cells:     6,
			cellSize:  100,
			want:      1,
		},
		{
			name:      "negative wraps to last cell",
			value:     -1,
			worldSize: 600,
			cells:     6,
			cellSize:  100,
			want:      5,
		},
		{
			name:      "exact world size wraps to zero",
			value:     600,
			worldSize: 600,
			cells:     6,
			cellSize:  100,
			want:      0,
		},
		{
			name:      "large positive wraps correctly",
			value:     650,
			worldSize: 600,
			cells:     6,
			cellSize:  100,
			want:      0,
		},
		{
			name:      "last in-range value lands in last cell",
			value:     599,
			worldSize: 600,
			cells:     6,
			cellSize:  100,
			want:      5,
		},
		{name: "first cell", value: 0, worldSize: 10000, cells: 5, cellSize: 2000, want: 0},
		{name: "middle cell", value: 2500, worldSize: 10000, cells: 5, cellSize: 2000, want: 1},
		{name: "last exact world point wraps to zero", value: 10000, worldSize: 10000, cells: 5, cellSize: 2000, want: 0},
		{name: "negative wraps to last", value: -1, worldSize: 10000, cells: 5, cellSize: 2000, want: 4},
		{name: "partial last cell is clamped", value: 9999, worldSize: 10000, cells: 4, cellSize: 3000, want: 3},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := worldToCell(tt.value, tt.worldSize, tt.cells, tt.cellSize)
			require.Equal(t, tt.want, got)
		})
	}
}

// TestResetGrid_UsesWidthForColsAndHeightForRows verifies reset Grid Uses Width For Cols And Height For Rows.
func TestResetGrid_UsesWidthForColsAndHeightForRows(t *testing.T) {
	g := newTestWorld(600, 400)

	g.resetGrid(100 * SCALE)

	require.Equal(t, 6, g.cols)
	require.Equal(t, 4, g.rows)
	require.Len(t, g.grid, 4)
	require.Len(t, g.grid[0], 6)
}

// TestIndexPoint verifies index Point.
func TestIndexPoint(t *testing.T) {
	g := newTestWorld(600, 600)
	g.resetGrid(100 * SCALE)

	id := PrimitiveID(1)
	p := Point{
		Id: id,
		X:  150 * SCALE,
		Y:  250 * SCALE,
	}

	g.indexObject(p)

	require.True(t, hasObjectInCell(g, 2, 1, id))
	require.Equal(t, 1, countObjectInGrid(g, id))
}

// TestIndexPoint_WrapsNegativeCoordinates verifies index Point Wraps Negative Coordinates.
func TestIndexPoint_WrapsNegativeCoordinates(t *testing.T) {
	g := newTestWorld(600, 600)
	g.resetGrid(100 * SCALE)

	id := PrimitiveID(1)
	p := Point{
		Id: id,
		X:  -1,
		Y:  -1,
	}

	g.indexObject(p)

	require.True(t, hasObjectInCell(g, 5, 5, id))
	require.Equal(t, 1, countObjectInGrid(g, id))
}

// TestIndexCircle_WrapsAcrossLeftAndTopEdges verifies index Circle Wraps Across Left And Top Edges.
func TestIndexCircle_WrapsAcrossLeftAndTopEdges(t *testing.T) {
	g := newTestWorld(600, 600)
	g.resetGrid(100 * SCALE)

	id := PrimitiveID(1)
	c := Circle{
		Id:     id,
		X:      50 * SCALE,
		Y:      50 * SCALE,
		Radius: 75 * SCALE,
	}

	g.indexObject(c)

	// The circle spans [-25..125] on both axes.
	// It must appear both near zero and near the wrapped end.
	require.True(t, hasObjectInCell(g, 0, 0, id))
	require.True(t, hasObjectInCell(g, 0, 5, id))
	require.True(t, hasObjectInCell(g, 5, 0, id))
	require.True(t, hasObjectInCell(g, 5, 5, id))

	// It also extends into the next cells near the origin.
	require.True(t, hasObjectInCell(g, 0, 1, id))
	require.True(t, hasObjectInCell(g, 1, 0, id))
	require.True(t, hasObjectInCell(g, 1, 1, id))
}

// TestIndexCircle_NoWrap verifies index Circle No Wrap.
func TestIndexCircle_NoWrap(t *testing.T) {
	g := newTestWorld(600, 600)
	g.resetGrid(100 * SCALE)

	id := PrimitiveID(1)
	c := Circle{
		Id:     id,
		X:      300 * SCALE,
		Y:      300 * SCALE,
		Radius: 50 * SCALE,
	}

	g.indexObject(c)

	require.True(t, hasObjectInCell(g, 2, 2, id))
	require.True(t, hasObjectInCell(g, 2, 3, id))
	require.True(t, hasObjectInCell(g, 3, 2, id))
	require.True(t, hasObjectInCell(g, 3, 3, id))
}

// TestIndexCircle_CoversWholeWorldWhenLargerThanWorld verifies index Circle Covers Whole World When Larger Than World.
func TestIndexCircle_CoversWholeWorldWhenLargerThanWorld(t *testing.T) {
	g := newTestWorld(600, 600)
	g.resetGrid(100 * SCALE)

	id := PrimitiveID(1)
	c := Circle{
		Id:     id,
		X:      300 * SCALE,
		Y:      300 * SCALE,
		Radius: 400 * SCALE,
	}

	g.indexObject(c)

	for row := 0; row < g.rows; row++ {
		for col := 0; col < g.cols; col++ {
			require.Truef(t, hasObjectInCell(g, row, col, id), "missing object in row=%d col=%d", row, col)
		}
	}
}

// TestIndexLine_HorizontalWrap verifies index Line Horizontal Wrap.
func TestIndexLine_HorizontalWrap(t *testing.T) {
	g := newTestWorld(600, 600)
	g.resetGrid(100 * SCALE)

	id := PrimitiveID(1)
	l := Line{
		Id: id,
		X1: 590 * SCALE,
		Y1: 200 * SCALE,
		X2: 10 * SCALE,
		Y2: 200 * SCALE,
	}

	g.indexObject(l)

	// The shortest torus representation crosses the right/left border.
	require.True(t, hasObjectInCell(g, 2, 5, id))
	require.True(t, hasObjectInCell(g, 2, 0, id))
}

// TestIndexLine_VerticalWrap verifies index Line Vertical Wrap.
func TestIndexLine_VerticalWrap(t *testing.T) {
	g := newTestWorld(600, 600)
	g.resetGrid(100 * SCALE)

	id := PrimitiveID(1)
	l := Line{
		Id: id,
		X1: 200 * SCALE,
		Y1: 590 * SCALE,
		X2: 200 * SCALE,
		Y2: 10 * SCALE,
	}

	g.indexObject(l)

	require.True(t, hasObjectInCell(g, 5, 2, id))
	require.True(t, hasObjectInCell(g, 0, 2, id))
}

// TestIndexLine_DiagonalWrapBothAxes verifies index Line Diagonal Wrap Both Axes.
func TestIndexLine_DiagonalWrapBothAxes(t *testing.T) {
	g := newTestWorld(600, 600)
	g.resetGrid(100 * SCALE)

	id := PrimitiveID(1)
	l := Line{
		Id: id,
		X1: 590 * SCALE,
		Y1: 590 * SCALE,
		X2: 10 * SCALE,
		Y2: 10 * SCALE,
	}

	g.indexObject(l)

	require.True(t, hasObjectInCell(g, 5, 5, id))
	require.True(t, hasObjectInCell(g, 0, 0, id))
}

// TestIndexLine_HorizontalNoWrap_DegenerateBBoxStillIndexes verifies index Line Horizontal No Wrap Degenerate B Box Still Indexes.
func TestIndexLine_HorizontalNoWrap_DegenerateBBoxStillIndexes(t *testing.T) {
	g := newTestWorld(600, 600)
	g.resetGrid(100 * SCALE)

	id := PrimitiveID(1)
	l := Line{
		Id: id,
		X1: 100 * SCALE,
		Y1: 200 * SCALE,
		X2: 300 * SCALE,
		Y2: 200 * SCALE,
	}

	g.indexObject(l)

	// The indexed interval is half-open: [100,300).
	// Therefore it occupies columns 1 and 2, but not column 3.
	require.True(t, hasObjectInCell(g, 2, 1, id))
	require.True(t, hasObjectInCell(g, 2, 2, id))
	require.False(t, hasObjectInCell(g, 2, 3, id))
}

// TestIndexLine_VerticalNoWrap_DegenerateBBoxStillIndexes verifies index Line Vertical No Wrap Degenerate B Box Still Indexes.
func TestIndexLine_VerticalNoWrap_DegenerateBBoxStillIndexes(t *testing.T) {
	g := newTestWorld(600, 600)
	g.resetGrid(100 * SCALE)

	id := PrimitiveID(1)
	l := Line{
		Id: id,
		X1: 200 * SCALE,
		Y1: 100 * SCALE,
		X2: 200 * SCALE,
		Y2: 300 * SCALE,
	}

	g.indexObject(l)

	// The indexed interval is half-open: [100,300).
	// Therefore it occupies rows 1 and 2, but not row 3.
	require.True(t, hasObjectInCell(g, 1, 2, id))
	require.True(t, hasObjectInCell(g, 2, 2, id))
	require.False(t, hasObjectInCell(g, 3, 2, id))
}

// TestIndexLine_ZeroLengthIndexesSingleCell verifies index Line Zero Length Indexes Single Cell.
func TestIndexLine_ZeroLengthIndexesSingleCell(t *testing.T) {
	g := newTestWorld(600, 600)
	g.resetGrid(100 * SCALE)

	id := PrimitiveID(1)
	l := Line{
		Id: id,
		X1: 250 * SCALE,
		Y1: 350 * SCALE,
		X2: 250 * SCALE,
		Y2: 350 * SCALE,
	}

	g.indexObject(l)

	require.True(t, hasObjectInCell(g, 3, 2, id))
	require.Equal(t, 1, countObjectInGrid(g, id))
}

// TestIndexLine_ExactlyOnCellBoundaryUsesHalfOpenInterval verifies index Line Exactly On Cell Boundary Uses Half Open Interval.
func TestIndexLine_ExactlyOnCellBoundaryUsesHalfOpenInterval(t *testing.T) {
	g := newTestWorld(600, 600)
	g.resetGrid(100 * SCALE)

	id := PrimitiveID(1)
	l := Line{
		Id: id,
		X1: 200 * SCALE,
		Y1: 100 * SCALE,
		X2: 400 * SCALE,
		Y2: 100 * SCALE,
	}

	g.indexObject(l)

	// The indexed interval is [200,400), so it must occupy columns 2 and 3 only.
	require.True(t, hasObjectInCell(g, 1, 2, id))
	require.True(t, hasObjectInCell(g, 1, 3, id))
	require.False(t, hasObjectInCell(g, 1, 4, id))
}

func collectOccupiedCells(g *World, id PrimitiveID) []gridCell {
	var cells []gridCell
	for row := range g.grid {
		for col := range g.grid[row] {
			for _, item := range g.grid[row][col] {
				if item.ID() == id {
					cells = append(cells, gridCell{Row: row, Col: col})
					break
				}
			}
		}
	}
	return cells
}

func allGridCells(rows, cols int) []gridCell {
	cells := make([]gridCell, 0, rows*cols)
	for row := 0; row < rows; row++ {
		for col := 0; col < cols; col++ {
			cells = append(cells, gridCell{Row: row, Col: col})
		}
	}
	return cells
}

func requireIndexedExactlyInCells(t *testing.T, g *World, id PrimitiveID, want []gridCell) {
	t.Helper()

	got := collectOccupiedCells(g, id)

	require.ElementsMatchf(
		t,
		want,
		got,
		"unexpected indexed cells for object %d",
		id,
	)
}

// TestIndexObject_Point_TableDriven verifies index Object Point Table Driven.
func TestIndexObject_Point_TableDriven(t *testing.T) {
	tests := []struct {
		name      string
		worldW    int
		worldH    int
		cellSize  int
		item      Point
		wantCells []gridCell
	}{
		{
			name:     "point inside world",
			worldW:   600,
			worldH:   600,
			cellSize: 100 * SCALE,
			item: Point{
				Id: PrimitiveID(1),
				X:  150 * SCALE,
				Y:  250 * SCALE,
			},
			wantCells: []gridCell{
				{Row: 2, Col: 1},
			},
		},
		{
			name:     "point wraps from negative coordinates to last cell",
			worldW:   600,
			worldH:   600,
			cellSize: 100 * SCALE,
			item: Point{
				Id: PrimitiveID(1),
				X:  -1,
				Y:  -1,
			},
			wantCells: []gridCell{
				{Row: 5, Col: 5},
			},
		},
		{
			name:     "point exactly at world boundary wraps to zero cell",
			worldW:   600,
			worldH:   600,
			cellSize: 100 * SCALE,
			item: Point{
				Id: PrimitiveID(1),
				X:  600 * SCALE,
				Y:  600 * SCALE,
			},
			wantCells: []gridCell{
				{Row: 0, Col: 0},
			},
		},
		{
			name:     "point on cell boundary belongs to that cell",
			worldW:   600,
			worldH:   600,
			cellSize: 100 * SCALE,
			item: Point{
				Id: PrimitiveID(1),
				X:  200 * SCALE,
				Y:  300 * SCALE,
			},
			wantCells: []gridCell{
				{Row: 3, Col: 2},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			g := newTestWorld(tt.worldW, tt.worldH)
			g.resetGrid(tt.cellSize)

			g.indexObject(tt.item)

			requireIndexedExactlyInCells(t, g, tt.item.Id, tt.wantCells)
		})
	}
}

// TestIndexObject_Circle_TableDriven verifies index Object Circle Table Driven.
func TestIndexObject_Circle_TableDriven(t *testing.T) {
	tests := []struct {
		name      string
		worldW    int
		worldH    int
		cellSize  int
		item      Circle
		wantCells []gridCell
	}{
		{
			name:     "circle without wrap",
			worldW:   600,
			worldH:   600,
			cellSize: 100 * SCALE,
			item: Circle{
				Id:     PrimitiveID(1),
				X:      300 * SCALE,
				Y:      300 * SCALE,
				Radius: 50 * SCALE,
			},
			wantCells: []gridCell{
				{Row: 2, Col: 2},
				{Row: 2, Col: 3},
				{Row: 3, Col: 2},
				{Row: 3, Col: 3},
			},
		},
		{
			name:     "circle wraps across left and top edges",
			worldW:   600,
			worldH:   600,
			cellSize: 100 * SCALE,
			item: Circle{
				Id:     PrimitiveID(1),
				X:      50 * SCALE,
				Y:      50 * SCALE,
				Radius: 75 * SCALE,
			},
			wantCells: []gridCell{
				{Row: 5, Col: 5},
				{Row: 5, Col: 0},
				{Row: 5, Col: 1},
				{Row: 0, Col: 5},
				{Row: 0, Col: 0},
				{Row: 0, Col: 1},
				{Row: 1, Col: 5},
				{Row: 1, Col: 0},
				{Row: 1, Col: 1},
			},
		},
		{
			name:     "circle wraps across right edge only",
			worldW:   600,
			worldH:   600,
			cellSize: 100 * SCALE,
			item: Circle{
				Id:     PrimitiveID(1),
				X:      575 * SCALE,
				Y:      300 * SCALE,
				Radius: 50 * SCALE,
			},
			wantCells: []gridCell{
				{Row: 2, Col: 5},
				{Row: 2, Col: 0},
				{Row: 3, Col: 5},
				{Row: 3, Col: 0},
			},
		},
		{
			name:     "circle wraps across bottom edge only",
			worldW:   600,
			worldH:   600,
			cellSize: 100 * SCALE,
			item: Circle{
				Id:     PrimitiveID(1),
				X:      300 * SCALE,
				Y:      575 * SCALE,
				Radius: 50 * SCALE,
			},
			wantCells: []gridCell{
				{Row: 5, Col: 2},
				{Row: 5, Col: 3},
				{Row: 0, Col: 2},
				{Row: 0, Col: 3},
			},
		},
		{
			name:     "circle larger than world covers the whole grid",
			worldW:   600,
			worldH:   600,
			cellSize: 100 * SCALE,
			item: Circle{
				Id:     PrimitiveID(1),
				X:      300 * SCALE,
				Y:      300 * SCALE,
				Radius: 400 * SCALE,
			},
			wantCells: allGridCells(6, 6),
		},
		{
			name:     "circle touching boundaries exactly uses half-open indexing",
			worldW:   600,
			worldH:   600,
			cellSize: 100 * SCALE,
			item: Circle{
				Id:     PrimitiveID(1),
				X:      300 * SCALE,
				Y:      300 * SCALE,
				Radius: 100 * SCALE, // bbox [200, 400) x [200, 400)
			},
			wantCells: []gridCell{
				{Row: 2, Col: 2},
				{Row: 2, Col: 3},
				{Row: 3, Col: 2},
				{Row: 3, Col: 3},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			g := newTestWorld(tt.worldW, tt.worldH)
			g.resetGrid(tt.cellSize)

			g.indexObject(tt.item)

			requireIndexedExactlyInCells(t, g, tt.item.Id, tt.wantCells)
		})
	}
}

// TestIndexObject_Line_TableDriven verifies index Object Line Table Driven.
func TestIndexObject_Line_TableDriven(t *testing.T) {
	tests := []struct {
		name      string
		worldW    int
		worldH    int
		cellSize  int
		item      Line
		wantCells []gridCell
	}{
		{
			name:     "horizontal line without wrap",
			worldW:   600,
			worldH:   600,
			cellSize: 100 * SCALE,
			item: Line{
				Id: PrimitiveID(1),
				X1: 100 * SCALE,
				Y1: 200 * SCALE,
				X2: 300 * SCALE,
				Y2: 200 * SCALE,
			},
			// Half-open interval [100,300), so only cols 1 and 2.
			wantCells: []gridCell{
				{Row: 2, Col: 1},
				{Row: 2, Col: 2},
			},
		},
		{
			name:     "vertical line without wrap",
			worldW:   600,
			worldH:   600,
			cellSize: 100 * SCALE,
			item: Line{
				Id: PrimitiveID(1),
				X1: 200 * SCALE,
				Y1: 100 * SCALE,
				X2: 200 * SCALE,
				Y2: 300 * SCALE,
			},
			// Half-open interval [100,300), so only rows 1 and 2.
			wantCells: []gridCell{
				{Row: 1, Col: 2},
				{Row: 2, Col: 2},
			},
		},
		{
			name:     "horizontal line wraps across left right border",
			worldW:   600,
			worldH:   600,
			cellSize: 100 * SCALE,
			item: Line{
				Id: PrimitiveID(1),
				X1: 590 * SCALE,
				Y1: 200 * SCALE,
				X2: 10 * SCALE,
				Y2: 200 * SCALE,
			},
			wantCells: []gridCell{
				{Row: 2, Col: 5},
				{Row: 2, Col: 0},
			},
		},
		{
			name:     "vertical line wraps across top bottom border",
			worldW:   600,
			worldH:   600,
			cellSize: 100 * SCALE,
			item: Line{
				Id: PrimitiveID(1),
				X1: 200 * SCALE,
				Y1: 590 * SCALE,
				X2: 200 * SCALE,
				Y2: 10 * SCALE,
			},
			wantCells: []gridCell{
				{Row: 5, Col: 2},
				{Row: 0, Col: 2},
			},
		},
		{
			name:     "diagonal line wraps across both axes",
			worldW:   600,
			worldH:   600,
			cellSize: 100 * SCALE,
			item: Line{
				Id: PrimitiveID(1),
				X1: 590 * SCALE,
				Y1: 590 * SCALE,
				X2: 10 * SCALE,
				Y2: 10 * SCALE,
			},
			wantCells: []gridCell{
				{Row: 5, Col: 5},
				{Row: 5, Col: 0},
				{Row: 0, Col: 5},
				{Row: 0, Col: 0},
			},
		},
		{
			name:     "zero length line indexes a single cell",
			worldW:   600,
			worldH:   600,
			cellSize: 100 * SCALE,
			item: Line{
				Id: PrimitiveID(1),
				X1: 250 * SCALE,
				Y1: 350 * SCALE,
				X2: 250 * SCALE,
				Y2: 350 * SCALE,
			},
			wantCells: []gridCell{
				{Row: 3, Col: 2},
			},
		},
		{
			name:     "line exactly on cell boundaries follows half-open interval",
			worldW:   600,
			worldH:   600,
			cellSize: 100 * SCALE,
			item: Line{
				Id: PrimitiveID(1),
				X1: 200 * SCALE,
				Y1: 100 * SCALE,
				X2: 400 * SCALE,
				Y2: 100 * SCALE,
			},
			// [200,400) => cols 2 and 3 only.
			wantCells: []gridCell{
				{Row: 1, Col: 2},
				{Row: 1, Col: 3},
			},
		},
		{
			name:     "diagonal line without wrap indexes its full bbox footprint",
			worldW:   600,
			worldH:   600,
			cellSize: 100 * SCALE,
			item: Line{
				Id: PrimitiveID(1),
				X1: 100 * SCALE,
				Y1: 100 * SCALE,
				X2: 300 * SCALE,
				Y2: 300 * SCALE,
			},
			// Indexing is bbox-based, not raster-based.
			// The bbox is [100,300) x [100,300), so four cells.
			wantCells: []gridCell{
				{Row: 1, Col: 1},
				{Row: 1, Col: 2},
				{Row: 2, Col: 1},
				{Row: 2, Col: 2},
			},
		},
		{
			name:     "horizontal wrap exactly on borders still indexes both edge cells",
			worldW:   600,
			worldH:   600,
			cellSize: 100 * SCALE,
			item: Line{
				Id: PrimitiveID(1),
				X1: 600 * SCALE,
				Y1: 100 * SCALE,
				X2: 0,
				Y2: 100 * SCALE,
			},
			// After wrapping both endpoints are equivalent to zero-width on the edge.
			// The degenerate bbox expansion should still index the first cell only.
			wantCells: []gridCell{
				{Row: 1, Col: 0},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			g := newTestWorld(tt.worldW, tt.worldH)
			g.resetGrid(tt.cellSize)

			g.indexObject(tt.item)

			requireIndexedExactlyInCells(t, g, tt.item.Id, tt.wantCells)
		})
	}
}

// TestIndexOnViewportChange_RebuildsGridAndIndexesObjects verifies index On Viewport Change Rebuilds Grid And Indexes Objects.
func TestIndexOnViewportChange_RebuildsGridAndIndexesObjects(t *testing.T) {
	g := newTestWorld(600, 400)

	pID := PrimitiveID(1)
	cID := PrimitiveID(2)
	lID := PrimitiveID(3)

	g.objects[pID] = Point{
		Id: pID,
		X:  50 * SCALE,
		Y:  50 * SCALE,
	}
	g.objects[cID] = Circle{
		Id:     cID,
		X:      300 * SCALE,
		Y:      200 * SCALE,
		Radius: 50 * SCALE,
	}
	g.objects[lID] = Line{
		Id: lID,
		X1: 590 * SCALE,
		Y1: 100 * SCALE,
		X2: 10 * SCALE,
		Y2: 100 * SCALE,
	}

	g.IndexOnViewportChange(500, 300, 1.)

	require.Greater(t, g.cellSize, 0)
	require.Equal(t, ceilDiv(g.W, g.cellSize), g.cols)
	require.Equal(t, ceilDiv(g.H, g.cellSize), g.rows)

	require.Greaterf(t, countObjectInGrid(g, pID), 0, "point %s was not indexed", pID)
	require.Greaterf(t, countObjectInGrid(g, cID), 0, "circle %s was not indexed", cID)
	require.Greaterf(t, countObjectInGrid(g, lID), 0, "line %s was not indexed", lID)
}

// TestIndexOnViewportChange_RebuildsGridShapeForNonSquareWorld verifies index On Viewport Change Rebuilds Grid Shape For Non Square World.
func TestIndexOnViewportChange_RebuildsGridShapeForNonSquareWorld(t *testing.T) {
	g := newTestWorld(600, 400)
	g.IndexOnViewportChange(500, 300, 1.)

	require.Equal(t, ceilDiv(g.W, g.cellSize), g.cols)
	require.Equal(t, ceilDiv(g.H, g.cellSize), g.rows)
	require.Len(t, g.grid, g.rows)
	require.Len(t, g.grid[0], g.cols)
}

// TestIndexOnViewportChange_ReindexesAfterCellSizeChange verifies index On Viewport Change Reindexes After Cell Size Change.
func TestIndexOnViewportChange_ReindexesAfterCellSizeChange(t *testing.T) {
	g := newTestWorld(600, 600)

	id := PrimitiveID(1)
	g.objects[id] = Circle{
		Id:     id,
		X:      300 * SCALE,
		Y:      300 * SCALE,
		Radius: 50 * SCALE,
	}

	g.IndexOnViewportChange(500, 500, 1.)
	firstCellSize := g.cellSize
	firstCount := countObjectInGrid(g, id)

	g.IndexOnViewportChange(200, 200, 1.)
	secondCellSize := g.cellSize
	secondCount := countObjectInGrid(g, id)

	require.NotEqual(t, firstCellSize, secondCellSize)
	require.Greater(t, firstCount, 0)
	require.Greater(t, secondCount, 0)

	if firstCellSize != secondCellSize && firstCount == secondCount {
		t.Logf(
			"cell size changed from %d to %d, but the indexed cell count happened to stay equal (%d)",
			firstCellSize,
			secondCellSize,
			firstCount,
		)
	}
}

// TestPrimitiveIndexing_ErrorMessagesStayReadable verifies primitive Indexing Error Messages Stay Readable.
func TestPrimitiveIndexing_ErrorMessagesStayReadable(t *testing.T) {
	g := newTestWorld(600, 600)
	g.resetGrid(100 * SCALE)

	id := PrimitiveID(1)
	p := Point{
		Id: id,
		X:  100 * SCALE,
		Y:  100 * SCALE,
	}

	g.indexObject(p)

	got := collectOccupiedCells(g, id)
	require.NotEmpty(t, got, fmt.Sprintf("object %d should occupy at least one cell", id))
}

// TestPrimitiveIDs verifies primitive I Ds.
func TestPrimitiveIDs(t *testing.T) {
	t.Parallel()

	id1 := PrimitiveID(1)
	id2 := PrimitiveID(2)
	id3 := PrimitiveID(3)

	p := Point{Id: id1}
	l := Line{Id: id2}
	c := Circle{Id: id3}

	if got := p.ID(); got != id1 {
		t.Fatalf("Point.ID() = %v, want %v", got, id1)
	}
	if got := l.ID(); got != id2 {
		t.Fatalf("Line.ID() = %v, want %v", got, id2)
	}
	if got := c.ID(); got != id3 {
		t.Fatalf("Circle.ID() = %v, want %v", got, id3)
	}
}

// TestLineMinMax verifies line Min Max.
func TestLineMinMax(t *testing.T) {
	t.Parallel()

	l := Line{
		X1: 7000, Y1: 2000,
		X2: 1000, Y2: 9000,
	}

	if got := l.MinX(); got != 1000 {
		t.Fatalf("Line.MinX() = %d, want 1000", got)
	}
	if got := l.MaxX(); got != 7000 {
		t.Fatalf("Line.MaxX() = %d, want 7000", got)
	}
	if got := l.MinY(); got != 2000 {
		t.Fatalf("Line.MinY() = %d, want 2000", got)
	}
	if got := l.MaxY(); got != 9000 {
		t.Fatalf("Line.MaxY() = %d, want 9000", got)
	}
}

// TestCircleBounds verifies circle Bounds.
func TestCircleBounds(t *testing.T) {
	t.Parallel()

	c := Circle{
		X:      4000,
		Y:      7000,
		Radius: 1500,
	}

	if got := c.MinX(); got != 2500 {
		t.Fatalf("Circle.MinX() = %d, want 2500", got)
	}
	if got := c.MaxX(); got != 5500 {
		t.Fatalf("Circle.MaxX() = %d, want 5500", got)
	}
	if got := c.MinY(); got != 5500 {
		t.Fatalf("Circle.MinY() = %d, want 5500", got)
	}
	if got := c.MaxY(); got != 8500 {
		t.Fatalf("Circle.MaxY() = %d, want 8500", got)
	}
}

// TestRender_CircleRadiusScale_AffectsRenderedRadiusPx verifies render Circle Radius Scale Affects Rendered Radius Px.
func TestRender_CircleRadiusScale_AffectsRenderedRadiusPx(t *testing.T) {
	t.Parallel()

	w := NewWorld(10, 10)
	w.resetGrid(2 * SCALE)

	// Ensure index state is initialized so Add triggers rebuild if needed.
	w.IndexOnViewportChange(10, 10, 1.0)

	_, err := w.AddCircle(5, 5, 2) // raw radius = 2 units
	require.NoError(t, err)

	// scale = 2.0
	require.NoError(t, w.SetCircleRadiusScaleFp(2*SCALE))

	// Reindex explicitly (safe).
	w.Reindex()

	params := RenderParams{
		ViewportWidthPx:  10,
		ViewportHeightPx: 10,
		MarginXPx:        0,
		MarginYPx:        0,
		CameraXWorldFp:   5 * SCALE,
		CameraYWorldFp:   5 * SCALE,
		CameraZoom:       1.0,
		Options: &RenderOptions{
			BackgroundColor: color.RGBA{A: 255},
		},
	}

	d := &fakePrimitiveDrawer{}
	require.NoError(t, w.Render(d, params))

	circles := d.CommandsByName("AddCircle")
	require.NotEmpty(t, circles)

	// AddCircle args: cx, cy, rPx
	rPx := circles[0].Args[2]
	require.Equal(t, float64(4), rPx, "raw radius=2 with scale=2 => eff radius=4 => rPx=4 at zoom=1")
}