import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { z } from "zod";
import express, { Request, Response } from "express";
import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
import { IncomingMessage, ServerResponse } from "http";
import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";

export const Logger = {
log: (...args: any[]) => {
console.log(...args);
},
error: (...args: any[]) => {
console.error(...args);
}
};

export class <%= serviceName %> {
    private readonly server: McpServer;
    private sseTransport: SSEServerTransport | null = null;

    constructor() {
    this.server = new McpServer(
    {
    name: "<%= projectName %>",
        version: "1.0.0",
        },
        // 使用正确格式的capabilities配置
        {
        capabilities: {
        tools: { listChanged: true },
        resources: { listChanged: true },
        prompts: { listChanged: true },
        logging: {}
        }
        }
        );

        this.registerTools();
        }

        private registerTools(): void {
        // 示例工具：打招呼
        this.server.tool(
        "say_hello",
        "返回一条问候消息",
        {
        name: z.string().describe("要问候的名字"),
        language: z.enum(["en", "zh"]).optional().describe("返回的语言，'en'为英语，'zh'为中文"),
        },
        async ({ name, language = "zh" }) => {
        try {
        const greeting = language === "zh"
        ? `你好，${name}！`
        : `Hello, ${name}!`;

        Logger.log(`问候消息已生成: ${greeting}`);

        return {
        content: [{
        type: "text",
        text: greeting
        }]
        };
        } catch (error) {
        Logger.error(`生成问候时出错:`, error);
        return {
        isError: true,
        content: [{
        type: "text",
        text: `生成问候时出错: ${error}`
        }]
        };
        }
        }
        );

        // 示例工具：计算器
        this.server.tool(
        "calculator",
        "执行简单的数学计算",
        {
        operation: z.enum(["add", "subtract", "multiply", "divide"]).describe("数学运算: add（加）, subtract（减）, multiply（乘）,
        divide（除）"),
        num1: z.number().describe("第一个数字"),
        num2: z.number().describe("第二个数字"),
        },
        async ({ operation, num1, num2 }) => {
        try {
        let result: number;
        let operationSymbol: string;

        switch (operation) {
        case "add":
        result = num1 + num2;
        operationSymbol = "+";
        break;
        case "subtract":
        result = num1 - num2;
        operationSymbol = "-";
        break;
        case "multiply":
        result = num1 * num2;
        operationSymbol = "×";
        break;
        case "divide":
        if (num2 === 0) {
        throw new Error("除数不能为零");
        }
        result = num1 / num2;
        operationSymbol = "÷";
        break;
        default:
        throw new Error("不支持的运算");
        }

        Logger.log(`计算完成: ${num1} ${operationSymbol} ${num2} = ${result}`);

        return {
        content: [{
        type: "text",
        text: `${num1} ${operationSymbol} ${num2} = ${result}`
        }]
        };
        } catch (error) {
        Logger.error(`计算时出错:`, error);
        return {
        isError: true,
        content: [{
        type: "text",
        text: `计算时出错: ${error}`
        }]
        };
        }
        }
        );

        // 你可以添加更多自定义工具...
        }

        async connect(transport: Transport): Promise<void> {
            try {
            await this.server.connect(transport);

            Logger.log = (...args: any[]) => {
            try {
            this.server.server.sendLoggingMessage({
            level: "info",
            data: args,
            });
            } catch (error) {
            console.log(...args);
            }
            };

            Logger.error = (...args: any[]) => {
            try {
            this.server.server.sendLoggingMessage({
            level: "error",
            data: args,
            });
            } catch (error) {
            console.error(...args);
            }
            };

            Logger.log("<%= projectName %> MCP服务器已连接并准备处理请求");
                } catch (error) {
                console.error("连接到传输时出错:", error);
                }
                }

                async startHttpServer(port: number): Promise<void> {
                    const app = express();

                    // SSE连接端点
                    app.get("/sse", (req: Request, res: Response) => {
                    // 初始化SSE传输
                    this.sseTransport = new SSEServerTransport(
                    "/messages",
                    res as unknown as ServerResponse<IncomingMessage>
                        );

                        try {
                        // 连接到传输层
                        this.server.connect(this.sseTransport)
                        .catch((err) => {
                        console.error("连接到SSE传输时出错:", err);
                        });

                        // 处理客户端断开连接
                        req.on('close', () => {
                        console.log('SSE客户端断开连接');
                        this.sseTransport = null;
                        });
                        } catch (error) {
                        console.error("建立SSE连接时出错:", error);
                        // 如果连接失败，关闭响应
                        if (!res.writableEnded) {
                        res.status(500).end();
                        }
                        }
                        });

                        // 消息端点
                        app.post("/messages", async (req: Request, res: Response) => {
                        if (!this.sseTransport) {
                        console.log("尝试发送消息，但SSE传输未初始化");
                        res.status(400).json({
                        error: 'SSE连接未建立',
                        message: '请先连接到/sse端点'
                        });
                        return;
                        }

                        try {
                        await this.sseTransport.handlePostMessage(
                        req as unknown as IncomingMessage,
                        res as unknown as ServerResponse<IncomingMessage>
                            );
                            } catch (error) {
                            console.error("处理消息时出错:", error);
                            if (!res.writableEnded) {
                            res.status(500).json({
                            error: "内部服务器错误",
                            message: String(error)
                            });
                            }
                            }
                            });

                            // 启动服务器
                            app.listen(port, () => {
                            Logger.log = console.log;
                            Logger.error = console.error;

                            Logger.log(`HTTP服务器监听端口: ${port}`);
                            Logger.log(`SSE端点: http://localhost:${port}/sse`);
                            Logger.log(`消息端点: http://localhost:${port}/messages`);
                            });
                            }
                            }