TOKEN = ENV_BOT_TOKEN;
const WEBHOOK = '/endpoint';
const SECRET = ENV_BOT_SECRET;
const ADMIN_UID = ENV_ADMIN_UID;

const USER_TAG_COUNTER_KEY = 'user-tag-counter';
const SESSION_HEADER_INTERVAL = 10 * 60 * 1000;

const NOTIFY_INTERVAL = 3600 * 1000;
const ENABLE_INSTANT_CONFIRM = false;
const START_MSG_ZH_URL = 'https://git.loliloli.li/Administrator/TPM/raw/branch/main/data/startMessage.zh.md';
const START_MSG_EN_URL = 'https://git.loliloli.li/Administrator/TPM/raw/branch/main/data/startMessage.en.md';
const ENABLE_NOTIFICATION = true;
const ENABLE_KEYWORD_FILTER = true;
const KEYWORD_STORE_KEY = 'kw-list';
const DEFAULT_BLOCKLIST_URL = 'https://git.loliloli.li/Administrator/TPM/raw/branch/main/data/blocklist.txt';
const BLOCKLIST_REFRESH_MS = 15 * 60 * 1000;
const REMOTE_CACHE_KEY = 'blocked-words-cache';
const REMOTE_ETAG_KEY = 'blocked-words-etag';
const REMOTE_LASTFETCH_KEY = 'blocked-words-lastfetch';
const VERIFY_STORE_KEY = (uid) => `verify-${uid}`;
const VERIFY_REQUIRED_ZH = '🛡 为了防止骚扰，请先完成一次验证：点击下方按钮。';
const VERIFY_REQUIRED_EN = '🛡 To prevent spam, please complete a quick verification: tap the button below.';
const VERIFIED_SUCCESS_ZH = '✅ 验证通过！现在您可以正常发送消息了。';
const VERIFIED_SUCCESS_EN = '✅ Verified! You can now send messages normally.';
const ADMIN_REPLY_PROMPT_ZH = '🙅 请点击**转发的用户消息**进行回复，这样我才能知道您是想回复哪位用户。直接发送消息我无法识别目标用户。';
const ADMIN_REPLY_PROMPT_EN = '🙅 Please click **reply to the forwarded user message** so I know which user you want to reply to. I cannot identify the target user if you send a message directly.';
const USER_BLOCKED_PROMPT_ZH = '🚫 您已被管理员屏蔽，无法发送消息。';
const USER_BLOCKED_PROMPT_EN = '🚫 You have been blocked by the administrator and cannot send messages.';
const MESSAGE_FORWARD_FAIL_PROMPT_ZH = '抱歉，您的消息未能成功转发给管理员，请稍后再试或联系管理员。';
const MESSAGE_FORWARD_FAIL_PROMPT_EN = 'Sorry, your message could not be forwarded to the administrator. Please try again later or contact the administrator.';
const MESSAGE_FORWARDED_NOTIF_ZH = "🔔 您好，您的消息已转发给管理员，请耐心等待回复。如长时间未收到答复，可适当再次留言。";
const MESSAGE_FORWARDED_NOTIF_EN = "🔔 Hello, your message has been forwarded to the administrator. Please wait patiently for a reply. If there’s no response for a long time, feel free to send another message.";
const MESSAGE_FORWARDED_OK_ZH = "💬 您的消息已成功转发，管理员将尽快回复您。";
const MESSAGE_FORWARDED_OK_EN = "💬 Your message has been successfully forwarded. The admin will reply soon.";
const USER_UNBLOCKED_PROMPT_ZH = '🎉 您已被管理员解除屏蔽，现在可以正常发送消息了。';
const USER_UNBLOCKED_PROMPT_EN = '🎉 You have been unblocked by the administrator. You can now send messages normally.';
const ADMIN_BLOCK_SELF_PROMPT_ZH = '⚠️ 不能屏蔽自己！';
const ADMIN_BLOCK_SELF_PROMPT_EN = '⚠️ You cannot block yourself!';
const ADMIN_CANNOT_IDENTIFY_USER_PROMPT_ZH = '❌ 无法识别要操作的用户。请确保您回复的是用户转发给您的消息。';
const ADMIN_CANNOT_IDENTIFY_USER_PROMPT_EN = '❌ Cannot identify the user to operate on. Please make sure you are replying to a message forwarded to you by the user.';
const ADMIN_CANNOT_FIND_USER_ID_PROMPT_ZH = '⚠️ 无法找到对应的用户ID。可能是旧的转发消息或非转发消息。请检查。';
const ADMIN_CANNOT_FIND_USER_ID_PROMPT_EN = '⚠️ Cannot find the corresponding user ID. This may be an old forwarded message or a non-forwarded message. Please check.';
const USER_KEYWORD_BLOCKED_PROMPT_ZH = '⚠️ 您的消息包含被屏蔽的关键词，未被转发给管理员。';
const USER_KEYWORD_BLOCKED_PROMPT_EN = '⚠️ Your message contains blocked keywords and was not forwarded to the admin.';
const ADMIN_KEYWORD_ADDED_ZH = kw => `✅ 已添加屏蔽关键词：\`${kw}\``;
const ADMIN_KEYWORD_ADDED_EN = kw => `✅ Added blocked keyword: \`${kw}\``;
const ADMIN_KEYWORD_REMOVED_ZH = kw => `✅ 已移除屏蔽关键词：\`${kw}\``;
const ADMIN_KEYWORD_REMOVED_EN = kw => `✅ Removed blocked keyword: \`${kw}\``;
const ADMIN_KEYWORD_LIST_TITLE_ZH = '📃 当前屏蔽关键词列表：';
const ADMIN_KEYWORD_LIST_TITLE_EN = '📃 Current blocked keywords:';
const ADMIN_KEYWORD_EMPTY_ZH = '（空）尚未添加任何关键词。';
const ADMIN_KEYWORD_EMPTY_EN = '(empty) no keywords yet.';
const ADMIN_KEYWORD_USAGE_ZH = '用法：/addkw 关键词 ｜ /rmkw 关键词 ｜ /listkw';
const ADMIN_KEYWORD_USAGE_EN = 'Usage: /addkw <keyword> | /rmkw <keyword> | /listkw';
const ADMIN_BLOCKLIST_RELOADED_ZH = (source, updated, count, url=undefined) => `✅ 词表已刷新（${source}${updated ? ', 已更新' : ''}）。` + (url ? `\n🌐 远程地址：${url}` : '') + `\n📦 当前共 ${count} 条。`;
const ADMIN_BLOCKLIST_RELOADED_EN = (source, updated, count, url=undefined) => `✅ Blocklist refreshed (${source}${updated ? ', updated' : ''}).` + (url ? `\n🌐 Remote URL: ${url}` : '') + `\n📦 Now ${count} items.`;
const ADMIN_BLOCKLIST_REMOTE_TITLE_ZH = (total, shown) => `🌐 远程词表信息：共 ${total} 条，前 ${shown} 条：`;
const ADMIN_BLOCKLIST_REMOTE_TITLE_EN = (total, shown) => `🌐 Remote blocklist: total ${total}, first ${shown}:`;
const ADMIN_BLOCKLIST_ALL_TITLE_ZH = (total, shown) => `🧩 合并列表（本地 + 远程）：共 ${total} 条，前 ${shown} 条：`;
const ADMIN_BLOCKLIST_ALL_TITLE_EN = (total, shown) => `🧩 Merged list (local + remote): total ${total}, first ${shown}:`;
const ADMIN_KV_ERROR_ZH = (ctx, err) => `❌ KV操作失败（${ctx}）：\n\`${String(err?.message || err)}\``;
const ADMIN_KV_ERROR_EN = (ctx, err) => `❌ KV operation failed (${ctx}):\n\`${String(err?.message || err)}\``;
const USER_TEMP_ERROR_ZH = '⚠️ 系统临时故障，请稍后再试。';
const USER_TEMP_ERROR_EN = '⚠️ Temporary system issue, please try again later.';

