'use strict';

import express from 'express';
import { createClient } from 'redis';
import crypto from 'node:crypto';

// ========================= 环境变量 =========================
const BOT_TOKEN       = process.env.BOT_TOKEN;
const ALLOWED_USER_ID = parseInt(process.env.ALLOWED_USER_ID, 10);
const VIEW_TOKEN      = process.env.VIEW_TOKEN;
const WEBHOOK_SECRET  = process.env.WEBHOOK_SECRET || '';
const PORT            = parseInt(process.env.PORT || '3000', 10);
const REDIS_URL       = process.env.REDIS_URL || 'redis://redis:6379';

if (!BOT_TOKEN || !ALLOWED_USER_ID || !VIEW_TOKEN) {
  console.error('❌ 缺少必要环境变量：BOT_TOKEN / ALLOWED_USER_ID / VIEW_TOKEN');
  process.exit(1);
}

// ========================= 常量 =========================
const MAX_TELEGRAM_TEXT   = 4000;
const FETCH_TIMEOUT_MS    = 8000;
const EXCHANGE_TIMEOUT_MS = 6000;
const RUN_LOCK_TTL        = 1800;
const RUN_TIMEOUT_MS      = 15000;  // 超时 15 秒，方便手动 /force_stop 控制

// ========================= Redis =========================
const redis = createClient({ url: REDIS_URL });
redis.on('error', err => console.error('[Redis]', err));
await redis.connect();
console.log('[Redis] 连接成功:', REDIS_URL);

const KV = {
  async get(key)              { return redis.get(key); },
  async put(key, value, opts) {
    if (opts?.expirationTtl)  await redis.set(key, value, { EX: opts.expirationTtl });
    else                      await redis.set(key, value);
  },
  async delete(key)           { await redis.del(key); }
};

// ========================= Redis 自动清理 =========================
// 每天凌晨 3 点检查一次，超过 20MB 则删除最旧的 PAGES_MSG_* 存档
const MAX_REDIS_BYTES = 20 * 1024 * 1024; // 20MB

async function scheduledClean() {
  try {
    // 获取 Redis 内存用量
    const info = await redis.info('memory');
    const match = info.match(/used_memory:(\d+)/);
    if (!match) return;
    const memoryBytes = parseInt(match[1], 10);

    console.log(`[AutoClean] Redis 当前用量: ${(memoryBytes / 1024 / 1024).toFixed(2)} MB`);

    if (memoryBytes <= MAX_REDIS_BYTES) {
      console.log('[AutoClean] 用量正常，无需清理');
      return;
    }

    // 扫描所有 PAGES_MSG_* key
    let keys = [];
    let cursor = 0;
    do {
      const result = await redis.scan(cursor, { MATCH: 'PAGES_MSG_*', COUNT: 100 });
      cursor = result.cursor;
      keys = keys.concat(result.keys);
    } while (cursor !== 0);

    if (keys.length === 0) return;

    // 按 key 里的 msgId 数字排序（数字越小越旧）
    keys.sort((a, b) => {
      const na = parseInt(a.replace('PAGES_MSG_', ''), 10) || 0;
      const nb = parseInt(b.replace('PAGES_MSG_', ''), 10) || 0;
      return na - nb;
    });

    // 删除最旧的一半
    const toDelete = keys.slice(0, Math.ceil(keys.length / 2));
    for (const k of toDelete) {
      await KV.delete(k);
    }
    console.log(`[AutoClean] 已删除 ${toDelete.length} 条旧存档，剩余 ${keys.length - toDelete.length} 条`);
  } catch (e) {
    console.error('[AutoClean] 清理失败:', e.message);
  }
}

// 每天凌晨 3 点执行一次
function scheduleNextClean() {
  const now = new Date();
  const next = new Date();
  next.setHours(3, 0, 0, 0);
  if (next <= now) next.setDate(next.getDate() + 1);
  const delay = next - now;
  setTimeout(() => {
    scheduledClean();
    setInterval(scheduledClean, 24 * 60 * 60 * 1000);
  }, delay);
  console.log(`[AutoClean] 下次清理时间: ${next.toLocaleString()}`);
}

// ========================= 工具函数 =========================
function safeTelegramText(text) {
  let s = String(text ?? '');
  if (s.length > MAX_TELEGRAM_TEXT) s = s.substring(0, MAX_TELEGRAM_TEXT);
  return s;
}

function escapeHTML(str) {
  return String(str ?? '')
    .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
}

function makeProgressBar(done, total, length = 10) {
  if (total <= 0) return '□□□□□□□□□□';
  const filled = Math.round(Math.max(0, Math.min(1, done / total)) * length);
  return '■'.repeat(filled) + '□'.repeat(length - filled);
}

function getPaginationKeyboard(currentPage) {
  return {
    inline_keyboard: [
      [
        { text: currentPage === 'page_1' ? '✅ 报价' : '🎮 报价', callback_data: 'page_1' },
        { text: currentPage === 'page_2' ? '✅ Surge' : '📦 Surge', callback_data: 'page_2' },
        { text: currentPage === 'page_3' ? '✅ 链接' : '🔗 链接', callback_data: 'page_3' }
      ],
      [
        { text: '🔄 恢复 Product', callback_data: 'restore_product' }
      ]
    ]
  };
}

async function fetchWithTimeout(url, options = {}, timeoutMs = FETCH_TIMEOUT_MS) {
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), timeoutMs);
  try {
    return await fetch(url, { ...options, signal: controller.signal });
  } finally {
    clearTimeout(timer);
  }
}

// ========================= Telegram API =========================
async function answerCallbackQuery(callbackQueryId, text = null) {
  const body = { callback_query_id: callbackQueryId };
  if (text) { body.text = text; body.show_alert = true; }
  await fetch(`https://api.telegram.org/bot${BOT_TOKEN}/answerCallbackQuery`, {
    method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body)
  });
}

async function sendTelegramMessage(chatId, text, replyMarkup = null) {
  const payload = { chat_id: chatId, text: safeTelegramText(text), parse_mode: 'HTML', disable_web_page_preview: true };
  if (replyMarkup) payload.reply_markup = replyMarkup;
  const resp = await fetch(`https://api.telegram.org/bot${BOT_TOKEN}/sendMessage`, {
    method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(payload)
  });
  try { return await resp.json(); } catch { return null; }
}

async function editTelegramMessage(chatId, messageId, text, replyMarkup = null) {
  const payload = { chat_id: chatId, message_id: messageId, text: safeTelegramText(text), parse_mode: 'HTML', disable_web_page_preview: true };
  if (replyMarkup) payload.reply_markup = replyMarkup;
  await fetch(`https://api.telegram.org/bot${BOT_TOKEN}/editMessageText`, {
    method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(payload)
  });
}

// ========================= 业务计算 =========================
function calculateProxyPrice(cnyPrices) {
  const totalCNY = cnyPrices.reduce((acc, val) => acc + parseFloat(val), 0);
  const count = cnyPrices.length;
  const baseStr = cnyPrices.join('+');
  const wrap = count > 1 ? `(${baseStr})` : baseStr;
  let proxyPrice, expressionStr;

  if (totalCNY < 40) {
    // 40元以内：+12元，超过3个游戏每多一个再+2元
    let fee = 12;
    let feeStr = '12';
    if (count > 3) {
      const extra = (count - 3) * 2;
      fee += extra;
      feeStr = `12+${count - 3}×2`;
    }
    proxyPrice = totalCNY + fee;
    expressionStr = `${baseStr}+${feeStr}=${proxyPrice.toFixed(2)}`;
  } else if (totalCNY <= 100) {
    // 40-100元：×1.25，但手续费不足12元按12元算
    const fee1 = totalCNY * 0.25;
    if (fee1 < 12) {
      // 手续费不足12元，改用 +12
      proxyPrice = totalCNY + 12;
      expressionStr = `${baseStr}+12=${proxyPrice.toFixed(2)}`;
    } else {
      proxyPrice = totalCNY * 1.25;
      expressionStr = `${wrap}×1.25=${proxyPrice.toFixed(2)}`;
    }
  } else {
    // 100元以上：×1.20
    proxyPrice = totalCNY * 1.20;
    expressionStr = `${wrap}×1.20=${proxyPrice.toFixed(2)}`;
  }

  return { totalCNY, proxyPrice, expressionStr };
}

