import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

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

// 注册工具
server.setRequestHandler("tools/list", async () => ({
  tools: [
    {
      name: "get_weather",
      description: "获取指定城市的天气信息",
      inputSchema: {
        type: "object",
        properties: {
          city: { type: "string", description: "城市名称" }
        },
        required: ["city"]
      }
    }
  ]
}));

// 处理工具调用
server.setRequestHandler("tools/call", async (request) => {
  const { name, arguments: args } = request.params;
  if (name === "get_weather") {
    const city = args?.city;
    // 这里接入真实天气 API
    return {
      content: [{ type: "text", text: `${city}今天晴，25°C，适合出门！` }]
    };
  }
  throw new Error(`未知工具: ${name}`);
});

// 启动服务
const transport = new StdioServerTransport();
await server.connect(transport);

import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://api.deepseek.com',
  apiKey: 'sk-your-api-key',
});

const completion = await client.chat.completions.create({
  model: 'deepseek-chat',
  messages: [
    { role: 'system', content: '你是一个有用的助手。' },
    { role: 'user', content: '用通俗的语言解释什么是 HTTPS。' },
  ],
});

console.log(completion.choices[0].message.content);

const stream = await client.chat.completions.create({
  model: 'deepseek-chat',
  messages: [{ role: 'user', content: '写一首关于夏天的诗' }],
  stream: true,
});

for await (const chunk of stream) {
  const content = chunk.choices[0]?.delta?.content;
  if (content) {
    process.stdout.write(content); // 逐字输出
  }
}

const messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[] = [
  { role: 'system', content: '你是一个编程助手。' },
];

async function chat(userInput: string): Promise<string> {
  messages.push({ role: 'user', content: userInput });

  const completion = await client.chat.completions.create({
    model: 'deepseek-chat',
    messages,
  });

  const reply = completion.choices[0].message.content || '';
  messages.push({ role: 'assistant', content: reply });

  return reply;
}

// 连续对话
await chat('JavaScript 有哪些基本数据类型？');
await chat('那 Symbol 类型有什么实际用途？'); // AI 会记住上一轮上下文

async function callWithRetry(
  messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[],
  maxRetries = 3
): Promise<string> {
  for (let i = 0; i < maxRetries; i++) {
    try {
      const completion = await client.chat.completions.create({
        model: 'deepseek-chat',
        messages,
        stream: false,
        timeout: 30000,
      });
      return completion.choices[0].message.content || '';
    } catch (error: any) {
      if (error.status === 429 || error.status >= 500) {
        const delay = Math.pow(2, i) * 1000; // 指数退避：1s, 2s, 4s
        console.warn(`请求失败 (${error.status})，${delay}ms 后重试...`);
        await new Promise(resolve => setTimeout(resolve, delay));
        continue;
      }
      throw error;
    }
  }
  throw new Error(`已重试 ${maxRetries} 次，仍然失败`);
}

// src/service/deepseek.service.ts
import { Provide, Init } from '@midwayjs/core';
import OpenAI from 'openai';

@Provide()
export class DeepSeekService {
  private client: OpenAI;

  @Init()
  async init() {
    this.client = new OpenAI({
      baseURL: 'https://api.deepseek.com',
      apiKey: process.env.DEEPSEEK_API_KEY,
    });
  }

  async chat(userMessage: string, context: string[] = []): Promise<string> {
    const messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[] = [
      { role: 'system', content: '你是98潮玩的智能助手。' },
      ...context.map((c, i) => ({
        role: i % 2 === 0 ? 'user' as const : 'assistant' as const,
        content: c,
      })),
      { role: 'user', content: userMessage },
    ];

    const completion = await this.client.chat.completions.create({
      model: 'deepseek-chat',
      messages,
    });

    return completion.choices[0].message.content || '';
  }

  async chatStream(
    userMessage: string,
    onChunk: (text: string) => void
  ): Promise<void> {
    const stream = await this.client.chat.completions.create({
      model: 'deepseek-chat',
      messages: [{ role: 'user', content: userMessage }],
      stream: true,
    });

    for await (const chunk of stream) {
      const content = chunk.choices[0]?.delta?.content;
      if (content) onChunk(content);
    }
  }
}

// ❌ 错误
const client = new OpenAI({ apiKey: 'sk-abc123' });

// ✅ 正确：用环境变量
const client = new OpenAI({ apiKey: process.env.DEEPSEEK_API_KEY });

const systemPrompt = `你是98潮玩平台的智能助手。请遵守以下规则：
- 只回答游戏、潮玩相关的问题
- 如果用户问无关问题，礼貌引导回正题
- 回答简洁，不超过200字
- 不编造不确定的信息`;

const completion = await client.chat.completions.create({
  model: 'deepseek-chat',
  messages,
  max_tokens: 500,
  temperature: 0.7,
});