function apiUrl(method, params = null) {
  let query = '';
  if (params) {
    query = '?' + new URLSearchParams(params).toString();
  }
  return `https://api.telegram.org/bot${TOKEN}/${method}${query}`;
}

function makeReqBody(body) {
  return {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(body)
  };
}

async function requestTelegram(method, body, params = null) {
  try {
    const response = await fetch(apiUrl(method, params), makeReqBody(body));
    if (!response.ok) {
      const errorBody = await response.text().catch(()=> '');
      console.error(`Telegram API请求失败 (${method}): ${response.status} ${response.statusText}`, errorBody);
      return {
        ok: false,
        description: `API请求失败: ${response.status} ${response.statusText}`,
        errorDetails: errorBody
      };
    }
    return response.json();
  } catch (error) {
    console.error(`执行 ${method} 方法时发生Fetch错误:`, error);
    return { ok: false, description: `网络或未知错误: ${error.message}` };
  }
}

const sendMessage = (msg) => requestTelegram('sendMessage', msg);
const copyMessage = (msg) => requestTelegram('copyMessage', msg);
const forwardMessage = (msg) => requestTelegram('forwardMessage', msg);
const answerCallbackQuery = (msg) => requestTelegram('answerCallbackQuery', msg);
const setMyCommands = (commands, scope = null) => {
  const body = { commands };
  if (scope && Object.keys(scope).length > 0) body.scope = scope;
  return requestTelegram('setMyCommands', body);
};
const setWebhook = (url, secret_token, opts = {}) =>
  requestTelegram('setWebhook', {
    url,
    secret_token,
    allowed_updates: opts.allowed_updates || ["message", "callback_query"],
    drop_pending_updates: !!opts.drop_pending_updates
  });

addEventListener('fetch', event => {
  const url = new URL(event.request.url);
  if (url.pathname === WEBHOOK) {
    event.respondWith(handleWebhook(event));
  } else if (url.pathname === '/registerWebhook') {
    event.respondWith(registerWebhook(event, url));
  } else if (url.pathname === '/unRegisterWebhook') {
    event.respondWith(unRegisterWebhook());
  } else if (url.pathname === '/setMenu') {
    event.respondWith(handleSetMenu());
  } else if (url.pathname === '/debugWebhook') {
    event.respondWith(debugWebhook());
  } else {
    event.respondWith(new Response('请求路径未找到处理程序', { status: 404 }));
  }
});

