OpenAIChatService.ts

import OpenAI from 'openai';
import type {
  ChatCompletionMessageParam,
  ChatCompletionMessageToolCall,
  ChatCompletionTool,
} from 'openai/resources/chat';
import { createLogger, LogCategory } from '../logging/Logger.js';
import type {
  ChatConfig,
  ChatResponse,
  IChatService,
  Message,
  StreamChunk,
} from './ChatServiceInterface.js';

const _logger = createLogger(LogCategory.CHAT);

export class OpenAIChatService implements IChatService {
  private client: OpenAI;

  constructor(private config: ChatConfig) {
    _logger.debug('🚀 [ChatService] Initializing ChatService');
    _logger.debug('⚙️ [ChatService] Config:', {
      model: config.model,
      baseUrl: config.baseUrl,
      temperature: config.temperature,
      maxContextTokens: config.maxContextTokens,
      timeout: config.timeout,
      hasApiKey: !!config.apiKey,
    });

    if (!config.baseUrl) {
      _logger.error('❌ [ChatService] baseUrl is required in ChatConfig');
      throw new Error('baseUrl is required in ChatConfig');
    }
    if (!config.apiKey) {
      _logger.error('❌ [ChatService] apiKey is required in ChatConfig');
      throw new Error('apiKey is required in ChatConfig');
    }
    if (!config.model) {
      _logger.error('❌ [ChatService] model is required in ChatConfig');
      throw new Error('model is required in ChatConfig');
    }

    this.client = new OpenAI({
      apiKey: config.apiKey,
      baseURL: config.baseUrl, // OpenAI SDK 使用 baseURL
      timeout: config.timeout ?? 180000, // 180秒超时（长上下文场景需要更长时间）
      maxRetries: 3,
    });

    _logger.debug('✅ [ChatService] ChatService initialized successfully');
  }

  async chat(
    messages: Message[],
    tools?: Array<{
      name: string;
      description: string;
      parameters: any;
    }>,
    signal?: AbortSignal
  ): Promise<ChatResponse> {
    const startTime = Date.now();
    _logger.debug('🚀 [ChatService] Starting chat request');
    _logger.debug('📝 [ChatService] Messages count:', messages.length);
    _logger.debug(
      '📝 [ChatService] Messages preview:',
      messages.map((m) => ({ role: m.role, contentLength: m.content.length }))
    );

    const openaiMessages: ChatCompletionMessageParam[] = messages.map((msg) => {
      if (msg.role === 'tool') {
        return {
          role: 'tool',
          content: msg.content,
          tool_call_id: msg.tool_call_id!,
        };
      }
      if (msg.role === 'assistant' && msg.tool_calls) {
        return {
          role: 'assistant',
          content: msg.content || null,
          tool_calls: msg.tool_calls,
        };
      }
      return {
        role: msg.role as 'user' | 'assistant' | 'system',
        content: msg.content,
      };
    });

    const openaiTools: ChatCompletionTool[] | undefined = tools?.map((tool) => ({
      type: 'function' as const,
      function: {
        name: tool.name,
        description: tool.description,
        parameters: tool.parameters,
      },
    }));
    _logger.debug('🔧 [ChatService] Tools count:', openaiTools?.length || 0);
    if (openaiTools && openaiTools.length > 0) {
      _logger.debug(
        '🔧 [ChatService] Available tools:',
        openaiTools.map((t) => (t.type === 'function' ? t.function.name : 'unknown'))
      );
    }

    const requestParams = {
      model: this.config.model,
      messages: openaiMessages,
      tools: openaiTools,
      tool_choice:
        openaiTools && openaiTools.length > 0 ? ('auto' as const) : undefined,
      max_tokens: this.config.maxOutputTokens ?? 32768,
      temperature: this.config.temperature ?? 0.0,
    };

    _logger.debug('📤 [ChatService] Request params:', {
      model: requestParams.model,
      messagesCount: requestParams.messages.length,
      toolsCount: requestParams.tools?.length || 0,
      tool_choice: requestParams.tool_choice,
      max_tokens: requestParams.max_tokens,
      temperature: requestParams.temperature,
    });

    try {
      const completion = await this.client.chat.completions.create(requestParams, {
        signal,
      });
      const requestDuration = Date.now() - startTime;

      _logger.debug('📥 [ChatService] Response received in', requestDuration, 'ms');

      // ✅ 验证响应格式
      if (!completion) {
        _logger.error('❌ [ChatService] API returned null/undefined response');
        throw new Error('API returned null/undefined response');
      }

      if (!completion.choices || !Array.isArray(completion.choices)) {
        _logger.error(
          '❌ [ChatService] Invalid API response format - missing choices array'
        );
        _logger.error(
          '❌ [ChatService] Response object:',
          JSON.stringify(completion, null, 2)
        );
        throw new Error(
          `Invalid API response: missing choices array. Response: ${JSON.stringify(completion)}`
        );
      }

      if (completion.choices.length === 0) {
        _logger.error('❌ [ChatService] API returned empty choices array');
        throw new Error('API returned empty choices array');
      }

      _logger.debug('📊 [ChatService] Response usage:', completion.usage);
      _logger.debug(
        '📊 [ChatService] Response choices count:',
        completion.choices.length
      );

      const choice = completion.choices[0];
      if (!choice) {
        _logger.error('❌ [ChatService] No completion choice returned');
        throw new Error('No completion choice returned');
      }

      _logger.debug('📝 [ChatService] Response choice:', {
        finishReason: choice.finish_reason,
        contentLength: choice.message.content?.length || 0,
        hasToolCalls: !!choice.message.tool_calls,
        toolCallsCount: choice.message.tool_calls?.length || 0,
      });

      if (choice.message.tool_calls) {
        _logger.debug(
          '🔧 [ChatService] Tool calls:',
          choice.message.tool_calls.map((tc) => ({
            id: tc.id,
            type: tc.type,
            functionName: tc.type === 'function' ? tc.function?.name : 'unknown',
            functionArgsLength:
              tc.type === 'function' ? tc.function?.arguments?.length || 0 : 0,
          }))
        );
      }

      const toolCalls = choice.message.tool_calls?.filter(
        (tc): tc is ChatCompletionMessageToolCall => tc.type === 'function'
      );

      // 提取 reasoning_content（DeepSeek R1 等 thinking 模型的扩展字段）
      const extendedMessage = choice.message as typeof choice.message & {
        reasoning_content?: string;
      };
      const reasoningContent = extendedMessage.reasoning_content || undefined;

      // 提取 reasoning_tokens（thinking 模型的扩展 usage 字段）
      const extendedUsage = completion.usage as typeof completion.usage & {
        reasoning_tokens?: number;
      };

      const response = {
        content: choice.message.content || '',
        reasoningContent,
        toolCalls: toolCalls,
        usage: {
          promptTokens: completion.usage?.prompt_tokens || 0,
          completionTokens: completion.usage?.completion_tokens || 0,
          totalTokens: completion.usage?.total_tokens || 0,
          reasoningTokens: extendedUsage?.reasoning_tokens,
        },
      };

      _logger.debug('✅ [ChatService] Chat completed successfully');
      _logger.debug('📊 [ChatService] Final response:', {
        contentLength: response.content.length,
        toolCallsCount: response.toolCalls?.length || 0,
        usage: response.usage,
      });

      return response;
    } catch (error) {
      const requestDuration = Date.now() - startTime;
      _logger.error(
        '❌ [ChatService] Chat request failed after',
        requestDuration,
        'ms'
      );
      _logger.error('❌ [ChatService] Error details:', error);
      throw error;
    }
  }

