admin-panel/src/main/java/ru/soune/nocopy/adminpanel/handler/AdminUserHandler.java

package ru.soune.nocopy.adminpanel.handler;

import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import ru.soune.nocopy.adminpanel.dto.*;
import ru.soune.nocopy.adminpanel.entity.AdminSection;
import ru.soune.nocopy.adminpanel.entity.AdminUser;
import ru.soune.nocopy.adminpanel.entity.PermissionType;
import ru.soune.nocopy.adminpanel.exceptions.AdminUserNotFoundException;
import ru.soune.nocopy.adminpanel.exceptions.EmailAlreadyExistsException;
import ru.soune.nocopy.adminpanel.exceptions.WrongPassword;
import ru.soune.nocopy.adminpanel.permission.AdminPermission;
import ru.soune.nocopy.adminpanel.service.AdminSectionPermissionService;
import ru.soune.nocopy.adminpanel.service.AdminUserService;
import ru.soune.nocopy.adminpanel.util.JwtUtil;
import ru.soune.nocopy.adminpanel.util.MessageCode;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Component
@RequiredArgsConstructor
@Slf4j
public class AdminUserHandler implements RequestHandler {

    private final ObjectMapper objectMapper;

    private final AdminUserService adminUserService;

    private final JwtUtil jwtUtil;

    private final AdminSectionPermissionService permissionService;

    @Override
    public BaseResponse handle(BaseRequest request) throws Exception {
        AdminUserRequest adminRequest = objectMapper.convertValue(request.getMessageBody(), AdminUserRequest.class);
        String action = adminRequest.getAction();

        return switch (action) {
            case "login" -> handleLogin(request, adminRequest);
            case "create" -> handleCreate(request, adminRequest);
            case "get_all" -> handleGetAll(request);
            case "get_by_id" -> handleGetById(request, adminRequest);
            case "update" -> handleUpdate(request, adminRequest);
            case "set_super_admin" -> handleSetSuperAdmin(request, adminRequest);
            case "toggle_active" -> handleToggleActive(request, adminRequest);
            case "delete" -> handleDelete(request, adminRequest);
            case "get_permissions_by_id" -> handleGetPermissionsById(request, adminRequest);
            case "get_permissions_by_token" -> handleGetPermissionsByToken(request);
            case "update_permissions" -> handleUpdatePermissions(request, adminRequest);
            default -> handleInvalidAction(request, action);
        };
    }

    private BaseResponse handleLogin(BaseRequest request, AdminUserRequest adminRequest) {
        String email = adminRequest.getEmail();
        String password = adminRequest.getPassword();

        boolean authenticated = adminUserService.authenticate(email, password);

        if (!authenticated) {
            return BaseResponse.builder()
                    .msgId(request.getMsgId())
                    .messageCode(MessageCode.INVALID_CREDENTIALS.getCode())
                    .messageDesc(MessageCode.INVALID_CREDENTIALS.getDescription())
                    .build();
        }

        try {
            AdminUser admin = adminUserService.findByEmail(email);

            if (!admin.getIsActive()) {
                return BaseResponse.builder()
                        .msgId(request.getMsgId())
                        .messageCode(MessageCode.ADMIN_INACTIVE.getCode())
                        .messageDesc(MessageCode.ADMIN_INACTIVE.getDescription())
                        .build();
            }

            String token = jwtUtil.generateToken(admin.getEmail(), admin.getId());

            LoginResponse loginResponse = LoginResponse.builder()
                    .success(true)
                    .token(token)
                    .admin(convertToResponse(admin))
                    .build();

            return BaseResponse.builder()
                    .msgId(request.getMsgId())
                    .messageCode(MessageCode.SUCCESS.getCode())
                    .messageDesc(MessageCode.SUCCESS.getDescription())
                    .messageBody(loginResponse)
                    .build();
        } catch (AdminUserNotFoundException e) {
            return BaseResponse.builder()
                    .msgId(request.getMsgId())
                    .messageCode(MessageCode.ADMIN_NOT_FOUND.getCode())
                    .messageDesc(MessageCode.ADMIN_NOT_FOUND.getDescription())
                    .build();
        }
    }