async function handleWebhook(event) {
  if (event.request.headers.get('X-Telegram-Bot-Api-Secret-Token') !== SECRET) {
    return new Response('未经授权', { status: 403 });
  }
  try {
    const update = await event.request.json();
    event.waitUntil(onUpdate(update));
    return new Response('Ok');
  } catch (error) {
    console.error('解析Webhook更新数据时出错:', error);
    return new Response('错误请求，JSON解析失败', { status: 400 });
  }
}

async function onUpdate(update) {
  if ('message' in update) {
    await onMessage(update.message);
  } else if ('callback_query' in update) {
    await onCallbackQuery(update.callback_query);
  }
}

function getLocalizedPrompt(langCode, prompts) {
  if (langCode && langCode.startsWith('zh')) return prompts.zh;
  return prompts.en;
}

async function notifyAdminKvError(lang, context, error) {
  const text = getLocalizedPrompt(lang, {
    zh: ADMIN_KV_ERROR_ZH(context, error),
    en: ADMIN_KV_ERROR_EN(context, error)
  });
  try {
    await sendMessage({
      chat_id: parseInt(ADMIN_UID),
      text,
      parse_mode: 'Markdown'
    });
  } catch (e) {
    console.error('通知管理员KV错误时再次失败：', e);
  }
}

async function kvPutJson(key, value) {
  await KV.put(key, JSON.stringify(value));
}

async function loadKeywordsLocal() {
  const arr = await KV.get(KEYWORD_STORE_KEY, { type: "json" });
  return Array.isArray(arr) ? arr : [];
}

async function saveKeywords(list) {
  const cleaned = Array.from(new Set(
    list.map(s => String(s || '').trim()).filter(Boolean)
  ));
  await kvPutJson(KEYWORD_STORE_KEY, cleaned);
  return cleaned;
}

async function addKeyword(kw) {
  const list = await loadKeywordsLocal();
  list.push(kw);
  return saveKeywords(list);
}

async function removeKeyword(kw) {
  const list = await loadKeywordsLocal();
  const lowered = String(kw).toLowerCase();
  const filtered = list.filter(x => String(x).toLowerCase() !== lowered);
  return saveKeywords(filtered);
}

function extractSearchableText(message) {
  const segs = [];
  if (typeof message.text === 'string') segs.push(message.text);
  if (typeof message.caption === 'string') segs.push(message.caption);
  return segs.join('\n').trim();
}

function hitBlockedKeyword(text, keywords) {
  if (!text) return null;
  const low = text.toLowerCase();
  for (const kw of keywords) {
    const k = String(kw || '').trim().toLowerCase();
    if (!k) continue;
    if (low.includes(k)) return kw;
  }
  return null;
}

function parseBlocklist(text) {
  const trimmed = (text || '').trim();
  if (!trimmed) return [];
  if ((trimmed.startsWith('[') && trimmed.endsWith(']')) ||
      (trimmed.startsWith('{') && trimmed.endsWith('}'))) {
    try {
      const data = JSON.parse(trimmed);
      if (Array.isArray(data)) return data.map(s => String(s).trim()).filter(Boolean);
      if (data && Array.isArray(data.words)) return data.words.map(s => String(s).trim()).filter(Boolean);
    } catch {}
  }
  return trimmed
    .split(/\r?\n/)
    .map(l => l.trim())
    .filter(l => l && !l.startsWith('#'));
}

async function getRemoteUrl() {
  return DEFAULT_BLOCKLIST_URL;
}

async function getRemoteCachedWords() {
  try {
    const txt = await KV.get(REMOTE_CACHE_KEY, { type: 'text' });
    if (!txt) return [];
    const obj = JSON.parse(txt);
    if (obj && Array.isArray(obj.words)) return obj.words;
  } catch {}
  return [];
}

async function saveRemoteCache(words) {
  const payload = { words, updatedAt: Date.now() };
  await KV.put(REMOTE_CACHE_KEY, JSON.stringify(payload));
  await KV.put(REMOTE_LASTFETCH_KEY, String(payload.updatedAt));
}

async function fetchRemoteBlocklist({ force = false } = {}) {
  const url = await getRemoteUrl();
  const lastFetchTxt = await KV.get(REMOTE_LASTFETCH_KEY, { type: 'text' });
  const lastFetch = lastFetchTxt ? parseInt(lastFetchTxt, 10) : 0;
  if (!force && lastFetch && (Date.now() - lastFetch) < BLOCKLIST_REFRESH_MS) {
    const words = await getRemoteCachedWords();
    return { words, updated: false, source: 'cache-fresh', url };
  }

  const etag = await KV.get(REMOTE_ETAG_KEY, { type: 'text' });
  const headers = {};
  if (etag) headers['If-None-Match'] = etag;

  let res;
  try {
    res = await fetch(url, { headers });
  } catch (e) {
    const words = await getRemoteCachedWords();
    return { words, updated: false, source: 'cache-fallback', url };
  }

  if (res.status === 304) {
    await KV.put(REMOTE_LASTFETCH_KEY, String(Date.now()));
    const words = await getRemoteCachedWords();
    return { words, updated: false, source: 'not-modified', url };
  }

  if (!res.ok) {
    const words = await getRemoteCachedWords();
    return { words, updated: false, source: 'cache-on-error', url };
  }

  const text = await res.text();
  const words = parseBlocklist(text);
  await saveRemoteCache(words);
  const newEtag = res.headers.get('ETag');
  if (newEtag) await KV.put(REMOTE_ETAG_KEY, newEtag);
  return { words, updated: true, source: 'remote', url };
}

