#!/usr/bin/env node
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";

const server = new Server(
  {
    name: "calculator-server",
    version: "1.0.0",
  },
  {
    capabilities: {
      tools: {},
    },
  }
);

// 사용 가능한 도구 목록
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: "add",
        description: "두 숫자를 더합니다",
        inputSchema: {
          type: "object",
          properties: {
            a: { type: "number", description: "첫 번째 숫자" },
            b: { type: "number", description: "두 번째 숫자" },
          },
          required: ["a", "b"],
        },
      },
      {
        name: "multiply",
        description: "두 숫자를 곱합니다",
        inputSchema: {
          type: "object",
          properties: {
            a: { type: "number", description: "첫 번째 숫자" },
            b: { type: "number", description: "두 번째 숫자" },
          },
          required: ["a", "b"],
        },
      },
      {
        name: "power",
        description: "거듭제곱을 계산합니다 (a의 b승)",
        inputSchema: {
          type: "object",
          properties: {
            base: { type: "number", description: "밑" },
            exponent: { type: "number", description: "지수" },
          },
          required: ["base", "exponent"],
        },
      },
    ],
  };
});

// 도구 실행
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  try {
    if (name === "add") {
      const { a, b } = args as { a: number; b: number };
      const result = a + b;
      return {
        content: [
          {
            type: "text",
            text: `${a} + ${b} = ${result}`,
          },
        ],
      };
    } else if (name === "multiply") {
      const { a, b } = args as { a: number; b: number };
      const result = a * b;
      return {
        content: [
          {
            type: "text",
            text: `${a} × ${b} = ${result}`,
          },
        ],
      };
    } else if (name === "power") {
      const { base, exponent } = args as { base: number; exponent: number };
      const result = Math.pow(base, exponent);
      return {
        content: [
          {
            type: "text",
            text: `${base}^${exponent} = ${result}`,
          },
        ],
      };
    }

    throw new Error(`알 수 없는 도구: ${name}`);
  } catch (error) {
    return {
      content: [
        {
          type: "text",
          text: `오류 발생: ${error instanceof Error ? error.message : String(error)}`,
        },
      ],
      isError: true,
    };
  }
});

// 서버 시작
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("Calculator MCP Server 시작됨");
}

main().catch((error) => {
  console.error("서버 시작 실패:", error);
  process.exit(1);
});

const ALLOWED_PATHS = [
  path.join(os.homedir(), 'Documents'),
  path.join(os.homedir(), 'Projects')
];

function isPathAllowed(requestedPath: string): boolean {
  const absolute = path.resolve(requestedPath);
  return ALLOWED_PATHS.some(allowed => 
    absolute.startsWith(allowed)
  );
}

function validateInput(input: unknown): asserts input is ValidInput {
  if (typeof input !== 'object' || input === null) {
    throw new Error('Invalid input');
  }
  
  // 추가 검증...
}

// 환경 변수에서 API 키 읽기
const API_KEY = process.env.API_KEY;
if (!API_KEY) {
  throw new Error('API_KEY 환경 변수가 필요합니다');
}

import { ConsoleLogger } from "@modelcontextprotocol/sdk/shared/logger.js";

const server = new Server(
  {
    name: "my-server",
    version: "1.0.0",
    logger: new ConsoleLogger()
  },
  {
    capabilities: { tools: {} }
  }
);

server.onerror = (error) => {
  console.error("[MCP Error]", error);
};

server.onclose = () => {
  console.log("[MCP] Connection closed");
};

const cache = new Map<string, { data: any; timestamp: number }>();
const CACHE_TTL = 60000; // 1분

function getCached(key: string) {
  const cached = cache.get(key);
  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
    return cached.data;
  }
  return null;
}

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  // 병렬 처리
  const results = await Promise.all([
    fetchData1(),
    fetchData2(),
    fetchData3()
  ]);
  
  return { content: [{ type: "text", text: JSON.stringify(results) }] };
});

const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
const MAX_RESULTS = 100;

if (fileSize > MAX_FILE_SIZE) {
  throw new Error('File too large');
}