package integration_test

import (
	"fmt"
	"strings"

	"github.com/udacity/graphb"

	"edge-infra.dev/test/framework/integration"

	"edge-infra.dev/pkg/edge/api/graph/model"
	edgebsl "edge-infra.dev/pkg/edge/bsl-reconciler"
)

func (s *Suite) TestWhoAmINoAuth() {
	integration.SkipIf(s.Framework)
	// whoAmi with no auth user should fail
	var resp interface{}
	// Set Authorization to empty to get error
	err := ResolverClient.Post("{whoAmI}", resp, SetHeader("Authorization", ""))
	s.Error(err)
	s.Nil(resp)
}

func (s *Suite) TestLogin() {
	integration.SkipIf(s.Framework)
	var resp struct{ Login *model.AuthPayload }
	mutation := loginMutation(testUser, "password", testOrg)
	s.NoError(ResolverClient.Post(mutation, &resp))
	s.NotNil(resp.Login)
	s.NotEmpty(resp.Login.Token)
	s.False(resp.Login.CredentialsExpired)
	s.NotEmpty(resp.Login.FullName)
	s.NotEmpty(resp.Login.FirstName)
	s.Contains(resp.Login.Roles, "EDGE_ORG_ADMIN")
	s.Equal(resp.Login.SessionTime, 15.0)
}

func (s *Suite) TestLoginWithOkta_Valid() {
	integration.SkipIf(s.Framework)
	var resp struct{ LoginWithOkta *model.OktaAuthPayload }
	mutation := loginWithOktaMutation("good-okta-token", "test-refresh-token", "test-org")
	s.NoError(ResolverClient.Post(mutation, &resp))
	s.Equal(resp.LoginWithOkta.Token, "good-okta-token")
	s.Equal(resp.LoginWithOkta.RefreshToken, "test-refresh-token")
}

func (s *Suite) TestLoginWithOkta_InValid() {
	integration.SkipIf(s.Framework)
	var resp struct{ LoginWithOkta *model.OktaAuthPayload }
	mutation := loginWithOktaMutation("bad-okta-token", "test-refresh-token", "test-org")
	s.Error(ResolverClient.Post(mutation, &resp))
}

func (s *Suite) TestVerifyOktaToken_Valid() {
	integration.SkipIf(s.Framework)
	var resp struct{ VerifyOktaToken bool }
	mutation := verifyOktaTokenMutation("good-okta-token")
	s.NoError(ResolverClient.Post(mutation, &resp))
}

func (s *Suite) TestVerifyOktaToken_InValid() {
	integration.SkipIf(s.Framework)
	var resp struct{ VerifyOktaToken bool }
	mutation := verifyOktaTokenMutation("bad-okta-token")
	s.Error(ResolverClient.Post(mutation, &resp))
}

func (s *Suite) TestLoginBadPassword() {
	integration.SkipIf(s.Framework)
	var resp struct{ Login *model.AuthPayload }
	mutation := loginMutation(testUser, "", testOrg)
	s.Error(ResolverClient.Post(mutation, &resp))
	s.Nil(resp.Login)
}

func (s *Suite) TestUpdateUserPassword() {
	integration.SkipIf(s.Framework)
	var resp struct{ UpdateUserPassword *model.EdgeResponsePayload }
	mutation := updateUserPasswordMutation(testUser, "new-password", testRootOrg)
	s.NoError(ResolverClient.Post(mutation, &resp))
	s.Equal(resp.UpdateUserPassword.StatusCode, 200)
	s.Equal(resp.UpdateUserPassword.Message, "Updated Successfully!")
}

func (s *Suite) TestTokenExchange() {
	integration.SkipIf(s.Framework)
	var resp struct{ TokenExchange string }
	mutation := tokenExchangeMutation()
	s.NoError(ResolverClient.Post(mutation, &resp))
	s.NotNil(resp.TokenExchange)
}

func (s *Suite) TestGetUserData() {
	integration.SkipIf(s.Framework)
	var resp struct{ UserData *model.UserData }
	query := getUserDataQuery(testUser)
	s.NoError(ResolverClient.Post(query, &resp))
	s.Len(resp.UserData.AssignedBanners, 3)
	s.Equal(resp.UserData.AssignedBanners[0].Name, "test-org")
	s.Equal(resp.UserData.AssignedBanners[0].BannerBSLId, "test-org-id")
	s.Equal(resp.UserData.AssignedBanners[1].Name, "test-org-banner")
	s.Equal(resp.UserData.AssignedBanners[1].BannerBSLId, "test-org-banner")
	s.Equal(resp.UserData.AssignedBanners[2].Name, "test-banner-eu")
	s.Equal(resp.UserData.AssignedBanners[2].BannerBSLId, "eu-banner-bsl-id")
	s.Len(resp.UserData.Roles, 1)
	s.Equal(resp.UserData.Roles[0], testUserRole)
}

