package world

import (
	"math"
	"testing"

	"github.com/stretchr/testify/require"
)

func TestWrap(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name  string
		value int
		size  int
		want  int
	}{
		{name: "zero", value: 0, size: 10, want: 0},
		{name: "inside range", value: 7, size: 10, want: 7},
		{name: "equal to size", value: 10, size: 10, want: 0},
		{name: "greater than size", value: 27, size: 10, want: 7},
		{name: "negative one", value: -1, size: 10, want: 9},
		{name: "negative many", value: -23, size: 10, want: 7},
	}

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

			if got := wrap(tt.value, tt.size); got != tt.want {
				t.Fatalf("wrap(%d, %d) = %d, want %d", tt.value, tt.size, got, tt.want)
			}
		})
	}
}

func TestClamp(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name     string
		value    int
		minValue int
		maxValue int
		want     int
	}{
		{name: "below range", value: -5, minValue: 0, maxValue: 10, want: 0},
		{name: "inside range", value: 5, minValue: 0, maxValue: 10, want: 5},
		{name: "above range", value: 15, minValue: 0, maxValue: 10, want: 10},
		{name: "equal min", value: 0, minValue: 0, maxValue: 10, want: 0},
		{name: "equal max", value: 10, minValue: 0, maxValue: 10, want: 10},
	}

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

			if got := clamp(tt.value, tt.minValue, tt.maxValue); got != tt.want {
				t.Fatalf("clamp(%d, %d, %d) = %d, want %d", tt.value, tt.minValue, tt.maxValue, got, tt.want)
			}
		})
	}
}

func TestCeilDiv(t *testing.T) {
	t.Parallel()

	tests := []struct {
		a    int
		b    int
		want int
	}{
		{a: 1, b: 1, want: 1},
		{a: 1, b: 2, want: 1},
		{a: 2, b: 2, want: 1},
		{a: 3, b: 2, want: 2},
		{a: 10, b: 3, want: 4},
		{a: 16, b: 8, want: 2},
		{a: 17, b: 8, want: 3},
	}

	for _, tt := range tests {
		if got := ceilDiv(tt.a, tt.b); got != tt.want {
			t.Fatalf("ceilDiv(%d, %d) = %d, want %d", tt.a, tt.b, got, tt.want)
		}
	}
}

func TestFloorDiv(t *testing.T) {
	t.Parallel()

	require.Equal(t, 0, floorDiv(0, 10))
	require.Equal(t, 0, floorDiv(1, 10))
	require.Equal(t, 0, floorDiv(9, 10))
	require.Equal(t, 1, floorDiv(10, 10))
	require.Equal(t, 1, floorDiv(19, 10))

	require.Equal(t, -1, floorDiv(-1, 10))
	require.Equal(t, -1, floorDiv(-9, 10))
	require.Equal(t, -1, floorDiv(-10, 10))
	require.Equal(t, -2, floorDiv(-11, 10))

	require.Panics(t, func() { _ = floorDiv(1, 0) })
	require.Panics(t, func() { _ = floorDiv(1, -1) })
}

func TestFixedPoint(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name string
		v    float64
		want int
	}{
		{name: "zero", v: 0, want: 0},
		{name: "integer", v: 3, want: 3000},
		{name: "fraction", v: 1.234, want: 1234},
		{name: "round down", v: 1.2344, want: 1234},
		{name: "round up", v: 1.2345, want: 1235},
		{name: "negative", v: -1.2345, want: -1235},
	}

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

			if got := fixedPoint(tt.v); got != tt.want {
				t.Fatalf("fixedPoint(%f) = %d, want %d", tt.v, got, tt.want)
			}
		})
	}
}

func TestAbs(t *testing.T) {
	t.Parallel()

	tests := []struct {
		v    int
		want int
	}{
		{v: 0, want: 0},
		{v: 7, want: 7},
		{v: -7, want: 7},
	}

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

func TestPixelSpanToWorldFixed(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name   string
		spanPx int
		zoomFp int
		want   int
	}{
		{name: "1x zoom", spanPx: 100, zoomFp: SCALE, want: 100 * SCALE},
		{name: "2x zoom", spanPx: 100, zoomFp: 2 * SCALE, want: 50 * SCALE},
		{name: "half zoom", spanPx: 100, zoomFp: SCALE / 2, want: 200 * SCALE},
		{name: "fractional result truncation", spanPx: 1, zoomFp: 3 * SCALE, want: 333},
	}

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

			if got := PixelSpanToWorldFixed(tt.spanPx, tt.zoomFp); got != tt.want {
				t.Fatalf("PixelSpanToWorldFixed(%d, %d) = %d, want %d", tt.spanPx, tt.zoomFp, got, tt.want)
			}
		})
	}
}

