Storyden

package account_test

import (
	"context"
	"net/http"
	"strings"
	"testing"

	"github.com/rs/xid"
	"github.com/samber/lo"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"go.uber.org/fx"

	"github.com/Southclaws/opt"
	"github.com/Southclaws/storyden/app/resources/account"
	"github.com/Southclaws/storyden/app/resources/account/account_querier"
	"github.com/Southclaws/storyden/app/resources/account/account_writer"
	"github.com/Southclaws/storyden/app/transports/http/openapi"
	"github.com/Southclaws/storyden/internal/integration"
	"github.com/Southclaws/storyden/internal/integration/e2e"
	"github.com/Southclaws/storyden/internal/utils"
	"github.com/Southclaws/storyden/tests"
)

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

	integration.Test(t, nil, e2e.Setup(), fx.Invoke(func(
		lc fx.Lifecycle,
		root context.Context,
		cl *openapi.ClientWithResponses,
		sh *e2e.SessionHelper,
		ar *account_querier.Querier,
	) {
		lc.Append(fx.StartHook(func() {
			r := require.New(t)
			a := assert.New(t)

			// Create 5 fresh accounts
			odin1 := newAccount(t, root, cl, ar, "odin")
			frigg := newAccount(t, root, cl, ar, "frigg")
			baldur := newAccount(t, root, cl, ar, "baldur")
			odin2 := newAccount(t, root, cl, ar, "odin2")
			thor := newAccount(t, root, cl, ar, "þórr")

			// Get them all, default params.

			list1, err := cl.ProfileListWithResponse(root, nil)
			r.NoError(err)
			r.NotNil(list1)
			r.Equal(http.StatusOK, list1.StatusCode())

			a.Equal(1, list1.JSON200.CurrentPage)
			a.GreaterOrEqual(len(list1.JSON200.Profiles), 5)

			// Get one specific name - search for "odin" should include both odins but exclude others

			list2, err := cl.ProfileListWithResponse(root, &openapi.ProfileListParams{
				Q: opt.New("odin").Ptr(),
			})
			r.NoError(err)
			r.NotNil(list2)
			r.Equal(http.StatusOK, list2.StatusCode())

			a.Equal(1, list2.JSON200.CurrentPage)
			a.Equal(50, list2.JSON200.PageSize)
			a.GreaterOrEqual(len(list2.JSON200.Profiles), 2)

			odinResults := findProfilesByNamePrefix(list2.JSON200.Profiles, "odin")
			a.GreaterOrEqual(len(odinResults), 2, "should find at least 2 odin profiles")

			_, foundOdin1 := findProfile(list2.JSON200.Profiles, odin1.Handle)
			_, foundOdin2 := findProfile(list2.JSON200.Profiles, odin2.Handle)
			_, foundFrigg := findProfile(list2.JSON200.Profiles, frigg.Handle)
			_, foundBaldur := findProfile(list2.JSON200.Profiles, baldur.Handle)
			_, foundThor := findProfile(list2.JSON200.Profiles, thor.Handle)

			a.True(foundOdin1, "odin1 should be in search results")
			a.True(foundOdin2, "odin2 should be in search results")
			a.False(foundFrigg, "frigg should not be in odin search results")
			a.False(foundBaldur, "baldur should not be in odin search results")
			a.False(foundThor, "thor should not be in odin search results")

			// Query an invalid page.

			list3, err := cl.ProfileListWithResponse(root, &openapi.ProfileListParams{
				Page: opt.New("2147483647").Ptr(),
			})
			r.NoError(err)
			r.NotNil(list3)
			r.Equal(http.StatusOK, list3.StatusCode())

			a.Equal(2147483647, list3.JSON200.CurrentPage)
			a.Nil(list3.JSON200.NextPage)
			a.Empty(list3.JSON200.Profiles)
		}))
	}))
}

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

	integration.Test(t, nil, e2e.Setup(), fx.Invoke(func(
		lc fx.Lifecycle,
		root context.Context,
		cl *openapi.ClientWithResponses,
		sh *e2e.SessionHelper,
		accountQuery *account_querier.Querier,
	) {
		lc.Append(fx.StartHook(func() {
			handle1 := "user-" + xid.New().String()
			acc1, err := cl.AuthPasswordSignupWithResponse(root, nil, openapi.AuthPair{handle1, "password"})
			tests.Ok(t, err, acc1)
			session1 := sh.WithSession(e2e.WithAccountID(root, account.AccountID(utils.Must(xid.FromString(acc1.JSON200.Id)))))

			handle2 := "user-" + xid.New().String()
			acc2, err := cl.AuthPasswordSignupWithResponse(root, nil, openapi.AuthPair{handle2, "password"})
			tests.Ok(t, err, acc2)
			session2 := sh.WithSession(e2e.WithAccountID(root, account.AccountID(utils.Must(xid.FromString(acc2.JSON200.Id)))))

			t.Run("update_profile", func(t *testing.T) {
				r := require.New(t)
				a := assert.New(t)

				// as guest
				get1, err := cl.ProfileGetWithResponse(root, handle1)
				tests.Ok(t, err, get1)
				r.Equal(handle1, get1.JSON200.Handle)
				r.Equal(handle1, get1.JSON200.Name)

				// as another user
				get2, err := cl.ProfileGetWithResponse(root, handle1, session2)
				tests.Ok(t, err, get2)
				r.Equal(handle1, get2.JSON200.Handle)
				r.Equal(handle1, get2.JSON200.Name)

				// update account profile
				newbio := "new bio"
				newhandle := "newhandle-" + xid.New().String()
				newname := "newname"
				newlinks := []openapi.ProfileExternalLink{
					{Text: "link1", Url: "https://example.com"},
				}
				newmeta := openapi.Metadata{
					"some": "data",
				}

				upd1, err := cl.AccountUpdateWithResponse(root, openapi.AccountUpdateJSONRequestBody{
					Bio:    &newbio,
					Handle: &newhandle,
					Name:   &newname,
					Links:  &newlinks,
					Meta:   &newmeta,
				}, session1)
				tests.Ok(t, err, upd1)

				a.Contains(upd1.JSON200.Bio, newbio)
				a.Equal(newhandle, upd1.JSON200.Handle)
				a.Equal(newname, upd1.JSON200.Name)
				r.Len(newlinks, 1)
				a.Equal(newlinks, upd1.JSON200.Links)
				a.Equal(newmeta, upd1.JSON200.Meta)

				// old handle should not work
				getold, err := cl.ProfileGetWithResponse(root, handle1)
				tests.Status(t, err, getold, http.StatusNotFound)

				// as guest
				getAfterUpdateAsGuest, err := cl.ProfileGetWithResponse(root, newhandle)
				tests.Ok(t, err, getAfterUpdateAsGuest)
				a.Contains(getAfterUpdateAsGuest.JSON200.Bio, newbio)
				a.Equal(newhandle, getAfterUpdateAsGuest.JSON200.Handle)
				a.Equal(newname, getAfterUpdateAsGuest.JSON200.Name)
				r.Len(newlinks, 1)
				a.Equal(newlinks, getAfterUpdateAsGuest.JSON200.Links)
				a.Equal(newmeta, getAfterUpdateAsGuest.JSON200.Meta)

				// as another user
				getAfterUpdateAsUser2, err := cl.ProfileGetWithResponse(root, newhandle, session2)
				tests.Ok(t, err, getAfterUpdateAsUser2)
				a.Contains(getAfterUpdateAsUser2.JSON200.Bio, newbio)
				a.Equal(newhandle, getAfterUpdateAsUser2.JSON200.Handle)
				a.Equal(newname, getAfterUpdateAsUser2.JSON200.Name)
				r.Len(newlinks, 1)
				a.Equal(newlinks, getAfterUpdateAsUser2.JSON200.Links)
				a.Equal(newmeta, getAfterUpdateAsUser2.JSON200.Meta)
			})
		}))
	}))
}

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

	integration.Test(t, nil, e2e.Setup(), fx.Invoke(func(
		lc fx.Lifecycle,
		root context.Context,
		cl *openapi.ClientWithResponses,
		sh *e2e.SessionHelper,
		ar *account_querier.Querier,
	) {
		lc.Append(fx.StartHook(func() {
			r := require.New(t)
			a := assert.New(t)

			prefix := "pft" + xid.New().String()[:3]
			acc1 := newAccount(t, root, cl, ar, prefix+"a")
			acc2 := newAccount(t, root, cl, ar, prefix+"b")
			acc3 := newAccount(t, root, cl, ar, prefix+"c")

			t.Run("sort_by_name_ascending", func(t *testing.T) {
				sortParam := "name"
				list, err := cl.ProfileListWithResponse(root, &openapi.ProfileListParams{
					Sort: &sortParam,
					Q:    &prefix,
				})
				tests.Ok(t, err, list)
				r.GreaterOrEqual(len(list.JSON200.Profiles), 3)

				for i := 0; i < len(list.JSON200.Profiles)-1; i++ {
					a.LessOrEqual(
						strings.ToLower(list.JSON200.Profiles[i].Name),
						strings.ToLower(list.JSON200.Profiles[i+1].Name),
						"profiles should be sorted by name in ascending order",
					)
				}
			})

			t.Run("sort_by_name_descending", func(t *testing.T) {
				sortParam := "-name"
				list, err := cl.ProfileListWithResponse(root, &openapi.ProfileListParams{
					Sort: &sortParam,
					Q:    &prefix,
				})
				tests.Ok(t, err, list)
				r.GreaterOrEqual(len(list.JSON200.Profiles), 3)

				for i := 0; i < len(list.JSON200.Profiles)-1; i++ {
					a.GreaterOrEqual(
						strings.ToLower(list.JSON200.Profiles[i].Name),
						strings.ToLower(list.JSON200.Profiles[i+1].Name),
						"profiles should be sorted by name in descending order",
					)
				}
			})

			t.Run("sort_by_created_at", func(t *testing.T) {
				sortParam := "created_at"
				list, err := cl.ProfileListWithResponse(root, &openapi.ProfileListParams{
					Sort: &sortParam,
				})
				tests.Ok(t, err, list)
				r.GreaterOrEqual(len(list.JSON200.Profiles), 3)
			})

			t.Run("filter_by_join_date_after", func(t *testing.T) {
				joinedParam := "2020-01-01T00:00:00Z/"
				list, err := cl.ProfileListWithResponse(root, &openapi.ProfileListParams{
					Joined: &joinedParam,
				})
				tests.Ok(t, err, list)
				r.GreaterOrEqual(len(list.JSON200.Profiles), 3)
			})

			t.Run("filter_by_join_date_before", func(t *testing.T) {
				joinedParam := "/2050-01-01T00:00:00Z"
				list, err := cl.ProfileListWithResponse(root, &openapi.ProfileListParams{
					Joined: &joinedParam,
				})
				tests.Ok(t, err, list)
				r.GreaterOrEqual(len(list.JSON200.Profiles), 3)
			})

			t.Run("filter_by_join_date_range", func(t *testing.T) {
				joinedParam := "2020-01-01T00:00:00Z/2050-01-01T00:00:00Z"
				list, err := cl.ProfileListWithResponse(root, &openapi.ProfileListParams{
					Joined: &joinedParam,
				})
				tests.Ok(t, err, list)
				r.GreaterOrEqual(len(list.JSON200.Profiles), 3)
			})

			t.Run("filter_by_join_date_no_slash", func(t *testing.T) {
				joinedParam := "2020-01-01T00:00:00Z"
				list, err := cl.ProfileListWithResponse(root, &openapi.ProfileListParams{
					Joined: &joinedParam,
				})
				tests.Ok(t, err, list)
				r.GreaterOrEqual(len(list.JSON200.Profiles), 3)
			})

			t.Run("empty_result_future_date", func(t *testing.T) {
				joinedParam := "2099-01-01T00:00:00Z"
				list, err := cl.ProfileListWithResponse(root, &openapi.ProfileListParams{
					Joined: &joinedParam,
				})
				tests.Ok(t, err, list)
				a.Empty(list.JSON200.Profiles)
			})

			t.Run("invalid_time_range_format", func(t *testing.T) {
				joinedParam := "2020-01-01T00:00:00Z/2025-01-01T00:00:00Z/2050-01-01T00:00:00Z"
				tests.AssertRequest(cl.ProfileListWithResponse(root, &openapi.ProfileListParams{
					Joined: &joinedParam,
				}))(t, 400)
			})

			_ = acc1
			_ = acc2
			_ = acc3
		}))
	}))
}

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

	integration.Test(t, nil, e2e.Setup(), fx.Invoke(func(
		lc fx.Lifecycle,
		root context.Context,
		cl *openapi.ClientWithResponses,
		sh *e2e.SessionHelper,
		ar *account_querier.Querier,
		aw *account_writer.Writer,
	) {
		lc.Append(fx.StartHook(func() {
			r := require.New(t)
			a := assert.New(t)

			adminCtx, admin := e2e.WithAccount(root, aw, account.Account{
				Handle: "admin",
				Name:   "Admin User",
				Admin:  true,
			})
			adminSession := sh.WithSession(adminCtx)

			role1Name := "moderator-" + xid.New().String()
			role1, err := cl.RoleCreateWithResponse(adminCtx, openapi.RoleCreateJSONRequestBody{
				Name:        role1Name,
				Colour:      "blue",
				Permissions: openapi.PermissionList{openapi.MANAGECATEGORIES},
			}, adminSession)
			tests.Ok(t, err, role1)

			role2Name := "editor-" + xid.New().String()
			role2, err := cl.RoleCreateWithResponse(adminCtx, openapi.RoleCreateJSONRequestBody{
				Name:        role2Name,
				Colour:      "green",
				Permissions: openapi.PermissionList{openapi.SUBMITLIBRARYNODE},
			}, adminSession)
			tests.Ok(t, err, role2)

			user1 := newAccount(t, root, cl, ar, "user1")
			user2 := newAccount(t, root, cl, ar, "user2")
			user3 := newAccount(t, root, cl, ar, "user3")

			_, err = cl.AccountAddRoleWithResponse(adminCtx, user1.Handle, role1.JSON200.Id, adminSession)
			r.NoError(err)

			_, err = cl.AccountAddRoleWithResponse(adminCtx, user2.Handle, role1.JSON200.Id, adminSession)
			r.NoError(err)
			_, err = cl.AccountAddRoleWithResponse(adminCtx, user2.Handle, role2.JSON200.Id, adminSession)
			r.NoError(err)

			_, err = cl.AccountAddRoleWithResponse(adminCtx, user3.Handle, role2.JSON200.Id, adminSession)
			r.NoError(err)

			t.Run("filter_by_single_role", func(t *testing.T) {
				roles := []openapi.Identifier{openapi.Identifier(role1.JSON200.Id)}
				list, err := cl.ProfileListWithResponse(root, &openapi.ProfileListParams{
					Roles: &roles,
				})
				tests.Ok(t, err, list)

				foundUser1 := false
				foundUser2 := false
				for _, profile := range list.JSON200.Profiles {
					if profile.Handle == user1.Handle {
						foundUser1 = true
					}
					if profile.Handle == user2.Handle {
						foundUser2 = true
					}
				}
				a.True(foundUser1, "user1 should be in results")
				a.True(foundUser2, "user2 should be in results")
			})

			t.Run("filter_by_multiple_roles_conjunction", func(t *testing.T) {
				roles := []openapi.Identifier{
					openapi.Identifier(role1.JSON200.Id),
					openapi.Identifier(role2.JSON200.Id),
				}
				list, err := cl.ProfileListWithResponse(root, &openapi.ProfileListParams{
					Roles: &roles,
				})
				tests.Ok(t, err, list)

				foundUser2 := false
				foundUser1 := false
				foundUser3 := false
				for _, profile := range list.JSON200.Profiles {
					if profile.Handle == user1.Handle {
						foundUser1 = true
					}
					if profile.Handle == user2.Handle {
						foundUser2 = true
					}
					if profile.Handle == user3.Handle {
						foundUser3 = true
					}
				}
				a.True(foundUser2, "user2 has both roles and should be in results")
				a.False(foundUser1, "user1 has only role1, not both")
				a.False(foundUser3, "user3 has only role2, not both")
			})

			_ = admin
		}))
	}))
}

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

	integration.Test(t, nil, e2e.Setup(), fx.Invoke(func(
		lc fx.Lifecycle,
		root context.Context,
		cl *openapi.ClientWithResponses,
		sh *e2e.SessionHelper,
		ar *account_querier.Querier,
		aw *account_writer.Writer,
	) {
		lc.Append(fx.StartHook(func() {
			r := require.New(t)
			a := assert.New(t)

			inviter1Ctx, inviter1 := e2e.WithAccount(root, aw, account.Account{
				Handle: "inviter1",
				Name:   "Inviter One",
				Admin:  true,
			})
			inviter1Session := sh.WithSession(inviter1Ctx)

			inviter2Ctx, inviter2 := e2e.WithAccount(root, aw, account.Account{
				Handle: "inviter2",
				Name:   "Inviter Two",
				Admin:  true,
			})
			inviter2Session := sh.WithSession(inviter2Ctx)

			message := "Join!"
			invite1, err := cl.InvitationCreateWithResponse(root, openapi.InvitationInitialProps{
				Message: &message,
			}, inviter1Session)
			tests.Ok(t, err, invite1)

			invite2, err := cl.InvitationCreateWithResponse(root, openapi.InvitationInitialProps{
				Message: &message,
			}, inviter2Session)
			tests.Ok(t, err, invite2)

			invitee1Handle := "invitee1-" + xid.New().String()
			invitee1Resp, err := cl.AuthPasswordSignupWithResponse(root, &openapi.AuthPasswordSignupParams{
				InvitationId: &invite1.JSON200.Id,
			}, openapi.AuthPair{Identifier: invitee1Handle, Token: "password"})
			tests.Ok(t, err, invitee1Resp)

			invitee2Handle := "invitee2-" + xid.New().String()
			invitee2Resp, err := cl.AuthPasswordSignupWithResponse(root, &openapi.AuthPasswordSignupParams{
				InvitationId: &invite2.JSON200.Id,
			}, openapi.AuthPair{Identifier: invitee2Handle, Token: "password"})
			tests.Ok(t, err, invitee2Resp)

			t.Run("filter_by_single_inviter", func(t *testing.T) {
				inviters := []openapi.AccountHandle{openapi.AccountHandle(inviter1.Handle)}
				list, err := cl.ProfileListWithResponse(root, &openapi.ProfileListParams{
					InvitedBy: &inviters,
				})
				tests.Ok(t, err, list)

				foundInvitee1 := false
				foundInvitee2 := false
				for _, profile := range list.JSON200.Profiles {
					if profile.Handle == invitee1Handle {
						foundInvitee1 = true
					}
					if profile.Handle == invitee2Handle {
						foundInvitee2 = true
					}
				}
				a.True(foundInvitee1, "invitee1 should be in results")
				a.False(foundInvitee2, "invitee2 was not invited by inviter1")
			})

			t.Run("filter_by_multiple_inviters", func(t *testing.T) {
				inviters := []openapi.AccountHandle{
					openapi.AccountHandle(inviter1.Handle),
					openapi.AccountHandle(inviter2.Handle),
				}
				list, err := cl.ProfileListWithResponse(root, &openapi.ProfileListParams{
					InvitedBy: &inviters,
				})
				tests.Ok(t, err, list)

				foundInvitee1 := false
				foundInvitee2 := false
				for _, profile := range list.JSON200.Profiles {
					if profile.Handle == invitee1Handle {
						foundInvitee1 = true
					}
					if profile.Handle == invitee2Handle {
						foundInvitee2 = true
					}
				}
				a.True(foundInvitee1, "invitee1 should be in results")
				a.True(foundInvitee2, "invitee2 should be in results")
			})

			_ = r
		}))
	}))
}

