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/adapter"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/role/command"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
)

type RoleService struct {
}

func NewRoleService() *RoleService {
	newRoleService := &RoleService{}
	return newRoleService
}

//// Create 创建
//func (rs *RoleService) Create(in *command.CreateRoleCommand) (interface{}, error) {
//	transactionContext, err := factory.ValidateStartTransaction(in)
//	if err != nil {
//		return nil, err
//	}
//	defer func() {
//		transactionContext.RollbackTransaction()
//	}()
//	roleRepository := factory.CreateRoleRepository(map[string]interface{}{"transactionContext": transactionContext})
//
//	// 检测名称重复
//	count, err := roleRepository.Count(map[string]interface{}{"name": in.Name, "companyId": in.CompanyId})
//	if err != nil {
//		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
//	}
//	if count > 0 {
//		return nil, application.ThrowError(application.BUSINESS_ERROR, "角色名称已存在")
//	}
//	newRole := &domain.Role{
//		Id:          0,
//		Name:        in.Name,
//		Type:        domain.RoleTypeCommon,
//		Description: in.Description,
//		CompanyId:   in.CompanyId,
//	}
//	role, err := roleRepository.Insert(newRole)
//	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 role, nil
//
//}
//
//func (rs *RoleService) Update(in *command.UpdateRoleCommand) (interface{}, error) {
//	transactionContext, err := factory.ValidateStartTransaction(in)
//	if err != nil {
//		return nil, err
//	}
//	defer func() {
//		transactionContext.RollbackTransaction()
//	}()
//
//	roleRepository := factory.CreateRoleRepository(map[string]interface{}{"transactionContext": transactionContext})
//
//	// 检测名称重复（排除自己）
//	count, err := roleRepository.Count(map[string]interface{}{"name": in.Name, "companyId": in.CompanyId, "notId": in.Id})
//	if err != nil {
//		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
//	}
//	if count > 0 {
//		return nil, application.ThrowError(application.BUSINESS_ERROR, "角色名称已存在")
//	}
//
//	role, err := roleRepository.FindOne(map[string]interface{}{"id": in.Id})
//	if err != nil {
//		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
//	}
//
//	role.Name = in.Name
//	role.Description = in.Description
//
//	role, err = roleRepository.Insert(role)
//	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 role, nil
//}
//

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

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

	role, err := roleRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	if role.Type == domain.RoleTypeSystem {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "系统预制角色不可删除")
	}

	if _, err := roleRepository.Remove(role); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 获取角色所有关联的用户，并删除
	_, roleUsers, err := roleUserRepository.Find(map[string]interface{}{"roleId": in.Id, "companyId": in.CompanyId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	ids := make([]int64, 0)
	for i := range roleUsers {
		ids = append(ids, roleUsers[i].Id)
	}
	if len(ids) > 0 {
		err := roleUserRepository.BatchDeleteById(ids)
		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 role, nil
}

func (rs *RoleService) ListForUser(in *command.QueryRoleUserCommand) (interface{}, error) {
	transactionContext, err := factory.StartTransaction()
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	roleRepository := factory.CreateRoleRepository(map[string]interface{}{"transactionContext": transactionContext})
	ruRepository := factory.CreateRoleUserRepository(map[string]interface{}{"transactionContext": transactionContext})

	in.PageNumber = 1
	in.PageSize = 9999999
	_, roles, err := roleRepository.Find(tool_funs.SimpleStructToMap(in))
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	adapterList := make([]*adapter.RoleUserAdapter, 0)

	// 如果不存在系统预支hrbp角色时，插入一条数据
	var havaSystemType = false
	for i := range roles {
		if roles[i].Type == domain.RoleTypeSystem {
			havaSystemType = true
			break
		}
	}
	if !havaSystemType {
		role := &domain.Role{
			Id:          0,
			Name:        "HRBP",
			Type:        domain.RoleTypeSystem,
			Description: "拥有全部权限，预置角色不可删除",
			CompanyId:   in.CompanyId,
		}
		role, err = roleRepository.Insert(role)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}

		// 创建HRBP角色
		roleUser := &adapter.RoleUserAdapter{}
		roleUser.Role = role
		roleUser.Users = make([]*domain.RoleContainUser, 0)
		adapterList = append(adapterList, roleUser)
	}

	for i := range roles {
		v := roles[i]
		tempList, err := ruRepository.FindAllContainUser(1, 10, in.CompanyId, v.Id)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		roleUser := &adapter.RoleUserAdapter{}
		roleUser.Role = v
		roleUser.Users = tempList
		adapterList = append(adapterList, roleUser)
	}

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

	return tool_funs.SimpleWrapGridMap(int64(len(adapterList)), adapterList), nil
}