package port_test

import (
	"cmp"
	"fmt"
	"net/http"
	"net/http/httptest"
	"slices"
	"strconv"
	"strings"
	"testing"
	"time"

	"gitea.dwysokinski.me/twhelp/corev3/internal/domain"
	"gitea.dwysokinski.me/twhelp/corev3/internal/domain/domaintest"
	"gitea.dwysokinski.me/twhelp/corev3/internal/port/internal/apimodel"
	"github.com/brianvoe/gofakeit/v7"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

const endpointListPlayers = "/v2/versions/%s/servers/%s/players"

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

	handler := newAPIHTTPHandler(t)
	players := getAllPlayers(t, handler)
	var server serverWithVersion

	for _, p := range players {
		if p.DeletedAt != nil {
			server = p.Server
			break
		}
	}

	require.NotZero(t, server)

	tests := []struct {
		name        string
		reqModifier func(t *testing.T, req *http.Request)
		assertResp  func(t *testing.T, req *http.Request, resp *http.Response)
	}{
		{
			name: "OK: without params",
			assertResp: func(t *testing.T, _ *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusOK, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ListPlayersResponse](t, resp.Body)
				assert.Zero(t, body.Cursor.Next)
				assert.NotZero(t, body.Cursor.Self)
				assert.NotZero(t, body.Data)
				assert.True(t, slices.IsSortedFunc(body.Data, func(a, b apimodel.Player) int {
					return cmp.Compare(a.Id, b.Id)
				}))
			},
		},
		{
			name: "OK: limit=1",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Set("limit", "1")
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusOK, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ListPlayersResponse](t, resp.Body)
				assert.NotZero(t, body.Cursor.Next)
				assert.NotZero(t, body.Cursor.Self)
				assert.NotZero(t, body.Data)
				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
				require.NoError(t, err)
				assert.Len(t, body.Data, limit)
			},
		},
		{
			name: "OK: limit=1 cursor",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()

				q := req.URL.Query()
				q.Set("limit", "1")
				req.URL.RawQuery = q.Encode()

				resp := doCustomRequest(handler, req.Clone(req.Context()))
				defer resp.Body.Close()
				body := decodeJSON[apimodel.ListPlayersResponse](t, resp.Body)
				require.NotEmpty(t, body.Cursor.Next)

				q.Set("cursor", body.Cursor.Next)
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusOK, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ListPlayersResponse](t, resp.Body)
				assert.Equal(t, req.URL.Query().Get("cursor"), body.Cursor.Self)
				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
				require.NoError(t, err)
				assert.Len(t, body.Data, limit)
			},
		},
		{
			name: "OK: sort=[deletedAt:DESC,points:ASC]",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Add("sort", "deletedAt:DESC")
				q.Add("sort", "points:ASC")
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, _ *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusOK, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ListPlayersResponse](t, resp.Body)
				assert.Zero(t, body.Cursor.Next)
				assert.NotZero(t, body.Cursor.Self)
				assert.NotZero(t, body.Data)
				assert.True(t, slices.IsSortedFunc(body.Data, func(a, b apimodel.Player) int {
					var aDeletedAt time.Time
					if a.DeletedAt != nil {
						aDeletedAt = *a.DeletedAt
					}

					var bDeletedAt time.Time
					if b.DeletedAt != nil {
						bDeletedAt = *b.DeletedAt
					}

					return cmp.Or(
						aDeletedAt.Compare(bDeletedAt)*-1,
						cmp.Compare(a.Points, b.Points),
						cmp.Compare(a.Id, b.Id),
					)
				}))
			},
		},
		{
			name: "OK: sort=[odScoreAtt:DESC]",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Set("sort", "odScoreAtt:DESC")
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, _ *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusOK, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ListPlayersResponse](t, resp.Body)
				assert.Zero(t, body.Cursor.Next)
				assert.NotZero(t, body.Cursor.Self)
				assert.NotZero(t, body.Data)
				assert.True(t, slices.IsSortedFunc(body.Data, func(a, b apimodel.Player) int {
					return cmp.Or(
						cmp.Compare(a.OpponentsDefeated.ScoreAtt, b.OpponentsDefeated.ScoreAtt)*-1,
						cmp.Compare(a.Id, b.Id),
					)
				}))
			},
		},
		{
			name: "OK: name",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()

				q := req.URL.Query()

				for _, p := range players {
					if p.Server.Key == server.Key {
						q.Add("name", p.Name)
					}

					if len(q["name"]) == 2 {
						break
					}
				}

				require.NotEmpty(t, q["name"])

				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusOK, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ListPlayersResponse](t, resp.Body)
				assert.NotZero(t, body.Cursor.Self)
				assert.NotZero(t, body.Data)
				names := req.URL.Query()["name"]
				assert.Len(t, body.Data, len(names))
				for _, p := range body.Data {
					assert.True(t, slices.Contains(names, p.Name))
				}
			},
		},
		{
			name: "OK: deleted=false",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Set("deleted", "false")
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, _ *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusOK, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ListPlayersResponse](t, resp.Body)
				assert.NotZero(t, body.Data)
				for _, p := range body.Data {
					assert.Nil(t, p.DeletedAt)
				}
			},
		},
		{
			name: "OK: deleted=true",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Set("deleted", "true")
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, _ *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusOK, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ListPlayersResponse](t, resp.Body)
				assert.NotZero(t, body.Data)
				for _, p := range body.Data {
					assert.NotNil(t, p.DeletedAt)
				}
			},
		},
		{
			name: "ERR: limit is not a string",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Set("limit", "asd")
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code: "invalid-param-format",
							Message: fmt.Sprintf(
								"error binding string parameter: strconv.ParseInt: parsing \"%s\": invalid syntax",
								req.URL.Query().Get("limit"),
							),
							Path: []string{"$query", "limit"},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: limit < 1",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Set("limit", "0")
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
				require.NoError(t, err)
				domainErr := domain.MinGreaterEqualError{
					Min:     1,
					Current: limit,
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"current": float64(domainErr.Current),
								"min":     float64(domainErr.Min),
							},
							Path: []string{"$query", "limit"},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: limit > 200",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Set("limit", "201")
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
				require.NoError(t, err)
				domainErr := domain.MaxLessEqualError{
					Max:     200,
					Current: limit,
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"current": float64(domainErr.Current),
								"max":     float64(domainErr.Max),
							},
							Path: []string{"$query", "limit"},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: len(cursor) < 1",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Set("cursor", "")
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				domainErr := domain.LenOutOfRangeError{
					Min:     1,
					Max:     1000,
					Current: len(req.URL.Query().Get("cursor")),
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"current": float64(domainErr.Current),
								"max":     float64(domainErr.Max),
								"min":     float64(domainErr.Min),
							},
							Path: []string{"$query", "cursor"},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: len(cursor) > 1000",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Set("cursor", gofakeit.LetterN(1001))
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				domainErr := domain.LenOutOfRangeError{
					Min:     1,
					Max:     1000,
					Current: len(req.URL.Query().Get("cursor")),
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"current": float64(domainErr.Current),
								"max":     float64(domainErr.Max),
								"min":     float64(domainErr.Min),
							},
							Path: []string{"$query", "cursor"},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: invalid cursor",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Set("cursor", gofakeit.LetterN(100))
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, _ *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				var domainErr domain.Error
				require.ErrorAs(t, domain.ErrInvalidCursor, &domainErr)
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Path:    []string{"$query", "cursor"},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: len(sort) > 2",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Add("sort", "odScoreAtt:DESC")
				q.Add("sort", "odScoreAtt:ASC")
				q.Add("sort", "points:ASC")
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				domainErr := domain.LenOutOfRangeError{
					Min:     1,
					Max:     2,
					Current: len(req.URL.Query()["sort"]),
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"current": float64(domainErr.Current),
								"max":     float64(domainErr.Max),
								"min":     float64(domainErr.Min),
							},
							Path: []string{"$query", "sort"},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: invalid sort",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Add("sort", "odScoreAtt:ASC")
				q.Add("sort", "test:DESC")
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				domainErr := domain.UnsupportedSortStringError{
					Sort: req.URL.Query()["sort"][1],
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"sort": domainErr.Sort,
							},
							Path: []string{"$query", "sort", "1"},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: sort conflict",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Add("sort", "odScoreAtt:ASC")
				q.Add("sort", "odScoreAtt:DESC")
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				q := req.URL.Query()
				domainErr := domain.SortConflictError{
					Sort: [2]string{q["sort"][0], q["sort"][1]},
				}
				paramSort := make([]any, len(domainErr.Sort))
				for i, s := range domainErr.Sort {
					paramSort[i] = s
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"sort": paramSort,
							},
							Path: []string{"$query", "sort"},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: len(name) > 100",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				for range 101 {
					q.Add("name", gofakeit.LetterN(50))
				}
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				domainErr := domain.LenOutOfRangeError{
					Min:     0,
					Max:     100,
					Current: len(req.URL.Query()["name"]),
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"current": float64(domainErr.Current),
								"max":     float64(domainErr.Max),
								"min":     float64(domainErr.Min),
							},
							Path: []string{"$query", "name"},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: len(name[1]) < 1",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Add("name", gofakeit.LetterN(50))
				q.Add("name", "")
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				domainErr := domain.LenOutOfRangeError{
					Min:     1,
					Max:     150,
					Current: len(req.URL.Query()["name"][1]),
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"current": float64(domainErr.Current),
								"max":     float64(domainErr.Max),
								"min":     float64(domainErr.Min),
							},
							Path: []string{"$query", "name", "1"},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: len(name[1]) > 150",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Add("name", gofakeit.LetterN(50))
				q.Add("name", gofakeit.LetterN(151))
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				domainErr := domain.LenOutOfRangeError{
					Min:     1,
					Max:     150,
					Current: len(req.URL.Query()["name"][1]),
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"current": float64(domainErr.Current),
								"max":     float64(domainErr.Max),
								"min":     float64(domainErr.Min),
							},
							Path: []string{"$query", "name", "1"},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: deleted is not a valid boolean",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Set("deleted", "asd")
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code: "invalid-param-format",
							Message: fmt.Sprintf(
								"error binding string parameter: strconv.ParseBool: parsing \"%s\": invalid syntax",
								req.URL.Query().Get("deleted"),
							),
							Path: []string{"$query", "deleted"},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: version not found",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				req.URL.Path = fmt.Sprintf(endpointListPlayers, domaintest.RandVersionCode(), server.Key)
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusNotFound, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				pathSegments := strings.Split(req.URL.Path, "/")
				require.Len(t, pathSegments, 7)
				domainErr := domain.VersionNotFoundError{
					VersionCode: pathSegments[3],
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"code": domainErr.VersionCode,
							},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: server not found",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				req.URL.Path = fmt.Sprintf(endpointListPlayers, server.Version.Code, domaintest.RandServerKey())
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusNotFound, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				pathSegments := strings.Split(req.URL.Path, "/")
				require.Len(t, pathSegments, 7)
				domainErr := domain.ServerNotFoundError{
					Key: pathSegments[5],
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"key": domainErr.Key,
							},
						},
					},
				}, body)
			},
		},
	}

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

			req := httptest.NewRequest(
				http.MethodGet,
				fmt.Sprintf(endpointListPlayers, server.Version.Code, server.Key),
				nil,
			)
			if tt.reqModifier != nil {
				tt.reqModifier(t, req)
			}

			resp := doCustomRequest(handler, req)
			defer resp.Body.Close()
			tt.assertResp(t, req, resp)
		})
	}
}

