随机签到得鸡腿？测测你是非酋还是欧皇

// ==UserScript==
// @name         NodeSeek 签到运势
// @namespace    https://www.nodeseek.com/
// @version      1.1.1
// @description  统计你在 NodeSeek 靠签到拿了多少鸡腿、平均每次几个、运气超过多少人，生成一张方便截图炫耀的卡片
// @author       coderZoe
// @match        https://www.nodeseek.com/*
// @match        https://nodeseek.com/*
// @icon         https://www.nodeseek.com/static/image/favicon/favicon-32x32.png
// @grant        GM_registerMenuCommand
// @grant        GM_getValue
// @grant        GM_setValue
// @grant        GM_setClipboard
// @grant        unsafeWindow
// @noframes
// @run-at       document-idle
// @license      MIT
// ==/UserScript==

(function () {
  'use strict';

  // ================= 可调参数 =================

  const SIGNIN_RE = /^签到收益(\d+)个鸡腿$/;
  const FIXED_REWARD = 5;   // 点「鸡腿 x 5」固定拿 5 个
  const LUCK_MEAN = 5;      // 随机签到单次的参考值：拿它和固定档比，高于它就算赌赢了
  const LUCK_SD = 2.22;     // 随机签到单次的波动（标准差），按 148 次真实随机签到估算
  const BIG_WIN = 8;        // 单次 ≥ 8 个算大暴击
  const PACE_MS = 340;      // 服务器每秒只放行 3 个请求（nginx 限速，超出的直接回 503），按这个间隔发正好不被拦
  const MAX_AHEAD = 8;      // 最多提前排队多少页
  const SAVE_EVERY = 10;    // 第一次翻整个账簿时，每翻 10 页存一次进度
  const MAX_PAGE = 100;     // 论坛只让翻到第 100 页（最近 2000 条），再往后接口会回「max page is 100」
  const CACHE_KEY = uid => `signin-cache-v2-${uid}`;

  // 按「运气超过了多少人」分档，从高往低匹配
  const TIERS = [
    { min: 0.99, emoji: '👑', title: '天选欧皇', theme: 'gold',
      quotes: ['这手气，建议立刻去买张彩票', '鸡腿之神是你亲戚吧', '服务器的随机数在偷偷给你开后门'] },
    { min: 0.90, emoji: '✨', title: '欧气附体', theme: 'purple',
      quotes: ['随机数都在偏袒你', '每天睁眼先吸一口欧气', '别人试手气，你是收手气'] },
    { min: 0.70, emoji: '🍀', title: '小有欧气', theme: 'green',
      quotes: ['比大多数人多啃了几口鸡腿', '手气不错，保持住', '运气站在你这边，但没站太近'] },
    { min: 0.30, emoji: '😐', title: '平平无奇', theme: 'blue',
      quotes: ['随机的尽头是平均，你就是那个平均', '不亏不赚，稳如老狗', '标准的鸡腿打工人'] },
    { min: 0.10, emoji: '🌧️', title: '略微背运', theme: 'gray',
      quotes: ['差一点点，明天一定', '运气在攒着，准备憋个大的', '就差那么一口鸡腿'] },
    { min: 0.01, emoji: '🌚', title: '非酋', theme: 'dark',
      quotes: ['建议改点「鸡腿 x 5」保平安', '随机数对你有意见', '每次试手气都在给系统交学费'] },
    { min: 0, emoji: '💀', title: '究极非酋', theme: 'abyss',
      quotes: ['服务器是不是针对你？', '建议先去庙里拜拜再签到', '这种手气，统计学都要为你破例'] },
  ];
  // 每次都是 5 个：多半一直点的固定档，不参与运气评比
  const ZEN_TIER = { emoji: '🧘', title: '佛系固定党', theme: 'zen',
    quotes: ['从不赌运气，稳稳拿满每一次', '随机数？与我无关', '不求暴击，只求安稳'] };

  const THEMES = {
    gold:   { bg: ['#fff4c2', '#ffd166', '#f59f5a'], text: '#3d2200', panel: 'rgba(255,255,255,.45)', track: 'rgba(61,34,0,.16)', accent: '#c2410c', bar: 'rgba(61,34,0,.32)' },
    purple: { bg: ['#fcd3f0', '#c7a8f5', '#8f7cf2'], text: '#26124a', panel: 'rgba(255,255,255,.42)', track: 'rgba(38,18,74,.16)', accent: '#6d28d9', bar: 'rgba(38,18,74,.3)' },
    green:  { bg: ['#e2fca0', '#9de8a8', '#5ccfa6'], text: '#0b3a2a', panel: 'rgba(255,255,255,.45)', track: 'rgba(11,58,42,.16)', accent: '#047857', bar: 'rgba(11,58,42,.3)' },
    blue:   { bg: ['#eaf2ff', '#cadcf6', '#a7c2ea'], text: '#172a45', panel: 'rgba(255,255,255,.55)', track: 'rgba(23,42,69,.15)', accent: '#2563eb', bar: 'rgba(23,42,69,.28)' },
    gray:   { bg: ['#e0e5ea', '#bcc6cf', '#98a6b3'], text: '#1b2530', panel: 'rgba(255,255,255,.42)', track: 'rgba(27,37,48,.16)', accent: '#475569', bar: 'rgba(27,37,48,.3)' },
    dark:   { bg: ['#40454e', '#272b32', '#15171b'], text: '#e8eaed', panel: 'rgba(255,255,255,.07)', track: 'rgba(255,255,255,.13)', accent: '#a5b4c8', bar: 'rgba(255,255,255,.24)' },
    abyss:  { bg: ['#33215a', '#1a1330', '#08070f'], text: '#e6defe', panel: 'rgba(255,255,255,.06)', track: 'rgba(255,255,255,.11)', accent: '#a78bfa', bar: 'rgba(230,222,254,.24)' },
    zen:    { bg: ['#faf7f0', '#ede6d6', '#d9ceb6'], text: '#3a3122', panel: 'rgba(255,255,255,.5)', track: 'rgba(58,49,34,.15)', accent: '#8a6d3b', bar: 'rgba(58,49,34,.28)' },
  };

  const CARD_W = 420;
  const CARD_H = 716;
  const SCALE = 3;
  const FONT = '-apple-system, BlinkMacSystemFont, "PingFang SC", "Hiragino Sans GB", "Microsoft YaHei", "Noto Sans SC", "Segoe UI", sans-serif';
  const EMOJI_FONT = '"Apple Color Emoji", "Segoe UI Emoji", "Noto Color Emoji", sans-serif';

  // ================= 取数据 =================

  class Cancelled extends Error {}
  const sleep = ms => new Promise(r => setTimeout(r, ms));

  function getUser() {
    const cfg = (typeof unsafeWindow !== 'undefined' ? unsafeWindow : window).__config__;
    const u = cfg && cfg.user;
    if (u && u.member_id) return { id: u.member_id, name: u.member_name };
    const a = document.querySelector('.user-card a.Username');
    const m = a && a.getAttribute('href').match(/\/space\/(\d+)/);
    return m ? { id: Number(m[1]), name: a.textContent.trim() } : null;
  }

  // 所有请求共用一张发送时间表：每个请求预约一个比上一个晚 pace 毫秒的时间点再发，不用等上一个返回。
  // 这样翻页速度只取决于服务器的限速，和网络来回要多久无关
  let nextSlot = 0;
  let pace = PACE_MS;

  // 账簿接口：/api/account/credit/page-N，每页 20 行，每行是 [鸡腿变动, 鸡腿总计, 理由, 时间]，新的在前
  async function fetchPage(page, stopped, onRetry) {
    for (let attempt = 1; ; attempt++) {
      const at = Math.max(Date.now(), nextSlot);
      nextSlot = at + pace;
      await sleep(at - Date.now());
      if (stopped()) throw new Cancelled();
      let problem;
      try {
        const res = await fetch(`${location.origin}/api/account/credit/page-${page}`, { credentials: 'include' });
        const body = await res.text();
        // 被限速时返回的是一张 503 网页，而不是数据
        if (body.trimStart().startsWith('{')) {
          const json = JSON.parse(body);
          // 翻过了论坛允许的最大页数：当作账簿到头了，而不是出错
          if (!json.success && /max page/i.test(json.message || '')) return { data: [], total: 0, pageLimited: true };
          if (!json.success) throw Object.assign(new Error(json.message || '账簿接口返回失败，可能没有登录'), { fatal: true });
          pace = Math.max(PACE_MS, pace * 0.9);
          return json;
        }
        problem = `第 ${page} 页被服务器限速了`;
      } catch (e) {
        if (e.fatal) throw e;
        problem = `第 ${page} 页请求失败（${e.message}）`;
      }
      if (attempt >= 8) throw new Error(`${problem}，重试多次仍然失败`);
      // 被拦了就放慢节奏，并且整体停一秒，让服务器那边的计数降下来
      pace = Math.min(pace * 1.5, 2000);
      nextSlot = Math.max(nextSlot, Date.now() + 1000);
      onRetry(problem);
    }
  }

  // 按页码顺序读账簿，后面的页提前排队发出去；visit 返回 false 就停。
  // 提前量从 1 页开始逐步翻倍，这样平时只需要看第 1 页的时候，不会白白多发一堆请求。
  // 返回的 cut 表示账簿超过了论坛允许翻的页数，最早的那部分读不到
  async function readPages(from, isCancelled, onRetry, visit) {
    const info = { cut: false };
    if (from > MAX_PAGE) return { cut: true };
    let stop = false;
    const stopped = () => stop || isCancelled();
    const queued = new Map();
    let pages = from, pageSize = 0, sent = from - 1;
    try {
      for (let page = from; page <= pages; page++) {
        const ahead = Math.min(MAX_AHEAD, 2 ** (page - from));
        while (sent < pages && sent < page + ahead - 1) {
          const p = ++sent;
          const job = fetchPage(p, stopped, onRetry);
          job.catch(() => {});
          queued.set(p, job);
        }
        const json = await queued.get(page);
        queued.delete(page);
        if (isCancelled()) throw new Cancelled();
        if (json.pageLimited) {
          info.cut = true;
          break;
        }
        if (!json.data.length) break;
        pageSize = pageSize || json.data.length;
        const allPages = Math.ceil(json.total / pageSize);
        info.cut = allPages > MAX_PAGE;
        pages = Math.max(page, Math.min(MAX_PAGE, allPages));
        if (visit(json.data, page, pages, info.cut) === false) break;
      }
    } finally {
      stop = true; // 还没发出去的请求就不发了
    }
    return info;
  }

  // 缓存里记着：已统计到的最新一条、所有签到记录；第一次翻整个账簿没翻完时，还记着翻到了哪里（tail）；
  // truncated 表示有一部分签到因为超出论坛允许翻的页数而没读到
  async function collect(uid, force, isCancelled, ui) {
    const saved = force ? null : GM_getValue(CACHE_KEY(uid), null);
    const cache = saved || { newestKey: null, newestTime: null, records: [], tail: { page: 1, lastTime: null, lastKeys: [] }, truncated: false };
    const save = () => GM_setValue(CACHE_KEY(uid), cache);

    // 1) 上次统计之后的新记录：从第 1 页往后翻，翻到上次看过的最新一条就停，通常只要一页
    if (cache.newestKey) {
      const fresh = [];
      let first = null, reached = false;
      const { cut } = await readPages(1, isCancelled, ui.retry, (rows, page) => {
        ui.progress(null, `正在检查新的记录（第 ${page} 页）`);
        for (const row of rows) {
          if (row.join('|') === cache.newestKey || row[3] < cache.newestTime) {
            reached = true;
            return false;
          }
          first = first || row;
          if (SIGNIN_RE.test(row[2])) fresh.push([Number(row[0]), row[3]]);
        }
      });
      // 隔太久没统计，新记录超过了 100 页，中间有一段读不到
      if (!reached && cut) cache.truncated = true;
      if (first) {
        cache.newestKey = first.join('|');
        cache.newestTime = first[3];
        cache.records = fresh.concat(cache.records);
        save();
      }
    }

    // 2) 第一次翻整个账簿，或者接着上次没翻完的地方往后翻
    const tail = cache.tail;
    if (tail) {
      let unsaved = 0;
      try {
        const { cut } = await readPages(tail.page, isCancelled, ui.retry, (rows, page, pages, cut) => {
          for (const row of rows) {
            const key = row.join('|'), time = row[3];
            // 翻页期间有新记录插到最前面，后面的行都会往后挪，已经处理过的行会再出现一次；账簿按时间排序，比处理过的最后一行新的都跳过
            if (tail.lastTime && (time > tail.lastTime || (time === tail.lastTime && tail.lastKeys.includes(key)))) continue;
            if (!cache.newestKey) {
              cache.newestKey = key;
              cache.newestTime = time;
            }
            if (SIGNIN_RE.test(row[2])) cache.records.push([Number(row[0]), time]);
            if (time === tail.lastTime) tail.lastKeys.push(key);
            else Object.assign(tail, { lastTime: time, lastKeys: [key] });
          }
          tail.page = page + 1;
          if (++unsaved >= SAVE_EVERY) {
            save();
            unsaved = 0;
          }
          const limitNote = cut ? `\n论坛只开放最近 ${MAX_PAGE} 页账簿，更早的记录读不到` : '';
          ui.progress(page / pages, `第 ${page} / ${pages} 页，预计还要 ${fmtDuration((pages - page) * pace)}${limitNote}\n进度会自动保存，中途关掉也没关系，下次接着翻`);
        });
        if (cut) cache.truncated = true;
        cache.tail = null;
      } finally {
        save();
      }
    }
    return { records: cache.records, truncated: !!cache.truncated };
  }

  function fmtDuration(ms) {
    const s = Math.ceil(ms / 1000);
    return s < 60 ? `${s} 秒` : `${Math.floor(s / 60)} 分 ${s % 60} 秒`;
  }

  // ================= 统计 =================

  const DAY = 86400000;
  const BEIJING = 8 * 3600000;
  const dayNum = t => Math.floor((Date.parse(t) + BEIJING) / DAY);
  const pad2 = x => String(x).padStart(2, '0');
  function fmtDay(d, sep = '.') {
    const x = new Date(d * DAY);
    return [x.getUTCFullYear(), pad2(x.getUTCMonth() + 1), pad2(x.getUTCDate())].join(sep);
  }

  // 标准正态分布的累积概率（Abramowitz-Stegun 近似，误差 < 1.5e-7）
  function normCdf(z) {
    const x = Math.abs(z) / Math.SQRT2;
    const t = 1 / (1 + 0.3275911 * x);
    const poly = ((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - 0.284496736) * t + 0.254829592) * t;
    const erf = 1 - poly * Math.exp(-x * x);
    return z >= 0 ? (1 + erf) / 2 : (1 - erf) / 2;
  }

  function analyze(records) {
    const n = records.length;
    const dist = new Map();
    let sum = 0, max = -Infinity, min = Infinity, bigWins = 0;
    for (const [amount] of records) {
      sum += amount;
      max = Math.max(max, amount);
      min = Math.min(min, amount);
      if (amount >= BIG_WIN) bigWins++;
      dist.set(amount, (dist.get(amount) || 0) + 1);
    }
    const avg = sum / n;

    const days = [...new Set(records.map(r => dayNum(r[1])))].sort((a, b) => a - b);
    let streak = 0, run = 0;
    days.forEach((d, i) => {
      run = i > 0 && d === days[i - 1] + 1 ? run + 1 : 1;
      streak = Math.max(streak, run);
    });

    // 所有人都从同一个随机规则里抽，所以不需要别人的数据：
    // 签 n 次的平均值会在 LUCK_MEAN 附近浮动，浮动幅度是 LUCK_SD / √n，
    // 算出你偏离了几个浮动单位，再查正态分布，就是「同样签 n 次的人里平均值比你低的比例」
    // 注意 LUCK_MEAN 本身是估出来的（148 次记录算出 4.89，误差约 ±0.18），所以这个百分比只能当娱乐
    const z = (avg - LUCK_MEAN) / (LUCK_SD / Math.sqrt(n));
    const luck = normCdf(z);
    const allFixed = n >= 3 && min === FIXED_REWARD && max === FIXED_REWARD;
    const tier = allFixed ? ZEN_TIER : TIERS.find(t => luck >= t.min);

    return {
      n, sum, avg, max, min, bigWins, dist, streak, luck, allFixed, tier,
      vsFixed: sum - FIXED_REWARD * n,
      quote: tier.quotes[n % tier.quotes.length],
      firstDay: fmtDay(days[0]),
      lastDay: fmtDay(days[days.length - 1]),
    };
  }

  function luckText(p) {
    const v = p * 100;
    if (v >= 99) return Math.min(99.9, v).toFixed(1);
    if (v < 1) return Math.max(0.1, v).toFixed(1);
    return String(Math.round(v));
  }

  const signed = x => (x > 0 ? `+${x}` : String(x));

  // ================= 画卡片 =================

  function roundRect(ctx, x, y, w, h, r) {
    const [tl, tr, br, bl] = (Array.isArray(r) ? r : [r, r, r, r]).map(v => Math.min(v, w / 2, h / 2));
    ctx.beginPath();
    ctx.moveTo(x + tl, y);
    ctx.arcTo(x + w, y, x + w, y + h, tr);
    ctx.arcTo(x + w, y + h, x, y + h, br);
    ctx.arcTo(x, y + h, x, y, bl);
    ctx.arcTo(x, y, x + w, y, tl);
    ctx.closePath();
  }

  function drawText(ctx, str, x, y, { size = 14, weight = 400, color, alpha = 1, align = 'left', baseline = 'alphabetic', font = FONT } = {}) {
    ctx.font = `${weight} ${size}px ${font}`;
    ctx.fillStyle = color;
    ctx.globalAlpha = alpha;
    ctx.textAlign = align;
    ctx.textBaseline = baseline;
    ctx.fillText(str, x, y);
    ctx.globalAlpha = 1;
    ctx.textBaseline = 'alphabetic';
  }

  function measure(ctx, str, size, weight = 400) {
    ctx.font = `${weight} ${size}px ${FONT}`;
    return ctx.measureText(str).width;
  }

  function fitText(ctx, str, size, weight, maxWidth) {
    if (measure(ctx, str, size, weight) <= maxWidth) return str;
    let s = str;
    while (s.length > 1 && measure(ctx, s + '…', size, weight) > maxWidth) s = s.slice(0, -1);
    return s + '…';
  }

  function drawCard(s, user, avatar) {
    const t = THEMES[s.tier.theme];
    const W = CARD_W, H = CARD_H, P = 28, CW = W - 2 * P, CX = W / 2;
    const canvas = document.createElement('canvas');
    canvas.width = W * SCALE;
    canvas.height = H * SCALE;
    const ctx = canvas.getContext('2d');
    ctx.scale(SCALE, SCALE);

    // 背景：圆角 + 斜向渐变 + 角落里一只很淡的大鸡腿
    roundRect(ctx, 0, 0, W, H, 24);
    ctx.save();
    ctx.clip();
    const bg = ctx.createLinearGradient(0, 0, W, H);
    t.bg.forEach((c, i) => bg.addColorStop(i / (t.bg.length - 1), c));
    ctx.fillStyle = bg;
    ctx.fillRect(0, 0, W, H);
    drawText(ctx, '🍗', W + 30, 250, { size: 170, font: EMOJI_FONT, align: 'right', alpha: 0.07, color: '#000' });

    // 头部：头像、用户名、签到时间范围、右上角标签
    const AV = 46;
    ctx.save();
    ctx.beginPath();
    ctx.arc(P + AV / 2, P + AV / 2, AV / 2, 0, Math.PI * 2);
    ctx.clip();
    ctx.fillStyle = t.panel;
    ctx.fillRect(P, P, AV, AV);
    if (avatar) ctx.drawImage(avatar, P, P, AV, AV);
    else drawText(ctx, user.name.slice(0, 1).toUpperCase(), P + AV / 2, P + AV / 2 + 8, { size: 22, weight: 700, color: t.text, align: 'center' });
    ctx.restore();

    const tag = 'NodeSeek 签到运势';
    const tagW = measure(ctx, tag, 11, 600) + 20;
    roundRect(ctx, W - P - tagW, P + 2, tagW, 22, 11);
    ctx.fillStyle = t.panel;
    ctx.fill();
    drawText(ctx, tag, W - P - tagW / 2, P + 17, { size: 11, weight: 600, color: t.text, align: 'center' });

    const nameX = P + AV + 12;
    const name = fitText(ctx, user.name, 18, 700, W - P - tagW - 10 - nameX);
    drawText(ctx, name, nameX, P + 20, { size: 18, weight: 700, color: t.text });
    const range = s.firstDay === s.lastDay ? s.firstDay : `${s.firstDay} → ${s.lastDay}`;
    drawText(ctx, range, nameX, P + 40, { size: 12, color: t.text, alpha: 0.7 });

    // 评级
    drawText(ctx, s.tier.emoji, CX, 150, { size: 54, font: EMOJI_FONT, align: 'center', color: t.text });
    drawText(ctx, s.tier.title, CX, 196, { size: 34, weight: 800, color: t.text, align: 'center' });
    drawText(ctx, s.quote, CX, 223, { size: 14, color: t.text, alpha: 0.8, align: 'center' });

    // 平均值
    drawText(ctx, '平均每次签到', CX, 262, { size: 13, color: t.text, alpha: 0.7, align: 'center' });
    const avgStr = s.avg.toFixed(2);
    const unit = '个 🍗';
    const avgW = measure(ctx, avgStr, 62, 800);
    const unitW = measure(ctx, unit, 18, 600);
    const avgX = CX - (avgW + 6 + unitW) / 2;
    drawText(ctx, avgStr, avgX, 322, { size: 62, weight: 800, color: t.text });
    drawText(ctx, unit, avgX + avgW + 6, 322, { size: 18, weight: 600, color: t.text });

    // 运气条：左端非酋、右端欧皇，颜色从灰到金，白底小鸡腿标出你的位置
    const luckMid = 345, luckH = 8, luckX = P + 64, luckW = CW - 128;
    ctx.font = `16px ${EMOJI_FONT}`;
    const moonW = ctx.measureText('🌚').width, crownW = ctx.measureText('👑').width;
    drawText(ctx, '🌚', P, luckMid, { size: 16, font: EMOJI_FONT, baseline: 'middle', color: t.text });
    drawText(ctx, '非酋', P + moonW + 4, luckMid + 0.5, { size: 11, weight: 600, color: t.text, alpha: 0.75, baseline: 'middle' });
    drawText(ctx, '👑', W - P, luckMid, { size: 16, font: EMOJI_FONT, baseline: 'middle', align: 'right', color: t.text });
    drawText(ctx, '欧皇', W - P - crownW - 4, luckMid + 0.5, { size: 11, weight: 600, color: t.text, alpha: 0.75, baseline: 'middle', align: 'right' });
    const spectrum = ctx.createLinearGradient(luckX, 0, luckX + luckW, 0);
    spectrum.addColorStop(0, '#4b5567');
    spectrum.addColorStop(0.5, '#aab4c1');
    spectrum.addColorStop(1, '#ffbd2e');
    roundRect(ctx, luckX, luckMid - luckH / 2, luckW, luckH, luckH / 2);
    ctx.fillStyle = spectrum;
    ctx.fill();
    // 圆钮半径 11，两头各收 6，免得运气极端时圆钮压到「非酋」「欧皇」两个字
    const knobX = Math.min(luckX + luckW - 6, Math.max(luckX + 6, luckX + luckW * (s.allFixed ? 0.5 : s.luck)));
    ctx.save();
    ctx.shadowColor = 'rgba(0, 0, 0, .28)';
    ctx.shadowBlur = 6;
    ctx.shadowOffsetY = 1;
    ctx.beginPath();
    ctx.arc(knobX, luckMid, 11, 0, Math.PI * 2);
    ctx.fillStyle = '#fff';
    ctx.fill();
    ctx.restore();
    drawText(ctx, '🍗', knobX, luckMid + 1, { size: 12, font: EMOJI_FONT, baseline: 'middle', align: 'center', color: '#000' });
    // 没有别人的数据，这个百分比是按概率推算的：同样签 n 次的人里，平均值比你低的占多少
    const luckLine = s.allFixed ? '一直拿固定档，运气与你无关' : `同样签 ${s.n} 次，理论上你手气好过 ${luckText(s.luck)}% 的人`;
    drawText(ctx, luckLine, CX, luckMid + 31, { size: 13, weight: 600, color: t.text, align: 'center' });

    // 六个小格子
    const cells = [
      [s.n, '次', '签到次数'],
      [s.sum, '个', '签到总收益'],
      [signed(s.vsFixed), '个', `对比固定拿 ${FIXED_REWARD} 个`],
      [s.max, '个', '单次最多'],
      [s.min, '个', '单次最少'],
      [s.streak, '天', '最长连签'],
    ];
    const gap = 10, cellW = (CW - 2 * gap) / 3, cellH = 64, gridY = 390;
    cells.forEach(([value, u, label], i) => {
      const x = P + (i % 3) * (cellW + gap);
      const y = gridY + Math.floor(i / 3) * (cellH + gap);
      roundRect(ctx, x, y, cellW, cellH, 12);
      ctx.fillStyle = t.panel;
      ctx.fill();
      const v = String(value);
      const vw = measure(ctx, v, 22, 800);
      const uw = measure(ctx, u, 12, 500);
      const vx = x + cellW / 2 - (vw + 3 + uw) / 2;
      drawText(ctx, v, vx, y + 31, { size: 22, weight: 800, color: t.text });
      drawText(ctx, u, vx + vw + 3, y + 31, { size: 12, weight: 500, color: t.text, alpha: 0.75 });
      drawText(ctx, label, x + cellW / 2, y + 51, { size: 12, color: t.text, alpha: 0.7, align: 'center' });
    });

    // 手气分布柱状图
    const histTitleY = gridY + 2 * cellH + gap + 34;
    drawText(ctx, '手气分布', P, histTitleY, { size: 13, weight: 700, color: t.text });
    drawText(ctx, `≥${BIG_WIN} 的大暴击共 ${s.bigWins} 次`, W - P, histTitleY, { size: 12, color: t.text, alpha: 0.7, align: 'right' });

    const lo = Math.min(1, s.min), hi = Math.max(10, s.max);
    const slots = hi - lo + 1;
    const slotW = CW / slots;
    const barW = Math.min(22, slotW * 0.64);
    const baseY = histTitleY + 84, maxBarH = 56;
    const maxCount = Math.max(...s.dist.values());
    ctx.fillStyle = t.track;
    ctx.fillRect(P, baseY, CW, 1);
    for (let v = lo; v <= hi; v++) {
      const count = s.dist.get(v) || 0;
      const bx = P + (v - lo) * slotW + (slotW - barW) / 2;
      const mid = bx + barW / 2;
      if (count) {
        const h = Math.max(3, (count / maxCount) * maxBarH);
        roundRect(ctx, bx, baseY - h, barW, h, [5, 5, 0, 0]);
        ctx.fillStyle = v >= BIG_WIN ? t.accent : t.bar;
        ctx.fill();
        drawText(ctx, String(count), mid, baseY - h - 4, { size: 10, weight: 600, color: t.text, alpha: 0.75, align: 'center' });
      }
      if (slots <= 16 || v % 2 === 0) {
        drawText(ctx, String(v), mid, baseY + 15, { size: 11, color: t.text, alpha: 0.65, align: 'center' });
      }
    }

    // 底部
    const note = s.truncated ? `论坛账簿只开放最近 ${MAX_PAGE} 页，更早的签到未计入`
      : s.n < 10 ? 'NodeSeek 签到运势 · 签到次数还少，结果仅供娱乐'
      : `NodeSeek 签到运势 · 统计于 ${fmtDay(dayNum(new Date().toISOString()), '-')}`;
    drawText(ctx, note, CX, H - 18, { size: 11, color: t.text, alpha: 0.5, align: 'center' });

    ctx.restore();
    return canvas;
  }

  function loadImage(src) {
    return new Promise(resolve => {
      const img = new Image();
      const timer = setTimeout(() => resolve(null), 3000);
      img.onload = () => { clearTimeout(timer); resolve(img); };
      img.onerror = () => { clearTimeout(timer); resolve(null); };
      img.src = src;
    });
  }

  // ================= 弹窗 =================

  const STYLE = `
    #nss-overlay { position: fixed; inset: 0; z-index: 2147483000; display: flex; align-items: center; justify-content: center;
      padding: 16px; background: rgba(10, 12, 16, .62); backdrop-filter: blur(3px); font-family: ${FONT}; }
    #nss-overlay * { box-sizing: border-box; }
    .nss-box { display: flex; flex-direction: column; align-items: center; gap: 14px; }
    .nss-card { display: block; border-radius: 24px; box-shadow: 0 24px 60px rgba(0, 0, 0, .45); }
    .nss-actions { display: flex; flex-wrap: wrap; justify-content: center; gap: 8px; }
    .nss-btn { appearance: none; border: 0; margin: 0; border-radius: 999px; padding: 9px 16px; cursor: pointer;
      font: 500 13px/1 ${FONT}; color: #1f2328; background: rgba(255, 255, 255, .92); transition: transform .1s, background .15s; }
    .nss-btn:hover { background: #fff; }
    .nss-btn:active { transform: scale(.96); }
    .nss-btn.primary { background: #2ea44f; color: #fff; }
    .nss-btn.primary:hover { background: #2c974b; }
    .nss-panel { width: 320px; max-width: 100%; padding: 22px 24px; border-radius: 18px; background: #1f2328; color: #e6edf3;
      box-shadow: 0 24px 60px rgba(0, 0, 0, .45); }
    .nss-panel-title { font-size: 16px; font-weight: 700; margin-bottom: 14px; }
    .nss-panel-text { font-size: 13px; line-height: 1.6; color: #b1bac4; white-space: pre-line; }
    .nss-progress { height: 8px; border-radius: 4px; background: rgba(255, 255, 255, .12); overflow: hidden; margin-bottom: 10px; }
    .nss-progress i { display: block; height: 100%; width: 0; border-radius: 4px; background: #f59f5a; transition: width .2s; }
    .nss-panel .nss-actions { justify-content: flex-end; margin-top: 16px; }
    .nss-toast { position: fixed; left: 50%; bottom: 32px; transform: translateX(-50%); z-index: 2147483001; padding: 10px 18px;
      border-radius: 999px; background: rgba(31, 35, 40, .95); color: #fff; font: 500 13px/1.4 ${FONT}; pointer-events: none; }
  `;

  let overlay = null;
  let runSeq = 0;

  function el(tag, className, text) {
    const e = document.createElement(tag);
    if (className) e.className = className;
    if (text != null) e.textContent = text;
    return e;
  }

  function button(label, onClick, { primary = false, title } = {}) {
    const b = el('button', primary ? 'nss-btn primary' : 'nss-btn', label);
    b.type = 'button';
    if (title) b.title = title;
    b.addEventListener('click', onClick);
    return b;
  }

  function onKey(e) {
    if (e.key === 'Escape') closeOverlay();
  }

  function fitCard() {
    const card = overlay && overlay.querySelector('.nss-card');
    if (!card) return;
    const k = Math.min(1, (innerHeight - 100) / CARD_H, (innerWidth - 32) / CARD_W);
    card.style.width = `${CARD_W * k}px`;
    card.style.height = `${CARD_H * k}px`;
  }

  function openOverlay() {
    closeOverlay();
    if (!document.getElementById('nss-style')) {
      const style = el('style', null, STYLE);
      style.id = 'nss-style';
      document.head.appendChild(style);
    }
    overlay = el('div');
    overlay.id = 'nss-overlay';
    overlay.addEventListener('click', e => { if (e.target === overlay) closeOverlay(); });
    document.body.appendChild(overlay);
    document.addEventListener('keydown', onKey);
    window.addEventListener('resize', fitCard);
  }

  function closeOverlay() {
    runSeq++; // 让还在翻页的那次统计停下来
    if (overlay) overlay.remove();
    overlay = null;
    document.removeEventListener('keydown', onKey);
    window.removeEventListener('resize', fitCard);
  }

  function showPanel(title, text, actions = []) {
    overlay.replaceChildren();
    const panel = el('div', 'nss-panel');
    panel.append(el('div', 'nss-panel-title', title));
    const progress = el('div', 'nss-progress');
    progress.append(el('i'));
    progress.hidden = true;
    const body = el('div', 'nss-panel-text', text);
    panel.append(progress, body);
    if (actions.length) {
      const bar = el('div', 'nss-actions');
      bar.append(...actions);
      panel.append(bar);
    }
    overlay.append(panel);
    return {
      set(ratio, msg) {
        progress.hidden = ratio == null;
        if (ratio != null) progress.firstChild.style.width = `${Math.round(ratio * 100)}%`;
        body.textContent = msg;
      },
      note(msg) {
        body.textContent = msg;
      },
    };
  }

  function toast(msg) {
    const t = el('div', 'nss-toast', msg);
    document.body.appendChild(t);
    setTimeout(() => t.remove(), 2200);
  }

  function shareText(s) {
    const lines = [
      `🍗 我的 NodeSeek 签到运势：${s.tier.emoji} ${s.tier.title}`,
      `签到 ${s.n} 次，靠签到拿了 ${s.sum} 个鸡腿，平均每次 ${s.avg.toFixed(2)} 个`,
    ];
    if (s.allFixed) {
      lines.push('一直拿固定档，从不赌运气');
    } else {
      const diff = s.vsFixed >= 0 ? `多赚 ${s.vsFixed}` : `少赚 ${-s.vsFixed}`;
      lines.push(`同样签 ${s.n} 次，理论上我手气好过 ${luckText(s.luck)}% 的人；比每次固定拿 ${FIXED_REWARD} 个${diff} 个`);
      lines.push(`单次最多 ${s.max} 个，最少 ${s.min} 个，≥${BIG_WIN} 的大暴击 ${s.bigWins} 次`);
    }
    lines.push(`「${s.quote}」`);
    if (s.truncated) lines.push(`（论坛账簿只开放最近 ${MAX_PAGE} 页，只统计了 ${s.firstDay} 以来的签到）`);
    return lines.join('\n');
  }

  async function copyImage(canvas) {
    try {
      const blob = new Promise(resolve => canvas.toBlob(resolve, 'image/png'));
      await navigator.clipboard.write([new ClipboardItem({ 'image/png': blob })]);
      toast('图片已复制，可以直接粘贴');
    } catch (e) {
      toast('浏览器不让直接复制图片，请用「下载图片」');
    }
  }

  function downloadImage(canvas, user) {
    canvas.toBlob(blob => {
      const url = URL.createObjectURL(blob);
      const a = el('a');
      a.href = url;
      a.download = `NodeSeek签到运势-${user.name}.png`;
      a.click();
      setTimeout(() => URL.revokeObjectURL(url), 1000);
    }, 'image/png');
  }

  function showCard(canvas, s, user) {
    overlay.replaceChildren();
    const box = el('div', 'nss-box');
    canvas.className = 'nss-card';
    const actions = el('div', 'nss-actions');
    actions.append(
      button('复制图片', () => copyImage(canvas), { primary: true }),
      button('下载图片', () => downloadImage(canvas, user)),
      button('复制文字', () => { GM_setClipboard(shareText(s), 'text'); toast('文字已复制'); }),
      button('重新统计', () => run(true), { title: '清掉缓存，从第一页重新翻整个账簿' }),
      button('关闭', closeOverlay),
    );
    box.append(canvas, actions);
    overlay.append(box);
    fitCard();
  }

  // ================= 主流程 =================

  async function run(force = false) {
    openOverlay();
    const mine = runSeq;
    const isCancelled = () => mine !== runSeq;
    const user = getUser();
    if (!user) {
      showPanel('没找到登录信息', '请先登录 NodeSeek 再来统计。', [button('关闭', closeOverlay)]);
      return;
    }

    const loading = showPanel('🍗 正在翻你的鸡腿账本…', '准备中');
    try {
      const { records, truncated } = await collect(user.id, force, isCancelled, {
        progress: (ratio, msg) => { if (!isCancelled()) loading.set(ratio, msg); },
        retry: msg => { if (!isCancelled()) loading.note(`${msg}，放慢一点再试…`); },
      });
      if (isCancelled()) return;
      if (!records.length) {
        showPanel('还没有签到记录', '账簿里没找到「签到收益」的记录，先去签个到吧。', [button('关闭', closeOverlay)]);
        return;
      }
      const s = { ...analyze(records), truncated };
      const avatar = await loadImage(`${location.origin}/avatar/${user.id}.png`);
      if (isCancelled()) return;
      showCard(drawCard(s, user, avatar), s, user);
    } catch (e) {
      if (e instanceof Cancelled || isCancelled()) return;
      console.error('[NodeSeek 签到运势]', e);
      // 服务器明确拒绝（比如没登录）时重试没用，只有网络、限速这类问题才提示接着翻
      const hint = e.fatal ? '' : '\n已经翻过的部分都存下了，点重试会接着翻。';
      showPanel('统计失败', `${e.message || e}${hint}`,
        [button('重试', () => run(false), { primary: true }), button('关闭', closeOverlay)]);
    }
  }

  GM_registerMenuCommand('🍗 统计签到运势', () => run(false));
})();