import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Base64;

@Service
public class PsdToBase64Service {
    
    /**
     * 將PSD文件轉(zhuǎn)換為Base64字符串
     * @param psdFile PSD文件路徑
     * @return Base64編碼字符串
     * @throws IOException 文件讀取異常
     */
    public String convertPsdToBase64(String psdFile) throws IOException {
        Path path = Paths.get(psdFile);
        byte[] fileBytes = Files.readAllBytes(path);
        return Base64.getEncoder().encodeToString(fileBytes);
    }
    
    /**
     * 處理Spring上傳的MultipartFile
     * @param multipartFile 上傳的PSD文件
     * @return Base64編碼字符串
     * @throws IOException 文件處理異常
     */
    public String convertMultipartPsdToBase64(MultipartFile multipartFile) throws IOException {
        if (multipartFile.isEmpty()) {
            throw new IllegalArgumentException("文件不能為空");
        }
        
        // 驗(yàn)證文件擴(kuò)展名
        String originalFilename = multipartFile.getOriginalFilename();
        if (originalFilename == null || !originalFilename.toLowerCase().endsWith(".psd")) {
            throw new IllegalArgumentException("請(qǐng)上傳PSD格式文件");
        }
        
        byte[] fileBytes = multipartFile.getBytes();
        return Base64.getEncoder().encodeToString(fileBytes);
    }
    
