ng-code/src/app/services/conversation.service.ts

import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { BehaviorSubject, Observable, Subject, of } from 'rxjs';
import { map, catchError } from 'rxjs/operators';
import { ChatMessage, StreamChunk, PromptStreamRequest, TextPart } from '../models/conversation.model';
import { AuthService } from './auth.service';

@Injectable({
  providedIn: 'root'
})
export class ConversationService {
  private newMessageSubject = new BehaviorSubject<ChatMessage | null>(null);
  newMessage$ = this.newMessageSubject.asObservable();
  
  private streamUpdateSubject = new Subject<StreamChunk>();
  streamUpdate$ = this.streamUpdateSubject.asObservable();

  constructor(
    private http: HttpClient,
    private authService: AuthService
  ) {}

  // 发送消息（流式响应）
  sendMessage(sessionId: string, message: string): Observable<void> {
    const request: PromptStreamRequest = {
      sessionID: sessionId,
      parts: [
        {
          type: 'text',
          text: message
        }
      ]
    };

    return new Observable<void>(observer => {
      // 获取认证token
      const token = this.authService.getToken();
      console.log('🔍 [ConversationService] 发送消息，sessionId:', sessionId);
      console.log('🔍 [ConversationService] 获取的token长度:', token?.length);
      console.log('🔍 [ConversationService] 当前认证状态:', this.authService.isAuthenticated());
      
      if (!token) {
        console.error('🔍 [ConversationService] 错误: 用户未认证，无法建立流式连接');
        observer.error(new Error('用户未认证，无法建立流式连接'));
        return;
      }
      
      console.log('🔍 [ConversationService] 发送POST请求启动流:', request);
      
      // 创建AbortController用于取消请求
      const abortController = new AbortController();
      
      // 发送超时定时器 - 控制发送消息到后端的超时（30秒）
      let sendTimeout: any = null;
      
      // 使用fetch API以便流式读取SSE响应
      fetch('/api/prompt/stream', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${token}`
        },
        body: JSON.stringify(request),
        signal: abortController.signal // 添加取消信号
      }).then(response => {
        console.log('🔍 [ConversationService] POST响应状态:', response.status, response.statusText);
        
        if (!response.ok) {
          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
        }
        
        if (!response.body) {
          throw new Error('响应体为空');
        }
        
        // 检查Content-Type是否为text/event-stream
        const contentType = response.headers.get('content-type');
        console.log('🔍 [ConversationService] 响应Content-Type:', contentType);
        
        // 消息发送成功，立即通知组件可以恢复发送按钮状态
        observer.next();
        
        // 创建SSE解析器
        const reader = response.body.getReader();
        const decoder = new TextDecoder();
        let buffer = '';
        
        // 发送请求超时（30秒）- 控制发送消息到后端的超时
        const SEND_TIMEOUT_MS = 30 * 1000; // 30秒
        sendTimeout = setTimeout(() => {
          console.error('🔍 [ConversationService] 发送请求超时（30秒未收到初始响应）');
          abortController.abort();
          this.streamUpdateSubject.next({ type: 'error', data: '发送请求超时，请重试' });
          observer.error(new Error('发送请求超时，请重试'));
        }, SEND_TIMEOUT_MS);
        
        // 请求成功后清除发送超时
        clearTimeout(sendTimeout);
        
        const readStream = () => {
           reader.read().then(({ done, value }) => {
              if (done) {
                console.log('🔍 [ConversationService] 流结束');
                     // 清除发送超时定时器
                     clearTimeout(sendTimeout);
                 this.streamUpdateSubject.next({ type: 'done', data: '' });
                 observer.complete();
                return;
             }
            
            // 解码数据
            buffer += decoder.decode(value, { stream: true });
            
            // 解析SSE格式：每个事件以"data: "开头，以两个换行符结束
            let eventEnd = buffer.indexOf('\n\n');
            while (eventEnd !== -1) {
              const event = buffer.substring(0, eventEnd);
              buffer = buffer.substring(eventEnd + 2); // 移除已处理的事件和两个换行符
              
              // 收到事件，继续处理
              
              // 检查是否为注释行（以冒号开头）
              if (event.startsWith(':')) {
                console.log('🔍 [ConversationService] 收到SSE注释:', event.substring(0, 50));
                // 心跳注释，继续处理下一个事件
                eventEnd = buffer.indexOf('\n\n');
                continue;
              }
              
              // 查找数据行
              const dataLineStart = event.indexOf('data: ');
              if (dataLineStart !== -1) {
                const data = event.substring(dataLineStart + 6); // 移除"data: "
                console.log('🔍 [ConversationService] 收到SSE数据:', data.substring(0, 100));
                
                if (data === '[DONE]') {
                    console.log('🔍 [ConversationService] 收到DONE标记');
                     // 清除发送超时定时器
                     clearTimeout(sendTimeout);
                    this.streamUpdateSubject.next({ type: 'done', data: '' });
                    observer.complete();
                   return;
                } else {
                  try {
                    // 解析JSON格式的SSE数据
                    const jsonData = JSON.parse(data);
                    console.log('🔍 [ConversationService] 解析JSON数据:', jsonData);
                    
                     // 根据payload类型处理不同事件
                     // 支持两种数据格式：直接 {payload: ...} 或 {directory: ..., payload: ...}
                     const payload = jsonData.payload || jsonData;
                       console.log('🔍 [ConversationService] payload类型:', payload.type);
                        
                        // 处理消息部分更新事件（包含文本内容）
                        if (payload.type === 'message.part.updated' && payload.properties?.part) {
                          const part = payload.properties.part;
                           // 支持 text、reasoning 和 tool 类型
                           if ((part.type === 'text' || part.type === 'reasoning' || part.type === 'tool') && part.text) {
                             // 优先使用 delta 字段（增量），如果没有则使用完整文本
                             const delta = payload.properties.delta || part.text;
                             
                             // 映射事件类型到前端消息类型
                             let frontendType: 'thinking' | 'tool' | 'reply' | 'error';
                             if (part.type === 'reasoning') {
                               frontendType = 'thinking';
                             } else if (part.type === 'tool') {
                               frontendType = 'tool';
                             } else {
                               frontendType = 'reply'; // text 类型
                             }
                             
                             console.log('🔍 [ConversationService] 收到部分内容 (类型:', part.type, '=>', frontendType, 'delta:', delta, '):', part.text.substring(0, 50));
                             this.streamUpdateSubject.next({ type: frontendType, data: delta });
                           }
                        }
                         // 处理消息更新事件（包含完整消息信息）
                         else if (payload.type === 'message.updated' && payload.properties?.info) {
                           const info = payload.properties.info;
                           if (info.role === 'assistant') {
                             console.log('🔍 [ConversationService] 收到助理消息更新，角色:', info.role, '消息ID:', info.id);
                             // 不发送文本内容，避免与message.part.updated重复
                             // 文本内容已通过message.part.updated事件流式传输
                           }
                         }
                        // 处理其他事件类型
                        else if (payload.type === 'session.updated') {
                          console.log('🔍 [ConversationService] 会话更新事件');
                        }
                        else if (payload.type === 'server.connected') {
                          console.log('🔍 [ConversationService] 服务器连接成功');
                        }
                         else if (payload.type === 'session.status') {
                           console.log('🔍 [ConversationService] 会话状态更新:', payload.properties?.status?.type);
                         }
                         else if (payload.type === 'session.idle') {
                           console.log('🔍 [ConversationService] AI进入空闲状态，保持连接可继续交互');
                         }
                  } catch (e) {
                    console.error('🔍 [ConversationService] 解析SSE JSON数据失败:', e, '原始数据:', data);
                     // 如果不是JSON，按纯文本处理
                     this.streamUpdateSubject.next({ type: 'reply', data });
                  }
                }
              }
              
              eventEnd = buffer.indexOf('\n\n');
            }
            
            // 继续读取
            readStream();
          }).catch(error => {
            // 检查是否是取消错误
            if (error.name === 'AbortError') {
              console.log('🔍 [ConversationService] 流式请求被取消');
              this.streamUpdateSubject.next({ type: 'done', data: '请求已取消' });
              observer.complete();
            } else {
              console.error('🔍 [ConversationService] 读取流错误:', error);
              this.streamUpdateSubject.next({ type: 'error', data: '流读取错误' });
              observer.error(error);
            }
          });
        };
        
        // 开始读取流
        readStream();
      }).catch(error => {
        // 检查是否是取消错误
        if (error.name === 'AbortError') {
          console.log('🔍 [ConversationService] 请求被取消');
          observer.complete();
        } else {
          console.error('🔍 [ConversationService] 启动流式请求失败:', error);
          this.streamUpdateSubject.next({ type: 'error', data: '连接错误' });
          observer.error(error);
        }
      });
      
       // 清理函数
       return () => {
         console.log('🔍 [ConversationService] 清理流式连接，取消请求');
         // 清除发送超时定时器
         clearTimeout(sendTimeout);
         // 取消fetch请求
         abortController.abort();
       };
    });
  }

  // 发送消息（非流式，同步）
  sendMessageSync(sessionId: string, message: string): Observable<ChatMessage> {
    const request: PromptStreamRequest = {
      sessionID: sessionId,
      parts: [
        {
          type: 'text',
          text: message
        }
      ]
    };

    // 注意：这里使用非流式端点，如果后端支持
    return this.http.post<any>('/api/prompt/sync', request).pipe(
      map(response => {
        console.log('🔍 [ConversationService] 同步响应:', response);
        if (response.success) {
          // 根据后端实际响应格式解析
          let content = '收到空响应';
          let messageId = Date.now().toString();
          
          if (response.data) {
            // 尝试从info.content获取内容
            if (response.data.info?.content) {
              content = response.data.info.content;
              messageId = response.data.info.id || messageId;
            } 
            // 尝试从parts中提取文本内容
            else if (response.data.parts && Array.isArray(response.data.parts)) {
              const textParts = response.data.parts.filter((part: any) => 
                part.type === 'text' && part.text
              );
              if (textParts.length > 0) {
                content = textParts.map((part: any) => part.text).join('\n');
              }
            }
            // 如果是直接的content字段
            else if (response.data.content) {
              content = response.data.content;
            }
          }
          
          const aiMessage: ChatMessage = {
            id: messageId,
            role: 'assistant',
            content: content,
            timestamp: new Date(),
            sessionID: sessionId
          };
          this.newMessageSubject.next(aiMessage);
          return aiMessage;
        } else {
          throw new Error(response.message || '发送消息失败');
        }
      }),
      catchError(error => {
        console.error('发送消息失败:', error);
        throw error;
      })
    );
  }

  // 添加新消息（用于测试或手动添加）
  addMessage(message: ChatMessage) {
    this.newMessageSubject.next(message);
  }

  // 获取历史消息（如果后端支持）
  getHistory(sessionId: string): Observable<ChatMessage[]> {
    // 模拟数据
    const mockMessages: ChatMessage[] = [
      {
        id: '1',
        role: 'user',
        content: '你好，请帮我分析这个代码',
        timestamp: new Date(Date.now() - 3600000),
        sessionID: sessionId
      },
      {
        id: '2',
        role: 'assistant',
        content: '你好！我可以帮您分析代码。请把代码发给我。',
        timestamp: new Date(Date.now() - 3500000),
        sessionID: sessionId
      }
    ];
    
    return of(mockMessages);
  }

  // 清空消息流
  clearStream() {
    this.streamUpdateSubject.next({ type: 'done', data: '' });
  }
}