    private BaseResponse handleCreate(BaseRequest request, AdminUserRequest adminRequest) {
        try {
            boolean superAdmin = adminRequest.getIsSuperAdmin() != null && adminRequest.getIsSuperAdmin();
            AdminUser admin = adminUserService.create(
                    adminRequest.getFullName(),
                    adminRequest.getEmail(),
                    adminRequest.getPassword(),
                    superAdmin);
            Map<AdminSection, Integer> sectionPermissons = new HashMap<>();
            
            if (superAdmin) {
                sectionPermissons.put(AdminSection.DASH, PermissionType.WRITE_AND_READ.getValue());
                sectionPermissons.put(AdminSection.USERS, PermissionType.WRITE_AND_READ.getValue());
                sectionPermissons.put(AdminSection.STAFF, PermissionType.WRITE_AND_READ.getValue());
                sectionPermissons.put(AdminSection.SUBSCRIPTIONS, PermissionType.WRITE_AND_READ.getValue());
                sectionPermissons.put(AdminSection.TARIFFS, PermissionType.WRITE_AND_READ.getValue());
                sectionPermissons.put(AdminSection.CONTENT_MODERATION, PermissionType.WRITE_AND_READ.getValue());
                sectionPermissons.put(AdminSection.COMPLAINTS, PermissionType.WRITE_AND_READ.getValue());
                sectionPermissons.put(AdminSection.CLAIMS, PermissionType.WRITE_AND_READ.getValue());
                sectionPermissons.put(AdminSection.MAILINGS, PermissionType.WRITE_AND_READ.getValue());
                sectionPermissons.put(AdminSection.API, PermissionType.WRITE_AND_READ.getValue());
                sectionPermissons.put(AdminSection.MONEY, PermissionType.WRITE_AND_READ.getValue());
                sectionPermissons.put(AdminSection.KYC, PermissionType.WRITE_AND_READ.getValue());
                sectionPermissons.put(AdminSection.AGREEMENTS, PermissionType.WRITE_AND_READ.getValue());
            } else {
                sectionPermissons.put(AdminSection.DASH, PermissionType.READ.getValue());
                sectionPermissons.put(AdminSection.USERS, PermissionType.READ.getValue());
                sectionPermissons.put(AdminSection.STAFF, PermissionType.READ.getValue());
                sectionPermissons.put(AdminSection.SUBSCRIPTIONS, PermissionType.READ.getValue());
                sectionPermissons.put(AdminSection.TARIFFS, PermissionType.READ.getValue());
                sectionPermissons.put(AdminSection.CONTENT_MODERATION, PermissionType.READ.getValue());
                sectionPermissons.put(AdminSection.COMPLAINTS, PermissionType.READ.getValue());
                sectionPermissons.put(AdminSection.CLAIMS, PermissionType.READ.getValue());
                sectionPermissons.put(AdminSection.MAILINGS, PermissionType.READ.getValue());
                sectionPermissons.put(AdminSection.API, PermissionType.READ.getValue());
                sectionPermissons.put(AdminSection.MONEY, PermissionType.READ.getValue());
                sectionPermissons.put(AdminSection.KYC, PermissionType.READ.getValue());
                sectionPermissons.put(AdminSection.AGREEMENTS, PermissionType.READ.getValue());
            }

            permissionService.setAllPermissions(admin.getId(), sectionPermissons);
            
            return BaseResponse.builder()
                    .msgId(request.getMsgId())
                    .messageCode(MessageCode.SUCCESS.getCode())
                    .messageDesc(MessageCode.SUCCESS.getDescription())
                    .messageBody(convertToResponse(admin))
                    .build();
        } catch (EmailAlreadyExistsException e) {
            return BaseResponse.builder()
                    .msgId(request.getMsgId())
                    .messageCode(MessageCode.EMAIL_ALREADY_EXISTS.getCode())
                    .messageDesc(MessageCode.EMAIL_ALREADY_EXISTS.getDescription())
                    .build();
        }
    }

    private BaseResponse handleGetAll(BaseRequest request) {
        List<AdminUserResponse> admins = adminUserService.findAll().stream()
                .map(this::convertToResponse)
                .collect(Collectors.toList());

        return BaseResponse.builder()
                .msgId(request.getMsgId())
                .messageCode(MessageCode.SUCCESS.getCode())
                .messageDesc(MessageCode.SUCCESS.getDescription())
                .messageBody(admins)
                .build();
    }

