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

// ==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));

})();