package domain_test

import (
	"testing"

	"gitea.dwysokinski.me/twhelp/dcbot/internal/domain"
	"github.com/google/uuid"
	"github.com/stretchr/testify/assert"
	"golang.org/x/text/language"
)

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

	assert.True(t, domain.GroupWithMonitors{
		Group: domain.Group{
			ChannelGains: uuid.NewString(),
		},
		Monitors: []domain.Monitor{
			{
				TribeID: 125,
			},
			{
				TribeID: 150,
			},
		},
	}.CanSendEnnoblementNotificationTypeGain(domain.Ennoblement{
		NewOwner: domain.PlayerMeta{
			ID: 125,
			Tribe: domain.NullTribeMeta{
				Tribe: domain.TribeMeta{
					ID: 150,
				},
				Valid: true,
			},
		},
		Village: domain.VillageMeta{
			Player: domain.NullPlayerMeta{
				Player: domain.PlayerMeta{
					ID: 130,
					Tribe: domain.NullTribeMeta{
						Tribe: domain.TribeMeta{
							ID: 151,
						},
						Valid: true,
					},
				},
				Valid: true,
			},
		},
	}))

	assert.False(t, domain.GroupWithMonitors{ // ChannelGains == ""
		Monitors: []domain.Monitor{
			{
				TribeID: 125,
			},
			{
				TribeID: 150,
			},
		},
	}.CanSendEnnoblementNotificationTypeGain(domain.Ennoblement{
		NewOwner: domain.PlayerMeta{
			ID: 125,
			Tribe: domain.NullTribeMeta{
				Tribe: domain.TribeMeta{
					ID: 150,
				},
				Valid: true,
			},
		},
		Village: domain.VillageMeta{
			Player: domain.NullPlayerMeta{
				Player: domain.PlayerMeta{
					ID: 130,
					Tribe: domain.NullTribeMeta{
						Tribe: domain.TribeMeta{
							ID: 151,
						},
						Valid: true,
					},
				},
				Valid: true,
			},
		},
	}))

	assert.True(t, domain.GroupWithMonitors{ // Barbarians=true
		Group: domain.Group{
			ChannelGains: uuid.NewString(),
			Barbarians:   true,
		},
		Monitors: []domain.Monitor{
			{
				TribeID: 125,
			},
			{
				TribeID: 150,
			},
		},
	}.CanSendEnnoblementNotificationTypeGain(domain.Ennoblement{
		NewOwner: domain.PlayerMeta{
			ID: 125,
			Tribe: domain.NullTribeMeta{
				Tribe: domain.TribeMeta{
					ID: 150,
				},
				Valid: true,
			},
		},
	}))

	assert.False(t, domain.GroupWithMonitors{ // Barbarians=false
		Group: domain.Group{
			ChannelGains: uuid.NewString(),
		},
		Monitors: []domain.Monitor{
			{
				TribeID: 125,
			},
			{
				TribeID: 150,
			},
		},
	}.CanSendEnnoblementNotificationTypeGain(domain.Ennoblement{
		NewOwner: domain.PlayerMeta{
			ID: 125,
			Tribe: domain.NullTribeMeta{
				Tribe: domain.TribeMeta{
					ID: 150,
				},
				Valid: true,
			},
		},
	}))

	assert.True(t, domain.GroupWithMonitors{ // Internals=true
		Group: domain.Group{
			ChannelGains: uuid.NewString(),
			Internals:    true,
		},
		Monitors: []domain.Monitor{
			{
				TribeID: 151,
			},
			{
				TribeID: 150,
			},
		},
	}.CanSendEnnoblementNotificationTypeGain(domain.Ennoblement{
		NewOwner: domain.PlayerMeta{
			ID: 125,
			Tribe: domain.NullTribeMeta{
				Tribe: domain.TribeMeta{
					ID: 150,
				},
				Valid: true,
			},
		},
		Village: domain.VillageMeta{
			Player: domain.NullPlayerMeta{
				Player: domain.PlayerMeta{
					ID: 130,
					Tribe: domain.NullTribeMeta{
						Tribe: domain.TribeMeta{
							ID: 151,
						},
						Valid: true,
					},
				},
				Valid: true,
			},
		},
	}))

	assert.False(t, domain.GroupWithMonitors{ // Internals=false
		Group: domain.Group{
			ChannelGains: uuid.NewString(),
		},
		Monitors: []domain.Monitor{
			{
				TribeID: 151,
			},
			{
				TribeID: 150,
			},
		},
	}.CanSendEnnoblementNotificationTypeGain(domain.Ennoblement{
		NewOwner: domain.PlayerMeta{
			ID: 125,
			Tribe: domain.NullTribeMeta{
				Tribe: domain.TribeMeta{
					ID: 150,
				},
				Valid: true,
			},
		},
		Village: domain.VillageMeta{
			Player: domain.NullPlayerMeta{
				Player: domain.PlayerMeta{
					ID: 130,
					Tribe: domain.NullTribeMeta{
						Tribe: domain.TribeMeta{
							ID: 151,
						},
						Valid: true,
					},
				},
				Valid: true,
			},
		},
	}))
}

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

	assert.True(t, domain.GroupWithMonitors{
		Group: domain.Group{
			ChannelLosses: uuid.NewString(),
		},
		Monitors: []domain.Monitor{
			{
				TribeID: 125,
			},
			{
				TribeID: 151,
			},
		},
	}.CanSendEnnoblementNotificationTypeLoss(domain.Ennoblement{
		NewOwner: domain.PlayerMeta{
			ID: 125,
			Tribe: domain.NullTribeMeta{
				Tribe: domain.TribeMeta{
					ID: 150,
				},
				Valid: true,
			},
		},
		Village: domain.VillageMeta{
			Player: domain.NullPlayerMeta{
				Player: domain.PlayerMeta{
					ID: 130,
					Tribe: domain.NullTribeMeta{
						Tribe: domain.TribeMeta{
							ID: 151,
						},
						Valid: true,
					},
				},
				Valid: true,
			},
		},
	}))

	assert.False(t, domain.GroupWithMonitors{ // ChannelLosses == ""
		Monitors: []domain.Monitor{
			{
				TribeID: 125,
			},
			{
				TribeID: 151,
			},
		},
	}.CanSendEnnoblementNotificationTypeLoss(domain.Ennoblement{
		NewOwner: domain.PlayerMeta{
			ID: 125,
			Tribe: domain.NullTribeMeta{
				Tribe: domain.TribeMeta{
					ID: 150,
				},
				Valid: true,
			},
		},
		Village: domain.VillageMeta{
			Player: domain.NullPlayerMeta{
				Player: domain.PlayerMeta{
					ID: 130,
					Tribe: domain.NullTribeMeta{
						Tribe: domain.TribeMeta{
							ID: 151,
						},
						Valid: true,
					},
				},
				Valid: true,
			},
		},
	}))

	assert.False(t, domain.GroupWithMonitors{ // Internal
		Group: domain.Group{
			ChannelLosses: uuid.NewString(),
		},
		Monitors: []domain.Monitor{
			{
				TribeID: 150,
			},
			{
				TribeID: 151,
			},
		},
	}.CanSendEnnoblementNotificationTypeLoss(domain.Ennoblement{
		NewOwner: domain.PlayerMeta{
			ID: 125,
			Tribe: domain.NullTribeMeta{
				Tribe: domain.TribeMeta{
					ID: 150,
				},
				Valid: true,
			},
		},
		Village: domain.VillageMeta{
			Player: domain.NullPlayerMeta{
				Player: domain.PlayerMeta{
					ID: 130,
					Tribe: domain.NullTribeMeta{
						Tribe: domain.TribeMeta{
							ID: 151,
						},
						Valid: true,
					},
				},
				Valid: true,
			},
		},
	}))
}

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

	assert.True(t, domain.GroupWithMonitors{
		Monitors: []domain.Monitor{
			{
				TribeID: 125,
			},
			{
				TribeID: 150,
			},
		},
	}.IsGain(domain.Ennoblement{
		NewOwner: domain.PlayerMeta{
			ID: 125,
			Tribe: domain.NullTribeMeta{
				Tribe: domain.TribeMeta{
					ID: 150,
				},
				Valid: true,
			},
		},
	}))

	assert.False(t, domain.GroupWithMonitors{ // self conquer
		Monitors: []domain.Monitor{
			{
				TribeID: 125,
			},
			{
				TribeID: 150,
			},
		},
	}.IsGain(domain.Ennoblement{
		NewOwner: domain.PlayerMeta{
			ID: 125,
			Tribe: domain.NullTribeMeta{
				Tribe: domain.TribeMeta{
					ID: 150,
				},
				Valid: true,
			},
		},
		Village: domain.VillageMeta{
			Player: domain.NullPlayerMeta{
				Player: domain.PlayerMeta{
					ID: 125,
					Tribe: domain.NullTribeMeta{
						Tribe: domain.TribeMeta{
							ID: 150,
						},
						Valid: true,
					},
				},
				Valid: true,
			},
		},
	}))

	assert.False(t, domain.GroupWithMonitors{
		Monitors: []domain.Monitor{
			{
				TribeID: 125,
			},
			{
				TribeID: 151,
			},
		},
	}.IsGain(domain.Ennoblement{
		NewOwner: domain.PlayerMeta{
			Tribe: domain.NullTribeMeta{
				Tribe: domain.TribeMeta{
					ID: 150,
				},
				Valid: true,
			},
		},
	}))

	assert.False(t, domain.GroupWithMonitors{
		Monitors: []domain.Monitor{
			{
				TribeID: 125,
			},
			{
				TribeID: 151,
			},
		},
	}.IsGain(domain.Ennoblement{}))
}

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

	assert.True(t, domain.GroupWithMonitors{
		Monitors: []domain.Monitor{
			{
				TribeID: 125,
			},
			{
				TribeID: 150,
			},
		},
	}.IsLoss(domain.Ennoblement{
		Village: domain.VillageMeta{
			Player: domain.NullPlayerMeta{
				Player: domain.PlayerMeta{
					ID: 125,
					Tribe: domain.NullTribeMeta{
						Tribe: domain.TribeMeta{
							ID: 150,
						},
						Valid: true,
					},
				},
				Valid: true,
			},
		},
	}))

	assert.False(t, domain.GroupWithMonitors{ // self conquer
		Monitors: []domain.Monitor{
			{
				TribeID: 125,
			},
			{
				TribeID: 150,
			},
		},
	}.IsLoss(domain.Ennoblement{
		NewOwner: domain.PlayerMeta{
			ID: 125,
			Tribe: domain.NullTribeMeta{
				Tribe: domain.TribeMeta{
					ID: 150,
				},
				Valid: true,
			},
		},
		Village: domain.VillageMeta{
			Player: domain.NullPlayerMeta{
				Player: domain.PlayerMeta{
					ID: 125,
					Tribe: domain.NullTribeMeta{
						Tribe: domain.TribeMeta{
							ID: 150,
						},
						Valid: true,
					},
				},
				Valid: true,
			},
		},
	}))

	assert.False(t, domain.GroupWithMonitors{
		Monitors: []domain.Monitor{
			{
				TribeID: 125,
			},
			{
				TribeID: 151,
			},
		},
	}.IsLoss(domain.Ennoblement{
		Village: domain.VillageMeta{
			Player: domain.NullPlayerMeta{
				Player: domain.PlayerMeta{
					ID: 125,
					Tribe: domain.NullTribeMeta{
						Tribe: domain.TribeMeta{
							ID: 150,
						},
						Valid: true,
					},
				},
				Valid: true,
			},
		},
	}))

	assert.False(t, domain.GroupWithMonitors{
		Monitors: []domain.Monitor{
			{
				TribeID: 125,
			},
			{
				TribeID: 151,
			},
		},
	}.IsLoss(domain.Ennoblement{}))
}

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

	assert.True(t, domain.GroupWithMonitors{
		Monitors: []domain.Monitor{
			{
				TribeID: 125,
			},
			{
				TribeID: 150,
			},
		},
	}.IsInternal(domain.Ennoblement{
		NewOwner: domain.PlayerMeta{
			ID: 125,
			Tribe: domain.NullTribeMeta{
				Tribe: domain.TribeMeta{
					ID: 150,
				},
				Valid: true,
			},
		},
		Village: domain.VillageMeta{
			Player: domain.NullPlayerMeta{
				Player: domain.PlayerMeta{
					ID: 125,
					Tribe: domain.NullTribeMeta{
						Tribe: domain.TribeMeta{
							ID: 125,
						},
						Valid: true,
					},
				},
				Valid: true,
			},
		},
	}))

	assert.True(t, domain.GroupWithMonitors{
		Monitors: []domain.Monitor{
			{
				TribeID: 125,
			},
			{
				TribeID: 150,
			},
		},
	}.IsInternal(domain.Ennoblement{
		NewOwner: domain.PlayerMeta{
			ID: 125,
			Tribe: domain.NullTribeMeta{
				Tribe: domain.TribeMeta{
					ID: 150,
				},
				Valid: true,
			},
		},
		Village: domain.VillageMeta{
			Player: domain.NullPlayerMeta{
				Player: domain.PlayerMeta{
					ID: 125,
					Tribe: domain.NullTribeMeta{
						Tribe: domain.TribeMeta{
							ID: 150,
						},
						Valid: true,
					},
				},
				Valid: true,
			},
		},
	}))

	assert.False(t, domain.GroupWithMonitors{
		Monitors: []domain.Monitor{
			{
				TribeID: 125,
			},
			{
				TribeID: 150,
			},
		},
	}.IsInternal(domain.Ennoblement{
		NewOwner: domain.PlayerMeta{
			ID: 125,
			Tribe: domain.NullTribeMeta{
				Tribe: domain.TribeMeta{
					ID: 150,
				},
				Valid: true,
			},
		},
	}))

	assert.False(t, domain.GroupWithMonitors{
		Monitors: []domain.Monitor{
			{
				TribeID: 125,
			},
			{
				TribeID: 150,
			},
		},
	}.IsInternal(domain.Ennoblement{
		Village: domain.VillageMeta{
			Player: domain.NullPlayerMeta{
				Player: domain.PlayerMeta{
					ID: 125,
					Tribe: domain.NullTribeMeta{
						Tribe: domain.TribeMeta{
							ID: 150,
						},
						Valid: true,
					},
				},
				Valid: true,
			},
		},
	}))
}

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

	tests := []struct {
		name          string
		serverID      string
		versionCode   string
		serverKey     string
		languageTag   string
		channelGains  string
		channelLosses string
		barbarians    bool
		internals     bool
		err           error
	}{
		{
			name:          "OK",
			serverID:      "123441",
			versionCode:   "en",
			serverKey:     "en113",
			languageTag:   language.English.String(),
			channelGains:  "1234",
			channelLosses: "1234",
			barbarians:    true,
			internals:     true,
			err:           nil,
		},
		{
			name:        "ERR: ServerID cannot be blank",
			versionCode: "",
			serverID:    "",
			err:         domain.RequiredError{Field: "ServerID"},
		},
		{
			name:        "ERR: VersionCode cannot be blank",
			serverID:    "1234",
			versionCode: "",
			err:         domain.RequiredError{Field: "VersionCode"},
		},
		{
			name:        "ERR: ServerKey cannot be blank",
			serverID:    "1234",
			versionCode: "en",
			serverKey:   "",
			err:         domain.RequiredError{Field: "ServerKey"},
		},
		{
			name:        "ERR: LanguageTag cannot be blank",
			serverID:    "1234",
			versionCode: "en",
			serverKey:   "en113",
			languageTag: "",
			err:         domain.RequiredError{Field: "LanguageTag"},
		},
	}

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

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

			res, err := domain.NewCreateGroupParams(
				tt.serverID,
				tt.versionCode,
				tt.serverKey,
				tt.languageTag,
				tt.channelGains,
				tt.channelLosses,
				tt.barbarians,
				tt.internals,
			)
			if tt.err != nil {
				assert.ErrorIs(t, err, tt.err)
				assert.Zero(t, res)
				return
			}
			assert.NoError(t, err)
			assert.Equal(t, tt.serverID, res.ServerID())
			assert.Equal(t, tt.serverKey, res.ServerKey())
			assert.Equal(t, tt.versionCode, res.VersionCode())
			assert.Equal(t, tt.channelGains, res.ChannelGains())
			assert.Equal(t, tt.channelLosses, res.ChannelLosses())
			assert.Equal(t, tt.barbarians, res.Barbarians())
			assert.Equal(t, tt.internals, res.Internals())
		})
	}
}

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

	tests := []struct {
		name   string
		params domain.UpdateGroupParams
		output bool
	}{
		{
			name: "OK: ChannelGains",
			params: domain.UpdateGroupParams{
				ChannelGains: domain.NullString{
					String: "123",
					Valid:  true,
				},
			},
			output: false,
		},
		{
			name: "OK: ChannelLosses",
			params: domain.UpdateGroupParams{
				ChannelLosses: domain.NullString{
					String: "123",
					Valid:  true,
				},
			},
			output: false,
		},
		{
			name: "OK: Barbarians",
			params: domain.UpdateGroupParams{
				Barbarians: domain.NullBool{
					Bool:  false,
					Valid: true,
				},
			},
			output: false,
		},
		{
			name: "OK: Internals",
			params: domain.UpdateGroupParams{
				Internals: domain.NullBool{
					Bool:  false,
					Valid: true,
				},
			},
			output: false,
		},
		{
			name: "OK: LanguageTag",
			params: domain.UpdateGroupParams{
				LanguageTag: domain.NullString{
					String: language.English.String(),
					Valid:  true,
				},
			},
			output: false,
		},
		{
			name:   "OK: empty struct",
			params: domain.UpdateGroupParams{},
			output: true,
		},
	}

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

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

			assert.Equal(t, tt.output, tt.params.IsZero())
		})
	}
}