// Copyright 2017 The Gitea Authors. All rights reserved.
// SPDX-License-Identifier: MIT

package user_test

import (
	"slices"
	"testing"

	"gitea.dev/models/db"
	"gitea.dev/models/unittest"
	user_model "gitea.dev/models/user"
	"gitea.dev/modules/optional"

	"github.com/stretchr/testify/assert"
)

func TestGetEmailAddresses(t *testing.T) {
	assert.NoError(t, unittest.PrepareTestDatabase())

	emails, _ := user_model.GetEmailAddresses(t.Context(), int64(1))
	if assert.Len(t, emails, 3) {
		assert.True(t, emails[0].IsPrimary)
		assert.True(t, emails[2].IsActivated)
		assert.False(t, emails[2].IsPrimary)
	}

	emails, _ = user_model.GetEmailAddresses(t.Context(), int64(2))
	if assert.Len(t, emails, 2) {
		assert.True(t, emails[0].IsPrimary)
		assert.True(t, emails[0].IsActivated)
	}
}

func TestIsEmailUsed(t *testing.T) {
	assert.NoError(t, unittest.PrepareTestDatabase())

	isExist, _ := user_model.IsEmailUsed(t.Context(), "")
	assert.True(t, isExist)
	isExist, _ = user_model.IsEmailUsed(t.Context(), "user11@example.com")
	assert.True(t, isExist)
	isExist, _ = user_model.IsEmailUsed(t.Context(), "user1234567890@example.com")
	assert.False(t, isExist)
}

func TestMakeEmailPrimary(t *testing.T) {
	assert.NoError(t, unittest.PrepareTestDatabase())

	err := user_model.MakeActiveEmailPrimary(t.Context(), 1, 9999999)
	assert.Error(t, err)
	assert.ErrorIs(t, err, user_model.ErrEmailAddressNotExist{})

	email := unittest.AssertExistsAndLoadBean(t, &user_model.EmailAddress{Email: "user11@example.com"})
	err = user_model.MakeActiveEmailPrimary(t.Context(), email.UID, email.ID)
	assert.Error(t, err)
	assert.ErrorIs(t, err, user_model.ErrEmailAddressNotExist{}) // inactive email is considered as not exist for "MakeActiveEmailPrimary"

	email = unittest.AssertExistsAndLoadBean(t, &user_model.EmailAddress{Email: "user9999999@example.com"})
	err = user_model.MakeActiveEmailPrimary(t.Context(), email.UID, email.ID)
	assert.Error(t, err)
	assert.True(t, user_model.IsErrUserNotExist(err))

	email = unittest.AssertExistsAndLoadBean(t, &user_model.EmailAddress{Email: "user101@example.com"})
	err = user_model.MakeActiveEmailPrimary(t.Context(), email.UID, email.ID)
	assert.NoError(t, err)

	user, _ := user_model.GetUserByID(t.Context(), int64(10))
	assert.Equal(t, "user101@example.com", user.Email)
}

func TestActivate(t *testing.T) {
	assert.NoError(t, unittest.PrepareTestDatabase())

	email := &user_model.EmailAddress{
		ID:    int64(1),
		UID:   int64(1),
		Email: "user11@example.com",
	}
	assert.NoError(t, user_model.ActivateEmail(t.Context(), email))

	emails, _ := user_model.GetEmailAddresses(t.Context(), int64(1))
	assert.Len(t, emails, 3)
	assert.True(t, emails[0].IsActivated)
	assert.True(t, emails[0].IsPrimary)
	assert.False(t, emails[1].IsPrimary)
	assert.True(t, emails[2].IsActivated)
	assert.False(t, emails[2].IsPrimary)
}

func TestListEmails(t *testing.T) {
	assert.NoError(t, unittest.PrepareTestDatabase())

	// Must find all users and their emails
	opts := &user_model.SearchEmailOptions{
		ListOptions: db.ListOptions{
			PageSize: 10000,
		},
	}
	emails, count, err := user_model.SearchEmails(t.Context(), opts)
	assert.NoError(t, err)
	assert.Greater(t, count, int64(5))

	contains := func(match func(s *user_model.SearchEmailResult) bool) bool {
		return slices.ContainsFunc(emails, match)
	}

	assert.True(t, contains(func(s *user_model.SearchEmailResult) bool { return s.UID == 18 }))
	// 'org3' is an organization
	assert.False(t, contains(func(s *user_model.SearchEmailResult) bool { return s.UID == 3 }))

	// Must find no records
	opts = &user_model.SearchEmailOptions{Keyword: "NOTFOUND"}
	emails, count, err = user_model.SearchEmails(t.Context(), opts)
	assert.NoError(t, err)
	assert.Equal(t, int64(0), count)

	// Must find users 'user2', 'user28', etc.
	opts = &user_model.SearchEmailOptions{Keyword: "user2"}
	emails, count, err = user_model.SearchEmails(t.Context(), opts)
	assert.NoError(t, err)
	assert.NotEqual(t, int64(0), count)
	assert.True(t, contains(func(s *user_model.SearchEmailResult) bool { return s.UID == 2 }))
	assert.True(t, contains(func(s *user_model.SearchEmailResult) bool { return s.UID == 27 }))

	// Must find only primary addresses (i.e. from the `user` table)
	opts = &user_model.SearchEmailOptions{IsPrimary: optional.Some(true)}
	emails, _, err = user_model.SearchEmails(t.Context(), opts)
	assert.NoError(t, err)
	assert.True(t, contains(func(s *user_model.SearchEmailResult) bool { return s.IsPrimary }))
	assert.False(t, contains(func(s *user_model.SearchEmailResult) bool { return !s.IsPrimary }))

	// Must find only inactive addresses (i.e. not validated)
	opts = &user_model.SearchEmailOptions{IsActivated: optional.Some(false)}
	emails, _, err = user_model.SearchEmails(t.Context(), opts)
	assert.NoError(t, err)
	assert.True(t, contains(func(s *user_model.SearchEmailResult) bool { return !s.IsActivated }))
	assert.False(t, contains(func(s *user_model.SearchEmailResult) bool { return s.IsActivated }))

	// Must find more than one page, but retrieve only one
	opts = &user_model.SearchEmailOptions{
		ListOptions: db.ListOptions{
			PageSize: 5,
			Page:     1,
		},
	}
	emails, count, err = user_model.SearchEmails(t.Context(), opts)
	assert.NoError(t, err)
	assert.Len(t, emails, 5)
	assert.Greater(t, count, int64(len(emails)))
}

func TestEmailAddressValidate(t *testing.T) {
	cases := map[string]bool{
		"":                   false,
		"root@localhost":     true,
		"user@[192.168.1.2]": true,
		"@a":                 false,
		"abc@gmail.com":      true,
		"abc@gmail.com\n":    false,
		"Foo <foo@bar.com>":  false,
		"abc@gmail.com (x)":  false,
		"jürgen@example.com": false,
		"a@foo_bar.com":      false,
	}
	for tc, isValid := range cases {
		t.Run(tc, func(t *testing.T) {
			err := user_model.ValidateEmail(tc)
			assert.Equal(t, err == nil, isValid)
		})
	}
}