func newAccount(t *testing.T, ctx context.Context, cl *openapi.ClientWithResponses, ar *account_querier.Querier, handle string) account.Account {
	r := require.New(t)

	hand1 := handle + "-" + xid.New().String()

	response, err := cl.AuthPasswordSignupWithResponse(ctx, nil, openapi.AuthPair{
		Identifier: hand1,
		Token:      "password",
	})
	r.NoError(err)
	r.NotNil(response)
	r.Equal(http.StatusOK, response.StatusCode())

	acc, err := ar.GetByID(ctx, account.AccountID(utils.Must(xid.FromString(response.JSON200.Id))))
	r.NoError(err)
	r.NotNil(acc)

	return acc.Account
}

func findProfile(profiles []openapi.PublicProfile, handle string) (openapi.PublicProfile, bool) {
	return lo.Find(profiles, func(p openapi.PublicProfile) bool {
		return p.Handle == handle
	})
}

func findProfilesByNamePrefix(profiles []openapi.PublicProfile, prefix string) []openapi.PublicProfile {
	return lo.Filter(profiles, func(p openapi.PublicProfile, _ int) bool {
		return strings.HasPrefix(strings.ToLower(p.Name), strings.ToLower(prefix))
	})
}

func getProfileIndex(profiles []openapi.PublicProfile, handle string) int {
	for i, p := range profiles {
		if p.Handle == handle {
			return i
		}
	}
	return -1
}