package usecase

import (
	"context"

	"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 RoleUseCaseParam struct {
	roleRepository repository.RoleRepository
}

type RoleUseCase struct {
	RoleUseCaseParam
}

func NewRoleUseCase(param RoleUseCaseParam) usecase.RoleUseCase {
	return &RoleUseCase{
		RoleUseCaseParam: param,
	}
}

func (use *RoleUseCase) List(ctx context.Context, param usecase.ListQuery) ([]usecase.Role, int64, error) {
	query := repository.ListQuery{
		PageSize:  param.PageSize,
		PageIndex: param.PageIndex,
		ClientID:  param.ClientID,
		Name:      param.Name,
		UID:       param.UID,
		Status:    param.Status,
	}
	if param.UID != nil {
		query.UID = param.UID
	}

	list, i, err := use.roleRepository.List(ctx, query)
	if err != nil {
		e := errs.DatabaseErrorWithScopeL(
			code.CloudEPPermission,
			domain.FailedToListRole,
			logx.WithContext(ctx),
			[]logx.LogField{
				{Key: "param", Value: param},
				{Key: "func", Value: "roleRepository.List"},
				{Key: "err", Value: err.Error()},
			},
			"failed to list role")

		return nil, 0, e
	}

	result := make([]usecase.Role, 0, len(list))

	for _, item := range list {
		result = append(result, usecase.Role{
			ID:       item.ID.Hex(),
			UID:      item.UID,
			Name:     item.Name,
			Status:   item.Status,
			ClientID: item.ClientID,
			CreateAt: item.CreateAt,
			UpdateAt: item.UpdateAt,
		})
	}

	return result, i, nil
}

func (use *RoleUseCase) All(ctx context.Context, clientID *string) ([]usecase.Role, error) {
	all, err := use.roleRepository.All(ctx, clientID)
	if err != nil {
		e := errs.DatabaseErrorWithScopeL(
			code.CloudEPPermission,
			domain.FailedToListRole,
			logx.WithContext(ctx),
			[]logx.LogField{
				{Key: "clientID", Value: clientID},
				{Key: "func", Value: "roleRepository.All"},
				{Key: "err", Value: err.Error()},
			},
			"failed to get all role")

		return nil, e
	}

	result := make([]usecase.Role, 0, len(all))

	for _, item := range all {
		result = append(result, usecase.Role{
			ID:       item.ID.Hex(),
			UID:      item.UID,
			Name:     item.Name,
			Status:   item.Status,
			ClientID: item.ClientID,
			CreateAt: item.CreateAt,
			UpdateAt: item.UpdateAt,
		})
	}

	return result, nil
}

func (use *RoleUseCase) GetByID(ctx context.Context, id string) (*usecase.Role, error) {
	byID, err := use.roleRepository.GetByID(ctx, id)
	if err != nil {
		e := errs.DatabaseErrorWithScopeL(
			code.CloudEPPermission,
			domain.FailedToGetRoleByID,
			logx.WithContext(ctx),
			[]logx.LogField{
				{Key: "id", Value: id},
				{Key: "func", Value: "roleRepository.GetByID"},
				{Key: "err", Value: err.Error()},
			},
			"failed to get role by id")

		return nil, e
	}

	return &usecase.Role{
		ID:       byID.ID.Hex(),
		UID:      byID.UID,
		Name:     byID.Name,
		Status:   byID.Status,
		ClientID: byID.ClientID,
		CreateAt: byID.CreateAt,
		UpdateAt: byID.UpdateAt,
	}, nil
}

func (use *RoleUseCase) GetByUID(ctx context.Context, uid string) (*usecase.Role, error) {
	byUID, err := use.roleRepository.GetByUID(ctx, uid)
	if err != nil {
		e := errs.DatabaseErrorWithScopeL(
			code.CloudEPPermission,
			domain.FailedToGetRoleByUID,
			logx.WithContext(ctx),
			[]logx.LogField{
				{Key: "uid", Value: uid},
				{Key: "func", Value: "roleRepository.GetByUID"},
				{Key: "err", Value: err.Error()},
			},
			"failed to get role by uid")

		return nil, e
	}

	return &usecase.Role{
		ID:       byUID.ID.Hex(),
		UID:      byUID.UID,
		Name:     byUID.Name,
		Status:   byUID.Status,
		ClientID: byUID.ClientID,
		CreateAt: byUID.CreateAt,
		UpdateAt: byUID.UpdateAt,
	}, nil
}

func (use *RoleUseCase) Create(ctx context.Context, role usecase.CreateRoleReq) error {
	err := use.roleRepository.Create(ctx, &entity.Role{
		UID:      role.UID,
		Name:     role.Name,
		Status:   role.Status,
		ClientID: role.ClientID,
	})
	if err != nil {
		e := errs.DatabaseErrorWithScopeL(
			code.CloudEPPermission,
			domain.FailedToCreateRole,
			logx.WithContext(ctx),
			[]logx.LogField{
				{Key: "param", Value: role},
				{Key: "func", Value: "roleRepository.Create"},
				{Key: "err", Value: err.Error()},
			},
			"failed to create role")

		return e
	}

	return nil
}

func (use *RoleUseCase) Update(ctx context.Context, id string, data usecase.CreateRoleReq) error {
	err := use.roleRepository.Update(ctx, repository.UpdateReq{
		ID:       id,
		Name:     &data.Name,
		ClientID: &data.ClientID,
		Status:   &data.Status,
	})
	if err != nil {
		e := errs.DatabaseErrorWithScopeL(
			code.CloudEPPermission,
			domain.FailedToUpdateRole,
			logx.WithContext(ctx),
			[]logx.LogField{
				{Key: "id", Value: id},
				{Key: "param", Value: data},
				{Key: "func", Value: "roleRepository.Update"},
				{Key: "err", Value: err.Error()},
			},
			"failed to update role")

		return e
	}

	return nil
}

func (use *RoleUseCase) Delete(ctx context.Context, id string) error {
	err := use.roleRepository.Delete(ctx, id)
	if err != nil {
		e := errs.DatabaseErrorWithScopeL(
			code.CloudEPPermission,
			domain.FailedToDelRole,
			logx.WithContext(ctx),
			[]logx.LogField{
				{Key: "id", Value: id},
				{Key: "func", Value: "roleRepository.Delete"},
				{Key: "err", Value: err.Error()},
			},
			"failed to delete role")

		return e
	}

	return nil
}