Merge branch 'dev' into NCBACK-35

# Conflicts:
#	README.md
#	src/main/java/ru/soune/nocopy/controller/ApiController.java
#	src/main/java/ru/soune/nocopy/handler/FileEntityHandler.java
#	src/main/java/ru/soune/nocopy/service/file/FileCleanupService.java
#	src/main/java/ru/soune/nocopy/service/file/FileEntityService.java
#	src/main/java/ru/soune/nocopy/service/file/impl/FileUploadServiceImpl.java
#	src/main/java/ru/soune/nocopy/service/file/impl/ProtectionFileProviderImpl.java

src/main/java/ru/soune/nocopy/handler/FileEntityHandler.java

@@ -3,23 +3,28 @@ package ru.soune.nocopy.handler;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.domain.Page;
 import org.springframework.stereotype.Component;
 import ru.soune.nocopy.dto.*;
 import ru.soune.nocopy.dto.file.*;
+import ru.soune.nocopy.entity.file.FileAppeal;
 import ru.soune.nocopy.entity.file.FileEntity;
 import ru.soune.nocopy.entity.file.FileStatus;
 import ru.soune.nocopy.entity.file.ProtectionStatus;
-import ru.soune.nocopy.exception.FileEntityNotFoundException;
-import ru.soune.nocopy.exception.NotFoundAuthToken;
+import ru.soune.nocopy.entity.file.moderation.ModerationLog;
+import ru.soune.nocopy.exception.*;
+import ru.soune.nocopy.repository.FileAppealRepository;
 import ru.soune.nocopy.repository.FileEntityRepository;
 import ru.soune.nocopy.service.file.cloud.CloudStorageService;
+import ru.soune.nocopy.repository.ModerationLogRepository;
+import ru.soune.nocopy.service.file.moderation.ModerationService;
 import ru.soune.nocopy.service.register.AuthService;
 import ru.soune.nocopy.service.file.FileEntityService;
 import ru.soune.nocopy.service.file.FileStatsService;
 
-import java.util.Arrays;
-import java.util.List;
-import java.util.Optional;
+import java.time.LocalDate;
+import java.util.*;
+import java.util.stream.Collectors;
 
 @Slf4j
 @Component
