package service

import (
	"github.com/linmadan/egglib-go/core/application"
	"github.com/linmadan/egglib-go/utils/tool_funs"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/factory"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/role/command"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
	"strconv"
)

type RoleUserService struct {
}

func NewRoleUserService() *RoleUserService {
	newRoleUserService := &RoleUserService{}
	return newRoleUserService
}

// Create 创建
func (rs *RoleUserService) Create(in *command.UserRoleCreateCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	roleUserRepository := factory.CreateRoleUserRepository(map[string]interface{}{"transactionContext": transactionContext})

	//int64Array := make([]int64, 0)
	//for i := range in.UserIds {
	//	int64Num, _ := strconv.ParseInt(in.UserIds[i], 10, 64)
	//	int64Array = append(int64Array, int64Num)
	//}
	// 检测已存在的关联用户
	_, rus, err := roleUserRepository.Find(map[string]interface{}{"roleId": in.RoleId, "companyId": in.CompanyId, "userIds": in.UserIds, "limit": int64(9999999)})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	existUserIds := make(map[int64]int64)
	for i := range rus {
		existUserIds[rus[i].UserId] = rus[i].UserId
	}
	for i := range in.UserIds {
		int64Num, _ := strconv.ParseInt(in.UserIds[i], 10, 64)
		// 不存在关联关系时，新增数据
		if _, ok := existUserIds[int64Num]; !ok {
			newRoleUser := &domain.RoleUser{
				Id:        0,
				RoleId:    in.RoleId,
				UserId:    int64Num,
				CompanyId: in.CompanyId,
			}
			_, err := roleUserRepository.Insert(newRoleUser)
			if err != nil {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			}
		}
	}

	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return nil, nil
}

func (rs *RoleUserService) Remove(in *command.UserRoleDeleteCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	roleUserRepository := factory.CreateRoleUserRepository(map[string]interface{}{"transactionContext": transactionContext})

	// 检测已存在的关联用户
	_, rus, err := roleUserRepository.Find(map[string]interface{}{"roleId": in.RoleId, "companyId": in.CompanyId, "userId": in.UserId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if len(rus) == 0 {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "数据不存在")
	}

	if _, err := roleUserRepository.Remove(rus[0]); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return rus, nil
}

func (rs *RoleUserService) ListRole(in *command.UserRoleQueryCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	ruRepository := factory.CreateRoleUserRepository(map[string]interface{}{"transactionContext": transactionContext})

	in.PageNumber = 1
	in.PageSize = 9999999

	tempList, err := ruRepository.FindAllContainUser(1, 10, in.CompanyId, in.RoleId)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return tool_funs.SimpleWrapGridMap(int64(len(tempList)), tempList), nil
}