async function getBlockedWordsRemote({ force = false } = {}) {
  const { words } = await fetchRemoteBlocklist({ force });
  return words;
}

async function getAllBlockedWords() {
  const local = await loadKeywordsLocal();
  const remote = await getBlockedWordsRemote();
  const set = new Set(local.map(x => String(x).toLowerCase()));
  for (const w of remote) set.add(String(w).toLowerCase());
  return Array.from(set);
}

async function onMessage(message) {
  const chatId = message.chat.id;
  const isAdmin = (message.from?.id?.toString() === ADMIN_UID);
  const lang = message.from?.language_code || 'en';

  if (message.text === '/start') {
    const startMsgUrl = lang.startsWith('zh') ? START_MSG_ZH_URL : START_MSG_EN_URL;
    try {
      const startMsg = await fetch(startMsgUrl).then(r => r.text());
      await sendMessage({ chat_id: chatId, text: startMsg, parse_mode: 'Markdown' });
    } catch (error) {
      const fallbackWelcome = getLocalizedPrompt(lang, {
        zh: '欢迎！很抱歉，未能加载完整的欢迎消息。',
        en: 'Welcome! Sorry, the full welcome message could not be loaded.'
      });
      await sendMessage({ chat_id: chatId, text: fallbackWelcome });
    }
    return;
  }

  if (isAdmin) {
    if (/^\/addkw(?:\s+(.+))?$/i.test(message.text || '')) {
      const m = (message.text || '').match(/^\/addkw(?:\s+(.+))?$/i);
      const kw = (m && m[1] || '').trim();
      const usage = getLocalizedPrompt(lang, { zh: ADMIN_KEYWORD_USAGE_ZH, en: ADMIN_KEYWORD_USAGE_EN });
      if (!kw) return sendMessage({ chat_id: ADMIN_UID, text: usage });
      try {
        await addKeyword(kw);
        const ok = getLocalizedPrompt(lang, { zh: ADMIN_KEYWORD_ADDED_ZH(kw), en: ADMIN_KEYWORD_ADDED_EN(kw) });
        await sendMessage({ chat_id: ADMIN_UID, text: ok, parse_mode: 'Markdown' });
      } catch (err) {
        await notifyAdminKvError(lang, 'addKeyword', err);
      }
      return;
    }

    if (/^\/rmkw(?:\s+(.+))?$/i.test(message.text || '')) {
      const m = (message.text || '').match(/^\/rmkw(?:\s+(.+))?$/i);
      const kw = (m && m[1] || '').trim();
      const usage = getLocalizedPrompt(lang, { zh: ADMIN_KEYWORD_USAGE_ZH, en: ADMIN_KEYWORD_USAGE_EN });
      if (!kw) return sendMessage({ chat_id: ADMIN_UID, text: usage });
      try {
        await removeKeyword(kw);
        const ok = getLocalizedPrompt(lang, { zh: ADMIN_KEYWORD_REMOVED_ZH(kw), en: ADMIN_KEYWORD_REMOVED_EN(kw) });
        await sendMessage({ chat_id: ADMIN_UID, text: ok, parse_mode: 'Markdown' });
      } catch (err) {
        await notifyAdminKvError(lang, 'removeKeyword', err);
      }
      return;
    }

    if (/^\/listkw$/i.test(message.text || '')) {
      try {
        const list = await loadKeywordsLocal();
        const title = getLocalizedPrompt(lang, { zh: ADMIN_KEYWORD_LIST_TITLE_ZH, en: ADMIN_KEYWORD_LIST_TITLE_EN });
        const empty = getLocalizedPrompt(lang, { zh: ADMIN_KEYWORD_EMPTY_ZH, en: ADMIN_KEYWORD_EMPTY_EN });
        const body = list.length
          ? list.map((x, i) => `${i + 1}. \`${x}\``).join('\n')
          : empty;
        await sendMessage({
          chat_id: ADMIN_UID,
          text: `${title}\n${body}`,
          parse_mode: 'Markdown'
        });
      } catch (err) {
        await notifyAdminKvError(lang, 'listKeywordsLocal', err);
      }
      return;
    }

    if ((message.text || '') === '/reloadblock') {
      try {
        const { words, updated, source, url } = await fetchRemoteBlocklist({ force: true });
        const t = getLocalizedPrompt(lang, {
          zh: ADMIN_BLOCKLIST_RELOADED_ZH(source, updated, words.length, url),
          en: ADMIN_BLOCKLIST_RELOADED_EN(source, updated, words.length, url)
        });
        await sendMessage({ chat_id: ADMIN_UID, text: t });
      } catch (err) {
        await notifyAdminKvError(lang, 'reloadblock', err);
      }
      return;
    }

    if ((message.text || '') === '/listkw_remote') {
      try {
        const words = await getBlockedWordsRemote();
        const sample = words.slice(0, 100);
        const t = getLocalizedPrompt(lang, {
          zh: ADMIN_BLOCKLIST_REMOTE_TITLE_ZH(words.length, sample.length),
          en: ADMIN_BLOCKLIST_REMOTE_TITLE_EN(words.length, sample.length)
        }) + '\n' + sample.join(', ');
        await sendMessage({ chat_id: ADMIN_UID, text: t });
      } catch (err) {
        await notifyAdminKvError(lang, 'listkw_remote', err);
      }
      return;
    }

    if ((message.text || '') === '/listkw_all') {
      try {
        const local = await loadKeywordsLocal();
        const remote = await getBlockedWordsRemote();
        const merged = Array.from(new Set([...local.map(String), ...remote.map(String)]));
        const sample = merged.slice(0, 100);
        const t = getLocalizedPrompt(lang, {
          zh: ADMIN_BLOCKLIST_ALL_TITLE_ZH(merged.length, sample.length),
          en: ADMIN_BLOCKLIST_ALL_TITLE_EN(merged.length, sample.length)
        }) + '\n' + sample.join(', ');
        await sendMessage({ chat_id: ADMIN_UID, text: t });
      } catch (err) {
        await notifyAdminKvError(lang, 'listkw_all', err);
      }
      return;
    }

    if ((message.text || '') === '/version') {
      await sendMessage({
        chat_id: ADMIN_UID,
        text: `ZH:\n${MESSAGE_FORWARDED_NOTIF_ZH}\n\nEN:\n${MESSAGE_FORWARDED_NOTIF_EN}`
      });
      return;
    }

    if ((message.text || '') === '/notifytest') {
      const lang2 = message.from?.language_code || 'en';
      const notificationText = getLocalizedPrompt(lang2, {
        zh: MESSAGE_FORWARDED_NOTIF_ZH,
        en: MESSAGE_FORWARDED_NOTIF_EN
      });
      await sendMessage({ chat_id: ADMIN_UID, text: notificationText });
      return;
    }

    if (/^\/resetnotify(?:\s+(\d+))?$/i.test(message.text || '')) {
      const m = (message.text || '').match(/^\/resetnotify(?:\s+(\d+))?$/i);
      const targetId = (m && m[1])
        ? m[1]
        : String(message.reply_to_message?.forward_from?.id || '');
      if (!targetId) {
        await sendMessage({
          chat_id: ADMIN_UID,
          text: '用法: /resetnotify <userId> 或对转发消息回复 /resetnotify'
        });
        return;
      }
      try {
        await KV.delete(`notify:until:${targetId}`);
        await KV.delete(`notify:last:${targetId}`);
        await KV.delete(`lastmsg-${targetId}`);
      } catch (_) {}
      await sendMessage({
        chat_id: ADMIN_UID,
        text: `已清理节流键：${targetId}`
      });
      return;
    }

    if (message.reply_to_message) {
      if (/^\/block$/.test(message.text)) return handleBlock(message, lang);
      if (/^\/unblock$/.test(message.text)) return handleUnblock(message, lang);
      if (/^\/checkblock$/.test(message.text)) return checkBlock(message, lang);

      try {
        const guestId = await KV.get('msg-map-' + message.reply_to_message.message_id, { type: "text" });
        if (guestId) {
          await copyMessage({
            chat_id: guestId,
            from_chat_id: message.chat.id,
            message_id: message.message_id
          });
        } else {
          const prompt = getLocalizedPrompt(lang, {
            zh: ADMIN_CANNOT_FIND_USER_ID_PROMPT_ZH,
            en: ADMIN_CANNOT_FIND_USER_ID_PROMPT_EN
          });
          await sendMessage({ chat_id: ADMIN_UID, text: prompt });
        }
      } catch (err) {
        await notifyAdminKvError(lang, 'admin_reply_lookup_msg_map', err);
      }
    } else {
      const prompt = getLocalizedPrompt(lang, {
        zh: ADMIN_REPLY_PROMPT_ZH,
        en: ADMIN_REPLY_PROMPT_EN
      });
      await sendMessage({ chat_id: ADMIN_UID, text: prompt });
    }
    return;
  }

  await handleGuestMessage(message, lang);
}

