package service_test

import (
	"context"
	"fmt"
	"testing"
	"time"

	"gitea.dwysokinski.me/twhelp/dcbot/internal/domain"
	"gitea.dwysokinski.me/twhelp/dcbot/internal/service"
	"gitea.dwysokinski.me/twhelp/dcbot/internal/service/internal/mock"
	"gitea.dwysokinski.me/twhelp/dcbot/internal/twhelp"
	"github.com/google/uuid"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

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

	params, err := domain.NewCreateGroupParams(
		"592292203234328587",
		"en",
		"en113",
		"1234",
		"1235",
	)
	require.NoError(t, err)

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

		repo := &mock.FakeGroupRepository{}
		repo.CreateCalls(func(_ context.Context, p domain.CreateGroupParams) (domain.Group, error) {
			return domain.Group{
				ID:            uuid.NewString(),
				ServerID:      p.ServerID(),
				ChannelGains:  p.ChannelGains(),
				ChannelLosses: p.ChannelLosses(),
				ServerKey:     p.ServerKey(),
				VersionCode:   p.VersionCode(),
				CreatedAt:     time.Now(),
			}, nil
		})
		repo.ListReturns(nil, nil)

		client := &mock.FakeTWHelpClient{}
		client.GetServerCalls(func(_ context.Context, _ string, server string) (twhelp.Server, error) {
			return twhelp.Server{
				Key:  server,
				URL:  fmt.Sprintf("https://%s.tribalwars.net", server),
				Open: true,
			}, nil
		})

		g, err := service.NewGroup(repo, client).Create(context.Background(), params)
		assert.NoError(t, err)
		assert.NotEmpty(t, g.ID)
		assert.Equal(t, params.ServerID(), g.ServerID)
		assert.Equal(t, params.ServerKey(), g.ServerKey)
		assert.Equal(t, params.VersionCode(), g.VersionCode)
		assert.Equal(t, params.ChannelGains(), g.ChannelGains)
		assert.Equal(t, params.ChannelLosses(), g.ChannelLosses)
		assert.NotEmpty(t, g.CreatedAt)
	})

	t.Run("ERR: group limit has been reached", func(t *testing.T) {
		t.Parallel()

		const maxGroupsPerServer = 10

		repo := &mock.FakeGroupRepository{}
		repo.ListReturns(make([]domain.Group, maxGroupsPerServer), nil)

		g, err := service.NewGroup(repo, nil).Create(context.Background(), params)
		assert.ErrorIs(t, err, domain.GroupLimitReachedError{
			Current: maxGroupsPerServer,
			Limit:   maxGroupsPerServer,
		})
		assert.Zero(t, g)
	})

	t.Run("ERR: server doesn't exist", func(t *testing.T) {
		t.Parallel()

		repo := &mock.FakeGroupRepository{}
		repo.ListReturns(nil, nil)

		client := &mock.FakeTWHelpClient{}
		client.GetServerCalls(func(_ context.Context, _ string, _ string) (twhelp.Server, error) {
			return twhelp.Server{}, twhelp.APIError{
				Code:    twhelp.ErrorCodeEntityNotFound,
				Message: "server not found",
			}
		})

		g, err := service.NewGroup(repo, client).Create(context.Background(), params)
		assert.ErrorIs(t, err, domain.ServerDoesNotExistError{
			VersionCode: params.VersionCode(),
			Key:         params.ServerKey(),
		})
		assert.Zero(t, g)
	})

	t.Run("ERR: server is closed", func(t *testing.T) {
		t.Parallel()

		repo := &mock.FakeGroupRepository{}
		repo.ListReturns(nil, nil)

		client := &mock.FakeTWHelpClient{}
		client.GetServerCalls(func(ctx context.Context, _ string, server string) (twhelp.Server, error) {
			return twhelp.Server{
				Key:  server,
				URL:  fmt.Sprintf("https://%s.tribalwars.net", server),
				Open: false,
			}, nil
		})

		g, err := service.NewGroup(repo, client).Create(context.Background(), params)
		assert.ErrorIs(t, err, domain.ServerIsClosedError{
			VersionCode: params.VersionCode(),
			Key:         params.ServerKey(),
		})
		assert.Zero(t, g)
	})
}

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

	id := uuid.NewString()
	versionCode := "pl"
	serverKey := "pl181"

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

		repo := &mock.FakeGroupRepository{}
		repo.UpdateByIDCalls(func(_ context.Context, id string, p domain.UpdateGroupParams) (domain.Group, error) {
			return domain.Group{
				ID:            id,
				ServerID:      uuid.NewString(),
				ChannelGains:  p.ChannelGains.String,
				ChannelLosses: p.ChannelLosses.String,
				ServerKey:     p.ServerKey.String,
				VersionCode:   p.VersionCode.String,
				CreatedAt:     time.Now(),
			}, nil
		})
		repo.ListReturns(nil, nil)

		client := &mock.FakeTWHelpClient{}
		client.GetServerCalls(func(_ context.Context, _ string, server string) (twhelp.Server, error) {
			return twhelp.Server{
				Key:  server,
				URL:  fmt.Sprintf("https://%s.tribalwars.net", server),
				Open: true,
			}, nil
		})

		g, err := service.NewGroup(repo, client).SetTWServer(context.Background(), id, versionCode, serverKey)
		assert.NoError(t, err)
		assert.Equal(t, id, g.ID)
		assert.Equal(t, serverKey, g.ServerKey)
		assert.Equal(t, versionCode, g.VersionCode)
	})

	t.Run("ERR: server doesn't exist", func(t *testing.T) {
		t.Parallel()

		client := &mock.FakeTWHelpClient{}
		client.GetServerCalls(func(_ context.Context, _ string, _ string) (twhelp.Server, error) {
			return twhelp.Server{}, twhelp.APIError{
				Code:    twhelp.ErrorCodeEntityNotFound,
				Message: "server not found",
			}
		})

		g, err := service.NewGroup(nil, client).SetTWServer(context.Background(), id, versionCode, serverKey)
		assert.ErrorIs(t, err, domain.ServerDoesNotExistError{
			VersionCode: versionCode,
			Key:         serverKey,
		})
		assert.Zero(t, g)
	})

	t.Run("ERR: server is closed", func(t *testing.T) {
		t.Parallel()

		client := &mock.FakeTWHelpClient{}
		client.GetServerCalls(func(ctx context.Context, _ string, server string) (twhelp.Server, error) {
			return twhelp.Server{
				Key:  server,
				URL:  fmt.Sprintf("https://%s.tribalwars.net", server),
				Open: false,
			}, nil
		})

		g, err := service.NewGroup(nil, client).SetTWServer(context.Background(), id, versionCode, serverKey)
		assert.ErrorIs(t, err, domain.ServerIsClosedError{
			VersionCode: versionCode,
			Key:         serverKey,
		})
		assert.Zero(t, g)
	})
}