package domain_test

import (
	"net/url"
	"slices"
	"testing"

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

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

	type args struct {
		versionCode string
		url         *url.URL
	}

	tests := []struct {
		name        string
		args        args
		expectedErr error
	}{
		{
			name: "OK",
			args: args{
				versionCode: "pl",
				url: &url.URL{
					Scheme: "https",
					Host:   "plemiona.pl",
				},
			},
		},
	}

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

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

			payload, err := domain.NewSyncServersCmdPayload(tt.args.versionCode, tt.args.url)
			require.ErrorIs(t, err, tt.expectedErr)
			if tt.expectedErr != nil {
				return
			}
			assert.Equal(t, tt.args.versionCode, payload.VersionCode())
			assert.Equal(t, tt.args.url, payload.URL())
		})
	}
}

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

	type args struct {
		versionCode string
		url         string
	}

	tests := []struct {
		name        string
		args        args
		expectedErr error
	}{
		{
			name: "OK",
			args: args{
				versionCode: "pl",
				url:         "https://plemiona.pl",
			},
		},
		{
			name: "ERR: invalid url",
			args: args{
				versionCode: "pl",
				url:         "plemiona.pl",
			},
			expectedErr: domain.InvalidURLError{
				URL: "plemiona.pl",
			},
		},
	}

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

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

			payload, err := domain.NewSyncServersCmdPayloadWithStringURL(tt.args.versionCode, tt.args.url)
			require.ErrorIs(t, err, tt.expectedErr)
			if tt.expectedErr != nil {
				return
			}
			assert.Equal(t, tt.args.versionCode, payload.VersionCode())
			assert.Equal(t, tt.args.url, payload.URL().String())
		})
	}
}

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

	server := domaintest.NewServer(t)

	payload, err := domain.NewServerSyncedEventPayload(server.Key(), server.URL().String(), server.VersionCode())
	require.NoError(t, err)
	assert.Equal(t, server.Key(), payload.Key())
	assert.Equal(t, server.URL(), payload.URL())
	assert.Equal(t, server.VersionCode(), payload.VersionCode())
}

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

	versionCode := domaintest.RandVersionCode()
	servers := domain.BaseServers{
		domaintest.NewBaseServer(t),
		domaintest.NewBaseServer(t),
	}

	payloads, err := domain.NewServerSyncedEventPayloads(servers, versionCode)
	require.NoError(t, err)
	for _, s := range servers {
		assert.True(t, slices.ContainsFunc(payloads, func(payload domain.ServerSyncedEventPayload) bool {
			return payload.Key() == s.Key() && payload.VersionCode() == versionCode && payload.URL() == s.URL()
		}))
	}
}