  async *streamChat(
    messages: Message[],
    tools?: Array<{
      name: string;
      description: string;
      // biome-ignore lint/suspicious/noExplicitAny: 工具参数格式不确定
      parameters: any;
    }>,
    signal?: AbortSignal
  ): AsyncGenerator<StreamChunk, void, unknown> {
    const startTime = Date.now();
    _logger.debug('🚀 [ChatService] Starting chat stream request');
    _logger.debug('📝 [ChatService] Messages count:', messages.length);
    _logger.debug(
      '📝 [ChatService] Messages preview:',
      messages.map((m) => ({ role: m.role, contentLength: m.content.length }))
    );

    const openaiMessages: ChatCompletionMessageParam[] = messages.map((msg) => {
      if (msg.role === 'tool') {
        return {
          role: 'tool',
          content: msg.content,
          tool_call_id: msg.tool_call_id!,
        };
      }
      if (msg.role === 'assistant' && msg.tool_calls) {
        return {
          role: 'assistant',
          content: msg.content || null,
          tool_calls: msg.tool_calls,
        };
      }
      return {
        role: msg.role as 'user' | 'assistant' | 'system',
        content: msg.content,
      };
    });

    const openaiTools: ChatCompletionTool[] | undefined = tools?.map((tool) => ({
      type: 'function' as const,
      function: {
        name: tool.name,
        description: tool.description,
        parameters: tool.parameters,
      },
    }));

    _logger.debug('🔧 [ChatService] Stream tools count:', openaiTools?.length || 0);
    if (openaiTools && openaiTools.length > 0) {
      _logger.debug(
        '🔧 [ChatService] Stream available tools:',
        openaiTools.map((t) => (t.type === 'function' ? t.function.name : 'unknown'))
      );
    }

    const requestParams = {
      model: this.config.model,
      messages: openaiMessages,
      tools: openaiTools,
      tool_choice:
        openaiTools && openaiTools.length > 0 ? ('auto' as const) : ('none' as const),
      max_tokens: this.config.maxOutputTokens ?? 32768,
      temperature: this.config.temperature ?? 0.0,
      stream: true as const,
    };

    _logger.debug('📤 [ChatService] Stream request params:', {
      model: requestParams.model,
      messagesCount: requestParams.messages.length,
      toolsCount: requestParams.tools?.length || 0,
      tool_choice: requestParams.tool_choice,
      max_tokens: requestParams.max_tokens,
      temperature: requestParams.temperature,
      stream: requestParams.stream,
    });

    try {
      const stream = await this.client.chat.completions.create(requestParams, {
        signal,
      });
      const requestDuration = Date.now() - startTime;
      _logger.debug('📥 [ChatService] Stream started in', requestDuration, 'ms');

      let chunkCount = 0;
      let totalContent = '';
      let totalReasoningContent = '';
      let toolCallsReceived = false;

      for await (const chunk of stream) {
        chunkCount++;

        // ✅ 验证 chunk 格式
        if (!chunk || !chunk.choices || !Array.isArray(chunk.choices)) {
          _logger.warn('⚠️ [ChatService] Invalid chunk format in stream', chunkCount);
          continue;
        }

        const delta = chunk.choices[0]?.delta;
        if (!delta) {
          _logger.warn('⚠️ [ChatService] Empty delta in chunk', chunkCount);
          continue;
        }

        // 提取 reasoning_content（DeepSeek R1 等 thinking 模型的扩展字段）
        const extendedDelta = delta as typeof delta & {
          reasoning_content?: string;
        };

        if (delta.content) {
          totalContent += delta.content;
        }

        if (extendedDelta.reasoning_content) {
          totalReasoningContent += extendedDelta.reasoning_content;
        }

        if (delta.tool_calls && !toolCallsReceived) {
          toolCallsReceived = true;
          _logger.debug('🔧 [ChatService] Tool calls detected in stream');
        }

        const finishReason = chunk.choices[0]?.finish_reason;
        if (finishReason) {
          _logger.debug('🏁 [ChatService] Stream finished with reason:', finishReason);
          _logger.debug('📊 [ChatService] Stream summary:', {
            totalChunks: chunkCount,
            totalContentLength: totalContent.length,
            totalReasoningContentLength: totalReasoningContent.length,
            hadToolCalls: toolCallsReceived,
            duration: Date.now() - startTime + 'ms',
          });
        }

        yield {
          content: delta.content || undefined,
          reasoningContent: extendedDelta.reasoning_content || undefined,
          toolCalls: delta.tool_calls,
          finishReason: finishReason || undefined,
        };
      }

      _logger.debug('✅ [ChatService] Stream completed successfully');
    } catch (error) {
      const requestDuration = Date.now() - startTime;
      _logger.error(
        '❌ [ChatService] Stream request failed after',
        requestDuration,
        'ms'
      );
      _logger.error('❌ [ChatService] Stream error details:', error);
      throw error;
    }
  }