// ========================= 汇率 =========================
async function getRealTimeExchangeRate() {
  const apis = [
    { url: 'https://open.er-api.com/v6/latest/NGN',                                                parse: d => d?.rates?.CNY },
    { url: 'https://cdn.jsdelivr.net/npm/@fawazahmed0/currency-api@latest/v1/currencies/ngn.json', parse: d => d?.ngn?.cny  },
    { url: 'https://api.exchangerate-api.com/v4/latest/NGN',                                        parse: d => d?.rates?.CNY }
  ];
  for (const api of apis) {
    try {
      const resp = await fetchWithTimeout(api.url, {}, EXCHANGE_TIMEOUT_MS);
      if (!resp.ok) continue;
      const rate = api.parse(await resp.json());
      if (rate && typeof rate === 'number') return rate;
    } catch (_) {}
  }
  throw new Error('所有备用实时汇率 API 均请求失败，请稍后再试。');
}

// ========================= KV Keys =========================
const getQueueKey         = userId => `xbox_urls_${userId}`;
const getRunLockKey       = userId => `RUNNING_${userId}`;
const getRunMetaKey       = userId => `RUN_META_${userId}`;
const getStateKey         = userId => `SUCCESS_STATE_${userId}`;
const getPagesKey         = userId => `LATEST_RESULT_${userId}`;
const getPagesByMsgKey    = msgId  => `PAGES_MSG_${msgId}`;
const getSurgeQueueKey    = userId => `SURGE_GROUP_QUEUE_${userId}`;
const getResolvedLinksKey = userId => `RESOLVED_LINKS_${userId}`;
const getSurgeLockKey     = userId => `SURGE_CONSUMING_${userId}`;

// ========================= 状态读写 =========================
async function loadPendingQueue(userId) {
  const raw = await KV.get(getQueueKey(userId));
  return raw ? JSON.parse(raw) : [];
}

async function savePendingQueue(userId, queue) {
  const unique = [...new Set(queue)];
  if (unique.length > 0) await KV.put(getQueueKey(userId), JSON.stringify(unique));
  else await KV.delete(getQueueKey(userId));
}

async function loadSuccessState(userId) {
  const raw = await KV.get(getStateKey(userId));
  if (!raw) return { items: [], lastRate: null, updatedAt: null };
  try {
    const p = JSON.parse(raw);
    return { items: Array.isArray(p.items) ? p.items : [], lastRate: p.lastRate ?? null, updatedAt: p.updatedAt ?? null };
  } catch { return { items: [], lastRate: null, updatedAt: null }; }
}

async function saveSuccessState(userId, state) {
  await KV.put(getStateKey(userId), JSON.stringify({
    items: state.items || [], lastRate: state.lastRate ?? null, updatedAt: new Date().toISOString()
  }));
}

async function loadResolvedLinks(userId) {
  const raw = await KV.get(getResolvedLinksKey(userId));
  if (!raw) return [];
  try { const p = JSON.parse(raw); return Array.isArray(p) ? p : []; } catch { return []; }
}

async function saveResolvedLinks(userId, links) {
  await KV.put(getResolvedLinksKey(userId), JSON.stringify(Array.isArray(links) ? links : []));
}

async function appendResolvedLink(userId, linkInfo) {
  const links = await loadResolvedLinks(userId);
  if (!links.some(x => x.sourceUrl === linkInfo.sourceUrl)) {
    links.push({ ...linkInfo, createdAt: new Date().toISOString() });
    await saveResolvedLinks(userId, links);
  }
}

async function loadRunMeta(userId) {
  const raw = await KV.get(getRunMetaKey(userId));
  return raw ? JSON.parse(raw) : null;
}

async function saveRunMeta(userId, meta) {
  await KV.put(getRunMetaKey(userId), JSON.stringify(meta), { expirationTtl: RUN_LOCK_TTL });
}

async function clearRunMeta(userId) { await KV.delete(getRunMetaKey(userId)); }

async function isRunActive(userId, runId) {
  const meta = await loadRunMeta(userId);
  return !!(meta && meta.runId === runId);
}

// ========================= Surge 队列 =========================
async function loadSurgeQueue(userId) {
  const raw = await KV.get(getSurgeQueueKey(userId));
  if (!raw) return { nextGroupIndex: 1, groups: [] };
  try {
    const p = JSON.parse(raw);
    return {
      nextGroupIndex: typeof p.nextGroupIndex === 'number' ? p.nextGroupIndex : 1,
      groups: Array.isArray(p.groups) ? p.groups : []
    };
  } catch { return { nextGroupIndex: 1, groups: [] }; }
}

async function saveSurgeQueue(userId, queue) {
  const safe = {
    nextGroupIndex: typeof queue.nextGroupIndex === 'number' ? queue.nextGroupIndex : 1,
    groups: Array.isArray(queue.groups) ? queue.groups : []
  };
  await KV.put(getSurgeQueueKey(userId), JSON.stringify(safe));
  if (safe.groups.length > 0) await KV.put('LATEST_XBOX_LIST', JSON.stringify(safe.groups[0].products));
  else await KV.delete('LATEST_XBOX_LIST');
}

// ★ 每次全新任务开始时重置，组号从 1 重新计数
async function resetSurgeQueue(userId) {
  await saveSurgeQueue(userId, { nextGroupIndex: 1, groups: [] });
}