function escapeHtml(s) {
  return String(s).replace(/[&<>"']/g, m => ({
    '&': '&amp;',
    '<': '&lt;',
    '>': '&gt;',
    '"': '&quot;',
    "'": '&#39;'
  }[m]));
}

function formatUserForAdmin(u) {
  const id = u?.id;
  const uname = u?.username;
  const name = [u?.first_name, u?.last_name].filter(Boolean).join(' ') || 'user';
  if (uname) return `@${uname}`;
  if (id) return `<a href="tg://user?id=${id}">${escapeHtml(name)}</a>`;
  return escapeHtml(name);
}

async function getOrCreateUserTag(userId) {
  const key = `user-tag-${userId}`;
  const existing = await KV.get(key, { type: 'text' }).catch(() => null);
  if (existing) return existing;

  let counter = 0;
  try {
    const raw = await KV.get(USER_TAG_COUNTER_KEY, { type: 'text' });
    counter = raw ? parseInt(raw, 10) || 0 : 0;
  } catch (_) {}

  counter += 1;
  const tag = 'U' + String(counter).padStart(3, '0');

  await KV.put(USER_TAG_COUNTER_KEY, String(counter));
  await KV.put(key, tag);

  return tag;
}

async function sendAdminSessionHeader(message, guestId, lang) {
  const tag = await getOrCreateUserTag(guestId);

  const key = `session-header-last:${guestId}`;
  let last = 0;
  try {
    const raw = await KV.get(key, { type: 'text' });
    last = raw ? parseInt(raw, 10) || 0 : 0;
  } catch (_) {}

  const now = Date.now();
  if (last && (now - last) < SESSION_HEADER_INTERVAL) {
    return;
  }

  await KV.put(key, String(now));

  const actor = formatUserForAdmin(message.from || {});
  const langCode = message.from?.language_code || 'n/a';

  const text =
    `📂 会话 ${tag}\n` +
    `👤 用户: ${actor}\n` +
    `🆔 ID: \`${guestId}\`\n` +
    `🌐 语言: \`${langCode}\``;

  await sendMessage({
    chat_id: parseInt(ADMIN_UID),
    text,
    parse_mode: 'Markdown'
  });
}