  getConfig(): ChatConfig {
    return { ...this.config };
  }

  updateConfig(newConfig: Partial<ChatConfig>): void {
    _logger.debug('🔄 [ChatService] Updating configuration');
    _logger.debug('🔄 [ChatService] New config:', {
      model: newConfig.model,
      baseUrl: newConfig.baseUrl,
      temperature: newConfig.temperature,
      maxContextTokens: newConfig.maxContextTokens,
      timeout: newConfig.timeout,
      hasApiKey: !!newConfig.apiKey,
    });

    const oldConfig = { ...this.config };
    this.config = { ...this.config, ...newConfig };

    this.client = new OpenAI({
      apiKey: this.config.apiKey,
      baseURL: this.config.baseUrl, // OpenAI SDK 使用 baseURL
      timeout: this.config.timeout ?? 180000, // 180秒超时（长上下文场景需要更长时间）
      maxRetries: 2, // 2次重试，平衡稳定性和响应速度
    });

    _logger.debug('✅ [ChatService] Configuration updated successfully');
    _logger.debug('📊 [ChatService] Config changes:', {
      modelChanged: oldConfig.model !== this.config.model,
      baseUrlChanged: oldConfig.baseUrl !== this.config.baseUrl,
      temperatureChanged: oldConfig.temperature !== this.config.temperature,
      maxContextTokensChanged:
        oldConfig.maxContextTokens !== this.config.maxContextTokens,
      timeoutChanged: oldConfig.timeout !== this.config.timeout,
      apiKeyChanged: oldConfig.apiKey !== this.config.apiKey,
    });
  }
}

/**
 * 向后兼容导出
 */
export { OpenAIChatService as ChatService };