func (s *Suite) TestGetUserData_Empty() {
	integration.SkipIf(s.Framework)
	var resp struct{ UserData *model.UserData }
	query := getUserDataQuery("acct:emerald-edge-dev@nodata")
	s.NoError(ResolverClient.Post(query, &resp))
	s.Empty(resp.UserData.AssignedBanners)
	s.Empty(resp.UserData.Roles)
}

func (s *Suite) TestGetUserData_Multiple() {
	integration.SkipIf(s.Framework)
	var resp struct{ UserData *model.UserData }
	query := getUserDataQuery("acct:emerald-edge-dev@multiple")
	s.NoError(ResolverClient.Post(query, &resp))
	s.Len(resp.UserData.AssignedBanners, 4)
	s.Equal(resp.UserData.AssignedBanners[0].Name, "test-org")
	s.Equal(resp.UserData.AssignedBanners[0].BannerBSLId, "test-org-id")
	s.Equal(resp.UserData.AssignedBanners[1].Name, "test-org-banner")
	s.Equal(resp.UserData.AssignedBanners[1].BannerBSLId, "test-org-banner")
	s.Equal(resp.UserData.AssignedBanners[2].Name, "test-banner-eu")
	s.Equal(resp.UserData.AssignedBanners[2].BannerBSLId, "eu-banner-bsl-id")
	s.Equal(resp.UserData.AssignedBanners[3].Name, "test-banner-eu")
	s.Equal(resp.UserData.AssignedBanners[3].BannerBSLId, "eu-banner-bsl-id")
	s.Len(resp.UserData.Roles, 1)
	s.Equal(resp.UserData.Roles[0], testUserRole)
}

func (s *Suite) TestUpdateUserPasswordWithToken() {
	integration.SkipIf(s.Framework)
	var resp struct{ UpdatePasswordWithToken bool }
	query := updateUserPasswordWithTokenMutation("good-token", "good-password", "good-org")
	err := ResolverClient.Post(query, &resp)
	s.NoError(err)
	s.True(resp.UpdatePasswordWithToken)
	query = updateUserPasswordWithTokenMutation("good-token", "bad-password", "good-org")
	s.Error(ResolverClient.Post(query, &resp))
	query = updateUserPasswordWithTokenMutation("bad-token", "bad-token", "good-org")
	s.Error(ResolverClient.Post(query, &resp))
}

func (s *Suite) TestForgotPassword() {
	integration.SkipIf(s.Framework)
	var resp struct{ ForgotPassword bool }
	mutation := forgotPasswordMutation(testUserName, testRootOrg)
	s.NoError(ResolverClient.Post(mutation, &resp))
	s.True(resp.ForgotPassword)
}

func (s *Suite) TestGetUser() {
	integration.SkipIf(s.Framework)
	var resp struct{ User *model.User }
	mutation := getUserMutation("acct:edge-dev0-edge-b413cb@test")
	s.NoError(ResolverClient.Post(mutation, &resp))
	s.NotEmpty(resp.User)
	s.Equal(*resp.User.Email, "test@ncr.com")
	s.Equal(resp.User.Status, "INACTIVE")
	s.Equal(resp.User.GivenName, "Peter")
	s.Equal(resp.User.FamilyName, "Doe")
}

func (s *Suite) TestUpdateUserProfile() {
	integration.SkipIf(s.Framework)
	var getUserResp struct{ User *model.User }
	getUserMutation := getUserMutation("acct:edge-dev0-edge-b413cb@test")
	s.NoError(ResolverClient.Post(getUserMutation, &getUserResp))
	s.NotEmpty(getUserResp.User)
	s.Equal(*getUserResp.User.Email, "test@ncr.com")
	s.Equal(getUserResp.User.Status, "INACTIVE")
	s.Equal(getUserResp.User.GivenName, "Peter")
	s.Equal(getUserResp.User.FamilyName, "Doe")

	var resp struct{ UpdateUserProfile *model.User }
	mutation := updateUserProfileMutation("acct:edge-dev0-edge-b413cb@test", "ACTIVE", "John")
	s.NoError(ResolverClient.Post(mutation, &resp))
	s.NotEmpty(resp.UpdateUserProfile)
	s.Equal(*resp.UpdateUserProfile.Email, *getUserResp.User.Email)
	s.Equal(resp.UpdateUserProfile.Status, "ACTIVE")
	s.Equal(resp.UpdateUserProfile.GivenName, "John")
	s.Equal(resp.UpdateUserProfile.FamilyName, getUserResp.User.FamilyName)
}

func (s *Suite) TestUsers() {
	integration.SkipIf(s.Framework)
	var response struct{ Users []*model.User }
	mutation := usersMutation("")
	s.NoError(ResolverClient.Post(mutation, &response))
	s.Equal(1, len(response.Users))
	if len(response.Users) > 0 {
		for _, user := range response.Users {
			s.True(!strings.HasSuffix(user.Username, fmt.Sprintf("-%s", edgebsl.BFFUsername)))
		}
	}
}

func (s *Suite) TestUsersOrgBanner() {
	integration.SkipIf(s.Framework)
	var response struct{ Users []*model.User }
	mutation := usersMutation("3396a52c-6a22-4049-9593-5a63b596a101")
	s.NoError(ResolverClient.Post(mutation, &response))
	s.Equal(len(response.Users), 1)
}

