import { Skill } from '@openclaw/core';
import { PolymarketClient } from './clients/polymarket';
import { KalshiClient } from './clients/kalshi';
import { BinanceClient } from './clients/binance';

interface ArbitrageOpportunity {
  market: string;
  platform1: { name: string; price: number; volume: number };
  platform2: { name: string; price: number; volume: number };
  spread: number; // 价差百分比
  expectedProfit: number;
  risk: 'low' | 'medium' | 'high';
}

export const cryptoArbitrageSkill = new Skill({
  name: 'crypto-arbitrage',
  description: '实时监控多个预测市场和加密交易所，自动执行套利交易',
  
  config: {
    checkInterval: 5000, // 5 秒检查一次
    minSpread: 0.03, // 最小价差 3%
    maxSlippage: 0.02, // 最大滑点 2%
    positionSize: 0.05, // 单笔仓位 5%
    stopLoss: 0.10, // 止损 10%
  },

  onStart: async (context) => {
    context.logger.info('🚀 启动套利机器人...');
    
    // 初始化客户端
    const polymarket = new PolymarketClient(process.env.POLYMARKET_API_KEY);
    const kalshi = new KalshiClient(process.env.KALSHI_API_KEY);
    const binance = new BinanceClient(process.env.BINANCE_API_KEY);

    // 启动监控循环
    while (context.isRunning) {
      try {
        // 1. 获取所有市场价格
        const [polyPrices, kalshiPrices, binancePrices] = await Promise.all([
          polymarket.getActiveMarkets(),
          kalshi.getActiveMarkets(),
          binance.getTickers()
        ]);

        // 2. 寻找套利机会
        const opportunities = findArbitrageOpportunities({
          polyPrices,
          kalshiPrices,
          binancePrices,
          minSpread: context.config.minSpread
        });

        // 3. 按预期收益排序
        opportunities.sort((a, b) => b.expectedProfit - a.expectedProfit);

        // 4. 执行前 3 个最佳机会
        for (const opp of opportunities.slice(0, 3)) {
          await executeArbitrage(opp, context);
        }

        // 5. 记录日志
        context.logger.info(`✅ 本轮发现 ${opportunities.length} 个机会，执行 ${Math.min(opportunities.length, 3)} 笔交易`);
        
      } catch (error) {
        context.logger.error('❌ 监控循环出错:', error);
        await context.notify('telegram', { 
          message: `⚠️ 套利机器人异常：${error.message}`,
          level: 'high'
        });
      }

      // 等待下一个周期
      await sleep(context.config.checkInterval);
    }
  },

  onStop: async (context) => {
    context.logger.info('🛑 停止套利机器人，平掉所有仓位...');
    await closeAllPositions();
  }
});

function findArbitrageOpportunities(data: {
  polyPrices: any[];
  kalshiPrices: any[];
  binancePrices: any[];
  minSpread: number;
}): ArbitrageOpportunity[] {
  const opportunities: ArbitrageOpportunity[] = [];

  // 示例：比较 Polymarket vs Kalshi 同一事件的价格
  for (const polyMarket of data.polyPrices) {
    const matchingKalshi = data.kalshiPrices.find(
      k => k.eventId === polyMarket.eventId
    );

    if (matchingKalshi) {
      const spread = Math.abs(polyMarket.price - matchingKalshi.price) / 
                     Math.min(polyMarket.price, matchingKalshi.price);

      if (spread >= data.minSpread) {
        opportunities.push({
          market: polyMarket.eventName,
          platform1: {
            name: 'Polymarket',
            price: polyMarket.price,
            volume: polyMarket.volume
          },
          platform2: {
            name: 'Kalshi',
            price: matchingKalshi.price,
            volume: matchingKalshi.volume
          },
          spread: spread * 100,
          expectedProfit: calculateExpectedProfit(spread, polyMarket.volume),
          risk: assessRisk(polyMarket, matchingKalshi)
        });
      }
    }
  }

  return opportunities;
}

async function executeArbitrage(
  opp: ArbitrageOpportunity,
  context: any
) {
  context.logger.info(`🎯 执行套利：${opp.market}, 价差 ${opp.spread.toFixed(2)}%`);

  // 1. 在低价平台买入
  const buyPlatform = opp.platform1.price < opp.platform2.price ? 
                      opp.platform1 : opp.platform2;
  const sellPlatform = buyPlatform === opp.platform1 ? 
                       opp.platform2 : opp.platform1;

  try {
    // 2. 并行执行买卖（减少时间差风险）
    const [buyResult, sellResult] = await Promise.all([
      executeBuy(buyPlatform.name, opp.market, context.config.positionSize),
      executeSell(sellPlatform.name, opp.market, context.config.positionSize)
    ]);

    // 3. 记录交易结果
    const profit = sellResult.amount - buyResult.amount;
    context.logger.info(`✅ 套利完成，利润：$${profit.toFixed(2)}`);

    // 4. 发送通知
    await context.notify('telegram', {
      message: `💰 套利成功\n市场：${opp.market}\n价差：${opp.spread.toFixed(2)}%\n利润：$${profit.toFixed(2)}`,
      level: 'info'
    });

  } catch (error) {
    context.logger.error('❌ 套利执行失败:', error);
    await handleExecutionError(error, opp, context);
  }
}

{
  "apiKeys": {
    "polymarket": "${POLYMARKET_API_KEY}",
    "kalshi": "${KALSHI_API_KEY}",
    "binance": "${BINANCE_API_KEY}",
    "okx": "${OKX_API_KEY}"
  },
  "strategy": {
    "checkIntervalMs": 5000,
    "minSpreadPercent": 3.0,
    "maxSlippagePercent": 2.0,
    "positionSizePercent": 5.0,
    "stopLossPercent": 10.0,
    "takeProfitPercent": 20.0,
    "maxConcurrentTrades": 5,
    "maxDailyTrades": 100
  },
  "riskManagement": {
    "maxTotalExposure": 50.0,
    "maxSingleMarketExposure": 10.0,
    "correlationThreshold": 0.7,
    "emergencyStop": true
  },
  "notifications": {
    "telegram": {
      "enabled": true,
      "botToken": "${TELEGRAM_BOT_TOKEN}",
      "chatId": "${TELEGRAM_CHAT_ID}"
    },
    "email": {
      "enabled": true,
      "smtpServer": "smtp.gmail.com",
      "from": "${EMAIL_FROM}",
      "to": ["${EMAIL_TO}"]
    }
  }
}