    private BaseResponse handleGetById(BaseRequest request, AdminUserRequest adminRequest) {
        try {
            AdminUser admin = adminUserService.findById(adminRequest.getAdminId());
            return BaseResponse.builder()
                    .msgId(request.getMsgId())
                    .messageCode(MessageCode.SUCCESS.getCode())
                    .messageDesc(MessageCode.SUCCESS.getDescription())
                    .messageBody(convertToResponse(admin))
                    .build();
        } catch (AdminUserNotFoundException e) {
            return BaseResponse.builder()
                    .msgId(request.getMsgId())
                    .messageCode(MessageCode.ADMIN_NOT_FOUND.getCode())
                    .messageDesc(MessageCode.ADMIN_NOT_FOUND.getDescription())
                    .build();
        }
    }

    private BaseResponse handleUpdate(BaseRequest request, AdminUserRequest adminRequest) {
        try {
            AdminUser admin = adminUserService.update(
                    adminRequest.getAdminId(),
                    adminRequest.getFullName(),
                    adminRequest.getEmail(),
                    adminRequest.getOldPassword(),
                    adminRequest.getNewPassword());

            return BaseResponse.builder()
                    .msgId(request.getMsgId())
                    .messageCode(MessageCode.SUCCESS.getCode())
                    .messageDesc(MessageCode.SUCCESS.getDescription())
                    .messageBody(convertToResponse(admin))
                    .build();
        } catch (AdminUserNotFoundException e) {
            return BaseResponse.builder()
                    .msgId(request.getMsgId())
                    .messageCode(MessageCode.ADMIN_NOT_FOUND.getCode())
                    .messageDesc(MessageCode.ADMIN_NOT_FOUND.getDescription())
                    .build();
        } catch (EmailAlreadyExistsException e) {
            return BaseResponse.builder()
                    .msgId(request.getMsgId())
                    .messageCode(MessageCode.EMAIL_ALREADY_EXISTS.getCode())
                    .messageDesc(MessageCode.EMAIL_ALREADY_EXISTS.getDescription())
                    .build();
        } catch (WrongPassword e) {
            return BaseResponse.builder()
                    .msgId(request.getMsgId())
                    .messageCode(MessageCode.WRONG_PASSWORD.getCode())
                    .messageDesc(MessageCode.WRONG_PASSWORD.getDescription())
                    .build();
        }
    }

    private BaseResponse handleSetSuperAdmin(BaseRequest request, AdminUserRequest adminRequest) {
        try {
            AdminUser admin = adminUserService.setSuperAdmin(adminRequest.getAdminId(), adminRequest.getIsSuperAdmin());

            Map<AdminSection, Integer> sectionPermissons = new HashMap<>();

            sectionPermissons.put(AdminSection.DASH, PermissionType.WRITE_AND_READ.getValue());
            sectionPermissons.put(AdminSection.USERS, PermissionType.WRITE_AND_READ.getValue());
            sectionPermissons.put(AdminSection.STAFF, PermissionType.WRITE_AND_READ.getValue());
            sectionPermissons.put(AdminSection.SUBSCRIPTIONS, PermissionType.WRITE_AND_READ.getValue());
            sectionPermissons.put(AdminSection.TARIFFS, PermissionType.WRITE_AND_READ.getValue());
            sectionPermissons.put(AdminSection.CONTENT_MODERATION, PermissionType.WRITE_AND_READ.getValue());
            sectionPermissons.put(AdminSection.COMPLAINTS, PermissionType.WRITE_AND_READ.getValue());
            sectionPermissons.put(AdminSection.CLAIMS, PermissionType.WRITE_AND_READ.getValue());
            sectionPermissons.put(AdminSection.MAILINGS, PermissionType.WRITE_AND_READ.getValue());
            sectionPermissons.put(AdminSection.API, PermissionType.WRITE_AND_READ.getValue());
            sectionPermissons.put(AdminSection.MONEY, PermissionType.WRITE_AND_READ.getValue());
            sectionPermissons.put(AdminSection.KYC, PermissionType.WRITE_AND_READ.getValue());
            sectionPermissons.put(AdminSection.AGREEMENTS, PermissionType.WRITE_AND_READ.getValue());

            permissionService.setAllPermissions(admin.getId(), sectionPermissons);

            return BaseResponse.builder()
                    .msgId(request.getMsgId())
                    .messageCode(MessageCode.SUCCESS.getCode())
                    .messageDesc(MessageCode.SUCCESS.getDescription())
                    .messageBody(convertToResponse(admin))
                    .build();
        } catch (AdminUserNotFoundException e) {
            return BaseResponse.builder()
                    .msgId(request.getMsgId())
                    .messageCode(MessageCode.ADMIN_NOT_FOUND.getCode())
                    .messageDesc(MessageCode.ADMIN_NOT_FOUND.getDescription())
                    .build();
        }
    }