async function ensureVerified(userId, lang) {
  const state = await KV.get(VERIFY_STORE_KEY(userId), { type: "json" }).catch(() => null);
  if (state && state.verified === true && state.verifiedAt && (Date.now() - state.verifiedAt) <= 3 * 60 * 60 * 1000)
    return true;

  const token = Math.random().toString(36).slice(2, 10);
  const payload = {
    token,
    exp: Date.now() + 10 * 60 * 1000,
    verified: false,
    verifiedAt: null
  };
  await kvPutJson(VERIFY_STORE_KEY(userId), payload);

  const text = getLocalizedPrompt(lang, {
    zh: VERIFY_REQUIRED_ZH,
    en: VERIFY_REQUIRED_EN
  });

  await sendMessage({
    chat_id: userId,
    text,
    reply_markup: {
      inline_keyboard: [[{
        text: lang && lang.startsWith('zh') ? '✅ 我是人类' : '✅ I’m human',
        callback_data: `verify:${token}`
      }]]
    }
  });

  return false;
}

async function onCallbackQuery(cbq) {
  const fromId = cbq.from?.id;
  const lang = cbq.from?.language_code || 'en';
  const data = cbq.data || '';
  if (!fromId || !data.startsWith('verify:')) {
    await answerCallbackQuery({ callback_query_id: cbq.id });
    return;
  }

  const token = data.split(':')[1];
  const key = VERIFY_STORE_KEY(fromId);
  const state = await KV.get(key, { type: "json" }).catch(() => null);
  if (!state || state.exp < Date.now() || state.verified === true) {
    await KV.delete(key).catch(()=>{});
    await ensureVerified(fromId, lang);
    await answerCallbackQuery({ callback_query_id: cbq.id });
    return;
  }

  if (state.token === token) {
    await kvPutJson(key, { verified: true, verifiedAt: Date.now() });
    await answerCallbackQuery({
      callback_query_id: cbq.id,
      text: lang.startsWith('zh') ? '已验证' : 'Verified'
    });
    const ok = getLocalizedPrompt(lang, {
      zh: VERIFIED_SUCCESS_ZH,
      en: VERIFIED_SUCCESS_EN
    });
    await sendMessage({ chat_id: fromId, text: ok });
  } else {
    await answerCallbackQuery({
      callback_query_id: cbq.id,
      text: lang.startsWith('zh') ? '验证失败，请重试' : 'Verification failed. Try again.'
    });
  }
}