@@ -38,6 +43,12 @@ public class FileEntityHandler implements RequestHandler {
 
     private final CloudStorageService cloudStorageService;
 
+    private final ModerationService moderationService;
+
+    private final FileAppealRepository fileAppealRepository;
+
+    private final ModerationLogRepository moderationLogRepository;
+
     @Override
     public BaseResponse handle(BaseRequest request) {
         try {
@@ -63,6 +74,18 @@ public class FileEntityHandler implements RequestHandler {
                     return handleProtectFile(request, fileRequest);
                 case "delete_file":
                     return handleDeleteFile(request, fileRequest);
+                case "change_file_status":
+                    return handleChangeStatus(request, fileRequest);
+                case "moderate_file":
+                    return handleModerateFile(request, fileRequest);
+                case "submit_appeal":
+                    return handleSubmitAppeal(request, fileRequest);
+                case "review_appeal":
+                    return handleReviewAppeal(request, fileRequest);
+                case "user_appeals":
+                    return handleGetUserAppeals(request, fileRequest);
+                case "files_for_moderation":
+                    return handleGetFilesForModeration(request, fileRequest);
                 default:
                     ActionResponse response = ActionResponse.builder()
                             .action(action)
@@ -186,53 +209,306 @@ public class FileEntityHandler implements RequestHandler {
         }
     }
 
+    private BaseResponse handleChangeStatus(BaseRequest request, FileEntityRequest fileRequest) {
+        FileStatus newStatus = fileRequest.getFileStatus();
+        String fileId = fileRequest.getFileId();
+
+        try {
+            fileEntityService.changeFileStatus(newStatus ,fileRequest.getFileId());
+        } catch (FileEntityNotFoundException e) {
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.FILE_NOT_FOUND.getCode(),
+                    MessageCode.FILE_NOT_FOUND.getDescription(),
+                    FileEntityResponse.builder().id(fileId).build());
+        }
+
+        return new BaseResponse(request.getMsgId(),
+                MessageCode.SUCCESS.getCode(),
+                MessageCode.SUCCESS.getDescription(),
+                FileEntityResponse.builder().status(newStatus).build());
+    }
+
     private BaseResponse handleSearchFiles(BaseRequest request, FileEntityRequest fileRequest) {
         try {
             Long userId = authService.useUserAuthToken(fileRequest.getToken());
             int page = fileRequest.getPage() != null ? fileRequest.getPage() : 1;
             int pageSize = fileRequest.getPageSize() != null ? fileRequest.getPageSize() : 20;
 
-            if (fileRequest.getQuery() == null || fileRequest.getQuery().isBlank()) {
-                return handleGetUserFiles(request, fileRequest);
-            }
+            String sortBy = fileRequest.getSortBy() != null ? fileRequest.getSortBy() : "fileName";
+            SortOrder sortOrder = SortOrder.fromString(fileRequest.getSortOrder());
 
             FileResponse allFiles = fileEntityService.getUserFiles(userId, 1, 1000, request.getVersion());
 
-            var filteredFiles = allFiles.getFiles().stream()
-                    .filter(f -> (f.getOriginalFileName() + f.getFileExtension()).toLowerCase()
-                            .contains(fileRequest.getQuery().toLowerCase()))
-                    .toList();
+            String searchQuery = fileRequest.getQuery() != null ? fileRequest.getQuery().toLowerCase().trim() : "";
+            String[] searchTerms = searchQuery.split("\\s+");
+            String filterType = fileRequest.getType();
+            String dateFilter = fileRequest.getDateFilter();
+
+            List<FileEntityResponse> filteredFiles = allFiles.getFiles().stream()
+                    .filter(f -> matchesSearch(f, searchTerms, searchQuery, filterType))
+                    .filter(f -> matchesDateFilter(f, dateFilter))
+                    .collect(Collectors.toList());
+
+            Comparator<FileEntityResponse> comparator = getComparator(sortBy, sortOrder);
+            filteredFiles.sort(comparator);
 
             int start = (page - 1) * pageSize;
             int end = Math.min(start + pageSize, filteredFiles.size());
-            List<FileEntityResponse> fileEntityResponses = filteredFiles.subList(start, Math.min(end, filteredFiles.size()));
-            long sumSize = fileEntityResponses.stream()
+
+            if (start >= filteredFiles.size()) {
+                return createEmptyResponse(request, page, pageSize, sortBy, sortOrder.getValue());
+            }
+
+            List<FileEntityResponse> paginatedFiles = filteredFiles.subList(start, end);
+            long totalSize = paginatedFiles.stream()
                     .mapToLong(FileEntityResponse::getFileSize)
                     .sum();
 
             FileListResponse response = FileListResponse.builder()
-                    .files(fileEntityResponses)
+                    .files(paginatedFiles)
                     .totalCount(filteredFiles.size())
-                    .totalSize(sumSize)
-                    .formattedTotalSize(fileEntityService.formatFileSize(sumSize))
+                    .totalSize(totalSize)
+                    .formattedTotalSize(fileEntityService.formatFileSize(totalSize))
                     .page(page)
                     .pageSize(pageSize)
+                    .sortBy(sortBy)
+                    .sortOrder(sortOrder.getValue())
                     .build();
 
             return new BaseResponse(request.getMsgId(),
                     MessageCode.SUCCESS.getCode(),
                     MessageCode.SUCCESS.getDescription(),
                     response);
+
         } catch (NotFoundAuthToken e) {
-            return new BaseResponse(request.getMsgId(), MessageCode.INVALID_TOKEN.getCode(),
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.INVALID_TOKEN.getCode(),
                     "Authentication required", null);
         } catch (Exception e) {
             log.error("Error searching files", e);
-            return new BaseResponse(request.getMsgId(), MessageCode.FILE_UPLOAD_ERROR.getCode(),
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.FILE_UPLOAD_ERROR.getCode(),
                     "Failed to search files: " + e.getMessage(), null);
         }
     }
 
+    private boolean matchesDateFilter(FileEntityResponse file, String dateFilter) {
+        if (dateFilter == null || dateFilter.isEmpty()) {
+            return true;
+        }
+
+        LocalDate fileDate = file.getCreatedAt().toLocalDate();
+        LocalDate now = LocalDate.now();
+
+        switch (dateFilter.toLowerCase()) {
+            case "today":
+                return fileDate.equals(now);
+            case "week":
+                return fileDate.isAfter(now.minusWeeks(1)) && !fileDate.isAfter(now);
+            case "month":
+                return fileDate.isAfter(now.minusMonths(1)) && !fileDate.isAfter(now);
+            default:
+                return true;
+        }
+    }
+
+    private boolean matchesSearch(FileEntityResponse file, String[] searchTerms, String fullQuery, String type) {
+        String fileName = getSafeString(file.getFileName());
+        String originalFileName = getSafeString(file.getOriginalFileName());
+        String mimeType = getSafeString(file.getMimeType());
+        String fileFormat = getSafeString(file.getFileFormat());
+        String fullFileName = fileName + " " + originalFileName;
+
+        boolean matchesType = true;
+        if (type != null && !type.isEmpty()) {
+            matchesType = matchesMimeType(mimeType, type);
+        }
+
+        if (!matchesType) {
+            return false;
+        }
+
+        if (fullQuery != null && !fullQuery.isEmpty()) {
+            if (fullFileName.toLowerCase().contains(fullQuery)) {
+                return true;
+            }
+
+            for (String term : searchTerms) {
+                if (term.length() < 2) continue;
+                if (fullFileName.toLowerCase().contains(term)) {
+                    return true;
+                }
+            }
+
+            if (fileFormat.toLowerCase().contains(fullQuery)) {
+                return true;
+            }
+
+            if (mimeType.toLowerCase().contains(fullQuery)) {
+                return true;
+            }
+
+            if (!fileFormat.isEmpty() && !fileName.toLowerCase().endsWith("." + fileFormat.toLowerCase())) {
+                String fileNameWithExtension = fileName + "." + fileFormat;
+                if (fileNameWithExtension.toLowerCase().contains(fullQuery)) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        return true;
+    }
+
+    private boolean matchesMimeType(String mimeType, String filterType) {
+        if (filterType == null || filterType.isEmpty()) return true;
+
+        String mimeTypeLower = mimeType.toLowerCase();
+        String filterTypeLower = filterType.toLowerCase().trim();
+
+        return mimeTypeLower.equals(filterTypeLower);
+    }
+
+    private String getSafeString(String value) {
+        return value != null ? value : "";
+    }
+
+    private Comparator<FileEntityResponse> getComparator(String sortBy, SortOrder sortOrder) {
+        Comparator<FileEntityResponse> comparator;
+
+        switch (sortBy) {
+            case "fileSize":
+                comparator = Comparator.comparingLong(
+                        FileEntityResponse::getFileSize
+                );
+                break;
+
+            case "fileType":
+                comparator = Comparator.comparing(
+                        FileEntityResponse::getMimeType);
+                break;
+
+            case "createdAt":
+                comparator = Comparator.comparing(
+                        FileEntityResponse::getCreatedAt,
+                        Comparator.nullsLast(Comparator.naturalOrder())
+                );
+                break;
+
+            case "updatedAt":
+                comparator = Comparator.comparing(
+                        FileEntityResponse::getUpdatedAt,
+                        Comparator.nullsLast(Comparator.naturalOrder())
+                );
+                break;
+
+            case "fileName":
+                comparator = Comparator.comparing(
+                        f -> getSafeString(f.getFileName()).toLowerCase(),
+                        Comparator.nullsLast(Comparator.naturalOrder())
+                );
+                break;
+
+            case "protectStatus":
+                comparator = Comparator.comparing(
+                        f -> getSafeString(f.getProtectStatus()).toLowerCase(),
+                        Comparator.nullsLast(Comparator.naturalOrder())
+                );
+                break;
+
+            case "supportId":
+                comparator = Comparator.comparing(
+                        FileEntityResponse::getSupportId,
+                        Comparator.nullsLast(Comparator.naturalOrder())
+                );
+                break;
+
+            default:
+                comparator = Comparator.comparing(
+                        f -> getSafeString(f.getFileName()).toLowerCase(),
+                        Comparator.nullsLast(Comparator.naturalOrder())
+                );
+                break;
+        }
+
+        return sortOrder == SortOrder.DESC ? comparator.reversed() : comparator;
+    }
+
+    private BaseResponse createEmptyResponse(BaseRequest request, int page, int pageSize,
+                                             String sortBy, String sortOrder) {
+        FileListResponse emptyResponse = FileListResponse.builder()
+                .files(Collections.emptyList())
+                .totalCount(0)
+                .totalSize(0L)
+                .formattedTotalSize("0 B")
+                .page(page)
+                .pageSize(pageSize)
+                .sortBy(sortBy)
+                .sortOrder(sortOrder)
+                .build();
+
+        return new BaseResponse(request.getMsgId(),
+                MessageCode.SUCCESS.getCode(),
+                MessageCode.SUCCESS.getDescription(),
+                emptyResponse);
+    }
+
+    private BaseResponse handleGetUserFilesWithSort(BaseRequest request, FileEntityRequest fileRequest,
+                                                    String sortBy, SortOrder sortOrder) {
+        try {
+            Long userId = authService.useUserAuthToken(fileRequest.getToken());
+            int page = fileRequest.getPage() != null ? fileRequest.getPage() : 1;
+            int pageSize = fileRequest.getPageSize() != null ? fileRequest.getPageSize() : 20;
+
+            FileResponse allFiles = fileEntityService.getUserFiles(userId, 1, 1000, request.getVersion());
+
+            List<FileEntityResponse> files = new ArrayList<>(allFiles.getFiles());
+
+            Comparator<FileEntityResponse> comparator = getComparator(sortBy, sortOrder);
+            files.sort(comparator);
+
+            int start = (page - 1) * pageSize;
+            int end = Math.min(start + pageSize, files.size());
+
+            if (start >= files.size()) {
+                return createEmptyResponse(request, page, pageSize, sortBy, sortOrder.getValue());
+            }
+
+            List<FileEntityResponse> paginatedFiles = files.subList(start, end);
+            long totalSize = paginatedFiles.stream()
+                    .mapToLong(FileEntityResponse::getFileSize)
+                    .sum();
+
+            FileListResponse response = FileListResponse.builder()
+                    .files(paginatedFiles)
+                    .totalCount(files.size())
+                    .totalSize(totalSize)
+                    .formattedTotalSize(fileEntityService.formatFileSize(totalSize))
+                    .page(page)
+                    .pageSize(pageSize)
+                    .sortBy(sortBy)
+                    .sortOrder(sortOrder.getValue())
+                    .build();
+
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.SUCCESS.getCode(),
+                    MessageCode.SUCCESS.getDescription(),
+                    response);
+
+        } catch (NotFoundAuthToken e) {
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.INVALID_TOKEN.getCode(),
+                    "Authentication required", null);
+        } catch (Exception e) {
+            log.error("Error getting user files with sort", e);
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.FILE_UPLOAD_ERROR.getCode(),
+                    "Failed to get files: " + e.getMessage(),
+                    null);
+        }
+    }
+
     private BaseResponse handleGetStorageUsage(BaseRequest request, FileEntityRequest fileRequest) {
         try {
             Long userId = authService.useUserAuthToken(fileRequest.getToken());
@@ -337,6 +613,326 @@ public class FileEntityHandler implements RequestHandler {
         }
     }
 
+    private BaseResponse handleModerateFile(BaseRequest request, FileEntityRequest fileRequest) {
+        try {
+            //TODO добавить проверку на админа
+//            Long moderatorId = authService.useAdminAuthToken(fileRequest.getToken());
+
+            ModerationActionRequest moderationRequest = ModerationActionRequest.builder()
+                    .fileId(fileRequest.getFileId())
+                    .newStatus(fileRequest.getFileStatus())
+                    .comment(fileRequest.getComment())
+                    .build();
+
+            //TODO set moderator ID
+            moderationService.moderateFile(moderationRequest, 0L);
+
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.SUCCESS_MODERATION.getCode(),
+                    MessageCode.SUCCESS_MODERATION.getDescription(),
+                    FileEntityResponse.builder().id(fileRequest.getFileId()).build());
+
+        } catch (SecurityException e) {
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.ACCESS_DENIED.getCode(),
+                    MessageCode.ACCESS_DENIED.getDescription(),
+                    FileEntityResponse.builder().id(fileRequest.getFileId()).build());
+        } catch (FileEntityNotFoundException e) {
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.FILE_NOT_FOUND.getCode(),
+                    MessageCode.FILE_NOT_FOUND.getDescription(),
+                    FileEntityResponse.builder()
+                            .id(fileRequest.getFileId()).build());
+        } catch (IllegalStateException e) {
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.ILLEGAL_STATE.getCode(),
+                    MessageCode.ILLEGAL_STATE.getDescription(),
+                    FileEntityResponse.builder()
+                            .status(fileRequest.getFileStatus()).build());
+        }
+    }
+
+    private BaseResponse handleSubmitAppeal(BaseRequest request, FileEntityRequest fileRequest) {
+        try {
+            Long userId = authService.useUserAuthToken(fileRequest.getToken());
+
+            AppealRequest appealRequest = AppealRequest.builder()
+                    .fileId(fileRequest.getFileId())
+                    .appealReason(fileRequest.getAppealReason())
+                    .additionalInfo(fileRequest.getAdditionalInfo())
+                    .build();
+
+            AppealResponse response = moderationService.submitAppeal(appealRequest, userId);
+
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.SUCCESS.getCode(),
+                    "Appeal submitted successfully",
+                    response);
+        } catch (InvalidAppealException e) {
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.INVALID_FIELD.getCode(),
+                    e.getMessage(),
+                    null);
+        } catch (Exception e) {
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.INVALID_FIELD.getCode(),
+                    "Failed to submit appeal: " + e.getMessage(),
+                    null);
+        }
+    }
+
+    private BaseResponse handleReviewAppeal(BaseRequest request, FileEntityRequest fileRequest) {
+        try {
+            // TODO
+//            Long moderatorId = authService.useAdminAuthToken(fileRequest.getToken());
+
+            String appealId = fileRequest.getAppealId();
+            Boolean approve = fileRequest.getApprove();
+            String comment = fileRequest.getComment();
+
+            if (appealId == null || approve == null) {
+                return new BaseResponse(request.getMsgId(),
+                        MessageCode.INVALID_FIELD.getCode(),
+                        "appealId and approve are required",
+                        null);
+            }
+            //TODO
+            moderationService.reviewAppeal(appealId, approve, comment, 0L);
+
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.SUCCESS.getCode(),
+                    "Appeal reviewed successfully",
+                    Map.of(
+                            "appealId", appealId,
+                            "approved", approve,
+                            "comment", comment
+                    ));
+
+        } catch (SecurityException e) {
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.ACCESS_DENIED.getCode(),
+                    "Admin access required",
+                    null);
+        } catch (IllegalStateException e) {
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.INVALID_FIELD.getCode(),
+                    e.getMessage(),
+                    null);
+        } catch (Exception e) {
+            log.error("Error reviewing appeal", e);
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.INVALID_FIELD.getCode(),
+                    "Failed to review appeal: " + e.getMessage(),
+                    null);
+        }
+    }
+
+    private BaseResponse handleGetUserAppeals(BaseRequest request, FileEntityRequest fileRequest) {
+        try {
+            Long userId = authService.useUserAuthToken(fileRequest.getToken());
+
+            int page = fileRequest.getPage() != null ? fileRequest.getPage() : 1;
+            int pageSize = fileRequest.getPageSize() != null ? fileRequest.getPageSize() : 20;
+
+            Page<AppealResponse> appeals = moderationService.getUserAppeals(userId, page - 1, pageSize);
+
+            Map<String, Object> response = Map.of(
+                    "appeals", appeals.getContent(),
+                    "totalCount", appeals.getTotalElements(),
+                    "totalPages", appeals.getTotalPages(),
+                    "currentPage", page,
+                    "pageSize", pageSize);
+
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.SUCCESS.getCode(),
+                    MessageCode.SUCCESS.getDescription(),
+                    response);
+
+        } catch (SecurityException e) {
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.INVALID_TOKEN.getCode(),
+                    "Authentication required",
+                    null);
+        } catch (Exception e) {
+            log.error("Error getting user appeals", e);
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.INVALID_FIELD.getCode(),
+                    "Failed to get appeals: " + e.getMessage(),
+                    null);
+        }
+    }
+
+    private BaseResponse handleGetFilesForModeration(BaseRequest request, FileEntityRequest fileRequest) {
+        try {
+            //TODO
+//            authService.useAdminAuthToken(fileRequest.getToken());
+
+            int page = fileRequest.getPage() != null ? fileRequest.getPage() : 1;
+            int pageSize = fileRequest.getPageSize() != null ? fileRequest.getPageSize() : 20;
+
+            Page<FileEntity> files = moderationService.getFilesForModeration(page - 1, pageSize);
+
+            List<Map<String, Object>> filesWithInfo = files.getContent().stream()
+                    .map(file -> {
+                        FileModerationInfo info = moderationService.getFileModerationInfo(file.getId());
+
+                        Map<String, Object> fileMap = new HashMap<>();
+                        fileMap.put("fileId", file.getId());
+                        fileMap.put("fileName", file.getOriginalFileName());
+                        fileMap.put("userId", file.getUserId());
+                        fileMap.put("status", file.getStatus() != null ? file.getStatus().name() : null);
+
+                        Map<String, Object> moderationInfoMap = new HashMap<>();
+                        moderationInfoMap.put("hasActiveAppeal", info != null && info.getHasActiveAppeal());
+
+                        if (info != null && info.getActiveAppeal() != null) {
+                            Map<String, Object> appealInfoMap = new HashMap<>();
+                            appealInfoMap.put("appealId", info.getActiveAppeal().getAppealId());
+                            appealInfoMap.put("status", info.getActiveAppeal().getStatus());
+                            appealInfoMap.put("createdAt", info.getActiveAppeal().getCreatedAt());
+                            moderationInfoMap.put("appealInfo", appealInfoMap);
+                        } else {
+                            moderationInfoMap.put("appealInfo", null);
+                        }
+
+                        fileMap.put("moderationInfo", moderationInfoMap);
+
+                        return fileMap;
+                    })
+                    .collect(Collectors.toList());
+
+            Map<String, Object> response = Map.of(
+                    "files", filesWithInfo,
+                    "totalCount", files.getTotalElements(),
+                    "totalPages", files.getTotalPages(),
+                    "currentPage", page,
+                    "pageSize", pageSize
+            );
+
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.SUCCESS.getCode(),
+                    MessageCode.SUCCESS.getDescription(),
+                    response);
+
+        } catch (SecurityException e) {
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.ACCESS_DENIED.getCode(),
+                    "Admin access required",
+                    null);
+        } catch (Exception e) {
+            log.error("Error getting files for moderation", e);
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.INVALID_FIELD.getCode(),
+                    "Failed to get files: " + e.getMessage(),
+                    null);
+        }
+    }
+
+    private BaseResponse handleGetFileModerationInfo(BaseRequest request, FileEntityRequest fileRequest) {
+        try {
+            // TODO
+            // authService.useAdminAuthToken(fileRequest.getToken());
+
+            String fileId = fileRequest.getFileId();
+            if (fileId == null) {
+                return new BaseResponse(request.getMsgId(),
+                        MessageCode.INVALID_FIELD.getCode(),
+                        "fileId is required",
+                        null);
+            }
+
+            FileModerationInfo moderationInfo = moderationService.getFileModerationInfo(fileId);
+
+            FileEntity file = fileEntityRepository.findById(fileId)
+                    .orElseThrow(() -> new FileEntityNotFoundException(fileId));
+
+            Map<String, Object> fileInfoMap = new HashMap<>();
+            fileInfoMap.put("id", file.getId());
+            fileInfoMap.put("fileName", file.getOriginalFileName());
+            fileInfoMap.put("storedFileName", file.getStoredFileName());
+            fileInfoMap.put("fileSize", file.getFileSize());
+            fileInfoMap.put("formattedSize", fileEntityService.formatFileSize(file.getFileSize()));
+            fileInfoMap.put("mimeType", file.getMimeType());
+            fileInfoMap.put("fileExtension", file.getFileExtension());
+            fileInfoMap.put("checksum", file.getChecksum());
+            fileInfoMap.put("status", file.getStatus() != null ? file.getStatus().name() : null);
+            fileInfoMap.put("createdAt", file.getCreatedAt());
+            fileInfoMap.put("updatedAt", file.getUpdatedAt());
+
+            Map<String, Object> response = new HashMap<>();
+            response.put("fileInfo", fileInfoMap);
+            response.put("moderationInfo", moderationInfo != null ? moderationInfo : new HashMap<>());
+            response.put("moderationHistory", getModerationHistory(fileId));
+            response.put("appeals", getFileAppeals(fileId));
+
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.SUCCESS.getCode(),
+                    MessageCode.SUCCESS.getDescription(),
+                    response);
+
+        } catch (SecurityException e) {
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.ACCESS_DENIED.getCode(),
+                    "Admin access required",
+                    null);
+        } catch (FileEntityNotFoundException e) {
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.FILE_NOT_FOUND.getCode(),
+                    e.getMessage(),
+                    null);
+        } catch (Exception e) {
+            log.error("Error getting file moderation info", e);
+            return new BaseResponse(request.getMsgId(),
+                    MessageCode.INVALID_FIELD.getCode(),
+                    "Failed to get file info: " + e.getMessage(),
+                    null);
+        }
+    }
+
+    private List<Map<String, Object>> getModerationHistory(String fileId) {
+        List<ModerationLog> logs = moderationLogRepository.findByFileIdOrderByCreatedAtDesc(fileId);
+        if (logs == null || logs.isEmpty()) {
+            return Collections.emptyList();
+        }
+
+        return logs.stream()
+                .map(log -> {
+                    Map<String, Object> logMap = new HashMap<>();
+                    logMap.put("id", log.getId());
+                    logMap.put("moderatorId", log.getModeratorId());
+                    logMap.put("oldStatus", log.getOldStatus() != null ? log.getOldStatus().name() : null);
+                    logMap.put("newStatus", log.getNewStatus() != null ? log.getNewStatus().name() : null);
+                    logMap.put("reason", log.getReason());
+                    logMap.put("comment", log.getComment());
+                    logMap.put("createdAt", log.getCreatedAt());
+                    return logMap;
+                })
+                .collect(Collectors.toList());
+    }
+
+    private List<Map<String, Object>> getFileAppeals(String fileId) {
+        List<FileAppeal> appeals = fileAppealRepository.findByFileId(fileId);
+        if (appeals == null || appeals.isEmpty()) {
+            return Collections.emptyList();
+        }
+
+        return appeals.stream()
+                .map(appeal -> {
+                    Map<String, Object> appealMap = new HashMap<>();
+                    appealMap.put("id", appeal.getId());
+                    appealMap.put("userId", appeal.getUserId());
+                    appealMap.put("appealReason", appeal.getAppealReason());
+                    appealMap.put("additionalInfo", appeal.getAdditionalInfo());
+                    appealMap.put("status", appeal.getStatus() != null ? appeal.getStatus().name() : null);
+                    appealMap.put("adminComment", appeal.getAdminComment());
+                    appealMap.put("moderatorId", appeal.getModeratorId());
+                    appealMap.put("createdAt", appeal.getCreatedAt());
+                    appealMap.put("resolvedAt", appeal.getResolvedAt());
+                    return appealMap;
+                })
+                .collect(Collectors.toList());
+    }
+
     private String formatFileSize(long size) {
         if (size < 1024) return size + " B";
         int exp = (int) (Math.log(size) / Math.log(1024));