package adapter_test

import (
	"cmp"
	"context"
	"fmt"
	"net/url"
	"slices"
	"testing"

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

func testServerRepository(t *testing.T, newRepos func(t *testing.T) repositories) {
	t.Helper()

	ctx := context.Background()

	t.Run("CreateOrUpdate", func(t *testing.T) {
		t.Parallel()

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

			repos := newRepos(t)

			versions, err := repos.version.List(ctx, domain.NewListVersionsParams())
			require.NoError(t, err)
			require.NotEmpty(t, versions)
			version := versions[0]

			serversToCreate := domain.BaseServers{
				domaintest.NewBaseServer(t),
				domaintest.NewBaseServer(t),
			}

			createParams, err := domain.NewCreateServerParams(serversToCreate, version.Code())
			require.NoError(t, err)

			require.NoError(t, repos.server.CreateOrUpdate(ctx, createParams...))

			keys := make([]string, 0, len(serversToCreate))
			for _, s := range serversToCreate {
				keys = append(keys, s.Key())
			}

			listCreatedServersParams := domain.NewListServersParams()
			require.NoError(t, listCreatedServersParams.SetKeys(keys))

			createdServers, err := repos.server.List(ctx, listCreatedServersParams)
			require.NoError(t, err)
			require.Len(t, createdServers, len(serversToCreate))
			for _, base := range serversToCreate {
				assert.True(t, slices.ContainsFunc(createdServers, func(server domain.Server) bool {
					return server.Key() == base.Key() &&
						server.Open() == base.Open() &&
						server.URL().String() == base.URL().String() &&
						server.VersionCode() == version.Code()
				}))
			}

			serversToUpdate := domain.BaseServers{
				domaintest.NewBaseServer(t, func(cfg *domaintest.BaseServerConfig) {
					cfg.Key = serversToCreate[0].Key()
					cfg.URL = randURL(t)
					cfg.Open = !serversToCreate[0].Open()
				}),
			}

			updateParams, err := domain.NewCreateServerParams(serversToUpdate, version.Code())
			require.NoError(t, err)

			require.NoError(t, repos.server.CreateOrUpdate(ctx, updateParams...))

			keys = make([]string, 0, len(serversToUpdate))
			for _, s := range serversToUpdate {
				keys = append(keys, s.Key())
			}

			listUpdatedServersParams := domain.NewListServersParams()
			require.NoError(t, listUpdatedServersParams.SetKeys(keys))

			updatedServers, err := repos.server.List(ctx, listUpdatedServersParams)
			require.NoError(t, err)
			require.Len(t, updatedServers, len(serversToUpdate))
			for _, base := range serversToUpdate {
				assert.True(t, slices.ContainsFunc(updatedServers, func(server domain.Server) bool {
					return server.Key() == base.Key() &&
						server.Open() == base.Open() &&
						server.URL().String() == base.URL().String() &&
						server.VersionCode() == version.Code()
				}))
			}
		})
	})

	t.Run("List & ListCount", func(t *testing.T) {
		t.Parallel()

		repos := newRepos(t)

		servers, listServersErr := repos.server.List(ctx, domain.NewListServersParams())
		require.NoError(t, listServersErr)
		require.NotEmpty(t, servers)
		randServer := servers[0]

		tests := []struct {
			name          string
			params        func(t *testing.T) domain.ListServersParams
			assertServers func(t *testing.T, params domain.ListServersParams, servers domain.Servers)
			assertError   func(t *testing.T, err error)
			assertTotal   func(t *testing.T, params domain.ListServersParams, total int)
		}{
			{
				name: "OK: default params",
				params: func(t *testing.T) domain.ListServersParams {
					t.Helper()
					return domain.NewListServersParams()
				},
				assertServers: func(t *testing.T, params domain.ListServersParams, servers domain.Servers) {
					t.Helper()
					assert.NotEmpty(t, len(servers))
					assert.True(t, slices.IsSortedFunc(servers, func(a, b domain.Server) int {
						return cmp.Compare(a.Key(), b.Key())
					}))
				},
				assertError: func(t *testing.T, err error) {
					t.Helper()
					require.NoError(t, err)
				},
				assertTotal: func(t *testing.T, params domain.ListServersParams, total int) {
					t.Helper()
					assert.NotEmpty(t, total)
				},
			},
			{
				name: "OK: sort=[open ASC, key ASC]",
				params: func(t *testing.T) domain.ListServersParams {
					t.Helper()
					params := domain.NewListServersParams()
					require.NoError(t, params.SetSort([]domain.ServerSort{domain.ServerSortOpenASC, domain.ServerSortKeyASC}))
					return params
				},
				assertServers: func(t *testing.T, params domain.ListServersParams, servers domain.Servers) {
					t.Helper()
					assert.NotEmpty(t, len(servers))
					assert.True(t, slices.IsSortedFunc(servers, func(a, b domain.Server) int {
						if a.Open() && !b.Open() {
							return 1
						}

						if !a.Open() && b.Open() {
							return -1
						}

						return cmp.Compare(a.Key(), b.Key())
					}))
				},
				assertError: func(t *testing.T, err error) {
					t.Helper()
					require.NoError(t, err)
				},
				assertTotal: func(t *testing.T, params domain.ListServersParams, total int) {
					t.Helper()
					assert.NotEmpty(t, total)
				},
			},
			{
				name: "OK: sort=[open DESC, key DESC]",
				params: func(t *testing.T) domain.ListServersParams {
					t.Helper()
					params := domain.NewListServersParams()
					require.NoError(t, params.SetSort([]domain.ServerSort{domain.ServerSortOpenDESC, domain.ServerSortKeyDESC}))
					return params
				},
				assertServers: func(t *testing.T, params domain.ListServersParams, servers domain.Servers) {
					t.Helper()
					assert.NotEmpty(t, len(servers))
					assert.True(t, slices.IsSortedFunc(servers, func(a, b domain.Server) int {
						if a.Open() && !b.Open() {
							return -1
						}

						if !a.Open() && b.Open() {
							return 1
						}

						return cmp.Compare(a.Key(), b.Key()) * -1
					}))
				},
				assertError: func(t *testing.T, err error) {
					t.Helper()
					require.NoError(t, err)
				},
				assertTotal: func(t *testing.T, params domain.ListServersParams, total int) {
					t.Helper()
					assert.NotEmpty(t, total)
				},
			},
			{
				name: fmt.Sprintf("OK: keys=[%s]", randServer.Key()),
				params: func(t *testing.T) domain.ListServersParams {
					t.Helper()
					params := domain.NewListServersParams()
					require.NoError(t, params.SetKeys([]string{randServer.Key()}))
					return params
				},
				assertServers: func(t *testing.T, params domain.ListServersParams, servers domain.Servers) {
					t.Helper()

					keys := params.Keys()

					assert.Len(t, servers, len(keys))
					for _, k := range keys {
						assert.True(t, slices.ContainsFunc(servers, func(server domain.Server) bool {
							return server.Key() == k
						}), k)
					}
				},
				assertError: func(t *testing.T, err error) {
					t.Helper()
					require.NoError(t, err)
				},
				assertTotal: func(t *testing.T, params domain.ListServersParams, total int) {
					t.Helper()
					assert.Equal(t, len(params.Keys()), total) //nolint:testifylint
				},
			},
			{
				name: fmt.Sprintf("OK: version code=[%s]", randServer.VersionCode()),
				params: func(t *testing.T) domain.ListServersParams {
					t.Helper()
					params := domain.NewListServersParams()
					require.NoError(t, params.SetVersionCodes([]string{randServer.VersionCode()}))
					return params
				},
				assertServers: func(t *testing.T, params domain.ListServersParams, servers domain.Servers) {
					t.Helper()

					versionCodes := params.VersionCodes()

					assert.NotEmpty(t, servers)
					for _, c := range versionCodes {
						assert.True(t, slices.ContainsFunc(servers, func(server domain.Server) bool {
							return server.VersionCode() == c
						}), c)
					}
				},
				assertError: func(t *testing.T, err error) {
					t.Helper()
					require.NoError(t, err)
				},
				assertTotal: func(t *testing.T, params domain.ListServersParams, total int) {
					t.Helper()
					assert.Equal(t, len(params.Keys()), total) //nolint:testifylint
				},
			},
			{
				name: fmt.Sprintf("OK: keyGT=%s", randServer.Key()),
				params: func(t *testing.T) domain.ListServersParams {
					t.Helper()
					params := domain.NewListServersParams()
					require.NoError(t, params.SetKeyGT(domain.NullString{
						Value: randServer.Key(),
						Valid: true,
					}))
					return params
				},
				assertServers: func(t *testing.T, params domain.ListServersParams, servers domain.Servers) {
					t.Helper()
					assert.NotEmpty(t, len(servers))
					for _, s := range servers {
						assert.Greater(t, s.Key(), params.KeyGT().Value, s.Key())
					}
				},
				assertError: func(t *testing.T, err error) {
					t.Helper()
					require.NoError(t, err)
				},
				assertTotal: func(t *testing.T, params domain.ListServersParams, total int) {
					t.Helper()
					assert.NotEmpty(t, total)
				},
			},
			{
				name: "OK: special=true",
				params: func(t *testing.T) domain.ListServersParams {
					t.Helper()
					params := domain.NewListServersParams()
					require.NoError(t, params.SetSpecial(domain.NullBool{
						Value: true,
						Valid: true,
					}))
					return params
				},
				assertServers: func(t *testing.T, params domain.ListServersParams, servers domain.Servers) {
					t.Helper()
					assert.NotEmpty(t, len(servers))
					for _, s := range servers {
						assert.True(t, s.Special(), s.Key())
					}
				},
				assertError: func(t *testing.T, err error) {
					t.Helper()
					require.NoError(t, err)
				},
				assertTotal: func(t *testing.T, params domain.ListServersParams, total int) {
					t.Helper()
					assert.NotEmpty(t, total)
				},
			},
			{
				name: "OK: open=false",
				params: func(t *testing.T) domain.ListServersParams {
					t.Helper()
					params := domain.NewListServersParams()
					require.NoError(t, params.SetOpen(domain.NullBool{
						Value: false,
						Valid: true,
					}))
					return params
				},
				assertServers: func(t *testing.T, params domain.ListServersParams, servers domain.Servers) {
					t.Helper()
					assert.NotEmpty(t, len(servers))
					for _, s := range servers {
						assert.False(t, s.Open(), s.Key())
					}
				},
				assertError: func(t *testing.T, err error) {
					t.Helper()
					require.NoError(t, err)
				},
				assertTotal: func(t *testing.T, params domain.ListServersParams, total int) {
					t.Helper()
					assert.NotEmpty(t, total)
				},
			},
			{
				name: "OK: offset=1 limit=2",
				params: func(t *testing.T) domain.ListServersParams {
					t.Helper()
					params := domain.NewListServersParams()
					require.NoError(t, params.SetOffset(1))
					require.NoError(t, params.SetLimit(2))
					return params
				},
				assertServers: func(t *testing.T, params domain.ListServersParams, servers domain.Servers) {
					t.Helper()
					assert.Len(t, servers, params.Limit())
				},
				assertError: func(t *testing.T, err error) {
					t.Helper()
					require.NoError(t, err)
				},
				assertTotal: func(t *testing.T, params domain.ListServersParams, total int) {
					t.Helper()
					assert.NotEmpty(t, total)
				},
			},
		}

		for _, tt := range tests {
			tt := tt

			t.Run(tt.name, func(t *testing.T) {
				t.Parallel()

				params := tt.params(t)

				res, err := repos.server.List(ctx, params)
				tt.assertError(t, err)
				tt.assertServers(t, params, res)
			})
		}
	})

	t.Run("Update", func(t *testing.T) {
		t.Parallel()

		repos := newRepos(t)

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

			listServersBeforeUpdateParams := domain.NewListServersParams()
			require.NoError(t, listServersBeforeUpdateParams.SetLimit(1))

			serversBeforeUpdate, err := repos.server.List(ctx, listServersBeforeUpdateParams)
			require.NoError(t, err)
			require.NotEmpty(t, serversBeforeUpdate)

			var updateParams domain.UpdateServerParams
			require.NoError(t, updateParams.SetConfig(domain.NullServerConfig{
				Value: domaintest.NewServerConfig(t),
				Valid: true,
			}))
			require.NoError(t, updateParams.SetUnitInfo(domain.NullUnitInfo{
				Value: domaintest.NewUnitInfo(t),
				Valid: true,
			}))
			require.NoError(t, updateParams.SetBuildingInfo(domain.NullBuildingInfo{
				Value: domaintest.NewBuildingInfo(t),
				Valid: true,
			}))

			require.NoError(t, repos.server.Update(ctx, serversBeforeUpdate[0].Key(), updateParams))

			listServersAfterUpdateParams := domain.NewListServersParams()
			require.NoError(t, listServersAfterUpdateParams.SetLimit(1))
			require.NoError(t, listServersAfterUpdateParams.SetKeys([]string{serversBeforeUpdate[0].Key()}))

			serversAfterUpdate, err := repos.server.List(ctx, listServersAfterUpdateParams)
			require.NoError(t, err)
			require.NotEmpty(t, serversAfterUpdate)
			assert.Equal(t, updateParams.Config().Value, serversAfterUpdate[0].Config())
			assert.Equal(t, updateParams.UnitInfo().Value, serversAfterUpdate[0].UnitInfo())
			assert.Equal(t, updateParams.BuildingInfo().Value, serversAfterUpdate[0].BuildingInfo())
		})

		t.Run("ERR: not found", func(t *testing.T) {
			t.Parallel()

			var updateParams domain.UpdateServerParams
			require.NoError(t, updateParams.SetConfig(domain.NullServerConfig{
				Value: domaintest.NewServerConfig(t),
				Valid: true,
			}))

			key := domaintest.RandServerKey()

			require.ErrorIs(t, repos.server.Update(ctx, key, updateParams), domain.ServerNotFoundError{
				Key: key,
			})
		})

		t.Run("ERR: nothing to update", func(t *testing.T) {
			t.Parallel()

			key := domaintest.RandServerKey()

			require.Error(t, repos.server.Update(ctx, key, domain.UpdateServerParams{}))
		})
	})
}

func randURL(tb testing.TB) *url.URL {
	tb.Helper()
	u, err := url.Parse("https://" + gofakeit.DomainName())
	require.NoError(tb, err)
	return u
}