func (s *Suite) TestUsersEUBanner() {
	integration.SkipIf(s.Framework)
	var response struct{ Users []*model.User }
	mutation := usersMutation("98ef1fcb-dc88-4c9f-9980-c09a04564a48")
	s.NoError(ResolverClient.Post(mutation, &response))
	s.Equal(len(response.Users), 1)
}

func loginMutation(username, password, organization string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeMutation,
		Fields: []*graphb.Field{
			{
				Name: "login",
				Arguments: []graphb.Argument{
					graphb.ArgumentString("username", username),
					graphb.ArgumentString("password", password),
					graphb.ArgumentString("organization", organization),
				},
				Fields: graphb.Fields("token", "firstName", "fullName", "roles", "credentialsExpired", "sessionTime"),
			},
		},
	})
}

func loginWithOktaMutation(oktaToken, refreshToken, organization string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeMutation,
		Fields: []*graphb.Field{
			{
				Name: "loginWithOkta",
				Arguments: []graphb.Argument{
					graphb.ArgumentString("oktaToken", oktaToken),
					graphb.ArgumentString("refreshToken", refreshToken),
					graphb.ArgumentString("organization", organization),
				},
				Fields: graphb.Fields("token", "refreshToken", "firstName", "fullName", "valid", "sessionTime"),
			},
		},
	})
}

func verifyOktaTokenMutation(oktaToken string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeMutation,
		Fields: []*graphb.Field{
			{
				Name: "verifyOktaToken",
				Arguments: []graphb.Argument{
					graphb.ArgumentString("oktaToken", oktaToken),
				},
			},
		},
	})
}

func tokenExchangeMutation() string {
	return MustParse(graphb.Query{
		Type: graphb.TypeMutation,
		Fields: []*graphb.Field{
			{
				Name: "tokenExchange",
			},
		},
	})
}

func updateUserPasswordWithTokenMutation(token, newPassword, organization string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeMutation,
		Fields: []*graphb.Field{
			{
				Name: "updatePasswordWithToken",
				Arguments: []graphb.Argument{
					graphb.ArgumentString("token", token),
					graphb.ArgumentString("newPassword", newPassword),
					graphb.ArgumentString("organization", organization),
				},
			},
		},
	})
}

func updateUserPasswordMutation(username, newPassword, organization string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeMutation,
		Fields: []*graphb.Field{
			{
				Name: "updateUserPassword",
				Arguments: []graphb.Argument{
					graphb.ArgumentString("username", username),
					graphb.ArgumentString("newPassword", newPassword),
					graphb.ArgumentString("organization", organization),
				},
				Fields: graphb.Fields("statusCode", "message"),
			},
		},
	})
}

func getUserDataQuery(username string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeQuery,
		Fields: []*graphb.Field{
			{
				Name: "userData",
				Arguments: []graphb.Argument{
					graphb.ArgumentString("username", username),
				},
				Fields: []*graphb.Field{
					graphb.NewField("assignedBanners", graphb.OfFields("bannerBSLId", "name", "bannerEdgeId")),
					graphb.NewField("roles"),
				},
			},
		},
	})
}

func usersMutation(bannerEdgeID string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeQuery,
		Fields: []*graphb.Field{
			{
				Name: "users",
				Arguments: []graphb.Argument{
					graphb.ArgumentString("bannerEdgeId", bannerEdgeID),
				},
				Fields: []*graphb.Field{
					graphb.NewField("email"),
					graphb.NewField("status"),
					graphb.NewField("givenName"),
					graphb.NewField("familyName"),
				},
			},
		},
	})
}

func forgotPasswordMutation(username, organization string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeMutation,
		Fields: []*graphb.Field{
			{
				Name: "forgotPassword",
				Arguments: []graphb.Argument{
					graphb.ArgumentString("username", username),
					graphb.ArgumentString("organization", organization),
				},
			},
		},
	})
}

func getUserMutation(username string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeQuery,
		Fields: []*graphb.Field{
			{
				Name: "user",
				Arguments: []graphb.Argument{
					graphb.ArgumentString("username", username),
				},
				Fields: []*graphb.Field{
					graphb.NewField("email"),
					graphb.NewField("status"),
					graphb.NewField("givenName"),
					graphb.NewField("familyName"),
				},
			},
		},
	})
}

func updateUserProfileMutation(username, status, givenName string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeMutation,
		Fields: []*graphb.Field{
			{
				Name: "updateUserProfile",
				Arguments: []graphb.Argument{
					graphb.ArgumentCustomType("user",
						graphb.ArgumentString("username", username),
						graphb.ArgumentString("givenName", givenName),
						graphb.ArgumentString("status", status),
					),
				},
				Fields: []*graphb.Field{
					graphb.NewField("email"),
					graphb.NewField("status"),
					graphb.NewField("givenName"),
					graphb.NewField("familyName"),
				},
			},
		},
	})
}