/**
 * AI 助手 API 客户端
 * 
 * 提供与 AI 助手后端服务交互的所有 API 方法
 */

import { api, API_URL } from '../api';

// ============ 类型定义 ============

export type ConversationStatus = 'ACTIVE' | 'CLOSED' | 'ESCALATED';
export type ConversationCategory = 'GENERAL' | 'IT' | 'HR' | 'ADMIN' | 'FINANCE';
export type MessageRole = 'USER' | 'ASSISTANT' | 'SYSTEM';
export type MessageSource = 'USER' | 'AI' | 'SYSTEM' | 'ESCALATION';
export type FeedbackType = 'LIKE' | 'DISLIKE';
export type TicketStatus = 'PENDING' | 'IN_PROGRESS' | 'RESOLVED' | 'CLOSED';
export type TicketCategory = 'IT' | 'HR' | 'ADMIN' | 'FINANCE' | 'OTHER';
export type TicketPriority = 'LOW' | 'MEDIUM' | 'HIGH' | 'URGENT';
export type KnowledgeFixStatus = 'PENDING' | 'APPROVED' | 'REJECTED';

// 对话
export interface Conversation {
  id: string;
  userId: string;
  title: string | null;
  status: ConversationStatus;
  category: ConversationCategory;
  tags: string[];
  createdAt: string;
  updatedAt: string;
  lastMessage?: Message;
  messageCount?: number;
}

// 消息
export interface Message {
  id: string;
  conversationId: string;
  role: MessageRole;
  source: MessageSource;
  content: string;
  tokens?: number;
  metadata?: Record<string, any>;
  createdAt: string;
  feedback?: MessageFeedback;
}

// 消息反馈
export interface MessageFeedback {
  id: string;
  messageId: string;
  type: FeedbackType;
  comment?: string;
  createdAt: string;
}

// 工单
export interface AITicket {
  id: string;
  conversationId: string;
  category: TicketCategory;
  priority: TicketPriority;
  status: TicketStatus;
  title: string;
  description?: string;
  assigneeId?: string;
  assigneeTeam?: string;
  resolution?: string;
  createdAt: string;
  updatedAt: string;
  assignedAt?: string;
  resolvedAt?: string;
}

// 知识纠正
export interface KnowledgeFix {
  id: string;
  messageId: string;
  correctAnswer: string;
  contributorId: string;
  status: KnowledgeFixStatus;
  reviewerId?: string;
  reviewNote?: string;
  createdAt: string;
  reviewedAt?: string;
}

// Prompt 模板
export interface PromptTemplate {
  id: string;
  name: string;
  category: ConversationCategory;
  content: string;
  version: number;
  isActive: boolean;
  createdAt: string;
  updatedAt: string;
}

// 统计概览
export interface StatsOverview {
  totalConversations: number;
  totalMessages: number;
  totalTickets: number;
  resolutionRate: number;
  averageSatisfaction: number;
  categoryBreakdown: Record<string, number>;
}

// 反馈统计
export interface FeedbackStats {
  total: number;
  likes: number;
  dislikes: number;
  likeRate: number;
  byCategory: Record<string, { likes: number; dislikes: number }>;
}

// 仪表盘数据
export interface DashboardData {
  callsLast24h: number;
  callsLast7d: number;
  successRate: number;
  avgResponseTime: number;
  categoryDistribution: Record<string, number>;
  satisfactionRate: number;
  hallucinations: number;
  pendingTickets: number;
}

// 分页响应
export interface PaginatedResponse<T> {
  items: T[];
  total: number;
  page: number;
  limit: number;
  totalPages: number;
  hasNext: boolean;
  hasPrev: boolean;
}

// ============ API 请求参数 ============

export interface CreateConversationParams {
  title?: string;
  category?: ConversationCategory;
}

export interface SendMessageParams {
  content: string;
  stream?: boolean;
}

export interface SubmitFeedbackParams {
  type: FeedbackType;
  comment?: string;
}

export interface EscalateParams {
  category?: TicketCategory;
  priority?: TicketPriority;
  description?: string;
}

export interface CreateKnowledgeFixParams {
  messageId: string;
  correctAnswer: string;
}

export interface CreatePromptTemplateParams {
  name: string;
  category: ConversationCategory;
  content: string;
}

export interface UpdatePromptTemplateParams {
  name?: string;
  content?: string;
}

export interface QueryParams {
  page?: number;
  limit?: number;
  status?: string;
  category?: string;
  startDate?: string;
  endDate?: string;
  search?: string;
}

// ============ SSE 流式消息处理 ============

export interface StreamCallbacks {
  onToken: (token: string) => void;
  /** 
   * 流式响应完成回调
   * @param fullContent 完整的响应内容
   * @param messageIds 消息 ID，包含 userMessageId 和 aiMessageId
   */
  onComplete: (fullContent: string, messageIds?: { userMessageId: string; aiMessageId: string }) => void;
  onError: (error: Error) => void;
}

/**
 * 发送消息并获取流式响应 (SSE)
 * 
 * 流程：
 * 1. 先调用 POST /messages 发送用户消息，获取消息 ID
 * 2. 然后调用 GET /messages/stream 获取流式响应
 */
