package resolver

// This file will be automatically regenerated based on the schema, any resolver implementations
// will be copied through when generating and any unknown code will be moved to the end.
// Code generated by github.com/99designs/gqlgen version v0.17.45

import (
	"context"
	"fmt"

	"edge-infra.dev/pkg/edge/api/graph/mapper"
	"edge-infra.dev/pkg/edge/api/graph/model"
	"edge-infra.dev/pkg/edge/api/middleware"
	"edge-infra.dev/pkg/edge/api/utils"
	"edge-infra.dev/pkg/edge/bsl"
	"edge-infra.dev/pkg/edge/constants/api/banner"
)

// Register is the resolver for the register field.
func (r *mutationResolver) Register(ctx context.Context, firstName string, lastName string, username string, email string, password string, organization string) (string, error) {
	organization = bsl.TrimOrg(organization)
	_, err := r.TenantService.GetByName(ctx, organization)
	if err != nil {
		return "", fmt.Errorf("organization %s, does not exist", organization)
	}
	authPayload, err := r.UserManagementService.Register(ctx, firstName, lastName, username, email, password, organization)
	if err != nil {
		return authPayload, err
	}
	err = r.RoleService.AddRoleToUserLegacy(ctx, organization, username, string(model.RoleEdgeBannerViewer))
	return authPayload, err
}

// Login is the resolver for the login field.
func (r *mutationResolver) Login(ctx context.Context, username string, password string, organization string) (*model.AuthPayload, error) {
	organization = bsl.TrimOrg(organization)
	_, err := r.TenantService.GetByName(ctx, organization)
	if err != nil {
		return nil, fmt.Errorf("organization %s, does not exist", organization)
	}
	payload, err := r.UserManagementService.Login(ctx, username, password, organization)
	return payload, err
}

// LoginWithOkta is the resolver for the loginWithOkta field.
func (r *mutationResolver) LoginWithOkta(ctx context.Context, oktaToken string, refreshToken string, organization string) (*model.OktaAuthPayload, error) {
	return r.UserManagementService.LoginWithOktaToken(ctx, oktaToken, refreshToken, organization)
}

// VerifyOktaToken is the resolver for the verifyOktaToken field.
func (r *mutationResolver) VerifyOktaToken(ctx context.Context, oktaToken string) (bool, error) {
	resp, err := r.UserManagementService.VerifyOktaToken(ctx, oktaToken)
	if err != nil {
		return false, err
	}
	return resp.Active, nil
}

// UpdateUserPassword is the resolver for the updateUserPassword field.
func (r *mutationResolver) UpdateUserPassword(ctx context.Context, username string, newPassword string, organization string) (*model.EdgeResponsePayload, error) {
	organization = bsl.GetOrgShortName(organization)
	if err := r.UserManagementService.ResetPassword(ctx, username, newPassword, organization); err != nil {
		return nil, err
	}
	return mapper.ToEdgeResponsePayload(200, "Updated Successfully!"), nil
}

// DeleteUser is the resolver for the deleteUser field.
func (r *mutationResolver) DeleteUser(ctx context.Context, username string) (bool, error) {
	if err := r.UserManagementService.Delete(ctx, username); err != nil {
		return false, err
	}
	return true, nil
}

// Logout is the resolver for the logout field.
func (r *mutationResolver) Logout(ctx context.Context) (bool, error) {
	return true, nil
}

// ForgotPassword is the resolver for the forgotPassword field.
func (r *mutationResolver) ForgotPassword(ctx context.Context, username string, organization string) (bool, error) {
	organization = bsl.GetOrgShortName(organization)
	if err := r.RoleService.RecoverPassword(ctx, username, organization); err != nil {
		return false, err
	}
	return true, nil
}

// UpdatePasswordWithToken is the resolver for the updatePasswordWithToken field.
func (r *mutationResolver) UpdatePasswordWithToken(ctx context.Context, token string, organization string, newPassword string) (bool, error) {
	if err := r.UserManagementService.UpdateUserPasswordWithToken(ctx, token, organization, newPassword); err != nil {
		return false, err
	}
	return true, nil
}

// TokenExchange is the resolver for the tokenExchange field.
func (r *mutationResolver) TokenExchange(ctx context.Context) (string, error) {
	user := middleware.ForContext(ctx)
	organization := bsl.GetOrgShortName(user.Organization)
	return r.UserManagementService.TokenExchange(ctx, organization, user, "bsl")
}