async function handleGuestMessage(message, lang) {
  const chatId = message.chat.id;

  const blocked = await KV.get(`isblocked-${chatId}`, { type: "json" }).catch(() => false);
  if (blocked) {
    const prompt = getLocalizedPrompt(lang, {
      zh: USER_BLOCKED_PROMPT_ZH,
      en: USER_BLOCKED_PROMPT_EN
    });
    return sendMessage({ chat_id: chatId, text: prompt });
  }

  const verifyState = await KV.get(VERIFY_STORE_KEY(chatId), { type: "json" }).catch(() => null);
  const now = Date.now();
  const maxValidMs = 3 * 60 * 60 * 1000;
  let needVerify = false;
  if (!verifyState || verifyState.verified !== true) {
    needVerify = true;
  } else if (!verifyState.verifiedAt || (now - verifyState.verifiedAt) > maxValidMs) {
    needVerify = true;
  }

  if (needVerify) {
    const ok = await ensureVerified(chatId, lang);
    if (!ok) return;
  }

  if (ENABLE_KEYWORD_FILTER) {
    try {
      const text = extractSearchableText(message);
      const allWords = await getAllBlockedWords();
      const hit = hitBlockedKeyword(text, allWords);
      if (hit) {
        const userMsg = getLocalizedPrompt(lang, {
          zh: USER_KEYWORD_BLOCKED_PROMPT_ZH,
          en: USER_KEYWORD_BLOCKED_PROMPT_EN
        });
        await sendMessage({ chat_id: chatId, text: userMsg });

        const actor = formatUserForAdmin(message.from || {});
        const adminAlert = getLocalizedPrompt(lang, {
          zh: `⚠️ ${actor} 的消息命中被屏蔽关键词：<code>${escapeHtml(hit)}</code>，已拦截。`,
          en: `⚠️ Message from ${actor} contained blocked keyword: <code>${escapeHtml(hit)}</code> and was intercepted.`
        });
        await sendMessage({
          chat_id: parseInt(ADMIN_UID),
          text: adminAlert,
          parse_mode: 'HTML'
        });
        return;
      }
    } catch (err) {
      const adminDegrade = getLocalizedPrompt(lang, {
        zh: `❗关键词过滤出现故障，已降级直转。\n<code>${escapeHtml(String(err?.message || err))}</code>`,
        en: `❗Keyword filter failed; falling back to forward.\n<code>${escapeHtml(String(err?.message || err))}</code>`
      });
      await sendMessage({
        chat_id: parseInt(ADMIN_UID),
        text: adminDegrade,
        parse_mode: 'HTML'
      });
    }
  }

  const forwardResult = await forwardMessage({
    chat_id: parseInt(ADMIN_UID),
    from_chat_id: chatId,
    message_id: message.message_id
  });

  if (forwardResult.ok) {
    await KV.put('msg-map-' + forwardResult.result.message_id, chatId.toString())
      .catch(err => notifyAdminKvError(lang, 'write_msg_map', err));

    await sendAdminSessionHeader(message, chatId, lang);

    if (ENABLE_INSTANT_CONFIRM) {
      const okText = getLocalizedPrompt(lang, {
        zh: MESSAGE_FORWARDED_OK_ZH,
        en: MESSAGE_FORWARDED_OK_EN
      });
      await sendMessage({ chat_id: chatId, text: okText });
    }

    await handleNotify(message, lang);
  } else {
    const prompt = getLocalizedPrompt(lang, {
      zh: MESSAGE_FORWARD_FAIL_PROMPT_ZH,
      en: MESSAGE_FORWARD_FAIL_PROMPT_EN
    });
    await sendMessage({ chat_id: chatId, text: prompt });
  }
}

async function handleNotify(message, lang) {
  const chatId = message.chat.id;
  if (!ENABLE_NOTIFICATION) return;

  const now = Date.now();
  const interval = NOTIFY_INTERVAL;
  const keyUntil = `notify:until:${chatId}`;
  const legacyJsonKey = `notify:last:${chatId}`;
  const legacyTextKey = 'lastmsg-' + chatId;

  let until = 0;

  try {
    const obj = await KV.get(keyUntil, { type: "json" });
    if (obj && typeof obj.until === "number" && isFinite(obj.until)) {
      until = obj.until;
    }
  } catch (_) {}

  if (!until) {
    try {
      const j = await KV.get(legacyJsonKey, { type: "json" });
      if (j && typeof j.t === "number" && isFinite(j.t)) {
        until = j.t + interval;
      }
    } catch (_) {}
    if (!until) {
      try {
        const s = await KV.get(legacyTextKey, { type: "text" });
        const t = s ? parseInt(s, 10) : 0;
        if (t && isFinite(t)) until = t + interval;
      } catch (_) {}
    }
  }

  if (until && now < until) return;

  try {
    await KV.put(keyUntil, JSON.stringify({ until: now + interval }));
  } catch (_) {}

  const notificationText = getLocalizedPrompt(lang, {
    zh: MESSAGE_FORWARDED_NOTIF_ZH,
    en: MESSAGE_FORWARDED_NOTIF_EN
  });
  await sendMessage({ chat_id: chatId, text: notificationText });
}

async function handleBlock(message, lang) {
  try {
    const guestId = await KV.get('msg-map-' + message.reply_to_message.message_id, { type: "text" });
    if (!guestId) {
      const prompt = getLocalizedPrompt(lang, {
        zh: ADMIN_CANNOT_IDENTIFY_USER_PROMPT_ZH,
        en: ADMIN_CANNOT_IDENTIFY_USER_PROMPT_EN
      });
      return sendMessage({ chat_id: ADMIN_UID, text: prompt });
    }

    if (guestId === ADMIN_UID) {
      const prompt = getLocalizedPrompt(lang, {
        zh: ADMIN_BLOCK_SELF_PROMPT_ZH,
        en: ADMIN_BLOCK_SELF_PROMPT_EN
      });
      return sendMessage({ chat_id: ADMIN_UID, text: prompt });
    }

    await kvPutJson('isblocked-' + guestId, true)
      .catch(err => notifyAdminKvError(lang, 'block_user', err));

    await sendMessage({
      chat_id: parseInt(ADMIN_UID),
      text: getLocalizedPrompt(lang, {
        zh: `✅ 用户 \`${guestId}\` 已被成功屏蔽。`,
        en: `✅ User \`${guestId}\` has been successfully blocked.`
      }),
      parse_mode: 'Markdown'
    });

    await sendMessage({
      chat_id: parseInt(guestId),
      text: `${USER_BLOCKED_PROMPT_ZH}\n${USER_BLOCKED_PROMPT_EN}`
    });
  } catch (err) {
    await notifyAdminKvError(lang, 'handleBlock', err);
  }
}