export async function sendMessageStream(
  conversationId: string,
  content: string,
  callbacks: StreamCallbacks,
): Promise<void> {
  const authToken = localStorage.getItem('token') || 
    (() => {
      try {
        const authStorage = localStorage.getItem('auth-storage');
        if (authStorage) {
          const { state } = JSON.parse(authStorage);
          return state?.token || null;
        }
      } catch {
        return null;
      }
      return null;
    })();

  // Step 1: 发送用户消息，获取消息 ID
  const sendResponse = await fetch(
    `${API_URL}/ai-assistant/conversations/${conversationId}/messages`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${authToken}`,
      },
      body: JSON.stringify({ content }),
    }
  );

  if (!sendResponse.ok) {
    const error = await sendResponse.json();
    throw new Error(error.error?.message || 'Failed to send message');
  }

  const sendResult = await sendResponse.json();
  const { userMessage, aiMessageId } = sendResult.data || sendResult;
  
  // Step 2: 获取流式响应
  const streamResponse = await fetch(
    `${API_URL}/ai-assistant/conversations/${conversationId}/messages/stream?messageId=${aiMessageId}`,
    {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${authToken}`,
        'Accept': 'text/event-stream',
      },
    }
  );

  if (!streamResponse.ok) {
    const error = await streamResponse.json();
    throw new Error(error.error?.message || 'Failed to get stream response');
  }

  const reader = streamResponse.body?.getReader();
  if (!reader) {
    throw new Error('No response body');
  }

  const decoder = new TextDecoder();
  let fullContent = '';

  // 用于处理跨 chunk 的不完整行
  let buffer = '';
  
  try {
    while (true) {
      const { done, value } = await reader.read();
      if (done) {
        console.log('[SSE] Stream ended');
        break;
      }

      const chunk = decoder.decode(value, { stream: true });
      console.log('[SSE] Raw chunk:', chunk);
      
      // 将新数据添加到缓冲区
      buffer += chunk;
      
      // 按双换行分割（SSE 消息以 \n\n 结尾）
      const messages = buffer.split('\n\n');
      // 最后一个可能是不完整的，保留在缓冲区
      buffer = messages.pop() || '';

      for (const message of messages) {
        const lines = message.split('\n');
        
        for (const line of lines) {
          if (line.startsWith('data: ')) {
            const data = line.slice(6).trim();
            console.log('[SSE] Parsed data:', data);
            
            // 跳过空数据
            if (!data) continue;
            
            // 处理 [DONE] 标记
            if (data === '[DONE]') {
              callbacks.onComplete(fullContent, { 
                userMessageId: userMessage.id, 
                aiMessageId 
              });
              return;
            }

            try {
              let parsed = JSON.parse(data);
              
              // 处理 NestJS SSE 双重包装: { data: '{"content":"..."}' }
              if (parsed.data && typeof parsed.data === 'string') {
                try {
                  parsed = JSON.parse(parsed.data);
                } catch {
                  // data 不是 JSON，保持原样
                }
              }
              
              console.log('[SSE] Parsed JSON:', parsed);
              
              // 处理完成消息 (后端发送 type: 'done')
              if (parsed.type === 'done') {
                callbacks.onComplete(fullContent, { 
                  userMessageId: userMessage.id, 
                  aiMessageId: parsed.messageId || aiMessageId 
                });
                return;
              }
              
              // 处理错误消息
              if (parsed.type === 'error') {
                callbacks.onError(new Error(parsed.error || 'Unknown error'));
                return;
              }
              
              // 处理降级消息
              if (parsed.type === 'fallback') {
                fullContent = parsed.content || '';
                callbacks.onToken(parsed.content || '');
                callbacks.onComplete(fullContent, { 
                  userMessageId: userMessage.id, 
                  aiMessageId 
                });
                return;
              }
              
              // 处理正常的内容 token
              if (parsed.content) {
                fullContent += parsed.content;
                callbacks.onToken(parsed.content);
              }
              
              // 处理旧格式的错误（向后兼容）
              if (parsed.error) {
                callbacks.onError(new Error(parsed.error));
                return;
              }
            } catch (parseError) {
              console.log('[SSE] Parse error:', parseError, 'data:', data);
              // 非 JSON 数据，直接作为 token
              if (data) {
                fullContent += data;
                callbacks.onToken(data);
              }
            }
          }
        }
      }
    }
    
    // 处理缓冲区中剩余的数据
    if (buffer.trim()) {
      console.log('[SSE] Processing remaining buffer:', buffer);
    }
    
    callbacks.onComplete(fullContent, { 
      userMessageId: userMessage.id, 
      aiMessageId 
    });
  } catch (error) {
    callbacks.onError(error as Error);
  }
}

// ============ API 方法 ============