// SessionRefresh is the resolver for the sessionRefresh field.
func (r *mutationResolver) SessionRefresh(ctx context.Context, provider model.AuthProvider) (string, error) {
	user := middleware.ForContext(ctx)
	organization := bsl.GetOrgShortName(user.Organization)
	return r.UserManagementService.TokenExchange(ctx, organization, user, provider.String())
}

// UpdateUserProfile is the resolver for the updateUserProfile field.
func (r *mutationResolver) UpdateUserProfile(ctx context.Context, user model.UpdateUser) (*model.User, error) {
	currentUser := middleware.ForContext(ctx)
	if currentUser == nil {
		return nil, fmt.Errorf("missing authenticated user")
	}
	organization := bsl.GetOrgShortName(currentUser.Organization)
	userProfile, err := r.UserManagementService.GetUser(ctx, user.Username, organization, currentUser.Token, currentUser.AuthProvider)
	if err != nil {
		return nil, err
	}
	if utils.IsNullOrEmpty(user.Status) {
		user.Status = &userProfile.Status
	}
	if utils.IsNullOrEmpty(user.FamilyName) {
		user.FamilyName = &userProfile.FamilyName
	}
	if utils.IsNullOrEmpty(user.Email) {
		user.Email = userProfile.Email
	}
	if utils.IsNullOrEmpty(user.FullName) {
		user.FullName = &userProfile.FullName
	}
	if utils.IsNullOrEmpty(user.GivenName) {
		user.GivenName = &userProfile.GivenName
	}
	return r.UserManagementService.UpdateUserProfile(ctx, &user)
}

// Users is the resolver for the users field.
func (r *queryResolver) Users(ctx context.Context, bannerEdgeID *string) ([]*model.User, error) {
	var users []*model.User
	var errs error
	if !utils.IsNullOrEmpty(bannerEdgeID) {
		b, err := r.BannerService.GetBanner(ctx, *bannerEdgeID)
		if err != nil {
			return nil, err
		}
		if banner.Type(b.BannerType) == banner.Org {
			users, errs = r.UserManagementService.GetUsersForOrgBanner(ctx, b.Name)
		} else {
			users, errs = r.BannerService.GetUsersForEuBanner(ctx, b.BannerBSLId)
		}
	} else {
		users, errs = r.UserManagementService.GetUsers(ctx)
	}
	if errs != nil {
		return users, errs
	}
	return users, errs
}

// UserData is the resolver for the userData field.
func (r *queryResolver) UserData(ctx context.Context, username string) (*model.UserData, error) {
	banners, err := r.BannerService.GetUserAssignedBanners(ctx, username)
	if err != nil {
		return &model.UserData{}, err
	}
	roles, err := r.RoleService.GetEdgeGroupsForUserUser(ctx, username)
	if err != nil {
		return &model.UserData{}, err
	}
	return &model.UserData{AssignedBanners: banners, Roles: roles}, nil
}

// WhoAmI is the resolver for the whoAmI field.
func (r *queryResolver) WhoAmI(ctx context.Context) (*model.User, error) {
	user := middleware.ForContext(ctx)
	if user == nil {
		return nil, fmt.Errorf("missing authenticated user")
	}
	organization := bsl.GetOrgShortName(user.Organization)
	return r.UserManagementService.WhoAmI(ctx, user.Username, organization, user.Token, user.AuthProvider)
}

// User is the resolver for the user field.
func (r *queryResolver) User(ctx context.Context, username string) (*model.User, error) {
	user := middleware.ForContext(ctx)
	if user == nil {
		return nil, fmt.Errorf("missing authenticated user")
	}
	organization := bsl.GetOrgShortName(user.Organization)
	userProfile, err := r.UserManagementService.GetUser(ctx, username, organization, user.Token, user.AuthProvider)
	if err != nil {
		return nil, err
	}
	return userProfile, nil
}

// SessionUserEdgeRole is the resolver for the sessionUserEdgeRole field.
func (r *queryResolver) SessionUserEdgeRole(ctx context.Context) ([]string, error) {
	user := middleware.ForContext(ctx)

	data, err := r.UserManagementService.GetSessionUserEdgeRoles(ctx, user.Username, user.Token, user.Organization, user.AuthProvider)
	if err != nil {
		return nil, err
	}
	return data, nil
}