package utils

import (
	"net/http/httptest"
	"testing"

	"github.com/gofiber/fiber/v2"
)

// pageFor spins a request through a throwaway Fiber app so ParsePage sees a
// real *fiber.Ctx rather than a hand-built stub.
func pageFor(t *testing.T, query string) Page {
	t.Helper()

	var got Page
	app := fiber.New()
	app.Get("/", func(c *fiber.Ctx) error {
		got = ParsePage(c)
		return nil
	})

	resp, err := app.Test(httptest.NewRequest("GET", "/?"+query, nil))
	if err != nil {
		t.Fatalf("test request failed: %v", err)
	}
	_ = resp.Body.Close()

	return got
}

func TestParsePageDefaults(t *testing.T) {
	p := pageFor(t, "")

	if p.No != 1 {
		t.Errorf("No = %d, want 1", p.No)
	}
	if p.Size != DefaultPageSize {
		t.Errorf("Size = %d, want %d", p.Size, DefaultPageSize)
	}
	if p.Offset != 0 {
		t.Errorf("Offset = %d, want 0", p.Offset)
	}
}

func TestParsePageClamping(t *testing.T) {
	cases := []struct {
		name       string
		query      string
		wantNo     int
		wantSize   int
		wantOffset int
	}{
		{
			name: "explicit page and size", query: "pageno=3&pagesize=20",
			wantNo: 3, wantSize: 20, wantOffset: 40,
		},
		{
			// A client must not be able to opt back into an unbounded scan.
			name: "oversized pagesize is capped", query: "pagesize=999999",
			wantNo: 1, wantSize: MaxPageSize, wantOffset: 0,
		},
		{
			name: "zero page falls back to first", query: "pageno=0",
			wantNo: 1, wantSize: DefaultPageSize, wantOffset: 0,
		},
		{
			name: "negative page falls back to first", query: "pageno=-5",
			wantNo: 1, wantSize: DefaultPageSize, wantOffset: 0,
		},
		{
			name: "zero pagesize falls back to default", query: "pagesize=0",
			wantNo: 1, wantSize: DefaultPageSize, wantOffset: 0,
		},
		{
			name: "negative pagesize falls back to default", query: "pagesize=-10",
			wantNo: 1, wantSize: DefaultPageSize, wantOffset: 0,
		},
		{
			// Garbage must degrade to defaults, not fail the request.
			name: "non-numeric values fall back to defaults", query: "pageno=abc&pagesize=xyz",
			wantNo: 1, wantSize: DefaultPageSize, wantOffset: 0,
		},
		{
			name: "offset is derived from page and size", query: "pageno=5&pagesize=100",
			wantNo: 5, wantSize: 100, wantOffset: 400,
		},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			p := pageFor(t, tc.query)

			if p.No != tc.wantNo {
				t.Errorf("No = %d, want %d", p.No, tc.wantNo)
			}
			if p.Size != tc.wantSize {
				t.Errorf("Size = %d, want %d", p.Size, tc.wantSize)
			}
			if p.Offset != tc.wantOffset {
				t.Errorf("Offset = %d, want %d", p.Offset, tc.wantOffset)
			}
		})
	}
}

func TestParsePageNeverExceedsMax(t *testing.T) {
	// Guards the invariant the cap exists for, independent of the table above.
	for _, q := range []string{"pagesize=1001", "pagesize=5000", "pagesize=2147483647"} {
		if p := pageFor(t, q); p.Size > MaxPageSize {
			t.Errorf("%s produced Size = %d, which exceeds MaxPageSize %d", q, p.Size, MaxPageSize)
		}
	}
}