/**
 * 会话历史管理模块
 * 功能：加载和选择会话历史
 * 依赖：vscode, chatHistoryManager, messageHandler
 * 使用场景：会话历史列表和切换
 */
import * as vscode from "vscode";
import { ChatHistoryManager } from "../../utils/chatHistoryManager";
import { MessageType } from "../../types/chatHistory";
import { setLastTaskId } from "../../utils/messageHandler";

export async function loadConversationHistory(
  panel: vscode.WebviewPanel,
  offset: number = 0,
  limit: number = 10,
) {
  try {
    const historyManager = ChatHistoryManager.getInstance();
    const workspacePath = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;

    if (!workspacePath) {
      panel.webview.postMessage({
        command: "conversationHistory",
        items: [],
        total: 0,
        hasMore: false,
      });
      return;
    }

    const result = await historyManager.getConversationHistoryList(
      workspacePath,
      offset,
      limit,
    );

    panel.webview.postMessage({
      command: "conversationHistory",
      items: result.items,
      total: result.total,
      hasMore: result.hasMore,
    });
  } catch (error) {
    console.error("加载会话历史失败:", error);
    panel.webview.postMessage({
      command: "conversationHistory",
      items: [],
      total: 0,
      hasMore: false,
    });
  }
}

export async function selectConversation(
  panel: vscode.WebviewPanel,
  taskId: string,
  extensionPath: string,
) {
  try {
    const historyManager = ChatHistoryManager.getInstance();
    const workspacePath = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;

    if (!workspacePath) {
      vscode.window.showErrorMessage("没有打开的工作区");
      return;
    }

    const taskSession = await historyManager.loadTaskSession(
      workspacePath,
      taskId,
    );

    if (!taskSession) {
      vscode.window.showErrorMessage(
        `加载任务 ${taskId} 失败: 任务不存在或数据损坏`,
      );
      return;
    }

    const switched = await historyManager.switchTask(workspacePath, taskId);
    if (!switched) {
      vscode.window.showErrorMessage(`切换到任务 ${taskId} 失败`);
      return;
    }

    setLastTaskId(taskId);

    const panelId = (panel as any).__uniqueId;
    historyManager.setPanelTask(panelId, taskId, workspacePath);

    panel.webview.postMessage({ command: "clearChat" });

    const segments: any[] = [];
    let i = 0;

    while (i < taskSession.messages.length) {
      const message = taskSession.messages[i];

      if (message.type === MessageType.USER) {
        if (segments.length > 0) {
          panel.webview.postMessage({
            command: "receiveSegments",
            segments: [...segments],
          });
          segments.length = 0;
        }

        const textContent = message.contents?.find((c) => c.type === "TEXT");
        if (textContent && "text" in textContent) {
          panel.webview.postMessage({
            command: "addUserMessage",
            text: textContent.text,
          });
        }
        i++;
      } else if (message.type === MessageType.AI) {
        if (message.segments && message.segments.length > 0) {
          panel.webview.postMessage({
            command: "receiveSegments",
            segments: message.segments,
          });
          i++;
        } else {
          if (message.text) {
            segments.push({ type: "text", content: message.text });
          }

          if (
            message.toolExecutionRequests &&
            message.toolExecutionRequests.length > 0
          ) {
            for (const toolReq of message.toolExecutionRequests) {
              let toolResult = "";
              if (i + 1 < taskSession.messages.length) {
                const nextMsg = taskSession.messages[i + 1];
                if (
                  nextMsg.type === MessageType.TOOL_EXECUTION_RESULT &&
                  nextMsg.id === toolReq.id
                ) {
                  toolResult = nextMsg.text;
                  i++;
                }
              }

              segments.push({
                type: "tool",
                toolName: toolReq.name,
                askId: toolReq.id,
                toolResult: toolResult,
              });
            }
          }

          i++;

          while (i < taskSession.messages.length) {
            const nextMsg = taskSession.messages[i];
            if (nextMsg.type === MessageType.USER) {
              break;
            }
            if (nextMsg.type === MessageType.AI) {
              if (nextMsg.segments && nextMsg.segments.length > 0) {
                break;
              }
              if (nextMsg.text) {
                segments.push({ type: "text", content: nextMsg.text });
              }
              if (
                nextMsg.toolExecutionRequests &&
                nextMsg.toolExecutionRequests.length > 0
              ) {
                for (const toolReq of nextMsg.toolExecutionRequests) {
                  let toolResult = "";
                  if (i + 1 < taskSession.messages.length) {
                    const resultMsg = taskSession.messages[i + 1];
                    if (
                      resultMsg.type === MessageType.TOOL_EXECUTION_RESULT &&
                      resultMsg.id === toolReq.id
                    ) {
                      toolResult = resultMsg.text;
                      i++;
                    }
                  }
                  segments.push({
                    type: "tool",
                    toolName: toolReq.name,
                    askId: toolReq.id,
                    toolResult: toolResult,
                  });
                }
              }
              i++;
            } else if (nextMsg.type === MessageType.TOOL_EXECUTION_RESULT) {
              i++;
            } else {
              i++;
            }
          }
        }
      } else {
        i++;
      }
    }

    if (segments.length > 0) {
      panel.webview.postMessage({
        command: "receiveSegments",
        segments: segments,
      });
    }

    // 发送任务完成消息（历史记录）
    panel.webview.postMessage({
      command: "taskCompleteHistory",
    });

    vscode.window.showInformationMessage(
      `已加载会话: ${taskSession.meta.taskName}`,
    );
  } catch (error) {
    console.error("选择会话失败:", error);
    vscode.window.showErrorMessage(`加载会话失败: ${error}`);
  }
}