E2E 导入导出架构重构

// 导出：返回加密后的字节流
POST /api/v1/e2e/export/:id
Body: { "password": "xxx" }
Response: 二进制流
 
// 导入：multipart 上传
POST /api/v1/e2e/import
Form: file, password, path
Response: FileMetadata

// 导出到本地路径（核心直接写文件）
POST /api/v1/e2e/export-by-path
Body: { "fileId", "password", "savePath" }
Response: { "taskId" }
 
// 从本地路径导入（核心直接读文件）
POST /api/v1/e2e/import-by-path
Body: { "filePath", "password", "targetPath" }
Response: { "taskId" }
 
// 进度查询
GET /api/v1/e2e/progress/:taskId
Response: E2EProgress

type E2EProgress struct {
    TaskID    string        `json:"taskId"`
    Phase     string        `json:"phase"`
    Progress  int           `json:"progress"`
    FileName  string        `json:"fileName"`
    FileSize  int64         `json:"fileSize"`
    Error     string        `json:"error,omitempty"`
    Result    *FileMetadata `json:"result,omitempty"`
    SavedPath string        `json:"savedPath,omitempty"`
}
 
// doExportByPath 实际执行导出（后台 goroutine）
func (s *Server) doExportByPath(taskID, fileID, password, savePath string, chunkMeta *crypto.ChunkMeta) {
    // 阶段1：下载并解密所有分块 (0-60%)
    progress.Phase = "downloading"
    for i := 0; i < chunkMeta.TotalChunks; i++ {
        chunkData := s.s3.DownloadBytes(...)
        decrypted := s.encryptor.DecryptChunkSimple(chunkData, fileKey)
        fileData = append(fileData, decrypted...)
        progress.Progress = (i + 1) * 60 / chunkMeta.TotalChunks
    }
    
    // 阶段2：用新密码加密为 E2E 格式 (60-90%)
    progress.Phase = "encrypting"
    e2eData := crypto.ExportToE2E(fileData, e2eMeta, password)
    
    // 阶段3：写入本地文件 (90-100%)
    progress.Phase = "writing"
    os.WriteFile(savePath, e2eData, 0644)
    
    progress.Phase = "done"
}
 
// doImportByPath 实际执行导入（后台 goroutine）
func (s *Server) doImportByPath(taskID, filePath, password, targetPath string, fileSize int64) {
    // 阶段1：读取本地文件 (0-20%)
    e2eData := os.ReadFile(filePath)
    
    // 阶段2：解密 E2E 文件 (20-40%)
    fileData, e2eMeta := crypto.ImportFromE2E(e2eData, password)
    
    // 阶段3：分块加密并上传到 S3 (40-90%)
    for i := 0; i < totalChunks; i++ {
        encrypted := s.encryptor.EncryptChunkSimple(chunk, fileKey)
        s.s3.UploadBytes(ctx, chunkKey, encrypted, ...)
    }
    
    // 阶段4：保存元数据 (90-100%)
    s.updateMetadataIndex(ctx, &metadata)
    
    progress.Phase = "done"
    progress.Result = &metadata
}

/// 导出路径模式：核心直接写文件到本地路径
Future<void> _doExportByPath(_DownloadJob job) async {
  // 计算保存路径
  final savePath = '${downloadDir.path}/$fileName';
 
  // 发起导出请求，获取 taskId
  final startResult = await api.exportToE2EByPath(
    fileId: job.file.id,
    password: job.exportPassword!,
    savePath: savePath,
  );
  final taskId = startResult.data!;
 
  // 轮询进度
  while (true) {
    await Future.delayed(const Duration(milliseconds: 500));
    final progressResult = await api.getE2EProgress(taskId);
    final progress = progressResult.data!;
    
    // 更新 UI 进度
    _transfers[idx] = _transfers[idx].copyWith(
      progress: progress.progress / 100.0,
    );
    
    if (progress.isDone) break;
  }
}
 
/// 导入任务（使用路径模式 API）
void _startImportJob(_ImportJob job) {
  // 类似的轮询逻辑...
}

// 解密 E2E 文件 → 保存到临时目录，返回路径和元数据
POST /api/v1/e2e/decrypt
{
  "filePath": "/path/to/file.e2e",
  "password": "xxx"
}
→ { "tempPath": "/tmp/xxx", "fileName": "原始文件名", "mimeType": "xxx", "size": 123 }
 
// 下载文件并 E2E 加密 → 保存到指定路径
POST /api/v1/e2e/encrypt
{
  "fileId": "xxx",
  "password": "xxx",
  "savePath": "/path/to/output.e2e"
}
→ { "savedPath": "...", "size": 123 }

void enqueueImport(String e2eFilePath, String password) {
  // 1. 调用 e2e/decrypt 解密到临时文件
  final decryptResult = await api.decryptE2E(e2eFilePath, password);
  // decryptResult = { tempPath, fileName, mimeType, size }
  
  // 2. 加入上传队列（复用现有上传逻辑）
  enqueueUploadToPath(
    filePath: decryptResult.tempPath,
    fileName: decryptResult.fileName,
    remotePath: targetPath,
    displayName: '导入: ${decryptResult.fileName}', // UI 显示为"导入"
  );
}

void enqueueExport(FileMetadata file, String password) {
  // 1. 加入下载队列
  // 2. 下载完成回调中：
  //    - 调用 e2e/encrypt 加密
  //    - 或者复用 _DownloadJob 的 isExport 标记，下载完成后自动加密
}

// POST /api/v1/e2e/decrypt
// 解密 E2E 文件到临时目录，返回路径和元数据
func (s *Server) decryptE2E(c *gin.Context)
 
// POST /api/v1/e2e/encrypt  
// 下载文件并加密为 E2E 格式，保存到指定路径
func (s *Server) encryptToE2E(c *gin.Context)

// 1. 解密 E2E 文件到临时目录
final decryptResult = await api.decryptE2E(
  filePath: job.filePath,
  password: job.password,
);
 
// 2. 复用 uploadByPath 上传（完全复用现有上传逻辑）
final taskResult = await api.uploadByPath(
  filePath: decrypted.tempPath,
  fileName: decrypted.fileName,
  remotePath: job.targetPath,
);
 
// 3. 轮询上传进度（复用 getUploadProgress）
while (true) {
  final progress = await api.getUploadProgress(taskId);
  // ...
}

// 直接调用 encryptToE2E，后端一步完成下载+加密+写文件
final result = await api.encryptToE2E(
  fileId: job.file.id,
  password: job.exportPassword!,
  savePath: savePath,
);

// 删除前
api.POST("/e2e/export/:id", s.exportToE2E)
api.POST("/e2e/import", s.importFromE2E)
 
// 保留
// E2E 简化 API（纯加解密，复用上传下载逻辑）
api.POST("/e2e/decrypt", s.decryptE2E)
api.POST("/e2e/encrypt", s.encryptToE2E)

// 删除旧版 API（~74 行）
Future<ApiResult<Uint8List>> exportToE2E(...) // 返回字节数据
Future<ApiResult<FileMetadata>> importFromE2E(...) // multipart 上传

/// 解密 E2E 文件到临时目录
Future<ApiResult<E2EDecryptResult>> decryptE2E({
  required String filePath,
  required String password,
})
 
/// 下载文件并加密为 E2E 格式
Future<ApiResult<E2EEncryptResult>> encryptToE2E({
  required String fileId,
  required String password,
  required String savePath,
})