import WechatPay from 'wechatpay-node-v3';
import fs from 'fs';

const wechatPay = new WechatPay({
  appid: 'wx1234567890',
  mchid: '1234567890',
  publicKey: fs.readFileSync('/path/to/apiclient_cert.pem'),
  privateKey: fs.readFileSync('/path/to/apiclient_key.pem'),
  // APIv3 密钥
  secretKey: 'your-32-char-api-v3-key',
});

// JSAPI 下单
const result = await wechatPay.transactions_jsapi({
  description: '98潮玩 - 游戏礼包',
  out_trade_no: 'ORDER20240718001',
  notify_url: 'https://yyimg.com/api/wxpay/notify',
  amount: {
    total: 1,  // 单位：分
    currency: 'CNY',
  },
  payer: {
    openid: 'oUpF8xxxxxxxxxxxx',
  },
});

console.log(result.prepay_id); // 传给前端调起支付

import { Controller, Post, Body, Headers } from '@midwayjs/core';

@Controller('/api/wxpay')
export class WxPayController {

  @Post('/notify')
  async notify(
    @Headers('wechatpay-signature') signature: string,
    @Headers('wechatpay-timestamp') timestamp: string,
    @Headers('wechatpay-nonce') nonce: string,
    @Headers('wechatpay-serial') serial: string,
    @Body() body: any
  ) {
    // 验证签名
    const verified = wechatPay.verifySignature(signature, timestamp, nonce, body);
    if (!verified) {
      return { code: 'FAIL', message: '签名验证失败' };
    }

    // 解密通知数据
    const resource = body.resource;
    const decrypted = wechatPay.decipher(resource.ciphertext, resource.associated_data, resource.nonce);

    console.log('支付成功:', decrypted);

    // 处理业务逻辑...
    return { code: 'SUCCESS', message: 'OK' };
  }
}

// 初始化时自动下载最新平台证书
await wechatPay.initPlatformCertificate();

// 建议配合定时任务定期刷新
setInterval(async () => {
  try {
    await wechatPay.initPlatformCertificate();
    console.log('平台证书已刷新');
  } catch (err) {
    console.error('平台证书刷新失败:', err);
  }
}, 12 * 60 * 60 * 1000); // 每12小时检查一次

const wechatPay = new WechatPay({
  // ...
  privateKey: fs.readFileSync(path.join(__dirname, process.env.WXPAY_KEY_PATH || '')),
  publicKey: fs.readFileSync(path.join(__dirname, process.env.WXPAY_CERT_PATH || '')),
});

const isProd = process.env.NODE_ENV === 'production';
const config = isProd ? {
  mchid: '真实商户号',
  // ... 真实证书
} : {
  mchid: '沙箱商户号',
  // ... 沙箱证书
};

// 计算某个时间点所属的营业日
function getBusinessDay(date: Date, openHour: number, closeHour: number): string {
  const hour = date.getHours();
  // 如果当前时间在营业结束时间之前（跨午夜后的时段）
  if (hour < closeHour) {
    // 归属于前一天的营业日
    const prevDay = new Date(date);
    prevDay.setDate(prevDay.getDate() - 1);
    return formatDate(prevDay);
  }
  // 否则属于当天的营业日
  return formatDate(date);
}

// 获取营业日的自然时间范围
function getBusinessDayRange(businessDay: string, openHour: number, closeHour: number) {
  const start = new Date(`${businessDay}T${String(openHour).padStart(2, '0')}:00:00`);
  const end = new Date(start);
  end.setDate(end.getDate() + 1);
  end.setHours(closeHour, 0, 0, 0);
  return { start, end };
}

// 示例
const date = new Date('2024-10-02T02:00:00');
console.log(getBusinessDay(date, 21, 5)); // "2024-10-01"
console.log(getBusinessDayRange('2024-10-01', 21, 5));
// { start: 2024-10-01 21:00, end: 2024-10-02 05:00 }

// 预定处理
function handleReservation(
  reserveTime: Date,    // 下单时间，如 10/2 02:00
  targetTimeStr: string // 预定时间段，如 "22:00"
) {
  const currentBizDay = getBusinessDay(reserveTime, 21, 5);  // "10-01"
  const targetHour = parseInt(targetTimeStr.split(':')[0]);
  
  // 确定目标营业日
  let targetBizDay: string;
  if (targetHour >= 21) {
    // 晚上9点后属于下一个营业日
    targetBizDay = getNextBusinessDay(currentBizDay);
  } else {
    // 凌晨时段，可能是当前营业日的后半段
    targetBizDay = currentBizDay;
  }
  
  // 保存到目标营业日
  saveReservation(targetBizDay, targetTimeStr, reserveTime);
  
  // 返回给前端的提示
  return {
    message: `预定成功，请在 ${targetBizDay} 日查看您在 ${targetTimeStr} 的预定`,
    displayDay: targetBizDay
  };
}