export const aiAssistantApi = {
  // ========== 对话管理 ==========
  
  /** 创建新对话 */
  createConversation: (params?: CreateConversationParams) =>
    api.post('/ai-assistant/conversations', params || {}),

  /** 获取对话列表 */
  getConversations: (params?: QueryParams) =>
    api.get('/ai-assistant/conversations', { params }),

  /** 获取对话详情 */
  getConversation: (id: string) =>
    api.get(`/ai-assistant/conversations/${id}`),

  /** 关闭对话 */
  closeConversation: (id: string) =>
    api.post(`/ai-assistant/conversations/${id}/close`),

  /** 删除对话 */
  deleteConversation: (id: string) =>
    api.delete(`/ai-assistant/conversations/${id}`),

  // ========== 消息管理 ==========

  /** 发送消息（非流式） */
  sendMessage: (conversationId: string, params: SendMessageParams) =>
    api.post(`/ai-assistant/conversations/${conversationId}/messages`, params),

  /** 发送消息（流式） - 使用 sendMessageStream 函数 */
  sendMessageStream,

  /** 获取对话消息列表 */
  getMessages: (conversationId: string, params?: { page?: number; limit?: number }) =>
    api.get(`/ai-assistant/conversations/${conversationId}/messages`, { params }),

  // ========== 反馈管理 ==========

  /** 提交消息反馈 */
  submitFeedback: (messageId: string, params: SubmitFeedbackParams) =>
    api.post(`/ai-assistant/messages/${messageId}/feedback`, params),

  /** 获取消息反馈 */
  getFeedback: (messageId: string) =>
    api.get(`/ai-assistant/messages/${messageId}/feedback`),

  /** 更新消息反馈 */
  updateFeedback: (messageId: string, params: SubmitFeedbackParams) =>
    api.patch(`/ai-assistant/messages/${messageId}/feedback`, params),

  // ========== 工单升级 ==========

  /** 升级对话为工单 */
  escalate: (conversationId: string, params?: EscalateParams) =>
    api.post(`/ai-assistant/conversations/${conversationId}/escalate`, params || {}),

  /** 获取工单列表 */
  getTickets: (params?: QueryParams) =>
    api.get('/ai-assistant/tickets', { params }),

  /** 获取工单详情 */
  getTicket: (id: string) =>
    api.get(`/ai-assistant/tickets/${id}`),

  /** 分配工单 */
  assignTicket: (id: string, params: { assigneeId?: string; assigneeTeam?: string }) =>
    api.post(`/ai-assistant/tickets/${id}/assign`, params),

  /** 解决工单 */
  resolveTicket: (id: string, params: { resolution: string }) =>
    api.post(`/ai-assistant/tickets/${id}/resolve`, params),

  // ========== 知识补充 ==========

  /** 提交知识纠正 */
  submitKnowledgeFix: (params: CreateKnowledgeFixParams) =>
    api.post('/ai-assistant/knowledge-fixes', params),

  /** 获取知识纠正列表 */
  getKnowledgeFixes: (params?: QueryParams) =>
    api.get('/ai-assistant/knowledge-fixes', { params }),

  /** 获取知识纠正详情 */
  getKnowledgeFix: (id: string) =>
    api.get(`/ai-assistant/knowledge-fixes/${id}`),

  /** 审核知识纠正 */
  reviewKnowledgeFix: (id: string, params: { status: 'APPROVED' | 'REJECTED'; reviewNote?: string }) =>
    api.post(`/ai-assistant/knowledge-fixes/${id}/review`, params),

  // ========== Prompt 模板管理 ==========

  /** 创建 Prompt 模板 */
  createPromptTemplate: (params: CreatePromptTemplateParams) =>
    api.post('/ai-assistant/prompts', params),

  /** 获取 Prompt 模板列表 */
  getPromptTemplates: (params?: QueryParams) =>
    api.get('/ai-assistant/prompts', { params }),

  /** 获取 Prompt 模板详情 */
  getPromptTemplate: (id: string) =>
    api.get(`/ai-assistant/prompts/${id}`),

  /** 更新 Prompt 模板 */
  updatePromptTemplate: (id: string, params: UpdatePromptTemplateParams) =>
    api.patch(`/ai-assistant/prompts/${id}`, params),

  /** 激活 Prompt 模板 */
  activatePromptTemplate: (id: string) =>
    api.post(`/ai-assistant/prompts/${id}/activate`),

  // ========== 配置管理 ==========

  /** 获取配置列表 */
  getConfigs: () =>
    api.get('/ai-assistant/config'),

  /** 更新配置 */
  updateConfig: (key: string, value: string) =>
    api.patch('/ai-assistant/config', { key, value }),

  // ========== 统计分析 ==========

  /** 获取统计概览 */
  getStatsOverview: (params?: { startDate?: string; endDate?: string }) =>
    api.get('/ai-assistant/stats/overview', { params }),

  /** 获取反馈统计 */
  getFeedbackStats: (params?: { startDate?: string; endDate?: string }) =>
    api.get('/ai-assistant/stats/feedback', { params }),

  /** 获取仪表盘数据 */
  getDashboard: () =>
    api.get('/ai-assistant/stats/dashboard'),

  /** 获取幻觉统计 */
  getHallucinationStats: (params?: { startDate?: string; endDate?: string }) =>
    api.get('/ai-assistant/stats/hallucinations', { params }),
};

export default aiAssistantApi;