async function appendProductToSurgeQueue(userId, item) {
  const queue = await loadSurgeQueue(userId);
  const product = { ProductId: item.bigId, SkuId: item.targetSkuId, AvailabilityId: item.targetAvailabilityId, PriceNGN: item.currentPriceNum ?? null };
  let last = queue.groups[queue.groups.length - 1];
  if (!last || last.count >= 15) {
    last = { groupIndex: queue.nextGroupIndex, count: 0, products: {} };
    queue.groups.push(last);
    queue.nextGroupIndex += 1;
  }
  last.count += 1;
  // 用 "(序号) 游戏名" 作为 key，方便识别
  const safeGameName = (item.gameName || 'Unknown').replace(/['"]/g, '');
  const productKey = `(${last.count}) ${safeGameName}`;
  last.products[productKey] = product;
  await saveSurgeQueue(userId, queue);
}

async function popFirstSurgeGroup(userId) {
  const queue = await loadSurgeQueue(userId);
  if (!queue.groups.length) return { ok: true, cleared: false, remainingGroups: 0, nextGroupIndex: null, nextGroupCount: 0 };
  const removed = queue.groups.shift();
  await saveSurgeQueue(userId, queue);

  // ★ 最后一组弹出后，清理本次任务所有数据，下次 run 从零开始
  const isLastGroup = queue.groups.length === 0;

  // ★ 先读取 pendingQueue（清理前），供通知使用
  const pendingQueue = await loadPendingQueue(userId);

  if (isLastGroup) {
    await KV.delete(getQueueKey(userId));
    await KV.delete(getStateKey(userId));
    await KV.delete(getResolvedLinksKey(userId));
    await KV.delete(getPagesKey(userId));
    console.log(`[popFirstSurgeGroup] 所有组已消费，任务数据已清理 userId=${userId}`);
  }

  // ★ 发送 Telegram 通知
  // 直接从 product 的 PriceNGN 字段取价格（存储在 Surge 分组里，不依赖 state）
  const groupNGN = Object.values(removed.products)
    .reduce((s, p) => s + (typeof p.PriceNGN === 'number' ? p.PriceNGN : 0), 0);
  const ngnStr = groupNGN > 0 ? `，游戏总价 <b>${groupNGN.toFixed(2)} NGN</b>` : '';

  let notifyText;
  if (isLastGroup) {
    notifyText =
      `📦 <b>第 ${removed.groupIndex} 组 Product 已同步完成${ngnStr}</b>

` +
      `✅ 所有分组已全部消费完毕，本次任务数据已清理。
` +
      `待处理链接队列: <b>${pendingQueue.length}</b> 个`;
  } else {
    notifyText =
      `📦 <b>第 ${removed.groupIndex} 组 Product 已同步完成${ngnStr}</b>

` +
      `剩余待同步分组: <b>${queue.groups.length}</b> 组
` +
      `下一组: 第 <b>${queue.groups[0].groupIndex}</b> 组（共 <b>${queue.groups[0].count}</b> 个商品）
` +
      `待处理链接队列: <b>${pendingQueue.length}</b> 个`;
  }
  sendTelegramMessage(userId, notifyText).catch(() => {});

  return {
    ok: true, cleared: true,
    clearedGroupIndex: removed.groupIndex, clearedGroupCount: removed.count,
    remainingGroups: queue.groups.length,
    nextGroupIndex: queue.groups[0]?.groupIndex ?? null,
    nextGroupCount: queue.groups[0]?.count ?? 0,
    groupNGN: groupNGN  // ★ 本组游戏总价
  };
}

// ========================= 页面渲染 =========================
// 按 Surge 分组（每组最多 15 个）拆分游戏列表，返回多段 page1 和对应 page2
// page1Chunks[i] 对应 surgeGroups[i]，序号连续衔接，总价只在最后一段
function buildPagesFromState(state, resolvedLinks, surgeQueue) {
  const items = Array.isArray(state.items) ? state.items : [];
  const rate = state.lastRate;
  const groups = Array.isArray(surgeQueue?.groups) ? surgeQueue.groups : [];
  const GROUP_SIZE = 15;

  // ── 构建多段 page1（每段对应一个 Surge 分组）──
  const page1Chunks = [];

  if (items.length === 0) {
    page1Chunks.push('📭 目前还没有成功解析的游戏。');
  } else {
    const totalGroups = Math.ceil(items.length / GROUP_SIZE);

    for (let g = 0; g < totalGroups; g++) {
      const groupItems = items.slice(g * GROUP_SIZE, (g + 1) * GROUP_SIZE);
      const isLast = g === totalGroups - 1;
      const startIdx = g * GROUP_SIZE; // 全局起始序号（0-based）

      let header = '<b>🎮 游戏比价及代购信息</b>';
      if (totalGroups > 1) header += ` <b>（第 ${g + 1} 组 / 共 ${totalGroups} 组）</b>`;
      header += '\n\n';
      if (rate) header += `💱 汇率: 1 NGN ≈ ${Number(rate).toFixed(6)} CNY\n\n`;

      let text = '';
      let groupNGN = 0;

      groupItems.forEach((info, idx) => {
        const displayNum = startIdx + idx + 1; // 序号从全局 1 开始
        text += `游戏（${displayNum}）\n名称: ${info.gameName}\n`;
        text += `原价: ${info.originalPriceStr}${info.originalPriceCNY !== 'N/A' ? ` (¥${info.originalPriceCNY})` : ''}\n`;
        text += `现价: ${info.currentPriceStr}${info.currentPriceCNY !== 'N/A' ? ` (¥${info.currentPriceCNY})` : ''}\n`;
        text += '----------------------------------------\n';
        if (typeof info.currentPriceNum === 'number') groupNGN += info.currentPriceNum;
      });

      // 多组：每组显示本组小计，最后一段额外追加全局总价（带分隔线）
      // 单组：直接显示游戏总价，不重复输出小计
      const allCnyPrices = items.map(i => i.currentPriceCNY).filter(p => p !== 'N/A');
      const totalNGN = items.reduce((s, i) => s + (typeof i.currentPriceNum === 'number' ? i.currentPriceNum : 0), 0);

      if (totalGroups === 1) {
        // 只有一组：直接输出总价
        text += `📊 游戏总价: NGN ${totalNGN.toFixed(2)}\n`;
        if (allCnyPrices.length > 0) {
          text += `🛍️ 代购总价: ${calculateProxyPrice(allCnyPrices).expressionStr}`;
        } else {
          text += '🛍️ 代购总价: ¥0.00';
        }
      } else {
        // 多组：每组有小计
        text += `📊 本组小计: NGN ${groupNGN.toFixed(2)}`;
        if (isLast) {
          text += `\n· · · · · · · · · · · · · · · ·\n📊 游戏总价: NGN ${totalNGN.toFixed(2)}\n`;
          if (allCnyPrices.length > 0) {
            text += `🛍️ 代购总价: ${calculateProxyPrice(allCnyPrices).expressionStr}`;
          } else {
            text += '🛍️ 代购总价: ¥0.00';
          }
        }
      }

      page1Chunks.push(header + `<pre>${escapeHTML(text.trim())}</pre>`);
    }
  }

  // ── page2：每段对应同序号的 Surge 分组 ──
  const page2Chunks = [];
  if (groups.length === 0) {
    page2Chunks.push('<b>📦 Surge 分组队列</b>\n\n📭 当前没有待同步的 Surge 数据。');
  } else {
    groups.forEach((group, idx) => {
      let p = '<b>📦 Surge 分组队列</b>\n\n';
      p += `当前剩余 <b>${groups.length}</b> 组待同步\n\n`;
      p += `<b>【 第 ${group.groupIndex} 组 】</b>共 ${group.count} 个商品\n`;
      p += `<code>${escapeHTML(JSON.stringify(group.products, null, 2))}</code>`;
      page2Chunks.push(p);
    });
    // 如果 Surge 组数少于游戏消息段数，最后几段复用最后一个 Surge 组
    while (page2Chunks.length < page1Chunks.length) {
      page2Chunks.push(page2Chunks[page2Chunks.length - 1]);
    }
  }

  // ── page3：链接记录，同样按 GROUP_SIZE 分段，序号衔接 ──
  const page3Chunks = [];
  if (resolvedLinks.length === 0) {
    page3Chunks.push('<b>🔗 已解析链接记录</b>\n\n📭 当前还没有已解析的链接记录。');
  } else {
    const totalGroups = Math.ceil(resolvedLinks.length / GROUP_SIZE);
    for (let g = 0; g < totalGroups; g++) {
      const groupLinks = resolvedLinks.slice(g * GROUP_SIZE, (g + 1) * GROUP_SIZE);
      const startIdx = g * GROUP_SIZE;
      let p = '<b>🔗 已解析链接记录</b>\n\n';
      groupLinks.forEach((item, idx) => {
        const displayNum = startIdx + idx + 1;
        p += `游戏（${displayNum}）\n`;
        p += `名称: ${item.gameName || 'Unknown Game'}\n`;
        p += `bigId: ${item.bigId || 'N/A'}\n`;
        p += `解析链接: ${escapeHTML(item.resolvedUrl || '')}\n`;
        p += '----------------------------------------\n';
      });
      page3Chunks.push(p);
    }
    while (page3Chunks.length < page1Chunks.length) {
      page3Chunks.push(page3Chunks[page3Chunks.length - 1]);
    }
  }

  // 兜底：确保三组 chunks 长度一致
  const maxLen = Math.max(page1Chunks.length, page2Chunks.length, page3Chunks.length);
  while (page1Chunks.length < maxLen) page1Chunks.push(page1Chunks[page1Chunks.length - 1] || '');
  while (page2Chunks.length < maxLen) page2Chunks.push(page2Chunks[page2Chunks.length - 1] || '');
  while (page3Chunks.length < maxLen) page3Chunks.push(page3Chunks[page3Chunks.length - 1] || '');

  // 向后兼容：page1/page2/page3 取第一段
  return {
    page1: page1Chunks[0],
    page2: page2Chunks[0],
    page3: page3Chunks[0],
    page1Chunks,
    page2Chunks,
    page3Chunks
  };
}

async function persistRenderedPages(userId) {
  const state         = await loadSuccessState(userId);
  const surgeQueue    = await loadSurgeQueue(userId);
  const resolvedLinks = await loadResolvedLinks(userId);
  const pages = buildPagesFromState(state, resolvedLinks, surgeQueue);
  // 存所有分段 + 原始 surgeGroups（供恢复 Product 用）
  await KV.put(getPagesKey(userId), JSON.stringify({
    page_1: pages.page1, page_2: pages.page2, page_3: pages.page3,
    page1Chunks: pages.page1Chunks, page2Chunks: pages.page2Chunks, page3Chunks: pages.page3Chunks,
    surgeGroups: surgeQueue.groups,  // ★ 原始分组数据
    stateItems: state.items          // ★ 商品价格数据，供恢复时计算总价
  }));
  return { ...pages, surgeGroups: surgeQueue.groups, stateItems: state.items };
}

async function showQuotePage(chatId, userId, messageId = null) {
  const pages = await persistRenderedPages(userId);
  const chunks = pages.page1Chunks;
  const sentMessageIds = []; // 记录所有发出去的消息 ID，顺序对应 chunk 序号

  for (let i = 0; i < chunks.length; i++) {
    const isLast = i === chunks.length - 1;
    const keyboard = isLast ? getPaginationKeyboard('page_1') : null;

    if (i === 0 && messageId) {
      // 第一段：edit 原进度消息
      try {
        await editTelegramMessage(chatId, messageId, chunks[i], keyboard);
        sentMessageIds.push(messageId);
      } catch (err) {
        console.error('[showQuotePage] edit 第1段失败:', err?.message || err);
        const msg = await sendTelegramMessage(chatId, chunks[i], keyboard);
        sentMessageIds.push(msg?.result?.message_id || null);
      }
    } else {
      const msg = await sendTelegramMessage(chatId, chunks[i], keyboard);
      sentMessageIds.push(msg?.result?.message_id || null);
    }
  }

  // 存档：以最后一条消息 ID 为 key，同时存入所有消息 ID，供翻页时按序 edit
  const lastMsgId = sentMessageIds[sentMessageIds.length - 1] || messageId;
  if (lastMsgId) {
    await KV.put(getPagesByMsgKey(lastMsgId), JSON.stringify({
      page_1: pages.page1, page_2: pages.page2, page_3: pages.page3,
      page1Chunks: pages.page1Chunks, page2Chunks: pages.page2Chunks, page3Chunks: pages.page3Chunks,
      messageIds: sentMessageIds,    // ★ 所有消息 ID，顺序与 chunk 对应
      surgeGroups: pages.surgeGroups, // ★ 原始分组数据，供恢复 Product 用
      stateItems: pages.stateItems    // ★ 商品价格数据，供恢复时计算总价
    }));

  }
}

// ========================= 单链接解析 =========================
async function processSingleXboxLink(startUrl, currentRate) {
  const urlObj = new URL(startUrl);
  urlObj.searchParams.set('r', 'en-us');

  const redirectResp = await fetchWithTimeout(urlObj.toString(), { redirect: 'follow' }, FETCH_TIMEOUT_MS);
  const finalUrl = redirectResp.url;
  try { redirectResp.body?.cancel(); } catch (_) {}

  const idMatch = finalUrl.match(/\/([a-zA-Z0-9]{12})(?:[\/?#]|$)/);
  if (!idMatch) throw new Error('无法提取 bigId');

  const bigId = idMatch[1];
  const apiResp = await fetchWithTimeout(
    `https://displaycatalog.mp.microsoft.com/v7.0/products?bigIds=${bigId}&market=NG&languages=en-ng&MS-CV=DUMMY.1`,
    {}, FETCH_TIMEOUT_MS
  );
  if (!apiResp.ok) throw new Error(`微软接口请求失败: ${apiResp.status}`);

  const data = await apiResp.json();
  if (!data.Products?.length) throw new Error('Products 为空');

  const product  = data.Products[0];
  const gameName = product.LocalizedProperties?.[0]?.ProductTitle || 'Unknown Game';

  let targetSkuId = '', targetAvailabilityId = '';
  let originalPriceStr = 'N/A', currentPriceStr = 'N/A';
  let originalPriceNum = null, currentPriceNum = null;

  for (const skuObj of product.DisplaySkuAvailabilities || []) {
    if (skuObj.Sku?.SkuType === 'full') {
      for (const avail of skuObj.Availabilities || []) {
        if (avail.Actions?.includes('Purchase')) {
          targetSkuId = skuObj.Sku.SkuId;
          targetAvailabilityId = avail.AvailabilityId;
          if (avail.OrderManagementData?.Price) {
            const p = avail.OrderManagementData.Price;
            originalPriceNum = p.MSRP;
            currentPriceNum  = p.ListPrice;
            originalPriceStr = `${p.CurrencyCode} ${originalPriceNum}`;
            currentPriceStr  = `${p.CurrencyCode} ${currentPriceNum}`;
          }
          break;
        }
      }
    }
    if (targetAvailabilityId) break;
  }

  if (!targetAvailabilityId) throw new Error('没有找到可购买的 SKU / Availability');

  return {
    sourceUrl: startUrl, resolvedUrl: finalUrl, bigId, gameName,
    targetSkuId, targetAvailabilityId,
    originalPriceStr, currentPriceStr, originalPriceNum, currentPriceNum,
    originalPriceCNY: originalPriceNum !== null ? (originalPriceNum * currentRate).toFixed(2) : 'N/A',
    currentPriceCNY:  currentPriceNum  !== null ? (currentPriceNum  * currentRate).toFixed(2) : 'N/A'
  };
}

// ========================= 美区链接解析（/us 命令用）=========================
async function processSingleXboxLinkUS(startUrl) {
  const urlObj = new URL(startUrl);
  urlObj.searchParams.set('r', 'en-us');

  const redirectResp = await fetchWithTimeout(urlObj.toString(), { redirect: 'follow' }, FETCH_TIMEOUT_MS);
  const finalUrl = redirectResp.url;
  try { redirectResp.body?.cancel(); } catch (_) {}

  const idMatch = finalUrl.match(/\/([a-zA-Z0-9]{12})(?:[\/?#]|$)/);
  if (!idMatch) throw new Error('无法提取 bigId');

  const bigId = idMatch[1];
  const apiResp = await fetchWithTimeout(
    `https://displaycatalog.mp.microsoft.com/v7.0/products?bigIds=${bigId}&market=US&languages=en-us&MS-CV=DUMMY.1`,
    {}, FETCH_TIMEOUT_MS
  );
  if (!apiResp.ok) throw new Error(`微软接口请求失败: ${apiResp.status}`);

  const data = await apiResp.json();
  if (!data.Products?.length) throw new Error('Products 为空');

  const product  = data.Products[0];
  const gameName = product.LocalizedProperties?.[0]?.ProductTitle || 'Unknown Game';

  let targetSkuId = '', targetAvailabilityId = '';

  for (const skuObj of product.DisplaySkuAvailabilities || []) {
    if (skuObj.Sku?.SkuType === 'full') {
      for (const avail of skuObj.Availabilities || []) {
        if (avail.Actions?.includes('Purchase')) {
          targetSkuId = skuObj.Sku.SkuId;
          targetAvailabilityId = avail.AvailabilityId;
          break;
        }
      }
    }
    if (targetAvailabilityId) break;
  }

  if (!targetAvailabilityId) throw new Error('没有找到可购买的 SKU / Availability');

  return { bigId, gameName, targetSkuId, targetAvailabilityId };
}

// ========================= 运行主逻辑 =========================
async function runQueueTask(chatId, userId, runId, progressMessageId, targets) {
  const total = targets.length;

  try {
    const rate = await getRealTimeExchangeRate();
    if (!(await isRunActive(userId, runId))) return;

    const state = await loadSuccessState(userId);
    state.lastRate = rate;
    await saveSuccessState(userId, state);

    if (progressMessageId) {
      try {
        await editTelegramMessage(chatId, progressMessageId,
          `⏳ <b>抓取进行中</b>\n\n` +
          `${makeProgressBar(0, total, 10)}\n<b>0/${total}</b>\n\n` +
          `汇率: <b>1 NGN ≈ ${Number(rate).toFixed(6)} CNY</b>`
        );
      } catch (_) {}
    }

    // 全量并发 + 超时保护
    const raceResult = await Promise.race([
      Promise.allSettled(targets.map(url => processSingleXboxLink(url, rate))),
      new Promise(resolve => setTimeout(() => resolve('__TIMEOUT__'), RUN_TIMEOUT_MS))
    ]);

    if (raceResult === '__TIMEOUT__') {
      await KV.delete(getRunLockKey(userId));
      await clearRunMeta(userId);
      await showQuotePage(chatId, userId, progressMessageId);
      return;
    }

    if (!(await isRunActive(userId, runId))) return;

    // 抓取完成，立即更新消息，告知用户正在写入
    if (progressMessageId) {
      try {
        await editTelegramMessage(chatId, progressMessageId,
          `⏳ <b>抓取完成，正在写入结果...</b>

` +
          `${makeProgressBar(total, total, 10)}
<b>${total}/${total}</b>

` +
          `汇率: <b>1 NGN ≈ ${Number(rate).toFixed(6)} CNY</b>`
        );
      } catch (_) {}
    }

    let successCount = 0, failCount = 0;
    const failedUrls = [];

    for (let i = 0; i < targets.length; i++) {
      const sourceUrl = targets[i];
      const result    = raceResult[i];

      if (result.status === 'fulfilled') {
        const item = result.value;
        const freshState = await loadSuccessState(userId);
        const freshSurge  = await loadSurgeQueue(userId);

        // ★ 双重去重：URL 去重 + ProductId（bigId）去重
        const urlExists = freshState.items.some(x => x.sourceUrl === sourceUrl);
        const existingProductIds = new Set(
          freshSurge.groups.flatMap(g => Object.values(g.products).map(p => (p.ProductId || '').toUpperCase()))
        );
        const productExists = existingProductIds.has((item.bigId || '').toUpperCase());

        if (!urlExists && !productExists) {
          freshState.items.push(item);
          freshState.lastRate = rate;
          await saveSuccessState(userId, freshState);
          await appendProductToSurgeQueue(userId, item);
          await appendResolvedLink(userId, {
            sourceUrl: item.sourceUrl,
            resolvedUrl: item.resolvedUrl,
            bigId: item.bigId,
            gameName: item.gameName
          });
        } else if (productExists) {
          console.log(`[run] 跳过重复 ProductId: ${item.bigId} (${item.gameName})`);
        }
        successCount++;
      } else {
        // ★ 失败：记录 URL，稍后写回队列
        failedUrls.push(sourceUrl);
        failCount++;
      }
    }

    // ★ 失败的 URL 写回队列，成功的则清掉
    if (failedUrls.length > 0) {
      await savePendingQueue(userId, failedUrls);
    } else {
      await KV.delete(getQueueKey(userId));
    }

    await KV.delete(getRunLockKey(userId));
    await clearRunMeta(userId);

    // 直接展示结果（相当于自动点击"查看信息"）
    await showQuotePage(chatId, userId, progressMessageId);

    // 有失败的链接，额外通知
    if (failCount > 0) {
      await sendTelegramMessage(chatId,
        `⚠️ <b>注意</b>：有 <b>${failCount}</b> 个链接解析失败，已保留，可重新发送链接重试。`
      );
    }

  } catch (error) {
    if (String(error?.message || '').includes('汇率')) {
      const msg = `❌ <b>任务终止</b>\n\n获取汇率失败，已停止执行。\n当前待处理仍保留在队列中。`;
      if (progressMessageId) {
        try { await editTelegramMessage(chatId, progressMessageId, msg, getPaginationKeyboard('page_1')); }
        catch (_) { await sendTelegramMessage(chatId, msg); }
      } else {
        await sendTelegramMessage(chatId, msg);
      }
    } else {
      await sendTelegramMessage(chatId, `❌ <b>执行异常</b>\n\n${escapeHTML(error?.message || '未知错误')}\n\n已完成的数据不会丢失。`);
    }
    await KV.delete(getRunLockKey(userId));
    await clearRunMeta(userId);
  }
}

// ========================= Surge 分组翻页 =========================
function buildSurgeGroupKeyboard(currentIdx, totalGroups) {
  const buttons = [];
  if (currentIdx > 0) {
    buttons.push({ text: '⬅️ 上一组', callback_data: `surge_page_${currentIdx - 1}` });
  }
  if (currentIdx < totalGroups - 1) {
    buttons.push({ text: '下一组 ➡️', callback_data: `surge_page_${currentIdx + 1}` });
  }
  if (!buttons.length) return null;
  return { inline_keyboard: [buttons] };
}

function buildSurgeGroupText(queue, idx) {
  const g = queue.groups[idx];
  return (
    `📦 <b>Surge 分组队列</b>  <b>${idx + 1} / ${queue.groups.length}</b>

` +
    `组编号: <b>${g.groupIndex}</b>　商品数: <b>${g.count}</b>

` +
    `<code>${escapeHTML(JSON.stringify(g.products, null, 2))}</code>`
  );
}

// ========================= Express =========================
const app = express();
app.use(express.json());

app.get('/surge', async (req, res) => {
  if (req.query.token !== VIEW_TOKEN) return res.status(403).send('Forbidden');
  const headers = { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' };
  const lockKey = getSurgeLockKey(ALLOWED_USER_ID);

  if (req.query.action === 'clear') {
    // ★ clear：只有持有锁的人才能清除，清除后释放锁
    const lock = await KV.get(lockKey);
    if (!lock) {
      // 没有锁，说明这次是重复触发，直接忽略
      console.log('[surge/clear] 无锁，忽略重复 clear');
      return res.set(headers).json({ ok: true, cleared: false, ignored: true });
    }
    await KV.delete(lockKey);
    return res.set(headers).json(await popFirstSurgeGroup(ALLOWED_USER_ID));
  }

  // 普通读取：先检查是否已有消费在进行中
  const existingLock = await KV.get(lockKey);
  if (existingLock) {
    // 已有消费进行中，返回空，防止重复触发
    console.log('[surge/read] 已有消费进行中，返回空');
    return res.set(headers).json({ ok: true, currentGroupIndex: null, currentGroupCount: 0, remainingGroups: 0, remainingAfterCurrent: 0, currentGroup: {} });
  }

  const queue = await loadSurgeQueue(ALLOWED_USER_ID);
  if (!queue.groups.length) {
    return res.set(headers).json({ ok: true, currentGroupIndex: null, currentGroupCount: 0, remainingGroups: 0, remainingAfterCurrent: 0, currentGroup: {} });
  }

  // 设置消费锁，TTL 60 秒（异常情况自动过期）
  await KV.put(lockKey, '1', { expirationTtl: 60 });

  const current = queue.groups[0];
  return res.set(headers).json({
    ok: true,
    currentGroupIndex: current.groupIndex,
    currentGroupCount: current.count,
    remainingGroups: queue.groups.length,
    remainingAfterCurrent: Math.max(queue.groups.length - 1, 0),
    currentGroup: current.products
  });
});

// POST：Surge clear 接口（避免被 Surge 规则重复拦截）
app.post('/surge/clear', async (req, res) => {
  if (req.query.token !== VIEW_TOKEN) return res.status(403).send('Forbidden');
  const headers = { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' };
  const lockKey = getSurgeLockKey(ALLOWED_USER_ID);
  const lock = await KV.get(lockKey);
  if (!lock) {
    console.log('[surge/clear POST] 无锁，忽略重复 clear');
    return res.set(headers).json({ ok: true, cleared: false, ignored: true });
  }
  await KV.delete(lockKey);
  console.log(`[surge/clear POST] 收到 clear 请求，时间: ${new Date().toISOString()}`);
  return res.set(headers).json(await popFirstSurgeGroup(ALLOWED_USER_ID));
});

// POST：只释放锁，不弹出分组（加购失败时调用，保留数据供重试）
app.post('/surge/unlock', async (req, res) => {
  if (req.query.token !== VIEW_TOKEN) return res.status(403).send('Forbidden');
  const headers = { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' };
  const lockKey = getSurgeLockKey(ALLOWED_USER_ID);
  await KV.delete(lockKey);
  console.log('[surge/unlock POST] 锁已释放，数据保留');
  return res.set(headers).json({ ok: true, unlocked: true });
});

// POST /surge/commit：提交本次执行结果
// body: { remaining: { product1: {...}, ... } }
// - remaining 有内容：用 remaining 更新当前组（删掉已成功的），释放锁
// - remaining 为空：弹出当前组（等同 clear），释放锁
app.post('/surge/commit', async (req, res) => {
  if (req.query.token !== VIEW_TOKEN) return res.status(403).send('Forbidden');
  const headers = { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' };
  const lockKey = getSurgeLockKey(ALLOWED_USER_ID);

  // 释放锁
  await KV.delete(lockKey);

  const remaining = req.body?.remaining ?? {};
  // 接受任意格式的 key（支持旧版 product1 和新版 (1) GameName）
  const remainingKeys = Object.keys(remaining).filter(k => remaining[k]?.ProductId || remaining[k]?.productId);

  if (remainingKeys.length === 0) {
    // 全部成功，弹出当前组
    console.log('[surge/commit] 全部成功，弹出当前组');
    return res.set(headers).json(await popFirstSurgeGroup(ALLOWED_USER_ID));
  }

  // 部分失败，用 remaining 更新当前组
  const queue = await loadSurgeQueue(ALLOWED_USER_ID);
  if (!queue.groups.length) {
    return res.set(headers).json({ ok: true, updated: false, reason: 'no groups' });
  }

  const originalGroup = queue.groups[0];
  const originalGroupIndex = originalGroup.groupIndex;
  const originalCount = originalGroup.count;
  const failedCount = remainingKeys.length;
  const successCount = originalCount - failedCount;

  // 重新编号，保持连续
  const reindexed = {};
  // 保留原 key 名（如 "(1) GameName"），直接写入
  remainingKeys.forEach(k => { reindexed[k] = remaining[k]; });

  queue.groups[0].products = reindexed;
  queue.groups[0].count = failedCount;
  await saveSurgeQueue(ALLOWED_USER_ID, queue);

  console.log(`[surge/commit] 部分失败，当前组更新为 ${failedCount} 个`);

  // ★ 发送 bot 通知
  // 直接从 product 的 PriceNGN 字段取价格
  const failedProductIdSet = new Set(
    Object.values(remaining).map(p => (p.ProductId || p.productId || '').toUpperCase())
  );
  // 已成功消费 = 原组里不在 remaining 里的
  const successNGN = Object.values(originalGroup.products)
    .filter(p => !failedProductIdSet.has((p.ProductId || p.productId || '').toUpperCase()))
    .reduce((s, p) => s + (typeof p.PriceNGN === 'number' ? p.PriceNGN : 0), 0);

  // 失败的游戏名称（从 state 里取，取不到就用 ProductId 代替）
  const stateForCommit = await loadSuccessState(ALLOWED_USER_ID);
  const failedNames = Object.values(remaining).map(p => {
    const pid = (p.ProductId || p.productId || '').toUpperCase();
    const found = (stateForCommit.items || []).find(i => (i.bigId || '').toUpperCase() === pid);
    return found ? found.gameName : (p.ProductId || p.productId || pid);
  });

  let notifyText =
    `⚠️ <b>第 ${originalGroupIndex} 组部分加购失败</b>

` +
    `成功: <b>${successCount}</b> 个
` +
    `失败: <b>${failedCount}</b> 个（已写回队列等待重试）
`;

  if (failedNames.length > 0) {
    notifyText += '\n加购失败的游戏：\n' + failedNames.map(n => `• ${n}`).join('\n') + '\n';
  }

  notifyText += `\n当前组已消费的游戏总价: <b>${successNGN.toFixed(2)} NGN</b>`;

  sendTelegramMessage(ALLOWED_USER_ID, notifyText).catch(() => {});

  return res.set(headers).json({
    ok: true, updated: true,
    remainingInGroup: failedCount,
    remainingGroups: queue.groups.length,
    successCount,
    failedCount,
    successNGN: successNGN,  // ★ 已成功消费的游戏总价
    failedNames               // ★ 失败的游戏名称列表
  });
});

// POST：更新当前组内容为失败的 product，并释放锁（部分失败时调用）
app.post('/surge/update_group', async (req, res) => {
  if (req.query.token !== VIEW_TOKEN) return res.status(403).send('Forbidden');
  const headers = { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' };

  let body = {};
  try { body = req.body || {}; } catch (_) {}

  const products = body.products; // { product1: {...}, product2: {...}, ... }
  if (!products || typeof products !== 'object' || Object.keys(products).length === 0) {
    return res.status(400).set(headers).json({ ok: false, error: 'products 为空或格式错误' });
  }

  const queue = await loadSurgeQueue(ALLOWED_USER_ID);
  if (queue.groups.length > 0) {
    // 用失败的 product 替换当前第一组内容
    queue.groups[0].products = products;
    queue.groups[0].count = Object.keys(products).length;
    await saveSurgeQueue(ALLOWED_USER_ID, queue);
    console.log(`[surge/update_group POST] 当前组更新为 ${queue.groups[0].count} 个失败 product`);
  }

  // 释放锁
  await KV.delete(getSurgeLockKey(ALLOWED_USER_ID));
  return res.set(headers).json({ ok: true, updated: true, count: Object.keys(products).length });
});

app.post('/webhook', async (req, res) => {
  if (WEBHOOK_SECRET && req.headers['x-telegram-bot-api-secret-token'] !== WEBHOOK_SECRET) {
    return res.status(403).send('Forbidden');
  }
  res.send('OK');
  handleUpdate(req.body).catch(err => console.error('[handleUpdate]', err));
});

async function handleUpdate(payload) {
  let chatId, userId, text;
  let cbId = null, callbackMessageId = null;

  if (payload.callback_query) {
    chatId = payload.callback_query.message.chat.id;
    userId = payload.callback_query.from.id;
    text   = payload.callback_query.data;
    cbId   = payload.callback_query.id;
    callbackMessageId = payload.callback_query.message.message_id;

    // ── 恢复 Product 回调 ──
    if (text === 'restore_product') {
      await answerCallbackQuery(cbId);
      let stored = await KV.get(getPagesByMsgKey(callbackMessageId));
      if (!stored) stored = await KV.get(getPagesKey(userId));
      if (!stored) {
        await answerCallbackQuery(cbId, '⚠️ 无法读取存档数据');
        return;
      }
      const pages = JSON.parse(stored);
      const surgeGroups = pages.surgeGroups;
      if (!surgeGroups || surgeGroups.length === 0) {
        await answerCallbackQuery(cbId, '⚠️ 存档中没有 Surge 分组数据');
        return;
      }
      // 合并所有组的 products 展示给用户确认
      let allProducts = {};
      let pIdx = 1;
      for (const g of surgeGroups) {
        for (const k of Object.keys(g.products)) {
          allProducts[k] = g.products[k];  // 保留原 key（如 "(1) GameName"）
          pIdx++;
        }
      }
      const totalCount = pIdx - 1;
      const confirmKeyboard = {
        inline_keyboard: [[
          { text: '✅ 确定恢复', callback_data: 'restore_confirm' },
          { text: '❌ 取消', callback_data: 'restore_cancel' }
        ]]
      };
      const confirmText =
        `🔄 <b>确认恢复 Product？</b>

` +
        `将恢复以下 <b>${totalCount}</b> 个商品（共 ${surgeGroups.length} 组）：

` +
        `<code>${escapeHTML(JSON.stringify(allProducts, null, 2))}</code>

` +
        `⚠️ 此操作将完全替换当前所有 Surge 队列数据。`;
      try {
        await editTelegramMessage(chatId, callbackMessageId, confirmText, confirmKeyboard);
      } catch (_) {
        await sendTelegramMessage(chatId, confirmText, confirmKeyboard);
      }
      return;
    }

    if (text === 'restore_confirm') {
      await answerCallbackQuery(cbId);
      // 从存档里取 surgeGroups 恢复
      let stored = await KV.get(getPagesByMsgKey(callbackMessageId));
      if (!stored) stored = await KV.get(getPagesKey(userId));
      if (!stored) {
        await editTelegramMessage(chatId, callbackMessageId, '⚠️ 无法读取存档数据，恢复失败。');
        return;
      }
      const pages = JSON.parse(stored);
      const surgeGroups = pages.surgeGroups;
      if (!surgeGroups || surgeGroups.length === 0) {
        await editTelegramMessage(chatId, callbackMessageId, '⚠️ 存档中没有分组数据，恢复失败。');
        return;
      }
      // 完全替换当前 Surge 队列
      const maxIdx = surgeGroups.reduce((m, g) => Math.max(m, g.groupIndex), 0);
      await saveSurgeQueue(userId, { nextGroupIndex: maxIdx + 1, groups: surgeGroups });
      const totalRestored = surgeGroups.reduce((s, g) => s + g.count, 0);

      // 第一步：把确认消息那条消息恢复为原始三元组页面（带翻页按钮）
      const restoredPage = pages.page_1 || pages.page1Chunks?.[0] || '';
      const restoredMessageIds = pages.messageIds;
      if (restoredMessageIds && restoredMessageIds.length > 1) {
        // 多段：逐条恢复
        const restoredChunks = pages.page1Chunks || [];
        for (let i = 0; i < restoredChunks.length; i++) {
          const isLast = i === restoredChunks.length - 1;
          const kb = isLast ? getPaginationKeyboard('page_1') : null;
          const msgId = restoredMessageIds[i];
          if (i === 0) {
            // 第一条就是 callbackMessageId
            try { await editTelegramMessage(chatId, callbackMessageId, restoredChunks[i], kb); } catch (_) {}
          } else if (msgId) {
            try { await editTelegramMessage(chatId, msgId, restoredChunks[i], kb); } catch (_) {}
          }
        }
      } else {
        // 单段
        try { await editTelegramMessage(chatId, callbackMessageId, restoredPage, getPaginationKeyboard('page_1')); } catch (_) {}
      }

      // 第二步：发送通知消息
      // 直接从 surgeGroups 的 PriceNGN 字段取价格（最可靠，不依赖 stateItems）
      const ngnSum = surgeGroups.reduce((s, g) =>
        s + Object.values(g.products).reduce((gs, p) => gs + (typeof p.PriceNGN === 'number' ? p.PriceNGN : 0), 0), 0);
      const ngnStr = ngnSum > 0 ? `${ngnSum.toFixed(2)} NGN` : '未知';
      await sendTelegramMessage(chatId,
        `✅ <b>Product 已恢复</b>\n\n` +
        `已用历史记录完全替换当前 Surge 队列。\n` +
        `共 <b>${surgeGroups.length}</b> 组，合计 <b>${totalRestored}</b> 个商品，共 <b>${ngnStr}</b>。`
      );
      return;
    }

    if (text === 'restore_cancel') {
      await answerCallbackQuery(cbId, '已取消');
      // 恢复原来的翻页键盘
      let stored = await KV.get(getPagesByMsgKey(callbackMessageId));
      if (!stored) stored = await KV.get(getPagesKey(userId));
      if (stored) {
        const pages = JSON.parse(stored);
        try {
          await editTelegramMessage(chatId, callbackMessageId, pages.page_1 || pages.page1Chunks?.[0] || '', getPaginationKeyboard('page_1'));
        } catch (_) {}
      }
      return;
    }

    if (text.startsWith('surge_page_')) {
      const idx = parseInt(text.replace('surge_page_', ''), 10);
      const queue = await loadSurgeQueue(userId);
      await answerCallbackQuery(cbId);
      if (!queue.groups.length || idx < 0 || idx >= queue.groups.length) {
        await answerCallbackQuery(cbId, '⚠️ 该分组不存在');
        return;
      }
      try {
        await editTelegramMessage(
          chatId, callbackMessageId,
          buildSurgeGroupText(queue, idx),
          buildSurgeGroupKeyboard(idx, queue.groups.length)
        );
      } catch (_) {}
      return;
    }

    if (text.startsWith('page_')) {
      let stored = await KV.get(getPagesByMsgKey(callbackMessageId));
      if (!stored) stored = await KV.get(getPagesKey(userId));

      if (stored) {
        const pages = JSON.parse(stored);
        const chunkKey = text.replace('page_', 'page') + 'Chunks'; // page1Chunks / page2Chunks / page3Chunks
        const chunks = pages[chunkKey];
        const messageIds = pages.messageIds; // 存档里的所有消息 ID

        await answerCallbackQuery(cbId);

        if (chunks && chunks.length > 1) {
          if (messageIds && messageIds.length === chunks.length) {
            // 已有所有消息 ID：直接逐条 edit，原地覆盖
            for (let i = 0; i < chunks.length; i++) {
              const isLast = i === chunks.length - 1;
              const keyboard = isLast ? getPaginationKeyboard(text) : null;
              const targetMsgId = messageIds[i];
              if (targetMsgId) {
                try { await editTelegramMessage(chatId, targetMsgId, chunks[i], keyboard); }
                catch (_) {}
              }
            }
          } else {
            // 首次展开多段（从摘要点击进来，没有 messageIds）：
            // edit 当前消息为第一段，其余段发新消息，收集所有 ID 写回存档
            const newMessageIds = [];
            for (let i = 0; i < chunks.length; i++) {
              const isLast = i === chunks.length - 1;
              const keyboard = isLast ? getPaginationKeyboard(text) : null;
              if (i === 0) {
                try { await editTelegramMessage(chatId, callbackMessageId, chunks[i], keyboard); }
                catch (_) { await sendTelegramMessage(chatId, chunks[i], keyboard); }
                newMessageIds.push(callbackMessageId);
              } else {
                const msg = await sendTelegramMessage(chatId, chunks[i], keyboard);
                newMessageIds.push(msg?.result?.message_id || null);
              }
            }
            // 以最后一条消息 ID 为 key 更新存档，存入 messageIds 供后续翻页使用
            const lastMsgId = newMessageIds[newMessageIds.length - 1] || callbackMessageId;
            pages.messageIds = newMessageIds;
            await KV.put(getPagesByMsgKey(lastMsgId), JSON.stringify(pages)); // pages 已含 surgeGroups/stateItems
          }
        } else if (pages[text]) {
          // 单段
          try { await editTelegramMessage(chatId, callbackMessageId, pages[text], getPaginationKeyboard(text)); }
          catch (_) {}
        } else {
          await answerCallbackQuery(cbId, '⚠️ 页面不存在');
        }
      } else {
        await answerCallbackQuery(cbId, '⚠️ 页面数据为空');
      }
      return;
    }

    if (text === 'action_run') await answerCallbackQuery(cbId);

  } else if (payload.message?.text) {
    chatId = payload.message.chat.id;
    userId = payload.message.from.id;
    text   = payload.message.text.trim();
  } else {
    return;
  }

  if (userId !== ALLOWED_USER_ID) return;

  // ── /us ──
  if (text.toLowerCase().startsWith('/us')) {
    // 合并 list 中的链接 + 消息中内联的链接，去重
    const listQueue   = await loadPendingQueue(userId);
    const inlineUrls  = text.match(/(https?:\/\/[^\s]+)/g) || [];
    const merged      = [...new Set([...listQueue, ...inlineUrls])];

    if (merged.length === 0) {
      await sendTelegramMessage(chatId, '📭 链接队列为空，且消息中未检测到链接。');
      return;
    }

    const listCount   = listQueue.length;
    const inlineCount = [...new Set(inlineUrls)].filter(u => !new Set(listQueue).has(u)).length;
    const total       = merged.length;
    const initMsg     = await sendTelegramMessage(chatId,
      `⏳ <b>正在获取美区参数...</b>\n\n共 <b>${total}</b> 个链接` +
      (listCount > 0 && inlineCount > 0 ? `（队列 ${listCount} 个 + 新增 ${inlineCount} 个）` :
       listCount > 0 ? `（来自队列）` : `（来自消息）`)
    );
    const msgId = initMsg?.result?.message_id || null;

    // 并发抓取
    const results = await Promise.allSettled(
      merged.map(url => processSingleXboxLinkUS(url))
    );

    // 处理队列：只有原本在 listQueue 里的 URL 才参与写回逻辑
    const listQueueSet = new Set(listQueue);
    const failedListUrls = merged.filter((url, i) =>
      results[i].status === 'rejected' && listQueueSet.has(url)
    );
    if (failedListUrls.length > 0) {
      // 有失败的队列链接，写回
      await savePendingQueue(userId, failedListUrls);
    } else if (listCount > 0) {
      // 队列链接全部成功，清空 list
      await KV.delete(getQueueKey(userId));
    }

    // 构建 Surge 参数 JSON
    const products = {};
    const failedUrls = [];
    let idx = 1;

    for (let i = 0; i < results.length; i++) {
      if (results[i].status === 'fulfilled') {
        const item = results[i].value;
        const safeUsName = (item.gameName || 'Unknown').replace(/['"]/g, '');
        products[`(${idx++}) ${safeUsName}`] = {
          ProductId: item.bigId,
          SkuId: item.targetSkuId,
          AvailabilityId: item.targetAvailabilityId,
          PriceNGN: 0  // 美区无 NGN 价格，标记为 0，不影响 AddToCart
        };
      } else {
        failedUrls.push(pendingQueue[i]);
      }
    }

    const successCount = idx - 1;
    const failCount = failedUrls.length;

    const jsonStr = escapeHTML(JSON.stringify(products, null, 2));
    const header =
      `✅ <b>美区参数获取完成</b>\n\n` +
      `成功: <b>${successCount}</b> 个\n` +
      `失败: <b>${failCount}</b> 个\n\n`;
    const footer = failCount > 0
      ? '\n\n⚠️ 失败链接：\n' + failedUrls.map((u, i) => `${i+1}. ${escapeHTML(u)}`).join('\n')
      : '';

    // 如果 JSON 太长，分多条消息发送
    const MAX_JSON = 3000;
    const jsonLines = JSON.stringify(products, null, 2);
    if (jsonStr.length <= MAX_JSON) {
      const resultText = header + `<code>${jsonStr}</code>` + footer;
      if (msgId) {
        try { await editTelegramMessage(chatId, msgId, resultText, null); }
        catch (_) { await sendTelegramMessage(chatId, resultText); }
      } else {
        await sendTelegramMessage(chatId, resultText);
      }
    } else {
      // 分段：头部信息先发，然后每段最多 3500 字符的 JSON
      if (msgId) {
        try { await editTelegramMessage(chatId, msgId, header + '（JSON 较长，分段发送）'); }
        catch (_) {}
      }
      // 按 product key 分段
      const entries = Object.entries(products);
      let chunk = {};
      for (const [k, v] of entries) {
        const testChunk = { ...chunk, [k]: v };
        if (escapeHTML(JSON.stringify(testChunk)).length > MAX_JSON && Object.keys(chunk).length > 0) {
          await sendTelegramMessage(chatId, `<code>${escapeHTML(JSON.stringify(chunk, null, 2))}</code>`);
          chunk = { [k]: v };
        } else {
          chunk[k] = v;
        }
      }
      if (Object.keys(chunk).length > 0) {
        await sendTelegramMessage(chatId, `<code>${escapeHTML(JSON.stringify(chunk, null, 2))}</code>` + footer);
      } else if (footer) {
        await sendTelegramMessage(chatId, footer);
      }
    }
    return;
  }

  if (text.toLowerCase() === '/view_product') {
    const queue = await loadSurgeQueue(userId);
    if (!queue.groups.length) {
      await sendTelegramMessage(chatId, '📭 当前没有待同步的 Surge 分组数据。');
    } else {
      await sendTelegramMessage(
        chatId,
        buildSurgeGroupText(queue, 0),
        buildSurgeGroupKeyboard(0, queue.groups.length)
      );
    }
    return;
  }

  if (text.toLowerCase().startsWith('/update_product')) {
    let rawStr = text.substring('/update_product'.length).trim();

    // ★ 自动从任意文本中提取第一个合法 JSON 对象
    // 支持直接粘贴 /view_product 完整输出，自动抽出 JSON 部分
    if (rawStr) {
      const jsonMatch = rawStr.match(/\{[\s\S]*\}/);
      if (jsonMatch) rawStr = jsonMatch[0];
    }

    if (!rawStr) { await sendTelegramMessage(chatId, '⚠️ 请在命令后附带合法的 JSON 字符串。'); return; }
    try {
      const parsedData = JSON.parse(rawStr);
      const keys = Object.keys(parsedData || {});
      await saveSurgeQueue(userId, { nextGroupIndex: 2, groups: keys.length > 0 ? [{ groupIndex: 1, count: keys.length, products: parsedData }] : [] });
      await persistRenderedPages(userId);
      await sendTelegramMessage(chatId, `✅ 成功覆盖更新 Surge 分组数据！\n\n已设置 <b>${keys.length}</b> 个商品。`);
    } catch (e) { await sendTelegramMessage(chatId, `❌ JSON 格式错误：\n${escapeHTML(e.message)}`); }
    return;
  }

  if (text.toLowerCase() === '/view_list') {
    const urls = await loadPendingQueue(userId);
    if (urls.length === 0) { await sendTelegramMessage(chatId, '📭 当前待处理链接队列为空。'); }
    else {
      let listText = `📋 <b>当前待处理链接（共 ${urls.length} 个）：</b>\n\n`;
      urls.forEach((url, i) => { listText += `${i + 1}. ${escapeHTML(url)}\n`; });
      await sendTelegramMessage(chatId, listText);
    }
    return;
  }

  if (text.toLowerCase() === '/force_stop') {
    const meta = await loadRunMeta(userId);
    if (!meta) { await sendTelegramMessage(chatId, 'ℹ️ 当前没有正在执行的任务。'); return; }
    await KV.delete(getRunLockKey(userId));
    await clearRunMeta(userId);
    await showQuotePage(chatId, userId, meta.progressMessageId);
    return;
  }

  if (text.toLowerCase() === '/clear') {
    await KV.delete(getQueueKey(userId));
    await KV.delete(getStateKey(userId));
    await KV.delete(getPagesKey(userId));
    await KV.delete(getRunMetaKey(userId));
    await KV.delete(getSurgeQueueKey(userId));
    await KV.delete(getResolvedLinksKey(userId));
    await KV.delete('LATEST_XBOX_LIST');
    await KV.delete(getRunLockKey(userId));
    await sendTelegramMessage(chatId, '🗑️ 已彻底清空<b>待处理队列</b>、<b>成功解析记录</b>、<b>已解析链接记录</b>、<b>分页缓存</b>与云端 <b>Product 数据</b>。');
    return;
  }

  if (text.toLowerCase() === '/run' || text === 'action_run') {
    let isRunning = await KV.get(getRunLockKey(userId));
    if (isRunning) {
      const meta = await loadRunMeta(userId);
      if (!meta) { await KV.delete(getRunLockKey(userId)); isRunning = null; }
    }
    if (isRunning) { await sendTelegramMessage(chatId, '⏳ 当前已有任务正在执行中，请先 /force_stop。'); return; }

    const pendingQueue = await loadPendingQueue(userId);
    if (pendingQueue.length === 0) { await sendTelegramMessage(chatId, '📭 链接队列为空，请先发送游戏链接。'); return; }

    // ★ 全新任务（state 为空）→ 重置 Surge 队列组号从 1 开始
    const existingState = await loadSuccessState(userId);
    if (existingState.items.length === 0) {
      await resetSurgeQueue(userId);
    }

    const total = pendingQueue.length;
    const initText =
      `⏳ <b>准备开始抓取</b>\n\n` +
      `共 <b>${total}</b> 个链接，全量并发执行\n\n` +
      `${makeProgressBar(0, total)}\n<b>0/${total}</b>`;

    let progressMessageId;
    if (callbackMessageId) {
      await editTelegramMessage(chatId, callbackMessageId, initText, null);
      progressMessageId = callbackMessageId;
    } else {
      const startMsg = await sendTelegramMessage(chatId, initText);
      progressMessageId = startMsg?.result?.message_id || null;
    }

    const runId = crypto.randomUUID();
    await KV.put(getRunLockKey(userId), runId, { expirationTtl: RUN_LOCK_TTL });
    await saveRunMeta(userId, { runId, chatId, progressMessageId, total, processed: 0, startedAt: new Date().toISOString() });

    runQueueTask(chatId, userId, runId, progressMessageId, pendingQueue)
      .catch(err => console.error('[runQueueTask]', err));
    return;
  }

  const newUrls = text.match(/(https?:\/\/[^\s]+)/g);
  if (newUrls?.length > 0) {
    const state         = await loadSuccessState(userId);
    const resolvedLinks = await loadResolvedLinks(userId);
    const successSet    = new Set((state.items || []).map(x => x.sourceUrl));
    const resolvedSet   = new Set(resolvedLinks.map(x => x.sourceUrl));
    const reallyNew     = newUrls.filter(url => !successSet.has(url) && !resolvedSet.has(url));

    if (reallyNew.length === 0) {
      // 全部已解析过，直接显示当前结果
      await showQuotePage(chatId, userId);
      return;
    }

    // ★ 检查是否已有任务在跑
    let isRunning = await KV.get(getRunLockKey(userId));
    if (isRunning) {
      const meta = await loadRunMeta(userId);
      if (!meta) { await KV.delete(getRunLockKey(userId)); isRunning = null; }
    }
    if (isRunning) {
      await sendTelegramMessage(chatId, '⏳ 当前已有任务正在执行中，请先 /force_stop。');
      return;
    }

    // 写入队列
    const pendingQueue = await loadPendingQueue(userId);
    const pendingSet   = new Set(pendingQueue);
    const toAdd        = reallyNew.filter(url => !pendingSet.has(url));
    const merged       = [...pendingQueue, ...toAdd];
    await savePendingQueue(userId, merged);

    // 重置 Surge 队列组号（全新任务）
    const existingState = await loadSuccessState(userId);
    if (existingState.items.length === 0) {
      await resetSurgeQueue(userId);
    }

    const total = merged.length;
    const initText =
      `⏳ <b>正在解析链接...</b>\n\n` +
      `共 <b>${reallyNew.length}</b> 个新链接\n\n` +
      `${makeProgressBar(0, total)} <b>0/${total}</b>`;

    const startMsg = await sendTelegramMessage(chatId, initText);
    const progressMessageId = startMsg?.result?.message_id || null;

    const runId = crypto.randomUUID();
    await KV.put(getRunLockKey(userId), runId, { expirationTtl: RUN_LOCK_TTL });
    await saveRunMeta(userId, { runId, chatId, progressMessageId, total, processed: 0, startedAt: new Date().toISOString() });

    runQueueTask(chatId, userId, runId, progressMessageId, merged)
      .catch(err => console.error('[runQueueTask]', err));
  }
}

// ========================= 启动 =========================
app.listen(PORT, () => {
  console.log(`[Bot] 服务已启动，监听端口 ${PORT}`);
  console.log(`[Bot] Webhook 地址: POST /webhook`);
  console.log(`[Bot] Surge 接口:   GET  /surge?token=<VIEW_TOKEN>`);
  scheduleNextClean();
});