package coresvc

import (
	"context"
	"crypto/ed25519"
	"wpw-common/pkg/gen/biz/core"
	"wpw-common/pkg/gen/biz/core/structs"

	"gorm.io/gorm"
)

var _ core.CoreService = (*CoreService)(nil)

func (c *CoreService) GetUserList(ctx context.Context, request *structs.GetUserListRequest) (r *structs.GetUserListResponse, err error) {
	c.logger.Infow("get users request", "req", request)
	var user *structs.User
	if user, err = c.getAndCheckSessionAdmin(ctx); err != nil {
		err = c.wrapServiceError(err)
		return
	}
	_ = user

	if err = c.checkRequest(ctx, request); err != nil {
		return
	}

	r = structs.NewGetUserListResponse()
	r.Pagination = request.Pagination

	// query scopes
	scopes := []scopeFunc{
		c.ScPaginate(request.Pagination),
	}

	// using search term
	if searchTerm := request.SearchTerm; searchTerm != "" {
		scopes = append(scopes, c.ScSearchTerm(request.SearchTerm,
			"username", "display_name"))
	}

	// get users
	tx := c.db.Scopes(scopes...).
		Preload("Roles").
		Find(&r.Users)
	if err = tx.Error; err != nil {
		err = c.wrapServiceError(err)
		return
	}

	// get total users count
	tx = c.db.Model(structs.User{}).Count(&r.TotalUsers)
	if err = tx.Error; err != nil {
		err = c.wrapServiceError(err)
		return
	}

	// strip users data
	for _, user := range r.Users {
		c.stripConfidentialUserData(user)
	}
	return
}

func (c *CoreService) CreateUser(ctx context.Context, request *structs.CreateUserRequest) (r *structs.CreateUserResponse, err error) {
	c.logger.Infow("create user request", "req", request)
	var user *structs.User
	if user, err = c.getAndCheckSessionAdmin(ctx); err != nil {
		return
	}
	_ = user

	// validate
	requestUser := request.User
	if err = c.checkRequest(ctx, requestUser); err != nil {
		return
	}

	daoUser := structs.NewUser()
	// pass necessary data.
	daoUser.Username = requestUser.Username
	daoUser.Password = c.passwordHasher(requestUser.Password)
	daoUser.DisplayName = requestUser.DisplayName

	var (
		pri ed25519.PrivateKey
		pub ed25519.PublicKey
	)
	if pri, pub, err = c.getEd25519KeyPair(); err != nil {
		err = c.wrapServiceError(err)
		return
	}
	daoUser.PrivateKey = pri
	daoUser.PublicKey = pub

	tx := c.db.Create(daoUser)
	if err = tx.Error; err != nil {
		err = c.wrapServiceError(err)
		return
	}

	r = structs.NewCreateUserResponse()
	return
}

func (c *CoreService) DeleteUsers(ctx context.Context, request *structs.DeleteUsersRequest) (r *structs.DeleteUsersResponse, err error) {
	c.logger.Infow("delete users request", "req", request)
	var user *structs.User
	if user, err = c.getAndCheckSessionAdmin(ctx); err != nil {
		return
	}
	_ = user

	if err = c.checkRequest(ctx, request); err != nil {
		return
	}

	var targetUsers []*structs.User
	tx := c.db.
		Where("id IN ?", request.UserIds).Select("id").
		Preload("Roles").
		Find(&targetUsers)
	if err = tx.Error; err != nil {
		err = c.wrapServiceError(err)
		return
	}

	var qualifiedTargetUsers []*structs.User
	var (
		idsSuccess []int64
		idsIgnored []int64
	)
	err = c.db.Transaction(func(tx *gorm.DB) (err error) {
		for _, targetUser := range targetUsers {
			if targetUser.ID == user.ID || c.isSystemUser(targetUser) {
				idsIgnored = append(idsIgnored, targetUser.ID)
				continue
			}
			qualifiedTargetUsers = append(qualifiedTargetUsers, targetUser)
			idsSuccess = append(idsSuccess, targetUser.ID)
		}
		if len(qualifiedTargetUsers) <= 0 {
			// has nothing to do with.
			return
		}
		tx = tx.Delete(qualifiedTargetUsers)
		if err = tx.Error; err != nil {
			return
		}
		return
	})
	if err != nil {
		err = c.wrapServiceError(err)
		return
	}

	r = structs.NewDeleteUsersResponse()
	r.Success = idsSuccess
	r.Ignored = idsIgnored
	return
}