class SSEPostClient {
  constructor(options = {}) {
    this.url = 'http://192.168.0.125:1804/model/workflows/run'; // SSE POST 接口地址
    this.options = {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json', // 可根据需求改为 form-data
        ...options.headers, // 自定义头（如 Token 认证）
      },
      body: JSON.stringify(options.body || {}), // POST 请求体
      // credentials: options.credentials || 'same-origin', // 跨域携带 Cookie
    };
    this.controller = new AbortController(); // 用于中断请求
    this.signal = this.controller.signal;
    this.listeners = new Map(); // 事件监听器（message、open、error、close）
    this.decoder = new TextDecoder('utf-8'); // 解码二进制流
    this.isConnected = false;
  }

  // 建立 POST 流式连接
  async connect() {
    try {
      // 发送 POST 请求，开启流式响应
      const response = await fetch(this.url, {
        ...this.options,
        signal: this.signal, // 关联中断信号
      });

      // 检查响应状态
      if (!response.ok) {
        throw new Error(`HTTP 错误！状态码：${response.status}`);
      }

      // 验证响应格式（必须是流式 event-stream）
      // if (response.headers.get('Content-Type') !== 'text/event-stream') {
      //   throw new Error('响应格式错误，需返回 text/event-stream');
      // }

      // 触发连接成功事件
      this.isConnected = true;
      this.emit('open');

      // 解析流式响应（核心）
      const reader = response.body.getReader();
      console.log('reader', reader);
      let remainingData = ''; // 缓存未完整解析的行

      while (true) {
        const { done, value } = await reader.read();
        if (done) {
          // 流结束，触发关闭事件
          this.emit('close');
          break;
        }

        // 解码二进制数据为文本，拼接缓存的剩余数据
        const chunk = this.decoder.decode(value, { stream: true });
        remainingData += chunk;

        // 按 SSE 格式分割数据（每行以 \n 结尾，每条消息以 \n\n 结尾）
        const lines = remainingData.split('\n');
        remainingData = lines.pop() || ''; // 未完整的行留到下一次解析

        // 解析每一行数据（SSE 格式：data: xxx 或 event: xxx）
        let currentEvent = { type: 'message', data: '' };
        for (const line of lines) {
          if (line.trim() === '') {
            // 空行表示一条消息结束，触发事件
            if (currentEvent.data) {
              this.emit(currentEvent.type, currentEvent.data);
            }
            currentEvent = { type: 'message', data: '' }; // 重置
            continue;
          }

          // 解析 SSE 字段（event: 自定义事件名；data: 消息内容）
          if (line.startsWith('event:')) {
            currentEvent.type = line.slice(6).trim();
          } else if (line.startsWith('data:')) {
            currentEvent.data += line.slice(5).trim() + '\n'; // 支持多行 data
          }
        }
      }
    } catch (error) {
      if (error.name !== 'AbortError') {
        // 排除手动中断的错误，触发错误事件
        this.emit('error', error);
      }
      this.isConnected = false;
    }
  }

  // 监听事件（message、open、error、close、自定义事件）
  on(eventName, callback) {
    if (!this.listeners.has(eventName)) {
      this.listeners.set(eventName, []);
    }
    this.listeners.get(eventName).push(callback);
  }

  // 触发事件（内部使用）
  emit(eventName, data) {
    const callbacks = this.listeners.get(eventName);
    callbacks?.forEach((cb) => {
      // 自动解析 JSON 格式数据（如果是对象字符串）
      let parsedData = data;
      try {
        parsedData = JSON.parse(data.trim());
      } catch (e) {
        // 非 JSON 数据直接返回原文本
      }
      cb(parsedData);
    });
  }

  // 关闭连接（中断请求）
  close() {
    this.controller.abort(); // 中断 fetch 请求
    this.isConnected = false;
    this.emit('close');
    this.listeners.clear(); // 清空监听器
    console.log('POST 流式连接已关闭');
  }
}

// 导出实例（可全局复用，也可按需创建多个）
export const createSSEPostClient = (url, options) => {
  return new SSEPostClient(url, options);
};