    private BaseResponse handleToggleActive(BaseRequest request, AdminUserRequest adminRequest) {
        try {
            adminUserService.toggleActive(adminRequest.getAdminId(), adminRequest.getIsActive());
            AdminUser admin = adminUserService.findById(adminRequest.getAdminId());

            return BaseResponse.builder()
                    .msgId(request.getMsgId())
                    .messageCode(MessageCode.SUCCESS.getCode())
                    .messageDesc(MessageCode.SUCCESS.getDescription())
                    .messageBody(convertToResponse(admin))
                    .build();
        } catch (AdminUserNotFoundException e) {
            return BaseResponse.builder()
                    .msgId(request.getMsgId())
                    .messageCode(MessageCode.ADMIN_NOT_FOUND.getCode())
                    .messageDesc(MessageCode.ADMIN_NOT_FOUND.getDescription())
                    .build();
        }
    }

    private BaseResponse handleDelete(BaseRequest request, AdminUserRequest adminRequest) {
        try {
            adminUserService.delete(adminRequest.getAdminId());

            return BaseResponse.builder()
                    .msgId(request.getMsgId())
                    .messageCode(MessageCode.SUCCESS.getCode())
                    .messageDesc(MessageCode.SUCCESS.getDescription())
                    .messageBody("Admin deleted successfully")
                    .build();
        } catch (AdminUserNotFoundException e) {
            return BaseResponse.builder()
                    .msgId(request.getMsgId())
                    .messageCode(MessageCode.ADMIN_NOT_FOUND.getCode())
                    .messageDesc(MessageCode.ADMIN_NOT_FOUND.getDescription())
                    .build();
        }
    }

    private BaseResponse handleInvalidAction(BaseRequest request, String action) {
        ActionResponse response = ActionResponse.builder()
                .action(action)
                .availableActions(Arrays.asList(
                        "login", "create", "get_all", "get_by_id",
                        "update", "set_super_admin", "toggle_active", "delete",
                        "get_permissions", "update_permissions"))
                .build();

        return BaseResponse.builder()
                .msgId(request.getMsgId())
                .messageCode(MessageCode.INVALID_ACTION.getCode())
                .messageDesc(MessageCode.INVALID_ACTION.getDescription())
                .messageBody(response)
                .build();
    }

    private BaseResponse handleGetPermissionsById(BaseRequest request, AdminUserRequest adminRequest) {
        try {
            Long userId = adminRequest.getAdminId();
            AdminUser admin = adminUserService.findById(userId);

            Map<AdminSection, Integer> sectionPermissions = permissionService.getAllPermissions(userId);

            Map<String, Integer> permissionsMap = new HashMap<>();
            sectionPermissions.forEach((section, value) ->
                    permissionsMap.put(section.name().toLowerCase(), value));

            AdminUserResponse response = AdminUserResponse.builder()
                    .id(admin.getId())
                    .fullName(admin.getFullName())
                    .email(admin.getEmail())
                    .isActive(admin.getIsActive())
                    .isSuperAdmin(AdminPermission.isSuperAdmin(admin.getPermissions()))
                    .createdAt(admin.getCreatedAt().toString())
                    .permissions(permissionsMap)
                    .build();

            return BaseResponse.builder()
                    .msgId(request.getMsgId())
                    .messageCode(MessageCode.SUCCESS.getCode())
                    .messageDesc(MessageCode.SUCCESS.getDescription())
                    .messageBody(response)
                    .build();
        } catch (AdminUserNotFoundException e) {
            return BaseResponse.builder()
                    .msgId(request.getMsgId())
                    .messageCode(MessageCode.ADMIN_NOT_FOUND.getCode())
                    .messageDesc(MessageCode.ADMIN_NOT_FOUND.getDescription())
                    .build();
        }
    }

