#!/usr/bin/env node
// 📍 Shebang行：告诉操作系统使用node解释器执行此脚本
// 这使得该文件可以作为可执行文件直接运行

// 🔧 导入核心模块
import { PromptFormatMcpServer } from "./server.js";  // 导入我们的MCP服务器类
import { config } from "dotenv";                       // 导入环境变量配置工具
import { resolve } from "path";                        // 导入路径解析工具
import { Logger } from "./utils/helpers.js";           // 导入日志工具

// 🌐 环境变量加载
// 尝试从.env文件加载环境变量（如果存在）
// 在MCP场景下，环境变量通常由客户端（如Cursor）通过配置传递
try {
  config({ path: resolve(process.cwd(), ".env") });    // 从当前工作目录加载.env文件
} catch (error) {
  // 静默忽略.env文件不存在的错误
  // 因为在MCP环境中，环境变量由客户端配置提供
}

// 🔒 环境变量验证
// 检查必需的API密钥是否存在
if (!process.env.SILICONFLOW_API_KEY) {
  // 如果API密钥不存在，输出详细的错误信息和解决方案
  console.error("错误: 请设置环境变量 SILICONFLOW_API_KEY");
  console.error("在MCP服务器配置中，请确保在env字段中设置了此变量");
  process.exit(1);  // 以错误状态退出程序
}

/**
 * 🚀 启动服务器函数
 * 这是程序的主入口点，负责创建和启动MCP服务器
 */
export async function startServer(): Promise<void> {
  try {
    // 创建MCP服务器实例
    const server = new PromptFormatMcpServer();
    
    // 输出启动日志
    Logger.log("启动 Prompt Format MCP 服务器...");
    
    // 启动stdio传输模式的服务器
    // stdio模式是MCP协议的标准传输方式，通过标准输入输出与客户端通信
    await server.startStdio();
  } catch (error) {
    // 如果启动失败，记录错误并退出
    Logger.error("服务器启动失败:", error);
    process.exit(1);
  }
}

// 🛡️ 全局异常处理
// 捕获未处理的异常，防止程序意外崩溃
process.on('uncaughtException', (error) => {
  Logger.error('未捕获的异常:', error);
  process.exit(1);  // 异常退出
});

// 🎯 程序启动点
// 调用启动函数，开始运行服务器
startServer();

// 🔧 导入MCP核心模块
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";      // MCP服务器核心类
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";  // stdio传输层
import { z } from "zod";                                                 // 参数验证和类型定义库

/**
 * 🎯 Prompt Format MCP 服务器类
 * 这是整个MCP服务器的核心类，负责：
 * 1. 创建和配置MCP服务器实例
 * 2. 注册和管理工具
 * 3. 处理客户端请求
 * 4. 管理与AI API的通信
 */
export class PromptFormatMcpServer {
  private server: McpServer;           // MCP服务器实例
  private apiClient: SiliconFlowClient; // AI API客户端实例

  constructor() {
    // 🔧 创建MCP服务器
    // 这是MCP协议的核心，定义了服务器的基本信息和能力
    this.server = new McpServer({
      name: "prompt-format-mcp",    // 服务器名称，客户端用此识别服务器
      version: "1.0.11",            // 服务器版本号
    }, {
      capabilities: {
        tools: {},                  // 声明此服务器支持工具功能
        // 其他可能的能力：
        // resources: {},           // 资源功能
        // prompts: {},             // 提示词模板功能
        // logging: {},             // 日志功能
      },
    });

    // 📝 注册工具
    this.registerTools();
  }

  /**
   * 🛠️ 工具注册方法
   * 这里注册所有MCP工具，每个工具都有特定的功能
   */
  private registerTools() {
    // 🔧 第一个工具：optimize-prompt
    this.server.tool(
      "optimize-prompt",                     // 工具名称，客户端调用时使用
      "Optimize prompt for better AI model performance",  // 工具描述
      {
        // 📋 参数模式定义
        // 使用zod库定义参数的类型和验证规则
        content: z.string().describe("Prompt content to optimize")
      },
      // 🎯 工具处理函数
      async ({ content }) => {
        // 🔄 使用重试机制调用AI API
        const optimized = await retry(
          () => this.apiClient.optimizePrompt(content),
          3,    // 最大重试次数
          1000  // 每次重试间隔（毫秒）
        );

        // 🎯 返回MCP标准响应格式
        return {
          content: [
            {
              type: "text",           // 内容类型：文本
              text: optimized         // 优化后的内容
            }
          ]
        };
      }
    );
  }

  /**
   * 🚀 启动stdio服务器
   * 这是MCP服务器的标准启动方法
   */
  async startStdio(): Promise<void> {
    // 🔌 创建stdio传输层
    const transport = new StdioServerTransport();
    
    // 🔗 连接服务器和传输层
    await this.server.connect(transport);
    
    Logger.log("MCP Server started on stdio");
  }
}

const server = new McpServer({
  name: "prompt-format-mcp",  // 服务器标识
  version: "1.0.11",          // 版本号
}, {
  capabilities: {
    tools: {},                // 声明支持的功能
  },
});

server.tool(
  "tool-name",               // 工具名称
  "Tool description",        // 工具描述
  parameterSchema,           // 参数验证模式
  handlerFunction            // 处理函数
);

export class SiliconFlowClient {
  private apiKey: string;     // API密钥
  private baseUrl: string;    // API基础URL
  private modelName: string;  // AI模型名称

  /**
   * 🔄 调用API的核心方法
   * 包含完整的错误处理和重试逻辑
   */
  private async callAPI(request: SiliconFlowRequest): Promise<SiliconFlowResponse> {
    const maxRetries = 3;
    
    for (let attempt = 1; attempt <= maxRetries; attempt++) {
      try {
        // 🌐 发送HTTP请求
        const response = await axios.post(
          `${this.baseUrl}/chat/completions`,
          request,
          {
            headers: {
              'Authorization': `Bearer ${this.apiKey}`,
              'Content-Type': 'application/json'
            },
            timeout: 90000,                    // 90秒超时
            validateStatus: (status) => status < 500  // 自定义状态码验证
          }
        );

        return response.data;
      } catch (error) {
        // 🔍 错误分类处理
        if (error.code === 'ECONNABORTED') {
          // 超时错误 - 重试
          if (attempt < maxRetries) {
            await new Promise(resolve => setTimeout(resolve, 2000 * attempt));
            continue;
          }
        }
        // 其他错误处理...
      }
    }
  }
}

/**
 * 🤖 SiliconFlow API响应类型
 * 符合OpenAI兼容的API响应格式
 */
export interface SiliconFlowResponse {
  choices: Array<{
    message: {
      content: string;    // AI生成的内容
      role: string;       // 消息角色
    };
    finish_reason: string; // 结束原因
    index: number;        // 选择索引
  }>;
  usage: {
    completion_tokens: number;  // 生成的token数
    prompt_tokens: number;      // 输入的token数
    total_tokens: number;       // 总token数
  };
}

/**
 * 🔄 重试函数
 * 提供自动重试机制，提高API调用的可靠性
 */
export async function retry<T>(
  fn: () => Promise<T>,      // 要重试的函数
  maxAttempts: number = 3,   // 最大重试次数
  delayMs: number = 1000     // 基础延迟时间
): Promise<T> {
  let lastError: Error;

  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    try {
      return await fn();
    } catch (error) {
      lastError = error as Error;
      
      if (attempt < maxAttempts) {
        // 递增延迟：第一次1s，第二次2s，第三次3s
        await delay(delayMs * attempt);
      }
    }
  }

  throw lastError!;
}