func TestWorldToCellPanicsOnInvalidGrid(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name     string
		cells    int
		cellSize int
	}{
		{name: "zero cells", cells: 0, cellSize: 1},
		{name: "negative cells", cells: -1, cellSize: 1},
		{name: "zero cell size", cells: 1, cellSize: 0},
		{name: "negative cell size", cells: 1, cellSize: -1},
	}

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

			defer func() {
				if recover() == nil {
					t.Fatalf("worldToCell did not panic for cells=%d cellSize=%d", tt.cells, tt.cellSize)
				}
			}()

			_ = worldToCell(0, 1000, tt.cells, tt.cellSize)
		})
	}
}

func TestShortestWrappedDelta(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name  string
		from  int
		to    int
		size  int
		wantA int
		wantB int
	}{
		{name: "no wrap forward", from: 1000, to: 3000, size: 10000, wantA: 1000, wantB: 3000},
		{name: "no wrap backward", from: 3000, to: 1000, size: 10000, wantA: 3000, wantB: 1000},
		{name: "wrap forward over half", from: 1000, to: 7000, size: 10000, wantA: 11000, wantB: 7000},
		{name: "wrap backward over half", from: 7000, to: 1000, size: 10000, wantA: 7000, wantB: 11000},
		{name: "tie positive half wraps", from: 1000, to: 6000, size: 10000, wantA: 11000, wantB: 6000},
		{name: "tie negative half stays", from: 6000, to: 1000, size: 10000, wantA: 6000, wantB: 1000},
		{name: "just below positive half does not wrap", from: 1000, to: 5999, size: 10000, wantA: 1000, wantB: 5999},
		{name: "just beyond negative half wraps", from: 6001, to: 1000, size: 10000, wantA: 6001, wantB: 11000},
	}

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

			gotA, gotB := shortestWrappedDelta(tt.from, tt.to, tt.size)
			if gotA != tt.wantA || gotB != tt.wantB {
				t.Fatalf("shortestWrappedDelta(%d, %d, %d) = (%d, %d), want (%d, %d)",
					tt.from, tt.to, tt.size, gotA, gotB, tt.wantA, tt.wantB)
			}

			delta := gotB - gotA
			half := tt.size / 2
			if delta < -half || delta >= half {
				t.Fatalf("normalized delta %d is outside [-%d, %d)", delta, half, half)
			}
		})
	}
}

func TestCameraZoomToWorldFixed(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name       string
		cameraZoom float64
		want       int
	}{
		{
			name:       "neutral zoom",
			cameraZoom: 1.0,
			want:       SCALE,
		},
		{
			name:       "integer zoom",
			cameraZoom: 2.0,
			want:       2 * SCALE,
		},
		{
			name:       "fractional zoom",
			cameraZoom: 1.25,
			want:       1250,
		},
		{
			name:       "minimum configured zoom value shape",
			cameraZoom: 0.25,
			want:       SCALE / 4,
		},
		{
			name:       "round down",
			cameraZoom: 1.2344,
			want:       1234,
		},
		{
			name:       "round up",
			cameraZoom: 1.2345,
			want:       1235,
		},
		{
			name:       "very small but still positive after rounding",
			cameraZoom: 0.0006,
			want:       1,
		},
	}

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

			got, err := cameraZoomToWorldFixed(tt.cameraZoom)
			require.NoError(t, err)
			require.Equal(t, tt.want, got)
		})
	}
}

func TestCameraZoomToWorldFixedReturnsError(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name       string
		cameraZoom float64
	}{
		{
			name:       "zero",
			cameraZoom: 0,
		},
		{
			name:       "negative",
			cameraZoom: -1,
		},
		{
			name:       "nan",
			cameraZoom: math.NaN(),
		},
		{
			name:       "positive infinity",
			cameraZoom: math.Inf(1),
		},
		{
			name:       "negative infinity",
			cameraZoom: math.Inf(-1),
		},
		{
			name:       "positive but rounds to zero",
			cameraZoom: 0.0004,
		},
	}

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

			got, err := cameraZoomToWorldFixed(tt.cameraZoom)
			require.ErrorIs(t, err, errInvalidCameraZoom)
			require.Zero(t, got)
		})
	}
}

func TestMustCameraZoomToWorldFixed(t *testing.T) {
	t.Parallel()

	require.Equal(t, 1250, mustCameraZoomToWorldFixed(1.25))

	require.Panics(t, func() {
		_ = mustCameraZoomToWorldFixed(0)
	})
}