async function uploadImageViaWebSocket(file, apiToken) {
  const socket = new WebSocket('ws://localhost:9393/watermark/stream');
  const CHUNK_SIZE = 1024 * 1024 - 1024; // 1MB - 1KB buffer
  
  return new Promise((resolve, reject) => {
    socket.onopen = async () => {
      try {
        // 1. 发送文件信息
        const totalChunks = file.size > CHUNK_SIZE ? 
          Math.ceil(file.size / CHUNK_SIZE) : 1;
        
        const fileInfo = {
          token: apiToken,
          filename: file.name,
          size: file.size,
          chunks: totalChunks,
          chunk_size: CHUNK_SIZE
        };
        
        socket.send(JSON.stringify(fileInfo));
        
        // 2. 读取文件数据
        const fileData = await file.arrayBuffer();
        
        // 3. 发送文件数据（分块或整体）
        if (file.size <= CHUNK_SIZE) {
          // 小文件，直接发送
          socket.send(fileData);
        } else {
          // 大文件，分块发送
          let chunkIndex = 0;
          
          const sendNextChunk = () => {
            if (chunkIndex < totalChunks) {
              const start = chunkIndex * CHUNK_SIZE;
              const end = Math.min(start + CHUNK_SIZE, file.size);
              const chunk = fileData.slice(start, end);
              
              socket.send(chunk);
              chunkIndex++;
            }
          };
          
          // 开始发送第一块
          sendNextChunk();
          
          // 监听服务器的块确认消息
          socket.addEventListener('message', (event) => {
            try {
              const response = JSON.parse(event.data);
              
              // 如果是块确认消息，继续发送下一块
              if (response.chunk_received && chunkIndex < totalChunks) {
                sendNextChunk();
              }
            } catch (e) {
              // 忽略非JSON消息（可能是最终的文件数据）
            }
          });
        }
      } catch (error) {
        reject(error);
      }
    };
    
    let awaitingResult = false;
    socket.onmessage = (event) => {
      try {
        // 尝试解析JSON响应
        const response = JSON.parse(event.data);
        
        // 如果是块确认消息，已在上面处理
        if (response.chunk_received) {
          return;
        }
        
        // 如果是处理结果
        if (response.success !== undefined) {
          if (response.success) {
            awaitingResult = true;
            console.log('图片处理成功，等待文件数据...');
          } else {
            reject(new Error(response.message || '处理失败'));
          }
        }
      } catch (e) {
        // 如果不是JSON，可能是文件二进制数据
        if (awaitingResult && event.data instanceof ArrayBuffer) {
          const blob = new Blob([event.data]);
          resolve(blob);
        }
      }
    };
    
    socket.onerror = (error) => reject(error);
    socket.onclose = () => {
      if (!awaitingResult) {
        reject(new Error('连接意外关闭'));
      }
    };
  });
}

// 使用示例
const fileInput = document.getElementById('file-input');
fileInput.addEventListener('change', async (event) => {
  const file = event.target.files[0];
  if (file) {
    try {
      const processedBlob = await uploadImageViaWebSocket(file, 'your_api_token');
      
      // 下载处理后的文件
      const url = URL.createObjectURL(processedBlob);
      const a = document.createElement('a');
      a.href = url;
      a.download = `watermarked_${file.name}`;
      a.click();
      URL.revokeObjectURL(url);
    } catch (error) {
      console.error('上传失败:', error);
    }
  }
});