    /**
     * 大文件分塊處理（內(nèi)存優(yōu)化版本）
     * @param psdFile PSD文件路徑
     * @return Base64編碼字符串
     * @throws IOException 文件讀取異常
     */
    public String convertLargePsdToBase64(String psdFile) throws IOException {
        try (FileInputStream fis = new FileInputStream(psdFile);
             ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
            
            byte[] buffer = new byte[8192]; // 8KB緩沖區(qū)
            int bytesRead;
            
            while ((bytesRead = fis.read(buffer)) != -1) {
                baos.write(buffer, 0, bytesRead);
            }
            
            return Base64.getEncoder().encodeToString(baos.toByteArray());
        }
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

@RestController
@RequestMapping("/api/psd")
public class PsdConversionController {
    
    @Autowired
    private PsdToBase64Service psdService;
    
    /**
     * 上傳PSD文件并轉(zhuǎn)換為Base64
     */
    @PostMapping("/upload-convert")
    public ResponseEntity<PsdConversionResponse> uploadAndConvert(
            @RequestParam("file") MultipartFile file) {
        
        try {
            String base64String = psdService.convertMultipartPsdToBase64(file);
            
            PsdConversionResponse response = new PsdConversionResponse();
            response.setSuccess(true);
            response.setBase64Data(base64String);
            response.setOriginalFileName(file.getOriginalFilename());
            response.setFileSize(file.getSize());
            response.setMessage("PSD文件轉(zhuǎn)換成功");
            
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            PsdConversionResponse errorResponse = new PsdConversionResponse();
            errorResponse.setSuccess(false);
            errorResponse.setMessage("轉(zhuǎn)換失敗: " + e.getMessage());
            return ResponseEntity.badRequest().body(errorResponse);
        }
    }
}

// 響應(yīng)實(shí)體類(lèi)
class PsdConversionResponse {
    private boolean success;
    private String base64Data;
    private String originalFileName;
    private long fileSize;
    private String message;
    
    // getter和setter方法
    public boolean isSuccess() { return success; }
    public void setSuccess(boolean success) { this.success = success; }
    
    public String getBase64Data() { return base64Data; }
    public void setBase64Data(String base64Data) { this.base64Data = base64Data; }
    
    public String getOriginalFileName() { return originalFileName; }
    public void setOriginalFileName(String originalFileName) { this.originalFileName = originalFileName; }
    
    public long getFileSize() { return fileSize; }
    public void setFileSize(long fileSize) { this.fileSize = fileSize; }
    
    public String getMessage() { return message; }
    public void setMessage(String message) { this.message = message; }
}

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConfigurationProperties(prefix = "app.file")
public class FileConfiguration {
    private long maxFileSize = 50 * 1024 * 1024; // 50MB
    private String[] allowedExtensions = {"psd"};
    
    // getter和setter
    public long getMaxFileSize() { return maxFileSize; }
    public void setMaxFileSize(long maxFileSize) { this.maxFileSize = maxFileSize; }
    
    public String[] getAllowedExtensions() { return allowedExtensions; }
    public void setAllowedExtensions(String[] allowedExtensions) { this.allowedExtensions = allowedExtensions; }
}

@Component
public class FileValidationUtil {
    
    @Autowired
    private FileConfiguration fileConfig;
    
    public void validatePsdFile(MultipartFile file) throws IllegalArgumentException {
        if (file.isEmpty()) {
            throw new IllegalArgumentException("文件不能為空");
        }
        
        if (file.getSize() > fileConfig.getMaxFileSize()) {
            throw new IllegalArgumentException("文件大小超過(guò)限制: " + fileConfig.getMaxFileSize() + " bytes");
        }
        
        String filename = file.getOriginalFilename();
        if (filename == null || !filename.toLowerCase().endsWith(".psd")) {
            throw new IllegalArgumentException("只支持PSD格式文件");
        }
    }
}

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import java.util.concurrent.CompletableFuture;

@Service
public class AsyncPsdConversionService {
    
    @Async
    public CompletableFuture<String> convertPsdToBase64Async(MultipartFile file) {
        try {
            // 模擬大文件處理時(shí)間
            Thread.sleep(1000);
            
            byte[] fileBytes = file.getBytes();
            String base64 = Base64.getEncoder().encodeToString(fileBytes);
            
            return CompletableFuture.completedFuture(base64);
        } catch (Exception e) {
            return CompletableFuture.failedFuture(e);
        }
    }
}

// 流式處理避免內(nèi)存溢出
public String convertPsdToBase64Stream(InputStream inputStream) throws IOException {
    try (ByteArrayOutputStream output = new ByteArrayOutputStream()) {
        byte[] buffer = new byte[4096];
        int n = 0;
        while (-1 != (n = inputStream.read(buffer))) {
            output.write(buffer, 0, n);
        }
        return Base64.getEncoder().encodeToString(output.toByteArray());
    }
}

@Service
public class CachedPsdConversionService {
    
    @Cacheable(value = "psdBase64Cache", key = "#file.originalFilename + '_' + #file.size")
    public String convertWithCache(MultipartFile file) throws IOException {
        return convertMultipartPsdToBase64(file);
    }
}

@Component
public class SecurityValidation {
    
    public void validateFileContent(byte[] fileBytes) throws SecurityException {
        // 檢查PSD文件頭
        if (fileBytes.length < 4) {
            throw new SecurityException("文件內(nèi)容不完整");
        }
        
        // PSD文件以"8BPS"開(kāi)頭
        String header = new String(fileBytes, 0, 4, StandardCharsets.US_ASCII);
        if (!"8BPS".equals(header)) {
            throw new SecurityException("不是有效的PSD文件");
        }
    }
}

import java.util.zip.GZIPOutputStream;
import java.util.zip.GZIPInputStream;

public class CompressedBase64Service {
    
    public String convertAndCompress(MultipartFile file) throws IOException {
        byte[] fileBytes = file.getBytes();
        
        // 壓縮后再轉(zhuǎn)Base64
        try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
             GZIPOutputStream gzipOut = new GZIPOutputStream(baos)) {
            
            gzipOut.write(fileBytes);
            gzipOut.finish();
            
            return Base64.getEncoder().encodeToString(baos.toByteArray());
        }
    }
}

@Component
public class ConversionMetrics {
    
    private final MeterRegistry meterRegistry;
    
    public ConversionMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
    }
    
    public String convertWithMetrics(MultipartFile file) throws IOException {
        Timer.Sample sample = Timer.start(meterRegistry);
        
        try {
            String result = convertMultipartPsdToBase64(file);
            
            // 記錄成功指標(biāo)
            meterRegistry.counter("psd.conversion.success").increment();
            meterRegistry.gauge("psd.file.size", file.getSize());
            
            return result;
        } catch (Exception e) {
            meterRegistry.counter("psd.conversion.error").increment();
            throw e;
        } finally {
            sample.stop(Timer.builder("psd.conversion.duration")
                       .register(meterRegistry));
        }
    }
}