const endpointListTribeMembers = "/v2/versions/%s/servers/%s/tribes/%d/members"

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

	handler := newAPIHTTPHandler(t)
	players := getAllPlayers(t, handler)
	var server serverWithVersion
	var tribeID int

	for _, p := range players {
		if p.Tribe != nil && p.Tribe.Id > 0 {
			server = p.Server
			tribeID = p.Tribe.Id
			break
		}
	}

	require.NotZero(t, server)

	tests := []struct {
		name        string
		reqModifier func(t *testing.T, req *http.Request)
		assertResp  func(t *testing.T, req *http.Request, resp *http.Response)
	}{
		{
			name: "OK: without params",
			assertResp: func(t *testing.T, _ *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusOK, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ListPlayersResponse](t, resp.Body)
				assert.Zero(t, body.Cursor.Next)
				assert.NotZero(t, body.Cursor.Self)
				assert.NotZero(t, body.Data)
				assert.False(t, slices.ContainsFunc(body.Data, func(player apimodel.Player) bool {
					return player.Tribe == nil || player.Tribe.Id != tribeID
				}))
				assert.True(t, slices.IsSortedFunc(body.Data, func(a, b apimodel.Player) int {
					return cmp.Compare(a.Id, b.Id)
				}))
			},
		},
		{
			name: "OK: limit=1",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Set("limit", "1")
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusOK, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ListPlayersResponse](t, resp.Body)
				assert.NotZero(t, body.Cursor.Next)
				assert.NotZero(t, body.Cursor.Self)
				assert.NotZero(t, body.Data)
				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
				require.NoError(t, err)
				assert.Len(t, body.Data, limit)
			},
		},
		{
			name: "OK: limit=1 cursor",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()

				q := req.URL.Query()
				q.Set("limit", "1")
				req.URL.RawQuery = q.Encode()

				resp := doCustomRequest(handler, req.Clone(req.Context()))
				defer resp.Body.Close()
				body := decodeJSON[apimodel.ListPlayersResponse](t, resp.Body)
				require.NotEmpty(t, body.Cursor.Next)

				q.Set("cursor", body.Cursor.Next)
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusOK, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ListPlayersResponse](t, resp.Body)
				assert.Equal(t, req.URL.Query().Get("cursor"), body.Cursor.Self)
				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
				require.NoError(t, err)
				assert.Len(t, body.Data, limit)
			},
		},
		{
			name: "OK: sort=[odScoreAtt:DESC]",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Set("sort", "odScoreAtt:DESC")
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, _ *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusOK, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ListPlayersResponse](t, resp.Body)
				assert.Zero(t, body.Cursor.Next)
				assert.NotZero(t, body.Cursor.Self)
				assert.NotZero(t, body.Data)
				assert.True(t, slices.IsSortedFunc(body.Data, func(a, b apimodel.Player) int {
					return cmp.Or(
						cmp.Compare(a.OpponentsDefeated.ScoreAtt, b.OpponentsDefeated.ScoreAtt)*-1,
						cmp.Compare(a.Id, b.Id),
					)
				}))
			},
		},
		{
			name: "ERR: limit is not a string",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Set("limit", "asd")
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code: "invalid-param-format",
							Message: fmt.Sprintf(
								"error binding string parameter: strconv.ParseInt: parsing \"%s\": invalid syntax",
								req.URL.Query().Get("limit"),
							),
							Path: []string{"$query", "limit"},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: limit < 1",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Set("limit", "0")
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
				require.NoError(t, err)
				domainErr := domain.MinGreaterEqualError{
					Min:     1,
					Current: limit,
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"current": float64(domainErr.Current),
								"min":     float64(domainErr.Min),
							},
							Path: []string{"$query", "limit"},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: limit > 200",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Set("limit", "201")
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				limit, err := strconv.Atoi(req.URL.Query().Get("limit"))
				require.NoError(t, err)
				domainErr := domain.MaxLessEqualError{
					Max:     200,
					Current: limit,
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"current": float64(domainErr.Current),
								"max":     float64(domainErr.Max),
							},
							Path: []string{"$query", "limit"},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: len(cursor) < 1",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Set("cursor", "")
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				domainErr := domain.LenOutOfRangeError{
					Min:     1,
					Max:     1000,
					Current: len(req.URL.Query().Get("cursor")),
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"current": float64(domainErr.Current),
								"max":     float64(domainErr.Max),
								"min":     float64(domainErr.Min),
							},
							Path: []string{"$query", "cursor"},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: len(cursor) > 1000",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Set("cursor", gofakeit.LetterN(1001))
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				domainErr := domain.LenOutOfRangeError{
					Min:     1,
					Max:     1000,
					Current: len(req.URL.Query().Get("cursor")),
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"current": float64(domainErr.Current),
								"max":     float64(domainErr.Max),
								"min":     float64(domainErr.Min),
							},
							Path: []string{"$query", "cursor"},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: invalid cursor",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Set("cursor", gofakeit.LetterN(100))
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, _ *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				var domainErr domain.Error
				require.ErrorAs(t, domain.ErrInvalidCursor, &domainErr)
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Path:    []string{"$query", "cursor"},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: len(sort) > 2",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Add("sort", "odScoreAtt:DESC")
				q.Add("sort", "odScoreAtt:ASC")
				q.Add("sort", "points:ASC")
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				domainErr := domain.LenOutOfRangeError{
					Min:     1,
					Max:     2,
					Current: len(req.URL.Query()["sort"]),
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"current": float64(domainErr.Current),
								"max":     float64(domainErr.Max),
								"min":     float64(domainErr.Min),
							},
							Path: []string{"$query", "sort"},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: invalid sort",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Add("sort", "odScoreAtt:ASC")
				q.Add("sort", "test:DESC")
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				domainErr := domain.UnsupportedSortStringError{
					Sort: req.URL.Query()["sort"][1],
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"sort": domainErr.Sort,
							},
							Path: []string{"$query", "sort", "1"},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: sort conflict",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				q := req.URL.Query()
				q.Add("sort", "odScoreAtt:ASC")
				q.Add("sort", "odScoreAtt:DESC")
				req.URL.RawQuery = q.Encode()
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				q := req.URL.Query()
				domainErr := domain.SortConflictError{
					Sort: [2]string{q["sort"][0], q["sort"][1]},
				}
				paramSort := make([]any, len(domainErr.Sort))
				for i, s := range domainErr.Sort {
					paramSort[i] = s
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"sort": paramSort,
							},
							Path: []string{"$query", "sort"},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: version not found",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				req.URL.Path = fmt.Sprintf(endpointListTribeMembers, domaintest.RandVersionCode(), server.Key, tribeID)
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusNotFound, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				pathSegments := strings.Split(req.URL.Path, "/")
				require.Len(t, pathSegments, 9)
				domainErr := domain.VersionNotFoundError{
					VersionCode: pathSegments[3],
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"code": domainErr.VersionCode,
							},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: server not found",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				req.URL.Path = fmt.Sprintf(endpointListTribeMembers, server.Version.Code, domaintest.RandServerKey(), tribeID)
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusNotFound, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				pathSegments := strings.Split(req.URL.Path, "/")
				require.Len(t, pathSegments, 9)
				domainErr := domain.ServerNotFoundError{
					Key: pathSegments[5],
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"key": domainErr.Key,
							},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: tribe not found",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				req.URL.Path = fmt.Sprintf(endpointListTribeMembers, server.Version.Code, server.Key, domaintest.RandID())
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusNotFound, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				pathSegments := strings.Split(req.URL.Path, "/")
				require.Len(t, pathSegments, 9)
				id, err := strconv.Atoi(pathSegments[7])
				require.NoError(t, err)
				domainErr := domain.TribeNotFoundError{
					ID:        id,
					ServerKey: pathSegments[5],
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"id":        float64(domainErr.ID),
								"serverKey": domainErr.ServerKey,
							},
						},
					},
				}, body)
			},
		},
	}

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

			req := httptest.NewRequest(
				http.MethodGet,
				fmt.Sprintf(endpointListTribeMembers, server.Version.Code, server.Key, tribeID),
				nil,
			)
			if tt.reqModifier != nil {
				tt.reqModifier(t, req)
			}

			resp := doCustomRequest(handler, req)
			defer resp.Body.Close()
			tt.assertResp(t, req, resp)
		})
	}
}

