# 用curl上传一个 Markdown 文件
# -F 参数会自动设置 multipart/form-data 格式
# @ 符号后面跟文件的绝对路径或相对路径
curl -X POST http://localhost:6872/api/upload \
  -F "file=@README.md"
  
# 响应
 {
  "message": "OK",
  "data": {
    "fileName": "README.md",
    "filePath": "/path/to/saved/file/example.txt",
    "fileSize": 1024
  }
}

func (c *ControllerV1) FileUpload(ctx context.Context, req *v1.FileUploadReq) (res *v1.FileUploadRes, err error) {
    // 从请求中获取上传的文件
    r := g.RequestFromCtx(ctx)
    uploadFile := r.GetUploadFile("file")
    if uploadFile == nil {
       return nil, gerror.New("请上传文件")
    }
    // 确保保存目录存在
    if !gfile.Exists(common.FileDir) {
       if err := gfile.Mkdir(common.FileDir); err != nil {
          return nil, gerror.Wrapf(err, "创建目录失败: %s", common.FileDir)
       }
    }
    // 获取原始文件名
    newFileName := uploadFile.Filename
    // 完整的保存路径
    savePath := filepath.Join(common.FileDir)
    // 保存文件
    _, err = uploadFile.Save(savePath, false)
    if err != nil {
       return nil, gerror.Wrapf(err, "保存文件失败")
    }
    // 获取文件信息
    fileInfo, err := os.Stat(savePath)
    if err != nil {
       return nil, gerror.Wrapf(err, "获取文件信息失败")
    }
    res = &v1.FileUploadRes{
       FileName: newFileName,
       FilePath: savePath,
       FileSize: fileInfo.Size(),
    }
    err = buildIntoIndex(ctx, common.FileDir+"/"+newFileName)
    if err != nil {
       return nil, gerror.Wrapf(err, "构建知识库失败")
    }
    return res, nil
}

func buildIntoIndex(ctx context.Context, path string) error {
    r, err := knowledge_index_pipeline.BuildKnowledgeIndexing(ctx)
    // 删除biz数据metadata中_source一样的数据
    loader, err := loader2.NewFileLoader(ctx)
    if err != nil {
       return err
    }
    // 加载文件到内存
    docs, err := loader.Load(ctx, document.Source{URI: path})
    if err != nil {
       return err
    }
    cli, err := client.NewMilvusClient(ctx)
    if err != nil {
       return err
    }
    // 查询所有metadata中_source一样的数据并删除
    expr := fmt.Sprintf(`metadata["_source"] == "%s"`, docs[0].MetaData["_source"])
    queryResult, err := cli.Query(ctx, common.MilvusCollectionName, []string{}, expr, []string{"id"})
    if err != nil {
       return err
    } else if len(queryResult) > 0 {
       // 提取所有需要删除的id
       var idsToDelete []string
       for _, column := range queryResult {
          if column.Name() == "id" {
             for i := 0; i < column.Len(); i++ {
                id, err := column.GetAsString(i)
                if err == nil {
                   idsToDelete = append(idsToDelete, id)
                }
             }
          }
       }
       // 删除这些数据
       if len(idsToDelete) > 0 {
          deleteExpr := fmt.Sprintf(`id in ["%s"]`, strings.Join(idsToDelete, `","`))
          err = cli.Delete(ctx, common.MilvusCollectionName, "", deleteExpr)
          if err != nil {
             fmt.Printf("[warn] delete existing data failed: %v\n", err)
          } else {
             fmt.Printf("[info] deleted %d existing records with _source: %s\n", len(idsToDelete), docs[0].MetaData["_source"])
          }
       }
    }
    // 重新构建
    ids, err := r.Invoke(ctx, document.Source{URI: path}, compose.WithCallbacks(log_call_back.LogCallback(nil)))
    if err != nil {
       return fmt.Errorf("invoke index graph failed: %w", err)
    }
    fmt.Printf("[done] indexing file: %s, len of parts: %d\n", path, len(ids))
    return nil
}

@PostMapping(value = "/api/upload", consumes = "multipart/form-data")
public ResponseEntity<?> upload(@RequestParam("file") MultipartFile file) {
    try {
        // 1. 首先将用户上传到文件保存到本地
        Files.copy(file.getInputStream(), filePath);
        logger.info("文件上传成功: {}", filePath);
        // 文件上传成功后，自动调用向量索引服务
        try {
            logger.info("开始为上传文件创建向量索引: {}", filePath);
            vectorIndexService.indexSingleFile(filePath.toString());
            logger.info("向量索引创建成功: {}", filePath);
        }
        FileUploadRes response = new FileUploadRes(
                originalFilename,
                filePath.toString(),
                file.getSize()
        );
        return ResponseEntity.ok(apiResponse);
    }
}

public void indexSingleFile(String filePath) throws Exception {
    // 1. 读取文件内容
    String content = Files.readString(path);
    logger.info("读取文件: {}, 内容长度: {} 字符", path, content.length());
    // 2. 删除该文件的旧数据（如果存在）
    deleteExistingData(path.toString());
    // 3. 文档分片
    List<DocumentChunk> chunks = chunkService.chunkDocument(content, path.toString());
    logger.info("文档分片完成: {} -> {} 个分片", filePath, chunks.size());
    // 4. 为每个分片生成向量并插入 Milvus
    for (int i = 0; i < chunks.size(); i++) {
        DocumentChunk chunk = chunks.get(i);
        try {
            // 生成向量
            List<Float> vector = embeddingService.generateEmbedding(chunk.getContent());
            // 构建元数据（包含文件信息）
            Map<String, Object> metadata = buildMetadata(path.toString(), chunk, chunks.size());
            // 插入到 Milvus
            insertToMilvus(chunk.getContent(), vector, metadata, chunk.getChunkIndex());
        }
    }
    logger.info("文件索引完成: {}, 共 {} 个分片", filePath, chunks.size());
}