snapshot/backend/src/main/java/com/snapshot/controller/UploadController.java

package com.snapshot.controller;

import com.snapshot.dto.ApiResponse;
import com.snapshot.dto.UploadRequest;
import com.snapshot.dto.UploadResponse;
import com.snapshot.entity.FileEntry;
import com.snapshot.service.FileStorageService;
import com.snapshot.service.UploadRecordService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.validation.Valid;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 上传控制器
 */
@Slf4j
@RestController
@RequestMapping("/api/upload")
@RequiredArgsConstructor
public class UploadController {

    private final UploadRecordService uploadRecordService;
    private final FileStorageService fileStorageService;

    @Value("${app.file.max-size:52428800}")
    private long maxFileSize;

    @Value("${app.file.max-count:10}")
    private int maxFileCount;

    /**
     * 创建上传记录
     */
    @PostMapping
    public ResponseEntity<ApiResponse<UploadResponse>> createUpload(
            @Valid @RequestBody UploadRequest request) {

        log.info("创建上传记录: 过期时间={}小时, 最大下载次数={}",
                request.getExpirationHours(), request.getMaxDownloadCount());

        UploadResponse response = uploadRecordService.createUploadRecord(request);

        return ResponseEntity.ok(ApiResponse.success(response));
    }

    /**
     * 上传文件
     */
    @PostMapping(value = "/{id}/files", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    public ResponseEntity<ApiResponse<Map<String, Object>>> uploadFiles(
            @PathVariable String id,
            @RequestParam("files") List<MultipartFile> files) {

        log.info("上传文件到记录 {}: 文件数量={}", id, files.size());

        // 验证文件数量
        if (!fileStorageService.isValidFileCount(files, maxFileCount)) {
            return ResponseEntity.badRequest()
                    .body(ApiResponse.error(400, "文件数量超过限制，最多" + maxFileCount + "个文件"));
        }

        // 验证文件大小
        for (MultipartFile file : files) {
            if (!fileStorageService.isValidFileSize(file, maxFileSize)) {
                return ResponseEntity.badRequest()
                        .body(ApiResponse.error(400,
                                "文件 " + file.getOriginalFilename() + " 超过大小限制，最大" + (maxFileSize / 1024 / 1024) + "MB"));
            }
        }

        try {
            List<FileEntry> fileEntries = fileStorageService.saveFiles(id, files);

            Map<String, Object> result = new HashMap<>();
            result.put("uploadId", id);
            result.put("fileCount", fileEntries.size());
            result.put("files", fileEntries);

            return ResponseEntity.ok(ApiResponse.success("文件上传成功", result));

        } catch (IOException e) {
            log.error("文件上传失败: {}", e.getMessage(), e);
            return ResponseEntity.status(500)
                    .body(ApiResponse.error("文件上传失败: " + e.getMessage()));
        }
    }

    /**
     * 获取上传记录详情
     */
    @GetMapping("/{id}")
    public ResponseEntity<ApiResponse<UploadResponse>> getUploadRecord(@PathVariable String id) {
        try {
            log.info("查询上传记录: {}", id);

            UploadResponse response = uploadRecordService.getUploadRecord(id);

            return ResponseEntity.ok(ApiResponse.success(response));

        } catch (RuntimeException e) {
            log.error("查询上传记录失败: {}", e.getMessage());
            return ResponseEntity.status(404)
                    .body(ApiResponse.error(404, e.getMessage()));
        }
    }

    /**
     * 验证密码
     */
    @PostMapping("/{id}/verify-password")
    public ResponseEntity<ApiResponse<Boolean>> verifyPassword(
            @PathVariable String id,
            @RequestBody Map<String, String> request) {

        String password = request.get("password");

        boolean valid = uploadRecordService.verifyPassword(id, password);

        return ResponseEntity.ok(ApiResponse.success(valid));
    }

    /**
     * 删除上传记录
     */
    @DeleteMapping("/{id}")
    public ResponseEntity<ApiResponse<Void>> deleteUploadRecord(@PathVariable String id) {
        log.info("删除上传记录: {}", id);

        uploadRecordService.deleteUploadRecord(id);

        return ResponseEntity.ok(ApiResponse.success("删除成功", null));
    }

    /**
     * 根据前缀查找ID
     */
    @GetMapping("/resolve/{prefix}")
    public ResponseEntity<ApiResponse<Map<String, String>>> resolveByPrefix(@PathVariable String prefix) {
        try {
            String fullId = uploadRecordService.resolveIdByPrefix(prefix);

            Map<String, String> result = new HashMap<>();
            result.put("prefix", prefix);
            result.put("fullId", fullId);

            return ResponseEntity.ok(ApiResponse.success(result));

        } catch (RuntimeException e) {
            return ResponseEntity.status(404)
                    .body(ApiResponse.error(404, e.getMessage()));
        }
    }
}