    private BaseResponse handleGetPermissionsByToken(BaseRequest request) {
        try {
            String token = request.getToken();
            if (token == null || token.isEmpty()) {
                return BaseResponse.builder()
                        .msgId(request.getMsgId())
                        .messageCode(MessageCode.INVALID_CREDENTIALS.getCode())
                        .messageDesc("Token is required")
                        .build();
            }

            String email = jwtUtil.extractEmail(token);
            AdminUser admin = adminUserService.findByEmail(email);
            Map<AdminSection, Integer> sectionPermissions = permissionService.getAllPermissions(admin.getId());

            Map<String, Integer> permissionsMap = new HashMap<>();
            sectionPermissions.forEach((section, value) ->
                    permissionsMap.put(section.name().toLowerCase(), value));

            AdminUserResponse response = AdminUserResponse.builder()
                    .id(admin.getId())
                    .fullName(admin.getFullName())
                    .email(admin.getEmail())
                    .isActive(admin.getIsActive())
                    .isSuperAdmin(AdminPermission.isSuperAdmin(admin.getPermissions()))
                    .createdAt(admin.getCreatedAt().toString())
                    .permissions(permissionsMap)
                    .build();

            return BaseResponse.builder()
                    .msgId(request.getMsgId())
                    .messageCode(MessageCode.SUCCESS.getCode())
                    .messageDesc(MessageCode.SUCCESS.getDescription())
                    .messageBody(response)
                    .build();
        } catch (AdminUserNotFoundException e) {
            return BaseResponse.builder()
                    .msgId(request.getMsgId())
                    .messageCode(MessageCode.ADMIN_NOT_FOUND.getCode())
                    .messageDesc(MessageCode.ADMIN_NOT_FOUND.getDescription())
                    .build();
        }
    }

    private BaseResponse handleUpdatePermissions(BaseRequest request, AdminUserRequest adminRequest) {
        try {
            Long userId = adminRequest.getAdminId();
            Map<String, Integer> permissionsMap = adminRequest.getPermissions();

            if (permissionsMap == null || permissionsMap.isEmpty()) {
                return BaseResponse.builder()
                        .msgId(request.getMsgId())
                        .messageCode(MessageCode.INVALID_ACTION.getCode())
                        .messageDesc("Permissions map is required")
                        .build();
            }

            Map<AdminSection, Integer> permissions = new HashMap<>();

            for (Map.Entry<String, Integer> entry : permissionsMap.entrySet()) {
                try {
                    AdminSection section = AdminSection.valueOf(entry.getKey().toUpperCase());
                    permissions.put(section, entry.getValue());
                } catch (IllegalArgumentException e) {
                    return BaseResponse.builder()
                            .msgId(request.getMsgId())
                            .messageCode(MessageCode.INVALID_ACTION.getCode())
                            .messageDesc("Invalid section: " + entry.getKey() +
                                    ". Valid sections: " + Arrays.toString(AdminSection.values()))
                            .build();
                }
            }

            permissionService.setAllPermissions(userId, permissions);

            AdminUser admin = adminUserService.findById(userId);
            Map<AdminSection, Integer> updatedPermissions = permissionService.getAllPermissions(userId);

            Map<String, Integer> updatedPermissionsMap = new HashMap<>();
            updatedPermissions.forEach((section, value) ->
                    updatedPermissionsMap.put(section.name().toLowerCase(), value));

            AdminUserResponse response = AdminUserResponse.builder()
                    .id(admin.getId())
                    .fullName(admin.getFullName())
                    .email(admin.getEmail())
                    .isActive(admin.getIsActive())
                    .isSuperAdmin(AdminPermission.isSuperAdmin(admin.getPermissions()))
                    .createdAt(admin.getCreatedAt().toString())
                    .permissions(updatedPermissionsMap)
                    .build();

            return BaseResponse.builder()
                    .msgId(request.getMsgId())
                    .messageCode(MessageCode.SUCCESS.getCode())
                    .messageDesc("Permissions updated successfully")
                    .messageBody(response)
                    .build();
        } catch (AdminUserNotFoundException e) {
            return BaseResponse.builder()
                    .msgId(request.getMsgId())
                    .messageCode(MessageCode.ADMIN_NOT_FOUND.getCode())
                    .messageDesc(MessageCode.ADMIN_NOT_FOUND.getDescription())
                    .build();
        }
    }

    private AdminUserResponse convertToResponse(AdminUser admin) {
        Map<AdminSection, Integer> sectionPermissions = permissionService.getAllPermissions(admin.getId());

        Map<String, Integer> permissionsMap = new HashMap<>();
        sectionPermissions.forEach((section, value) ->
                permissionsMap.put(section.name().toLowerCase(), value));

        return AdminUserResponse.builder()
                .id(admin.getId())
                .fullName(admin.getFullName())
                .email(admin.getEmail())
                .isActive(admin.getIsActive())
                .isSuperAdmin(AdminPermission.isSuperAdmin(admin.getPermissions()))
                .createdAt(admin.getCreatedAt().toString())
                .permissions(permissionsMap)
                .activePassword(admin.getIsActivePassword())
                .build();
    }
}