package usecase

import (
	"context"

	"code.30cm.net/digimon/app-cloudep-permission-server/pkg/domain/entity"
	"code.30cm.net/digimon/app-cloudep-permission-server/pkg/domain/permission"
	"code.30cm.net/digimon/app-cloudep-permission-server/pkg/domain/repository"
	"code.30cm.net/digimon/app-cloudep-permission-server/pkg/domain/usecase"
)

type RolePermissionUseCaseParam struct {
	rolePermissionRepository repository.RolePermissionRepository
	permissionRepository     repository.PermissionRepository
	roleRepository           repository.RoleRepository
	userRoleRepository       repository.UserRoleRepository
}

type RolePermissionUseCase struct {
	RolePermissionUseCaseParam
}

func NewRolePermissionUseCase(param RolePermissionUseCaseParam) usecase.RolePermissionUseCase {
	return &RolePermissionUseCase{
		RolePermissionUseCaseParam: param,
	}
}

// Get 拿到這個 Role ID 底下有哪些權限是開的
func (use *RolePermissionUseCase) Get(ctx context.Context, roleID string) (permission.Permissions, error) {
	// 拿到這個 role 底下有哪些 Permission
	rolePermission, err := use.rolePermissionRepository.Get(ctx, roleID)
	if err != nil {
		return nil, err
	}
	p, err := use.permissionRepository.GetAll(ctx, nil) // -> 開的關的 permission 都會拿到
	if err != nil {
		return nil, err
	}

	return GeneratePermissionTree(p).getFullParentPermission(rolePermission), nil
}

func (use *RolePermissionUseCase) Create(ctx context.Context, roleID string, permissions permission.Permissions) error {
	// 如果加了一個，要把上面的節點都加入才可以
	permissionIDs, err := use.getPermissionIDs(ctx, permissions)
	if err != nil {
		return err
	}
	insert := make([]entity.RolePermission, 0, len(permissions))

	for _, permissionID := range permissionIDs {
		insert = append(insert, entity.RolePermission{
			RoleID:       roleID,
			PermissionID: permissionID,
		})
	}

	err = use.rolePermissionRepository.Create(ctx, insert)
	if err != nil {
		return err
	}

	return nil
}

func (use *RolePermissionUseCase) getPermissionIDs(ctx context.Context, setPermissions permission.Permissions) ([]string, error) {
	p, err := use.permissionRepository.GetAll(ctx, nil)
	if err != nil {
		return nil, err
	}

	return GeneratePermissionTree(p).getFullParentPermissionIDs(setPermissions)
}

func (use *RolePermissionUseCase) Delete(ctx context.Context, roleID string, permissions permission.Permissions) error {
	// 如果加了一個，要把上面的節點都加入才可以
	permissionIDs, err := use.getPermissionIDs(ctx, permissions)
	if err != nil {
		return err
	}
	del := make([]string, 0, len(permissions))
	for _, permissionID := range permissionIDs {
		del = append(del, permissionID)
	}

	err = use.rolePermissionRepository.Delete(ctx, roleID, del)
	if err != nil {
		return err
	}

	return nil
}

func (use *RolePermissionUseCase) List(ctx context.Context, req usecase.ListQuery) (usecase.RoleResp, error) {
	roles, total, err := use.roleRepository.List(ctx, repository.ListQuery{
		PageIndex: req.PageIndex,
		PageSize:  req.PageSize,
		ClientID:  req.ClientID,
		UID:       req.UID,
		Name:      req.Name,
		Status:    req.Status,
	})
	if err != nil {
		return usecase.RoleResp{}, err
	}

	result := make([]usecase.Role, 0, len(roles))
	for _, item := range roles {
		result = append(result, usecase.Role{
			ID:       item.ID.Hex(),
			UID:      item.UID,
			Name:     item.Name,
			Status:   item.Status,
			ClientID: item.ClientID,
		})
	}

	return usecase.RoleResp{
		Total: total,
		Roles: result,
	}, nil
}

//// GetByRoleUID 拿到這個 UID 底下有哪些權限是開的
//func (use *RolePermissionUseCase) GetByRoleUID(ctx context.Context, uid string) (permission.Permissions, error) {
//	permissions := make(permission.Permissions)
//
//	// admin權限
//	if uid == permission.AdminRoleUID {
//		data, err := use.permissionRepository.GetAll(ctx, nil)
//		if err != nil {
//			return nil, err
//		}
//
//		for _, v := range data {
//			permissions[v.Name] = permission.OpenPermission
//		}
//	} else {
//		role, err := use.roleRepository.GetByUID(ctx, uid)
//		if err != nil {
//			return nil, err
//		}
//
//		permissions, err = use.Get(ctx, role.ID.Hex())
//		if err != nil {
//			return nil, err
//		}
//	}
//
//	return permissions, nil
//}
//
//func (use *RolePermissionUseCase) GetByUser(ctx context.Context, uid string) (usecase.UserPermission, error) {
//	userRole, err := use.userRoleRepository.GetByUserID(ctx, uid)
//	if err != nil {
//		return usecase.UserPermission{}, err
//	}
//
//	p, err := use.Get(ctx, userRole.RoleID)
//	if err != nil {
//		return usecase.UserPermission{}, err
//	}
//
//	return usecase.UserPermission{
//		RoleID:      userRole.RoleID,
//		Permissions: p,
//	}, nil
//}