package usecase

import (
	"context"
	"fmt"

	"code.30cm.net/digimon/app-cloudep-permission-server/pkg/domain"
	"code.30cm.net/digimon/app-cloudep-permission-server/pkg/domain/entity"
	"code.30cm.net/digimon/app-cloudep-permission-server/pkg/domain/repository"
	"code.30cm.net/digimon/app-cloudep-permission-server/pkg/domain/usecase"
	"code.30cm.net/digimon/library-go/errs"
	"code.30cm.net/digimon/library-go/errs/code"
	"github.com/zeromicro/go-zero/core/logx"
)

type UserRoleUseCaseParam struct {
	userRoleRepository repository.UserRoleRepository
}

type UserRoleUseCase struct {
	UserRoleUseCaseParam
}

func NewUserRoleUseCase(param UserRoleUseCaseParam) usecase.UserRoleUseCase {
	return &UserRoleUseCase{
		UserRoleUseCaseParam: param,
	}
}

func (use *UserRoleUseCase) Select(ctx context.Context, filter usecase.UserRoleFilter) ([]usecase.UserRole, error) {
	id, err := use.userRoleRepository.GetUsersByRoleID(ctx, filter.RoleID)
	if err != nil {
		e := errs.DatabaseErrorWithScopeL(
			code.CloudEPPermission,
			domain.FailedToGetUserRole,
			logx.WithContext(ctx),
			[]logx.LogField{
				{Key: "req", Value: filter},
				{Key: "func", Value: "userRoleRepository.GetUsersByRoleID"},
				{Key: "err", Value: err.Error()},
			},
			"failed to get users by role id")

		return nil, e
	}

	result := make([]usecase.UserRole, 0, len(id))
	for _, item := range result {
		result = append(result, usecase.UserRole{
			UID:      item.UID,
			RoleID:   filter.RoleID,
			CreateAt: item.CreateAt,
			UpdateAt: item.UpdateAt,
		})
	}

	return result, nil
}

func (use *UserRoleUseCase) Get(ctx context.Context, uid string) (usecase.UserRole, error) {
	id, err := use.userRoleRepository.GetByUserID(ctx, uid)
	if err != nil {
		e := errs.DatabaseErrorWithScopeL(
			code.CloudEPPermission,
			domain.FailedToGetUserRoleByUID,
			logx.WithContext(ctx),
			[]logx.LogField{
				{Key: "uid", Value: uid},
				{Key: "func", Value: "userRoleRepository.GetByUserID"},
				{Key: "err", Value: err.Error()},
			},
			"failed to get users by role id")

		return usecase.UserRole{}, e
	}

	return usecase.UserRole{
		UID:      id.UID,
		RoleID:   id.RoleID,
		CreateAt: id.CreateAt,
		UpdateAt: id.UpdateAt,
	}, nil
}

func (use *UserRoleUseCase) Create(ctx context.Context, uid, roleID string) (usecase.UserRole, error) {
	ins := entity.UserRole{
		UID:    uid,
		RoleID: roleID,
	}
	err := use.userRoleRepository.CreateUserRole(ctx, ins)
	if err != nil {
		e := errs.DatabaseErrorWithScopeL(
			code.CloudEPPermission,
			domain.FailedToCreateUserRole,
			logx.WithContext(ctx),
			[]logx.LogField{
				{Key: "uid-role", Value: fmt.Sprintf("%s-%s", uid, roleID)},
				{Key: "func", Value: "userRoleRepository.CreateUserRole"},
				{Key: "err", Value: err.Error()},
			},
			"failed to create user role")

		return usecase.UserRole{}, e
	}

	return usecase.UserRole{
		UID:      ins.UID,
		RoleID:   ins.RoleID,
		CreateAt: ins.CreateAt,
		UpdateAt: ins.UpdateAt,
	}, nil
}

func (use *UserRoleUseCase) Update(ctx context.Context, uid, roleID string) error {
	_, err := use.userRoleRepository.UpdateUserRole(ctx, uid, roleID)
	if err != nil {
		e := errs.DatabaseErrorWithScopeL(
			code.CloudEPPermission,
			domain.FailedToUpdateUserRole,
			logx.WithContext(ctx),
			[]logx.LogField{
				{Key: "uid-role", Value: fmt.Sprintf("%s-%s", uid, roleID)},
				{Key: "func", Value: "userRoleRepository.UpdateUserRole"},
				{Key: "err", Value: err.Error()},
			},
			"failed to update user role")

		return e
	}

	return nil
}