package domain_test

import (
	"cmp"
	"fmt"
	"slices"
	"testing"
	"time"

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

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

	server := domaintest.NewServer(t)

	active := domain.BaseTribes{
		domaintest.NewBaseTribe(t),
		domaintest.NewBaseTribe(t),
		domaintest.NewBaseTribe(t),
	}

	tribes := domain.Tribes{
		domaintest.NewTribe(t, func(cfg *domaintest.TribeConfig) {
			cfg.ID = active[0].ID()
			cfg.ServerKey = server.Key()
		}),
		domaintest.NewTribe(t, func(cfg *domaintest.TribeConfig) {
			cfg.ServerKey = server.Key()
		}),
		domaintest.NewTribe(t, func(cfg *domaintest.TribeConfig) {
			cfg.ServerKey = server.Key()
			cfg.DeletedAt = time.Now()
		}),
		domaintest.NewTribe(t, func(cfg *domaintest.TribeConfig) {
			cfg.ID = active[1].ID()
			cfg.ServerKey = server.Key()
		}),
		domaintest.NewTribe(t, func(cfg *domaintest.TribeConfig) {
			cfg.ID = active[2].ID()
			cfg.ServerKey = domaintest.RandServerKey()
		}),
	}

	expectedIDs := []int{tribes[1].ID()}

	slices.Sort(expectedIDs)

	slices.SortFunc(active, func(a, b domain.BaseTribe) int {
		return cmp.Compare(a.ID(), b.ID())
	})

	slices.SortFunc(tribes, func(a, b domain.Tribe) int {
		return cmp.Or(
			cmp.Compare(a.ServerKey(), b.ServerKey()),
			cmp.Compare(a.ID(), b.ID()),
		)
	})

	assert.Equal(t, expectedIDs, tribes.Delete(server.Key(), active))
}

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

	now := time.Now()

	server := domaintest.NewServer(t)

	tribes := domain.BaseTribes{
		domaintest.NewBaseTribe(t),
		domaintest.NewBaseTribe(t),
		domaintest.NewBaseTribe(t),
	}

	storedTribes := domain.Tribes{
		domaintest.NewTribe(t, func(cfg *domaintest.TribeConfig) {
			cfg.ID = tribes[0].ID()
			cfg.ServerKey = domaintest.RandServerKey()
		}),
		domaintest.NewTribe(t, func(cfg *domaintest.TribeConfig) {
			cfg.ID = tribes[0].ID()
			cfg.ServerKey = server.Key()
			cfg.BestRank = tribes[0].Rank() + 1
			cfg.BestRankAt = now.Add(-time.Hour)
			cfg.MostPoints = tribes[0].AllPoints() - 1
			cfg.MostPointsAt = now.Add(-time.Hour)
			cfg.MostVillages = tribes[0].NumVillages() - 1
			cfg.MostVillagesAt = now.Add(-time.Hour)
		}),
		domaintest.NewTribe(t, func(cfg *domaintest.TribeConfig) {
			cfg.ID = tribes[1].ID()
			cfg.ServerKey = server.Key()
			cfg.BestRank = tribes[1].Rank() - 1
			cfg.BestRankAt = now.Add(-time.Hour)
			cfg.MostPoints = tribes[1].AllPoints() + 1
			cfg.MostPointsAt = now.Add(-time.Hour)
			cfg.MostVillages = tribes[1].NumVillages() + 1
			cfg.MostVillagesAt = now.Add(-time.Hour)
		}),
	}

	expectedParams := []struct {
		base           domain.BaseTribe
		serverKey      string
		bestRank       int
		bestRankAt     time.Time
		mostPoints     int
		mostPointsAt   time.Time
		mostVillages   int
		mostVillagesAt time.Time
	}{
		{
			base:           tribes[0],
			serverKey:      server.Key(),
			bestRank:       tribes[0].Rank(),
			bestRankAt:     now,
			mostPoints:     tribes[0].AllPoints(),
			mostPointsAt:   now,
			mostVillages:   tribes[0].NumVillages(),
			mostVillagesAt: now,
		},
		{
			base:           tribes[1],
			serverKey:      server.Key(),
			bestRank:       storedTribes[2].BestRank(),
			bestRankAt:     storedTribes[2].BestRankAt(),
			mostPoints:     storedTribes[2].MostPoints(),
			mostPointsAt:   storedTribes[2].MostPointsAt(),
			mostVillages:   storedTribes[2].MostVillages(),
			mostVillagesAt: storedTribes[2].MostVillagesAt(),
		},
		{
			base:           tribes[2],
			serverKey:      server.Key(),
			bestRank:       tribes[2].Rank(),
			bestRankAt:     now,
			mostPoints:     tribes[2].AllPoints(),
			mostPointsAt:   now,
			mostVillages:   tribes[2].NumVillages(),
			mostVillagesAt: now,
		},
	}

	slices.SortFunc(tribes, func(a, b domain.BaseTribe) int {
		return cmp.Compare(a.ID(), b.ID())
	})

	slices.SortFunc(storedTribes, func(a, b domain.Tribe) int {
		return cmp.Or(
			cmp.Compare(a.ServerKey(), b.ServerKey()),
			cmp.Compare(a.ID(), b.ID()),
		)
	})

	res, err := domain.NewCreateTribeParams(server.Key(), tribes, storedTribes)
	require.NoError(t, err)
	assert.Len(t, res, len(expectedParams))
	for i, expected := range expectedParams {
		idx := slices.IndexFunc(res, func(params domain.CreateTribeParams) bool {
			return params.Base().ID() == expected.base.ID() && params.ServerKey() == expected.serverKey
		})
		require.GreaterOrEqualf(t, idx, 0, "expectedParams[%d] not found", i)

		params := res[idx]

		assert.Equalf(t, expected.base, params.Base(), "expectedParams[%d]", i)
		assert.Equalf(t, expected.serverKey, params.ServerKey(), "expectedParams[%d]", i)
		assert.Equalf(t, expected.bestRank, params.BestRank(), "expectedParams[%d]", i)
		assert.WithinDurationf(t, expected.bestRankAt, params.BestRankAt(), time.Minute, "expectedParams[%d]", i)
		assert.Equalf(t, expected.mostPoints, params.MostPoints(), "expectedParams[%d]", i)
		assert.WithinDurationf(t, expected.mostPointsAt, params.MostPointsAt(), time.Minute, "expectedParams[%d]", i)
		assert.Equalf(t, expected.mostVillages, params.MostVillages(), "expectedParams[%d]", i)
		assert.WithinDurationf(t, expected.mostVillagesAt, params.MostVillagesAt(), time.Minute, "expectedParams[%d]", i)
	}
}

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

	type args struct {
		sorts [2]domain.TribeSort
	}

	tests := []struct {
		name        string
		args        args
		expectedRes bool
	}{
		{
			name: "OK: id:ASC serverKey:ASC",
			args: args{
				sorts: [2]domain.TribeSort{domain.TribeSortIDASC, domain.TribeSortServerKeyASC},
			},
			expectedRes: false,
		},
		{
			name: "OK: id:DESC serverKey:ASC",
			args: args{
				sorts: [2]domain.TribeSort{domain.TribeSortIDDESC, domain.TribeSortServerKeyASC},
			},
			expectedRes: false,
		},
		{
			name: "OK: id:ASC id:ASC",
			args: args{
				sorts: [2]domain.TribeSort{domain.TribeSortIDASC, domain.TribeSortIDASC},
			},
			expectedRes: true,
		},
		{
			name: "OK: id:ASC id:DESC",
			args: args{
				sorts: [2]domain.TribeSort{domain.TribeSortIDASC, domain.TribeSortIDDESC},
			},
			expectedRes: true,
		},
		{
			name: "OK: serverKey:DESC serverKey:ASC",
			args: args{
				sorts: [2]domain.TribeSort{domain.TribeSortServerKeyDESC, domain.TribeSortServerKeyASC},
			},
			expectedRes: true,
		},
		{
			name: "OK: odScoreAtt:ASC odScoreAtt:DESC",
			args: args{
				sorts: [2]domain.TribeSort{domain.TribeSortODScoreAttASC, domain.TribeSortODScoreAttDESC},
			},
			expectedRes: true,
		},
		{
			name: "OK: odScoreDef:ASC odScoreDef:DESC",
			args: args{
				sorts: [2]domain.TribeSort{domain.TribeSortODScoreDefASC, domain.TribeSortODScoreDefDESC},
			},
			expectedRes: true,
		},
		{
			name: "OK: odScoreTotal:ASC odScoreTotal:DESC",
			args: args{
				sorts: [2]domain.TribeSort{domain.TribeSortODScoreTotalASC, domain.TribeSortODScoreTotalDESC},
			},
			expectedRes: true,
		},
		{
			name: "OK: points:ASC points:DESC",
			args: args{
				sorts: [2]domain.TribeSort{domain.TribeSortPointsASC, domain.TribeSortPointsDESC},
			},
			expectedRes: true,
		},
		{
			name: "OK: dominance:ASC dominance:DESC",
			args: args{
				sorts: [2]domain.TribeSort{domain.TribeSortDominanceASC, domain.TribeSortDominanceDESC},
			},
			expectedRes: true,
		},
		{
			name: "OK: deletedAt:ASC deletedAt:DESC",
			args: args{
				sorts: [2]domain.TribeSort{domain.TribeSortDeletedAtASC, domain.TribeSortDeletedAtDESC},
			},
			expectedRes: true,
		},
	}

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

			assert.Equal(t, tt.expectedRes, tt.args.sorts[0].IsInConflict(tt.args.sorts[1]))
		})
	}
}

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

	validTribeCursor := domaintest.NewTribeCursor(t)

	type args struct {
		id           int
		serverKey    string
		odScoreAtt   int
		odScoreDef   int
		odScoreTotal int
		points       int
		dominance    float64
		deletedAt    time.Time
	}

	type test struct {
		name        string
		args        args
		expectedErr error
	}

	tests := []test{
		{
			name: "OK",
			args: args{
				id:           validTribeCursor.ID(),
				serverKey:    validTribeCursor.ServerKey(),
				odScoreAtt:   validTribeCursor.ODScoreAtt(),
				odScoreDef:   validTribeCursor.ODScoreDef(),
				odScoreTotal: validTribeCursor.ODScoreTotal(),
				points:       validTribeCursor.Points(),
				dominance:    validTribeCursor.Dominance(),
				deletedAt:    validTribeCursor.DeletedAt(),
			},
			expectedErr: nil,
		},
		{
			name: "ERR: id < 1",
			args: args{
				id:           0,
				serverKey:    validTribeCursor.ServerKey(),
				odScoreAtt:   validTribeCursor.ODScoreAtt(),
				odScoreDef:   validTribeCursor.ODScoreDef(),
				odScoreTotal: validTribeCursor.ODScoreTotal(),
				points:       validTribeCursor.Points(),
				dominance:    validTribeCursor.Dominance(),
				deletedAt:    validTribeCursor.DeletedAt(),
			},
			expectedErr: domain.ValidationError{
				Model: "TribeCursor",
				Field: "id",
				Err: domain.MinGreaterEqualError{
					Min:     1,
					Current: 0,
				},
			},
		},
		{
			name: "ERR: odScoreAtt < 0",
			args: args{
				id:           validTribeCursor.ID(),
				serverKey:    validTribeCursor.ServerKey(),
				odScoreAtt:   -1,
				odScoreDef:   validTribeCursor.ODScoreDef(),
				odScoreTotal: validTribeCursor.ODScoreTotal(),
				points:       validTribeCursor.Points(),
				dominance:    validTribeCursor.Dominance(),
				deletedAt:    validTribeCursor.DeletedAt(),
			},
			expectedErr: domain.ValidationError{
				Model: "TribeCursor",
				Field: "odScoreAtt",
				Err: domain.MinGreaterEqualError{
					Min:     0,
					Current: -1,
				},
			},
		},
		{
			name: "ERR: odScoreDef < 0",
			args: args{
				id:           validTribeCursor.ID(),
				serverKey:    validTribeCursor.ServerKey(),
				odScoreAtt:   validTribeCursor.ODScoreAtt(),
				odScoreDef:   -1,
				odScoreTotal: validTribeCursor.ODScoreTotal(),
				points:       validTribeCursor.Points(),
				dominance:    validTribeCursor.Dominance(),
				deletedAt:    validTribeCursor.DeletedAt(),
			},
			expectedErr: domain.ValidationError{
				Model: "TribeCursor",
				Field: "odScoreDef",
				Err: domain.MinGreaterEqualError{
					Min:     0,
					Current: -1,
				},
			},
		},
		{
			name: "ERR: odScoreTotal < 0",
			args: args{
				id:           validTribeCursor.ID(),
				serverKey:    validTribeCursor.ServerKey(),
				odScoreAtt:   validTribeCursor.ODScoreAtt(),
				odScoreDef:   validTribeCursor.ODScoreDef(),
				odScoreTotal: -1,
				points:       validTribeCursor.Points(),
				dominance:    validTribeCursor.Dominance(),
				deletedAt:    validTribeCursor.DeletedAt(),
			},
			expectedErr: domain.ValidationError{
				Model: "TribeCursor",
				Field: "odScoreTotal",
				Err: domain.MinGreaterEqualError{
					Min:     0,
					Current: -1,
				},
			},
		},
		{
			name: "ERR: points < 0",
			args: args{
				id:           validTribeCursor.ID(),
				serverKey:    validTribeCursor.ServerKey(),
				odScoreAtt:   validTribeCursor.ODScoreAtt(),
				odScoreDef:   validTribeCursor.ODScoreDef(),
				odScoreTotal: validTribeCursor.ODScoreTotal(),
				points:       -1,
				dominance:    validTribeCursor.Dominance(),
				deletedAt:    validTribeCursor.DeletedAt(),
			},
			expectedErr: domain.ValidationError{
				Model: "TribeCursor",
				Field: "points",
				Err: domain.MinGreaterEqualError{
					Min:     0,
					Current: -1,
				},
			},
		},
	}

	for _, serverKeyTest := range newServerKeyValidationTests() {
		tests = append(tests, test{
			name: serverKeyTest.name,
			args: args{
				id:           validTribeCursor.ID(),
				serverKey:    serverKeyTest.key,
				odScoreAtt:   validTribeCursor.ODScoreAtt(),
				odScoreDef:   validTribeCursor.ODScoreDef(),
				odScoreTotal: validTribeCursor.ODScoreTotal(),
				points:       validTribeCursor.Points(),
				dominance:    validTribeCursor.Dominance(),
				deletedAt:    validTribeCursor.DeletedAt(),
			},
			expectedErr: domain.ValidationError{
				Model: "TribeCursor",
				Field: "serverKey",
				Err:   serverKeyTest.expectedErr,
			},
		})
	}

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

			tc, err := domain.NewTribeCursor(
				tt.args.id,
				tt.args.serverKey,
				tt.args.odScoreAtt,
				tt.args.odScoreDef,
				tt.args.odScoreTotal,
				tt.args.points,
				tt.args.dominance,
				tt.args.deletedAt,
			)
			require.ErrorIs(t, err, tt.expectedErr)
			if tt.expectedErr != nil {
				return
			}
			assert.Equal(t, tt.args.id, tc.ID())
			assert.Equal(t, tt.args.serverKey, tc.ServerKey())
			assert.Equal(t, tt.args.odScoreAtt, tc.ODScoreAtt())
			assert.Equal(t, tt.args.odScoreDef, tc.ODScoreDef())
			assert.Equal(t, tt.args.odScoreTotal, tc.ODScoreTotal())
			assert.Equal(t, tt.args.points, tc.Points())
			assert.InDelta(t, tt.args.dominance, tc.Dominance(), 0.001)
			assert.Equal(t, tt.args.deletedAt, tc.DeletedAt())
			assert.NotEmpty(t, tc.Encode())
		})
	}
}

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

	type args struct {
		ids []int
	}

	tests := []struct {
		name        string
		args        args
		expectedErr error
	}{
		{
			name: "OK",
			args: args{
				ids: []int{
					domaintest.RandID(),
					domaintest.RandID(),
					domaintest.RandID(),
				},
			},
		},
		{
			name: "ERR: value < 1",
			args: args{
				ids: []int{
					domaintest.RandID(),
					domaintest.RandID(),
					domaintest.RandID(),
					0,
					domaintest.RandID(),
				},
			},
			expectedErr: domain.SliceElementValidationError{
				Model: "ListTribesParams",
				Field: "ids",
				Index: 3,
				Err: domain.MinGreaterEqualError{
					Min:     1,
					Current: 0,
				},
			},
		},
	}

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

			params := domain.NewListTribesParams()

			require.ErrorIs(t, params.SetIDs(tt.args.ids), tt.expectedErr)
			if tt.expectedErr != nil {
				return
			}
			assert.Equal(t, tt.args.ids, params.IDs())
		})
	}
}

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

	type args struct {
		serverKeys []string
	}

	type test struct {
		name        string
		args        args
		expectedErr error
	}

	tests := []test{
		{
			name: "OK",
			args: args{
				serverKeys: []string{
					domaintest.RandServerKey(),
				},
			},
		},
	}

	for _, serverKeyTest := range newServerKeyValidationTests() {
		tests = append(tests, test{
			name: serverKeyTest.name,
			args: args{
				serverKeys: []string{serverKeyTest.key},
			},
			expectedErr: domain.SliceElementValidationError{
				Model: "ListTribesParams",
				Field: "serverKeys",
				Index: 0,
				Err:   serverKeyTest.expectedErr,
			},
		})
	}

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

			params := domain.NewListTribesParams()

			require.ErrorIs(t, params.SetServerKeys(tt.args.serverKeys), tt.expectedErr)
			if tt.expectedErr != nil {
				return
			}
			assert.Equal(t, tt.args.serverKeys, params.ServerKeys())
		})
	}
}

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

	type args struct {
		tags []string
	}

	tests := []struct {
		name        string
		args        args
		expectedErr error
	}{
		{
			name: "OK",
			args: args{
				tags: []string{
					domaintest.RandTribeTag(),
					domaintest.RandTribeTag(),
					domaintest.RandTribeTag(),
					domaintest.RandTribeTag(),
					domaintest.RandTribeTag(),
				},
			},
		},
		{
			name: "ERR: len(tags) < 1",
			args: args{
				tags: nil,
			},
			expectedErr: domain.ValidationError{
				Model: "ListTribesParams",
				Field: "tags",
				Err: domain.LenOutOfRangeError{
					Min:     1,
					Max:     100,
					Current: 0,
				},
			},
		},
		{
			name: "ERR: len(tags) > 100",
			args: args{
				tags: func() []string {
					tags := make([]string, 101)
					for i := range tags {
						tags[i] = domaintest.RandTribeTag()
					}
					return tags
				}(),
			},
			expectedErr: domain.ValidationError{
				Model: "ListTribesParams",
				Field: "tags",
				Err: domain.LenOutOfRangeError{
					Min:     1,
					Max:     100,
					Current: 101,
				},
			},
		},
	}

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

			params := domain.NewListTribesParams()

			require.ErrorIs(t, params.SetTags(tt.args.tags), tt.expectedErr)
			if tt.expectedErr != nil {
				return
			}
			assert.Equal(t, tt.args.tags, params.Tags())
		})
	}
}

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

	type args struct {
		sort []domain.TribeSort
	}

	tests := []struct {
		name        string
		args        args
		expectedErr error
	}{
		{
			name: "OK",
			args: args{
				sort: []domain.TribeSort{
					domain.TribeSortPointsASC,
					domain.TribeSortIDASC,
					domain.TribeSortServerKeyASC,
				},
			},
		},
		{
			name: "ERR: len(sort) < 1",
			args: args{
				sort: nil,
			},
			expectedErr: domain.ValidationError{
				Model: "ListTribesParams",
				Field: "sort",
				Err: domain.LenOutOfRangeError{
					Min:     1,
					Max:     3,
					Current: 0,
				},
			},
		},
		{
			name: "ERR: len(sort) > 3",
			args: args{
				sort: []domain.TribeSort{
					domain.TribeSortDominanceASC,
					domain.TribeSortPointsASC,
					domain.TribeSortIDASC,
					domain.TribeSortServerKeyASC,
				},
			},
			expectedErr: domain.ValidationError{
				Model: "ListTribesParams",
				Field: "sort",
				Err: domain.LenOutOfRangeError{
					Min:     1,
					Max:     3,
					Current: 4,
				},
			},
		},
		{
			name: "ERR: conflict",
			args: args{
				sort: []domain.TribeSort{
					domain.TribeSortIDASC,
					domain.TribeSortIDDESC,
				},
			},
			expectedErr: domain.ValidationError{
				Model: "ListTribesParams",
				Field: "sort",
				Err: domain.SortConflictError{
					Sort: [2]string{domain.TribeSortIDASC.String(), domain.TribeSortIDDESC.String()},
				},
			},
		},
	}

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

			params := domain.NewListTribesParams()

			require.ErrorIs(t, params.SetSort(tt.args.sort), tt.expectedErr)
			if tt.expectedErr != nil {
				return
			}
			assert.Equal(t, tt.args.sort, params.Sort())
		})
	}
}

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

	defaultNewParams := func(t *testing.T) domain.ListTribesParams {
		t.Helper()
		return domain.ListTribesParams{}
	}

	type args struct {
		sort []string
	}

	tests := []struct {
		name         string
		newParams    func(t *testing.T) domain.ListTribesParams
		args         args
		expectedSort []domain.TribeSort
		expectedErr  error
	}{
		{
			name: "OK: [odScoreAtt:ASC, odScoreDef:ASC, odScoreTotal:ASC]",
			args: args{
				sort: []string{
					"odScoreAtt:ASC",
					"odScoreDef:ASC",
					"odScoreTotal:ASC",
				},
			},
			expectedSort: []domain.TribeSort{
				domain.TribeSortODScoreAttASC,
				domain.TribeSortODScoreDefASC,
				domain.TribeSortODScoreTotalASC,
			},
		},
		{
			name: "OK: [odScoreAtt:DESC, odScoreDef:DESC, odScoreTotal:DESC]",
			args: args{
				sort: []string{
					"odScoreAtt:DESC",
					"odScoreDef:DESC",
					"odScoreTotal:DESC",
				},
			},
			expectedSort: []domain.TribeSort{
				domain.TribeSortODScoreAttDESC,
				domain.TribeSortODScoreDefDESC,
				domain.TribeSortODScoreTotalDESC,
			},
		},
		{
			name: "OK: [points:ASC, dominance:ASC, deletedAt:ASC]",
			args: args{
				sort: []string{
					"points:ASC",
					"dominance:ASC",
					"deletedAt:ASC",
				},
			},
			expectedSort: []domain.TribeSort{
				domain.TribeSortPointsASC,
				domain.TribeSortDominanceASC,
				domain.TribeSortDeletedAtASC,
			},
		},
		{
			name: "OK: [points:DESC, dominance:DESC, deletedAt:DESC]",
			args: args{
				sort: []string{
					"points:DESC",
					"dominance:DESC",
					"deletedAt:DESC",
				},
			},
			expectedSort: []domain.TribeSort{
				domain.TribeSortPointsDESC,
				domain.TribeSortDominanceDESC,
				domain.TribeSortDeletedAtDESC,
			},
		},
		{
			name: "ERR: len(sort) < 1",
			args: args{
				sort: nil,
			},
			expectedErr: domain.ValidationError{
				Model: "ListTribesParams",
				Field: "sort",
				Err: domain.LenOutOfRangeError{
					Min:     1,
					Max:     3,
					Current: 0,
				},
			},
		},
		{
			name: "ERR: len(sort) > 3",
			args: args{
				sort: []string{
					"odScoreAtt:ASC",
					"odScoreDef:ASC",
					"odScoreTotal:ASC",
					"points:ASC",
				},
			},
			expectedErr: domain.ValidationError{
				Model: "ListTribesParams",
				Field: "sort",
				Err: domain.LenOutOfRangeError{
					Min:     1,
					Max:     3,
					Current: 4,
				},
			},
		},
		{
			name: "ERR: custom params + len(sort) > 2",
			newParams: func(t *testing.T) domain.ListTribesParams {
				t.Helper()
				params := domain.NewListTribesParams()
				require.NoError(t, params.SetSort([]domain.TribeSort{domain.TribeSortIDASC}))
				return params
			},
			args: args{
				sort: []string{
					"odScoreAtt:ASC",
					"odScoreDef:ASC",
					"odScoreTotal:ASC",
				},
			},
			expectedErr: domain.ValidationError{
				Model: "ListTribesParams",
				Field: "sort",
				Err: domain.LenOutOfRangeError{
					Min:     1,
					Max:     2,
					Current: 3,
				},
			},
		},
		{
			name:      "ERR: unsupported sort string",
			newParams: defaultNewParams,
			args: args{
				sort: []string{
					"odScoreAtt:ASC",
					"odScoreDef:ASC",
					"odScoreTotal:",
				},
			},
			expectedErr: domain.SliceElementValidationError{
				Model: "ListTribesParams",
				Field: "sort",
				Index: 2,
				Err: domain.UnsupportedSortStringError{
					Sort: "odScoreTotal:",
				},
			},
		},
		{
			name: "ERR: conflict",
			args: args{
				sort: []string{
					"odScoreAtt:ASC",
					"odScoreAtt:DESC",
				},
			},
			expectedErr: domain.ValidationError{
				Model: "ListTribesParams",
				Field: "sort",
				Err: domain.SortConflictError{
					Sort: [2]string{domain.TribeSortODScoreAttASC.String(), domain.TribeSortODScoreAttDESC.String()},
				},
			},
		},
	}

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

			newParams := defaultNewParams
			if tt.newParams != nil {
				newParams = tt.newParams
			}
			params := newParams(t)

			require.ErrorIs(t, params.PrependSortString(tt.args.sort), tt.expectedErr)
			if tt.expectedErr != nil {
				return
			}
			assert.Equal(t, tt.expectedSort, params.Sort())
		})
	}
}

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

	validCursor := domaintest.NewTribeCursor(t)

	type args struct {
		cursor string
	}

	tests := []struct {
		name           string
		args           args
		expectedCursor domain.TribeCursor
		expectedErr    error
	}{
		{
			name: "OK",
			args: args{
				cursor: validCursor.Encode(),
			},
			expectedCursor: validCursor,
		},
		{
			name: "ERR: len(cursor) < 1",
			args: args{
				cursor: "",
			},
			expectedErr: domain.ValidationError{
				Model: "ListTribesParams",
				Field: "cursor",
				Err: domain.LenOutOfRangeError{
					Min:     1,
					Max:     1000,
					Current: 0,
				},
			},
		},
		{
			name: "ERR: len(cursor) > 1000",
			args: args{
				cursor: gofakeit.LetterN(1001),
			},
			expectedErr: domain.ValidationError{
				Model: "ListTribesParams",
				Field: "cursor",
				Err: domain.LenOutOfRangeError{
					Min:     1,
					Max:     1000,
					Current: 1001,
				},
			},
		},
		{
			name: "ERR: malformed base64",
			args: args{
				cursor: "112345",
			},
			expectedErr: domain.ValidationError{
				Model: "ListTribesParams",
				Field: "cursor",
				Err:   domain.ErrInvalidCursor,
			},
		},
	}

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

			params := domain.NewListTribesParams()

			require.ErrorIs(t, params.SetEncodedCursor(tt.args.cursor), tt.expectedErr)
			if tt.expectedErr != nil {
				return
			}
			assert.Equal(t, tt.expectedCursor, params.Cursor())
			assert.Equal(t, tt.args.cursor, params.Cursor().Encode())
		})
	}
}

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

	type args struct {
		limit int
	}

	tests := []struct {
		name        string
		args        args
		expectedErr error
	}{
		{
			name: "OK",
			args: args{
				limit: domain.TribeListMaxLimit,
			},
		},
		{
			name: "ERR: limit < 1",
			args: args{
				limit: 0,
			},
			expectedErr: domain.ValidationError{
				Model: "ListTribesParams",
				Field: "limit",
				Err: domain.MinGreaterEqualError{
					Min:     1,
					Current: 0,
				},
			},
		},
		{
			name: fmt.Sprintf("ERR: limit > %d", domain.TribeListMaxLimit),
			args: args{
				limit: domain.TribeListMaxLimit + 1,
			},
			expectedErr: domain.ValidationError{
				Model: "ListTribesParams",
				Field: "limit",
				Err: domain.MaxLessEqualError{
					Max:     domain.TribeListMaxLimit,
					Current: domain.TribeListMaxLimit + 1,
				},
			},
		},
	}

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

			params := domain.NewListTribesParams()

			require.ErrorIs(t, params.SetLimit(tt.args.limit), tt.expectedErr)
			if tt.expectedErr != nil {
				return
			}
			assert.Equal(t, tt.args.limit, params.Limit())
		})
	}
}

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

	tribes := domain.Tribes{
		domaintest.NewTribe(t),
		domaintest.NewTribe(t),
		domaintest.NewTribe(t),
	}
	next := domaintest.NewTribe(t)

	t.Run("OK: with next", func(t *testing.T) {
		t.Parallel()

		res, err := domain.NewListTribesResult(tribes, next)
		require.NoError(t, err)
		assert.Equal(t, tribes, res.Tribes())
		assert.Equal(t, tribes[0].ID(), res.Self().ID())
		assert.Equal(t, tribes[0].ServerKey(), res.Self().ServerKey())
		assert.Equal(t, next.ID(), res.Next().ID())
		assert.Equal(t, next.ServerKey(), res.Next().ServerKey())
	})

	t.Run("OK: without next", func(t *testing.T) {
		t.Parallel()

		res, err := domain.NewListTribesResult(tribes, domain.Tribe{})
		require.NoError(t, err)
		assert.Equal(t, tribes, res.Tribes())
		assert.Equal(t, tribes[0].ID(), res.Self().ID())
		assert.Equal(t, tribes[0].ServerKey(), res.Self().ServerKey())
		assert.True(t, res.Next().IsZero())
	})

	t.Run("OK: 0 tribes", func(t *testing.T) {
		t.Parallel()

		res, err := domain.NewListTribesResult(nil, domain.Tribe{})
		require.NoError(t, err)
		assert.Zero(t, res.Tribes())
		assert.True(t, res.Self().IsZero())
		assert.True(t, res.Next().IsZero())
	})
}