async function handleUnblock(message, lang) {
  try {
    const guestId = await KV.get('msg-map-' + message.reply_to_message.message_id, { type: "text" });
    if (!guestId) {
      const prompt = getLocalizedPrompt(lang, {
        zh: ADMIN_CANNOT_IDENTIFY_USER_PROMPT_ZH,
        en: ADMIN_CANNOT_IDENTIFY_USER_PROMPT_EN
      });
      return sendMessage({ chat_id: ADMIN_UID, text: prompt });
    }

    await kvPutJson('isblocked-' + guestId, false)
      .catch(err => notifyAdminKvError(lang, 'unblock_user', err));

    await sendMessage({
      chat_id: parseInt(ADMIN_UID),
      text: getLocalizedPrompt(lang, {
        zh: `✅ 用户 \`${guestId}\` 已被成功解除屏蔽。`,
        en: `✅ User \`${guestId}\` has been successfully unblocked.`
      }),
      parse_mode: 'Markdown'
    });

    await sendMessage({
      chat_id: parseInt(guestId),
      text: `${USER_UNBLOCKED_PROMPT_ZH}\n${USER_UNBLOCKED_PROMPT_EN}`
    });
  } catch (err) {
    await notifyAdminKvError(lang, 'handleUnblock', err);
  }
}

async function checkBlock(message, lang) {
  try {
    const guestId = await KV.get('msg-map-' + message.reply_to_message.message_id, { type: "text" });
    if (!guestId) {
      const prompt = getLocalizedPrompt(lang, {
        zh: ADMIN_CANNOT_IDENTIFY_USER_PROMPT_ZH,
        en: ADMIN_CANNOT_IDENTIFY_USER_PROMPT_EN
      });
      return sendMessage({ chat_id: ADMIN_UID, text: prompt });
    }

    let blocked = false;
    blocked = await KV.get('isblocked-' + guestId, { type: "json" }).catch(err => {
      notifyAdminKvError(lang, 'read_block_state_in_checkBlock', err);
      return false;
    });

    await sendMessage({
      chat_id: parseInt(ADMIN_UID),
      text: getLocalizedPrompt(lang, {
        zh: `用户信息：\`${guestId}\` ${blocked ? '已被屏蔽 🚫' : '未被屏蔽 ✅'}`,
        en: `User Info: \`${guestId}\` ${blocked ? 'is blocked 🚫' : 'is not blocked ✅'}`
      }),
      parse_mode: 'Markdown'
    });
  } catch (err) {
    await notifyAdminKvError(lang, 'checkBlock', err);
  }
}

async function registerWebhook(event, url) {
  const webhookUrl = `${url.protocol}//${url.hostname}${WEBHOOK}`;
  const res = await setWebhook(webhookUrl, SECRET, {
    allowed_updates: ["message", "callback_query"],
    drop_pending_updates: true
  });
  return new Response(JSON.stringify(res, null, 2), {
    headers: { 'Content-Type': 'application/json' }
  });
}

async function unRegisterWebhook() {
  const res = await setWebhook('', undefined, {
    drop_pending_updates: false
  });
  return new Response(JSON.stringify(res, null, 2), {
    headers: { 'Content-Type': 'application/json' }
  });
}

async function setBotCommands() {
  const adminCommands = [
    { command: "block", description: "屏蔽用户 (需回复用户消息)" },
    { command: "unblock", description: "解除屏蔽 (需回复用户消息)" },
    { command: "checkblock", description: "查询屏蔽状态 (需回复用户消息)" },
    { command: "addkw", description: "添加屏蔽关键词" },
    { command: "rmkw", description: "移除屏蔽关键词" },
    { command: "listkw", description: "查看本地关键词" },
    { command: "reloadblock", description: "刷新远程拦截词" },
    { command: "listkw_all", description: "查看合并关键词预览" }
  ];

  const userCommands = [
    { command: "start", description: "获取关于此机器人的信息" }
  ];

  const userRes = await setMyCommands(userCommands);
  if (!userRes.ok) console.error('设置用户命令失败:', userRes);

  const adminScope = { type: "chat", chat_id: parseInt(ADMIN_UID) };
  const adminRes = await setMyCommands(adminCommands, adminScope);
  if (!adminRes.ok) console.error('设置管理员命令失败:', adminRes);

  return {
    userCommandsSet: userRes.ok,
    adminCommandsSet: adminRes.ok,
    adminResponse: adminRes
  };
}

async function handleSetMenu() {
  const res = await setBotCommands();
  return new Response(JSON.stringify(res, null, 2), {
    headers: { 'Content-Type': 'application/json' }
  });
}

async function debugWebhook() {
  const r = await fetch(`https://api.telegram.org/bot${TOKEN}/getWebhookInfo`);
  const j = await r.json();
  return new Response(JSON.stringify(j, null, 2), {
    headers: { 'Content-Type': 'application/json' }
  });
}