const endpointGetPlayer = "/v2/versions/%s/servers/%s/players/%d"

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

	handler := newAPIHTTPHandler(t)
	player := randSliceElement(getAllPlayers(t, handler))

	tests := []struct {
		name        string
		reqModifier func(t *testing.T, req *http.Request)
		assertResp  func(t *testing.T, req *http.Request, resp *http.Response)
	}{
		{
			name: "OK",
			assertResp: func(t *testing.T, _ *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusOK, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.GetPlayerResponse](t, resp.Body)
				assert.Equal(t, player.Player, body.Data)
			},
		},
		{
			name: "ERR: id < 1",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				req.URL.Path = fmt.Sprintf(
					endpointGetPlayer,
					player.Server.Version.Code,
					player.Server.Key,
					domaintest.RandID()*-1,
				)
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusBadRequest, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				pathSegments := strings.Split(req.URL.Path, "/")
				require.Len(t, pathSegments, 8)
				id, err := strconv.Atoi(pathSegments[7])
				require.NoError(t, err)
				domainErr := domain.MinGreaterEqualError{
					Min:     1,
					Current: id,
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"min":     float64(domainErr.Min),
								"current": float64(domainErr.Current),
							},
							Path: []string{"$path", "playerId"},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: version not found",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				req.URL.Path = fmt.Sprintf(endpointGetPlayer, domaintest.RandVersionCode(), player.Server.Key, player.Id)
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusNotFound, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				pathSegments := strings.Split(req.URL.Path, "/")
				require.Len(t, pathSegments, 8)
				domainErr := domain.VersionNotFoundError{
					VersionCode: pathSegments[3],
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"code": domainErr.VersionCode,
							},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: server not found",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				req.URL.Path = fmt.Sprintf(endpointGetPlayer, player.Server.Version.Code, domaintest.RandServerKey(), player.Id)
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusNotFound, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				pathSegments := strings.Split(req.URL.Path, "/")
				require.Len(t, pathSegments, 8)
				domainErr := domain.ServerNotFoundError{
					Key: pathSegments[5],
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"key": domainErr.Key,
							},
						},
					},
				}, body)
			},
		},
		{
			name: "ERR: player not found",
			reqModifier: func(t *testing.T, req *http.Request) {
				t.Helper()
				req.URL.Path = fmt.Sprintf(
					endpointGetPlayer,
					player.Server.Version.Code,
					player.Server.Key,
					domaintest.RandID(),
				)
			},
			assertResp: func(t *testing.T, req *http.Request, resp *http.Response) {
				t.Helper()

				assert.Equal(t, http.StatusNotFound, resp.StatusCode)

				// body
				body := decodeJSON[apimodel.ErrorResponse](t, resp.Body)
				pathSegments := strings.Split(req.URL.Path, "/")
				require.Len(t, pathSegments, 8)
				id, err := strconv.Atoi(pathSegments[7])
				require.NoError(t, err)
				domainErr := domain.PlayerNotFoundError{
					ID:        id,
					ServerKey: pathSegments[5],
				}
				assert.Equal(t, apimodel.ErrorResponse{
					Errors: []apimodel.Error{
						{
							Code:    domainErr.Code(),
							Message: domainErr.Error(),
							Params: map[string]any{
								"id":        float64(domainErr.ID),
								"serverKey": domainErr.ServerKey,
							},
						},
					},
				}, body)
			},
		},
	}

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

			req := httptest.NewRequest(
				http.MethodGet,
				fmt.Sprintf(endpointGetPlayer, player.Server.Version.Code, player.Server.Key, player.Id),
				nil,
			)
			if tt.reqModifier != nil {
				tt.reqModifier(t, req)
			}

			resp := doCustomRequest(handler, req)
			defer resp.Body.Close()
			tt.assertResp(t, req, resp)
		})
	}
}

type playerWithServer struct {
	apimodel.Player
	Server serverWithVersion
}

func getAllPlayers(tb testing.TB, h http.Handler) []playerWithServer {
	tb.Helper()

	servers := getAllServers(tb, h)

	var players []playerWithServer

	for _, s := range servers {
		resp := doRequest(h, http.MethodGet, fmt.Sprintf(endpointListPlayers, s.Version.Code, s.Key), nil)
		require.Equal(tb, http.StatusOK, resp.StatusCode)

		for _, p := range decodeJSON[apimodel.ListPlayersResponse](tb, resp.Body).Data {
			players = append(players, playerWithServer{
				Player: p,
				Server: s,
			})
		}

		_ = resp.Body.Close()
	}

	require.NotZero(tb, players)

	return players
}