在nodeloc.cc上的帖子使用,让chrome浏览器自动向下滑动刷时间

博主： wszx01
发布时间：2025 年 06 月 08 日
8 次浏览
暂无评论
188999字数
分类：技术

在nodeloc.cc上的帖子使用,让 **chrome浏览器自动向下滑动刷时间** 
在Tampermonkey使用的代码，功能是开启后，让chrome浏览器自动向下滑动，模仿人在看帖子
找一个回帖长的页面，如 [2200多个回帖页](https://nodeloc.cc/t/topic/32583) ，Tampermonkey自动刷时间开始，期间可以页面最小化后做其它事。

3、NodeLOC控制面板【2025年7月2日更新，添加控制面板】
```
// ==UserScript==
// @name         NodeLOC控制面板
// @namespace    http://tampermonkey.net/
// @version      v 0.3
// @description  自动向下、上滚动页面，模拟人在浏览NodeLOC上的帖子，并增加控制面板
// @author       You
// @match        https://nodeloc.cc/*
// @grant        GM_addStyle
// @grant        GM_getValue
// @grant        GM_setValue
// @grant        GM_registerMenuCommand
// ==/UserScript==

(function () {
    'use strict';

// 配置参数
    const config = {
        scrollInterval: 3000, // 滚动间隔（毫秒）
        scrollAmount: window.innerHeight * 1.8, // 每次滚动距离（像素）
        maxScrolls: 100 // 设置最大滚动次数,1次6个回帖左右，根据回帖多少设置
    };

let scrollCount = 0;
    let scrollDirection = 1; // 滚动方向：1为向下，-1为向上
    let isScrolling = false;

// 创建控制UI
    function createControlUI() {
        // 创建控制面板元素
        const controlPanel = document.createElement('div');
        controlPanel.id = 'autoScrollControl';
        document.body.appendChild(controlPanel);

// 创建UI元素
        controlPanel.innerHTML = `
<div class="control-header">
    <div class="control-title">自动滚动控制</div>
    <button class="close-btn" id="closeControl">×</button>
</div>
<div class="buttons">
    <button class="btn btn-start" id="startBtn">开始滚动</button>
    <button class="btn btn-stop" id="stopBtn">停止滚动</button>
</div>`;

// 添加样式
        GM_addStyle(`
#autoScrollControl {
    position: fixed;
    bottom: 20px;
    right: 20px;
    z-index: 9999;
    background: rgba(30, 30, 50, 0.9);
    border-radius: 10px;
    padding: 15px;
    box-shadow: 0 4px 20px rgba(0, 0, 0, 0.4);
    border: 1px solid #444;
    backdrop-filter: blur(5px);
    min-width: 250px;
    color: #fff;
    font-family: Arial, sans-serif;
    transition: transform 0.3s ease;
}

#autoScrollControl:hover {
    transform: translateY(-5px);
}

#autoScrollControl .control-header {
    display: flex;
    justify-content: space-between;
    align-items: center;
    margin-bottom: 15px;
    padding-bottom: 10px;
    border-bottom: 1px solid #444;
}

#autoScrollControl .control-title {
    font-size: 18px;
    font-weight: bold;
    color: #ff8a00;
}

#autoScrollControl .close-btn {
    background: none;
    border: none;
    color: #aaa;
    font-size: 20px;
    cursor: pointer;
    transition: color 0.3s;
}

#autoScrollControl .close-btn:hover {
    color: #fff;
}

#autoScrollControl .buttons {
    display: flex;
    gap: 10px;
    margin-top: 10px;
}

#autoScrollControl .btn {
    flex: 1;
    padding: 8px 15px;
    border: none;
    border-radius: 6px;
    font-size: 14px;
    font-weight: bold;
    cursor: pointer;
    transition: all 0.3s ease;
}

#autoScrollControl .btn-start {
    background: linear-gradient(to right, #22c1c3, #1a9c9e);
    color: white;
}

#autoScrollControl .btn-stop {
    background: linear-gradient(to right, #e52e71, #c41c5c);
    color: white;
}`);

// 获取UI元素
        const startBtn = controlPanel.querySelector('#startBtn');
        const stopBtn = controlPanel.querySelector('#stopBtn');
        const closeBtn = controlPanel.querySelector('#closeControl');

// 按钮事件
        startBtn.addEventListener('click', startAutoScroll);
        stopBtn.addEventListener('click', stopAutoScroll);

// 关闭按钮
        closeBtn.addEventListener('click', function () {
            controlPanel.style.display = 'none';
        });
    }

// 开始滚动
    function startAutoScroll() {
        if (isScrolling) return;
        isScrolling = true;
        startBtn.disabled = true;
        stopBtn.disabled = false;

setTimeout(startAutoScrollInternal, config.scrollInterval);
    }

function startAutoScrollInternal() {
        if (!isScrolling) return;

if (scrollCount >= config.maxScrolls) {
            console.log('已达到最大滚动次数，将在45秒后反向滚动');
            setTimeout(() => {
                scrollCount = 0; // 重置滚动计数器
                scrollDirection *= -1; // 切换滚动方向
                startAutoScrollInternal(); // 重新开始滚动
            }, 45000); // 45秒后重启
            return;
        }

window.scrollBy({
            top: config.scrollAmount * scrollDirection,
            left: 0,
            behavior: 'smooth'
        });

scrollCount++;
        console.log(`第${scrollCount}次滚动`);

setTimeout(startAutoScrollInternal, config.scrollInterval);
    }

// 停止滚动
    function stopAutoScroll() {
        isScrolling = false;
        startBtn.disabled = false;
        stopBtn.disabled = true;
    }

// 初始化
    window.addEventListener('load', function () {
        createControlUI();
    });
})();

```

2、循环自动滚动NodeLOC【2025年6月9日更新】
```
// ==UserScript==
// @name         循环自动滚动NodeLOC
// @namespace    http://tampermonkey.net/
// @version      0.1
// @description  自动向下滚动页面，模拟人在浏览NodeLOC上的帖子
// @author       You
// @match        https://nodeloc.cc/*
// @grant        none
// ==/UserScript==

(function() {
    'use strict';

// 配置参数
    const config = {
        scrollInterval: 5000, // 滚动间隔（毫秒）
        scrollAmount: window.innerHeight * 0.8, // 每次滚动距离（像素）
        maxScrolls: 60 // 最大滚动次数，10次约为30个回帖，60次约为180个回帖，找一个180个回帖以上的
    };

let scrollCount = 0;
    let scrollDirection = 1; // 滚动方向：1为向下，-1为向上

// 开始自动滚动
    function startAutoScroll() {
        if (scrollCount >= config.maxScrolls) {
            console.log('已达到最大滚动次数，将在45秒后反向滚动');
            setTimeout(() => {
                scrollCount = 0; // 重置滚动计数器
                scrollDirection *= -1; // 切换滚动方向
                startAutoScroll(); // 重新开始滚动
            }, 45000); // 45秒后重启
            return;
        }

window.scrollBy({
            top: config.scrollAmount * scrollDirection,
            left: 0,
            behavior: 'smooth'
        });

scrollCount++;
        console.log(`第${scrollCount}次滚动`);

setTimeout(startAutoScroll, config.scrollInterval);
    }

// 初始化
    setTimeout(startAutoScroll, config.scrollInterval);
})();
```

1、单向自动滚动NodeLOC【2025年6月8日】
```
// ==UserScript==
// @name         自动滚动NodeLOC
// @namespace    http://tampermonkey.net/
// @version      0.1
// @description  自动向下滚动页面，模拟人在浏览NodeLOC上的帖子
// @author       You
// @match        https://nodeloc.cc/*
// @grant        none
// ==/UserScript==

(function() {
    'use strict';

// 配置参数
    const config = {
        scrollInterval: 5000, // 滚动间隔（毫秒）
        scrollAmount: window.innerHeight * 0.8, // 每次滚动距离（像素）
        maxScrolls: 200 // 最大滚动次数
    };

let scrollCount = 0;

// 开始自动滚动
    function startAutoScroll() {
        if (scrollCount >= config.maxScrolls) {
            console.log('已达到最大滚动次数，停止自动滚动');
            return;
        }

window.scrollBy({
            top: config.scrollAmount,
            left: 0,
            behavior: 'smooth'
        });

scrollCount++;
        console.log(`第${scrollCount}次滚动`);

setTimeout(startAutoScroll, config.scrollInterval);
    }

// 初始化
    setTimeout(startAutoScroll, config.scrollInterval);
})();

```

{dotted startColor="#ff6c6c" endColor="#1989fa"/}

坛友做的
1.自动滚动辅助器，还行，有不足
```
// ==UserScript==
// @name         自动滚动辅助器
// @namespace    https://example.com/
// @version      1.6
// @description  自动向下/向上滚动页面，到达底部时自动反向滚动
// @author       DeepSeek-R1
// @match        *://*/*
// @grant        GM_addStyle
// @grant        GM_getValue
// @grant        GM_setValue
// @grant        GM_registerMenuCommand
// ==/UserScript==

(function () {
    'use strict';

// 配置参数
    const defaultSettings = {
        scrollSpeed: 1,         // 每次滚动的像素数
        scrollInterval: 25,     // 滚动间隔(ms)
        threshold: 100,         // 底部/顶部检测阈值(px)
        enableUI: true          // 是否显示控制UI
    };

// 加载用户设置
    let settings = Object.assign({}, defaultSettings);
    if (GM_getValue('autoScrollSettings')) {
        settings = Object.assign(settings, GM_getValue('autoScrollSettings'));
    }

// 状态变量
    let scrollDirection = 1;    // 1=向下, -1=向上
    let scrollIntervalId = null;
    let isScrolling = false;

// 创建UI元素
        controlPanel.innerHTML = `
<div class="control-header">
    <div class="control-title">自动滚动控制</div>
    <button class="close-btn" id="closeControl">×</button>
</div>
<div class="control-group">
    <label class="control-label">滚动速度: px/帧</label>
    <div class="slider-container">
        <input type="range" id="speedSlider" class="slider" min="1" max="10" value="${settings.scrollSpeed}">
        <div class="value-display" id="speedDisplay">${settings.scrollSpeed}</div>
    </div>
</div>
<div class="control-group">
    <label class="control-label">刷新间隔: ms</label>
    <div class="slider-container">
        <input type="range" id="intervalSlider" class="slider" min="5" max="100" value="${settings.scrollInterval}">
        <div class="value-display" id="intervalDisplay">${settings.scrollInterval}</div>
    </div>
</div>
<div class="buttons">
    <button class="btn btn-start" id="startBtn">开始滚动</button>
    <button class="btn btn-stop" id="stopBtn">停止滚动</button>
</div>`;

#autoScrollControl:hover {
    transform: translateY(-5px);
}

#autoScrollControl .control-title {
    font-size: 18px;
    font-weight: bold;
    color: #ff8a00;
}

#autoScrollControl .close-btn {
    background: none;
    border: none;
    color: #aaa;
    font-size: 20px;
    cursor: pointer;
    transition: color 0.3s;
}

#autoScrollControl .close-btn:hover {
    color: #fff;
}

#autoScrollControl .control-group {
    margin-bottom: 15px;
}

#autoScrollControl .control-label {
    display: block;
    margin-bottom: 8px;
    font-size: 14px;
    color: #a0b3ff;
}

#autoScrollControl .slider-container {
    display: flex;
    align-items: center;
    gap: 10px;
}

#autoScrollControl .slider {
    flex: 1;
    height: 6px;
    -webkit-appearance: none;
    background: rgba(255, 255, 255, 0.1);
    outline: none;
    border-radius: 3px;
}

#autoScrollControl .slider::-webkit-slider-thumb {
    -webkit-appearance: none;
    width: 18px;
    height: 18px;
    border-radius: 50%;
    background: #ff8a00;
    cursor: pointer;
    box-shadow: 0 0 5px rgba(255, 138, 0, 0.7);
}

#autoScrollControl .value-display {
    min-width: 40px;
    text-align: center;
    font-size: 14px;
    font-weight: bold;
    color: #ff8a00;
}

#autoScrollControl .buttons {
    display: flex;
    gap: 10px;
    margin-top: 10px;
}

#autoScrollControl .btn-start {
    background: linear-gradient(to right, #22c1c3, #1a9c9e);
    color: white;
}

#autoScrollControl .btn-stop {
    background: linear-gradient(to right, #e52e71, #c41c5c);
    color: white;
}`);

// 获取UI元素
        const speedSlider = controlPanel.querySelector('#speedSlider');
        const speedDisplay = controlPanel.querySelector('#speedDisplay');
        const intervalSlider = controlPanel.querySelector('#intervalSlider');
        const intervalDisplay = controlPanel.querySelector('#intervalDisplay');
        const startBtn = controlPanel.querySelector('#startBtn');
        const stopBtn = controlPanel.querySelector('#stopBtn');
        const closeBtn = controlPanel.querySelector('#closeControl');

// 滑块事件
        speedSlider.addEventListener('input', function () {
            settings.scrollSpeed = parseInt(this.value);
            speedDisplay.textContent = settings.scrollSpeed;
            GM_setValue('autoScrollSettings', settings);

if (isScrolling) {
                stopAutoScroll();
                startAutoScroll();
            }
        });

intervalSlider.addEventListener('input', function () {
            settings.scrollInterval = parseInt(this.value);
            intervalDisplay.textContent = settings.scrollInterval;
            GM_setValue('autoScrollSettings', settings);

if (isScrolling) {
                stopAutoScroll();
                startAutoScroll();
            }
        });

// 按钮事件
        startBtn.addEventListener('click', startAutoScroll);
        stopBtn.addEventListener('click', stopAutoScroll);

// 关闭按钮
        closeBtn.addEventListener('click', function () {
            controlPanel.style.display = 'none';
            settings.enableUI = false;
            GM_setValue('autoScrollSettings', settings);
        });
    }

// 开始滚动
    function startAutoScroll() {
        if (scrollIntervalId) return;
        isScrolling = true;

scrollIntervalId = setInterval(() => {
            // 获取页面当前滚动位置和最大滚动位置
            const currentPos = window.pageYOffset || document.documentElement.scrollTop;
            const maxPos = document.documentElement.scrollHeight - window.innerHeight;

// 检查是否到达底部或顶部
            if (scrollDirection === 1 && currentPos >= maxPos - settings.threshold) {
                scrollDirection = -1; // 到达底部，改为向上滚动
            } else if (scrollDirection === -1 && currentPos <= settings.threshold) {
                scrollDirection = 1; // 到达顶部，改为向下滚动
            }

// 执行滚动
            window.scrollBy({
                top: settings.scrollSpeed * scrollDirection,
                behavior: 'instant'
            });
        }, settings.scrollInterval);
    }

// 停止滚动
    function stopAutoScroll() {
        if (scrollIntervalId) {
            clearInterval(scrollIntervalId);
            scrollIntervalId = null;
            isScrolling = false;
        }
    }

// 注册菜单命令
    GM_registerMenuCommand('开始自动滚动', startAutoScroll);
    GM_registerMenuCommand('停止自动滚动', stopAutoScroll);
    GM_registerMenuCommand('显示控制面板', function () {
        document.getElementById('autoScrollControl').style.display = 'block';
        settings.enableUI = true;
        GM_setValue('autoScrollSettings', settings);
    });

// 初始化
    window.addEventListener('load', function () {
        createControlUI();
        if (!settings.enableUI) {
            document.getElementById('autoScrollControl').style.display = 'none';
        }
    });
})();

```

坛友做的
2.智能助手， **功能多用不上，电脑配置低卡，不推荐** 
```
// ==UserScript==
// @name         智能论坛助手 Pro
// @namespace    http://tampermonkey.net/
// @version      2.6.0
// @description  NodeLoc智能论坛助手 - 自动阅读/点赞/回复，升级进度追踪，弹窗检测，限制监控，数据统计，位置记忆等全方位功能
// @author       Enhanced by AI
// @match        https://meta.discourse.org/*
// @match        https://meta.appinn.net/*
// @match        https://community.openai.com/*
// @match        https://nodeloc.cc/*
// @match        https://bbs.tampermonkey.net.cn/*
// @match        https://greasyfork.org/*
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        GM_deleteValue
// @grant        GM_listValues
// @grant        GM_notification
// @grant        GM_openInTab
// @grant        GM_xmlhttpRequest
// @grant        unsafeWindow
// @license      MIT
// @icon         https://www.google.com/s2/favicons?domain=discourse.org
// @downloadURL  https://update.greasyfork.org/scripts/enhanced-forum-assistant/Enhanced%20Forum%20Assistant.user.js
// @updateURL    https://update.greasyfork.org/scripts/enhanced-forum-assistant/Enhanced%20Forum%20Assistant.meta.js
// ==/UserScript==

(function () {
  "use strict";

// ===== 配置管理类 =====
  class ConfigManager {
    constructor() {
      this.defaultConfig = {
        // 基础配置
        possibleBaseURLs: [
          "https://linux.do",
          "https://meta.discourse.org",
          "https://meta.appinn.net",
          "https://community.openai.com",
          "https://nodeloc.cc",
          "https://bbs.tampermonkey.net.cn",
          "https://greasyfork.org"
        ],

// 行为参数
        commentLimit: 1000,
        topicListLimit: 100,
        likeLimit: 55,
        stuckTimeout: 15000,
        minScrollDelta: 50,
        maxIdleTime: 60000,
        maxLogEntries: 200,
        minTopicChangeDelay: 3000,
        maxTopicChangeDelay: 8000,
        minReadTimeLower: 45000,
        minReadTimeUpper: 120000,
        fetchRetryDelay: 30000,

// 滚动参数
        scrollSegmentDistanceMin: 300,
        scrollSegmentDistanceMax: 1000,
        scrollSegmentDurationMin: 2000,
        scrollSegmentDurationMax: 6000,
        randomPauseProbability: 0.2,
        randomPauseDurationMin: 100,
        randomPauseDurationMax: 800,

// 贝塞尔曲线参数
        bezierP1Min: 0.1,
        bezierP1Max: 0.4,
        bezierP2Min: 0.6,
        bezierP2Max: 0.9,

// 新增功能配置
        enableMouseSimulation: true,
        enableAdvancedBehavior: true,
        enableDataAnalysis: true,
        enableSafetyFeatures: true,
        autoReplyEnabled: false,
        keywordMonitoring: false,
        proxyEnabled: false,

// UI配置
        theme: 'dark',
        language: 'zh-CN',
        showStatistics: true,
        compactMode: false
      };

this.config = this.loadConfig();
    }

loadConfig() {
      try {
        const saved = GM_getValue('forumAssistantConfig', '{}');
        return { ...this.defaultConfig, ...JSON.parse(saved) };
      } catch (e) {
        console.warn('配置加载失败，使用默认配置:', e);
        return { ...this.defaultConfig };
      }
    }

saveConfig() {
      try {
        GM_setValue('forumAssistantConfig', JSON.stringify(this.config));
        return true;
      } catch (e) {
        console.error('配置保存失败:', e);
        return false;
      }
    }

get(key) {
      return this.config[key];
    }

set(key, value) {
      this.config[key] = value;
      this.saveConfig();
    }

reset() {
      this.config = { ...this.defaultConfig };
      this.saveConfig();
    }

exportConfig() {
      return JSON.stringify(this.config, null, 2);
    }

importConfig(configStr) {
      try {
        const imported = JSON.parse(configStr);
        this.config = { ...this.defaultConfig, ...imported };
        this.saveConfig();
        return true;
      } catch (e) {
        console.error('配置导入失败:', e);
        return false;
      }
    }
  }

// ===== 工具类 =====
  class Utils {
    static getRandomInt(min, max) {
      return Math.floor(Math.random() * (max - min + 1)) + min;
    }

static getRandomFloat(min, max) {
      return Math.random() * (max - min) + min;
    }

static sleep(ms) {
      return new Promise(resolve => setTimeout(resolve, ms));
    }

// 安全的DOM元素创建
    static safeCreateElement(tagName, options = {}) {
      try {
        const element = document.createElement(tagName);
        if (!element) {
          console.error(`无法创建 ${tagName} 元素`);
          return null;
        }

// 设置属性
        if (options.id) element.id = options.id;
        if (options.className) element.className = options.className;
        if (options.textContent) element.textContent = options.textContent;
        if (options.innerHTML) element.innerHTML = options.innerHTML;

// 设置样式
        if (options.style && typeof options.style === 'object') {
          Object.assign(element.style, options.style);
        }

return element;
      } catch (e) {
        console.error(`创建 ${tagName} 元素失败:`, e);
        return null;
      }
    }

// 安全的DOM元素查找
    static safeQuerySelector(selector, parent = document) {
      try {
        if (!parent || typeof parent.querySelector !== 'function') {
          console.warn('无效的父元素');
          return null;
        }
        return parent.querySelector(selector);
      } catch (e) {
        console.error(`查找元素失败 (${selector}):`, e);
        return null;
      }
    }

// 安全的DOM元素添加
    static safeAppendChild(parent, child) {
      try {
        if (!parent || !child) {
          console.warn('父元素或子元素为空');
          return false;
        }
        if (typeof parent.appendChild !== 'function') {
          console.warn('父元素不支持appendChild');
          return false;
        }
        parent.appendChild(child);
        return true;
      } catch (e) {
        console.error('添加子元素失败:', e);
        return false;
      }
    }

// 安全的样式设置
    static safeSetStyle(element, property, value) {
      try {
        if (!element || !element.style) {
          console.warn('元素或样式对象不存在');
          return false;
        }
        element.style[property] = value;
        return true;
      } catch (e) {
        console.error(`设置样式失败 (${property}):`, e);
        return false;
      }
    }

// 安全的内容设置
    static safeSetContent(element, content, useInnerHTML = false) {
      try {
        if (!element) {
          console.warn('元素不存在');
          return false;
        }
        if (useInnerHTML) {
          element.innerHTML = content;
        } else {
          element.textContent = content;
        }
        return true;
      } catch (e) {
        console.error('设置内容失败:', e);
        return false;
      }
    }

static formatTime(ms) {
      const seconds = Math.floor(ms / 1000);
      const minutes = Math.floor(seconds / 60);
      const hours = Math.floor(minutes / 60);

if (hours > 0) {
        return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
      } else if (minutes > 0) {
        return `${minutes}m ${seconds % 60}s`;
      } else {
        return `${seconds}s`;
      }
    }

static formatNumber(num) {
      if (num >= 1000000) {
        return (num / 1000000).toFixed(1) + 'M';
      } else if (num >= 1000) {
        return (num / 1000).toFixed(1) + 'K';
      }
      return num.toString();
    }

static debounce(func, wait) {
      let timeout;
      return function executedFunction(...args) {
        const later = () => {
          clearTimeout(timeout);
          func(...args);
        };
        clearTimeout(timeout);
        timeout = setTimeout(later, wait);
      };
    }

static throttle(func, limit) {
      let inThrottle;
      return function() {
        const args = arguments;
        const context = this;
        if (!inThrottle) {
          func.apply(context, args);
          inThrottle = true;
          setTimeout(() => inThrottle = false, limit);
        }
      };
    }

static generateUUID() {
      return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
        const r = Math.random() * 16 | 0;
        const v = c == 'x' ? r : (r & 0x3 | 0x8);
        return v.toString(16);
      });
    }

static detectForumType(url) {
      if (url.includes('discourse')) return 'discourse';
      if (url.includes('linux.do')) return 'discourse';
      if (url.includes('nodeloc.cc')) return 'discourse';
      if (url.includes('greasyfork.org')) return 'greasyfork';
      return 'unknown';
    }

static cubicBezier(t, p0, p1, p2, p3) {
      const u = 1 - t;
      const tt = t * t;
      const uu = u * u;
      const uuu = uu * u;
      const ttt = tt * t;
      return uuu * p0 + 3 * uu * t * p1 + 3 * u * tt * p2 + ttt * p3;
    }
  }

// ===== 日志管理类 =====
  class LogManager {
    constructor(config) {
      this.config = config;
      this.entries = [];
      this.logWindow = null;
      this.logContent = null;
      // 从存储中恢复统计数据，如果不存在则使用默认值
      const savedStats = GM_getValue('statistics', null);
      if (savedStats) {
        this.statistics = {
          totalActions: savedStats.totalActions || 0,
          totalReadTime: savedStats.totalReadTime || 0,
          topicsRead: savedStats.topicsRead || 0,
          likesGiven: savedStats.likesGiven || 0,
          errorsCount: savedStats.errorsCount || 0,
          startTime: savedStats.startTime || Date.now()
        };
      } else {
        this.statistics = {
          totalActions: 0,
          totalReadTime: 0,
          topicsRead: 0,
          likesGiven: 0,
          errorsCount: 0,
          startTime: Date.now()
        };
      }
    }

createLogWindow() {
      if (this.logWindow) return;

const isDark = this.config.get('theme') === 'dark';
      const isCompact = this.config.get('compactMode');

this.logWindow = Utils.safeCreateElement("div", {
        id: "forum-assistant-log",
        style: {
          position: "fixed",
          top: "10px",
          right: "10px",
          width: isCompact ? "280px" : "350px",
          maxHeight: isCompact ? "300px" : "500px",
          backgroundColor: isDark ? "#2d3748" : "#fff",
          color: isDark ? "#e2e8f0" : "#2d3748",
          border: `1px solid ${isDark ? "#4a5568" : "#e2e8f0"}`,
          borderRadius: "8px",
          boxShadow: "0 4px 12px rgba(0,0,0,0.15)",
          zIndex: "10000",
          display: "flex",
          flexDirection: "column",
          fontFamily: "'Consolas', 'Monaco', monospace",
          fontSize: isCompact ? "11px" : "12px",
          backdropFilter: "blur(10px)",
          resize: "both",
          overflow: "hidden"
        }
      });

if (!this.logWindow) {
        console.error('无法创建日志窗口');
        return;
      }

this.createLogHeader(isDark);
      this.createLogContent(isDark);
      this.createLogControls(isDark);

if (!Utils.safeAppendChild(document.body, this.logWindow)) {
        console.error('无法添加日志窗口到页面');
        return;
      }

this.makeResizable();
    }

createLogHeader(isDark) {
      const header = document.createElement("div");
      Object.assign(header.style, {
        backgroundColor: isDark ? "#4a5568" : "#f7fafc",
        padding: "8px 12px",
        borderBottom: `1px solid ${isDark ? "#718096" : "#e2e8f0"}`,
        fontWeight: "bold",
        display: "flex",
        justifyContent: "space-between",
        alignItems: "center",
        cursor: "move"
      });

const title = document.createElement("span");
      title.textContent = "智能论坛助手 Pro";

const controls = document.createElement("div");
      controls.style.display = "flex";
      controls.style.gap = "5px";

// 最小化按钮
      const minimizeBtn = this.createControlButton("−", () => this.toggleMinimize());
      // 关闭按钮
      const closeBtn = this.createControlButton("×", () => this.toggleVisibility());

controls.appendChild(minimizeBtn);
      controls.appendChild(closeBtn);
      header.appendChild(title);
      header.appendChild(controls);
      this.logWindow.appendChild(header);

// 使窗口可拖拽
      this.makeDraggable(header);
    }

createLogContent(isDark) {
      this.logContent = Utils.safeCreateElement("pre", {
        style: {
          margin: "0",
          padding: "10px",
          overflowY: "auto",
          flex: "1",
          fontSize: "inherit",
          lineHeight: "1.4",
          whiteSpace: "pre-wrap",
          wordBreak: "break-word"
        }
      });

if (this.logContent && this.logWindow) {
        Utils.safeAppendChild(this.logWindow, this.logContent);
      }
    }

createLogControls(isDark) {
      const controls = document.createElement("div");
      Object.assign(controls.style, {
        padding: "8px",
        borderTop: `1px solid ${isDark ? "#718096" : "#e2e8f0"}`,
        display: "flex",
        gap: "5px",
        flexWrap: "wrap"
      });

const clearBtn = this.createActionButton("清空", () => this.clear());
      const exportBtn = this.createActionButton("导出", () => this.exportLogs());
      const statsBtn = this.createActionButton("统计", () => this.showStatistics());

controls.appendChild(clearBtn);
      controls.appendChild(exportBtn);
      controls.appendChild(statsBtn);
      this.logWindow.appendChild(controls);
    }

createControlButton(text, onClick) {
      const btn = document.createElement("button");
      btn.textContent = text;
      Object.assign(btn.style, {
        background: "none",
        border: "none",
        color: "inherit",
        cursor: "pointer",
        padding: "2px 6px",
        borderRadius: "3px",
        fontSize: "14px",
        fontWeight: "bold"
      });
      btn.addEventListener("click", onClick);
      btn.addEventListener("mouseenter", () => {
        btn.style.backgroundColor = "rgba(255,255,255,0.1)";
      });
      btn.addEventListener("mouseleave", () => {
        btn.style.backgroundColor = "transparent";
      });
      return btn;
    }

createActionButton(text, onClick) {
      const btn = document.createElement("button");
      btn.textContent = text;
      Object.assign(btn.style, {
        padding: "4px 8px",
        border: "1px solid currentColor",
        backgroundColor: "transparent",
        color: "inherit",
        cursor: "pointer",
        borderRadius: "4px",
        fontSize: "11px"
      });
      btn.addEventListener("click", onClick);
      return btn;
    }

makeDraggable(header) {
      if (!header || !this.logWindow) return;

let isDragging = false;
      let currentX, currentY, initialX, initialY;

header.addEventListener("mousedown", (e) => {
        if (!this.logWindow) return;
        isDragging = true;
        initialX = e.clientX - this.logWindow.offsetLeft;
        initialY = e.clientY - this.logWindow.offsetTop;
      });

document.addEventListener("mousemove", (e) => {
        if (isDragging && this.logWindow) {
          e.preventDefault();
          currentX = e.clientX - initialX;
          currentY = e.clientY - initialY;
          this.logWindow.style.left = currentX + "px";
          this.logWindow.style.top = currentY + "px";
          this.logWindow.style.right = "auto";
        }
      });

document.addEventListener("mouseup", () => {
        isDragging = false;
      });
    }

makeResizable() {
      if (!this.logWindow) return;

// 简单的调整大小功能
      const resizer = document.createElement("div");
      Object.assign(resizer.style, {
        position: "absolute",
        bottom: "0",
        right: "0",
        width: "10px",
        height: "10px",
        cursor: "se-resize",
        backgroundColor: "rgba(128,128,128,0.3)"
      });
      this.logWindow.appendChild(resizer);

let isResizing = false;
      resizer.addEventListener("mousedown", (e) => {
        isResizing = true;
        e.preventDefault();
      });

document.addEventListener("mousemove", (e) => {
        if (isResizing && this.logWindow) {
          const rect = this.logWindow.getBoundingClientRect();
          const newWidth = e.clientX - rect.left;
          const newHeight = e.clientY - rect.top;

if (newWidth > 200) this.logWindow.style.width = newWidth + "px";
          if (newHeight > 150) this.logWindow.style.height = newHeight + "px";
        }
      });

document.addEventListener("mouseup", () => {
        isResizing = false;
      });
    }

log(message, type = 'info') {
      const timestamp = new Date().toLocaleTimeString();
      const entry = {
        timestamp,
        message,
        type,
        id: Utils.generateUUID()
      };

this.entries.push(entry);
      this.statistics.totalActions++;

if (type === 'error') this.statistics.errorsCount++;

// 限制日志条目数量
      const maxEntries = this.config.get('maxLogEntries');
      if (this.entries.length > maxEntries) {
        this.entries = this.entries.slice(-maxEntries);
      }

this.updateLogDisplay();

// 控制台输出
      const consoleMethod = type === 'error' ? 'error' : type === 'warn' ? 'warn' : 'log';
      console[consoleMethod](`[论坛助手] [${timestamp}] ${message}`);

// 重要消息通知
      if (type === 'error' || (type === 'info' && message.includes('完成'))) {
        this.showNotification(message, type);
      }
    }

updateLogDisplay() {
      if (!this.logContent) {
        console.warn('日志内容元素不存在');
        return;
      }

try {
        const displayEntries = this.entries.map(entry => {
          const typeIcon = this.getTypeIcon(entry.type);
          return `${typeIcon} [${entry.timestamp}] ${entry.message}`;
        });

this.logContent.textContent = displayEntries.join('\n');
        this.logContent.scrollTop = this.logContent.scrollHeight;
      } catch (e) {
        console.error('更新日志显示失败:', e);
      }
    }

getTypeIcon(type) {
      const icons = {
        info: '📘',
        warn: '⚠️',
        error: '❌',
        success: '✅',
        action: '🔄'
      };
      return icons[type] || '📘';
    }

showNotification(message, type) {
      if (typeof GM_notification !== 'undefined') {
        GM_notification({
          text: message,
          title: '智能论坛助手',
          timeout: 3000,
          onclick: () => {
            window.focus();
            this.logWindow?.scrollIntoView();
          }
        });
      }
    }

clear() {
      this.entries = [];
      this.updateLogDisplay();
      this.log('日志已清空', 'action');
    }

exportLogs() {
      const exportData = {
        timestamp: new Date().toISOString(),
        statistics: this.statistics,
        logs: this.entries,
        config: this.config.config
      };

const blob = new Blob([JSON.stringify(exportData, null, 2)], {
        type: 'application/json'
      });

const url = URL.createObjectURL(blob);
      const a = document.createElement('a');
      a.href = url;
      a.download = `forum-assistant-logs-${new Date().toISOString().split('T')[0]}.json`;
      document.body.appendChild(a);
      a.click();
      document.body.removeChild(a);
      URL.revokeObjectURL(url);

this.log('日志已导出', 'success');
    }

showStatistics() {
      const runtime = Date.now() - this.statistics.startTime;
      const stats = `
📊 运行统计
━━━━━━━━━━━━━━━━━━━━
⏱️ 运行时间: ${Utils.formatTime(runtime)}
📖 已读话题: ${this.statistics.topicsRead}
👍 点赞数量: ${this.statistics.likesGiven}
🔄 总操作数: ${this.statistics.totalActions}
❌ 错误次数: ${this.statistics.errorsCount}
📈 效率: ${(this.statistics.topicsRead / (runtime / 3600000)).toFixed(2)} 话题/小时
━━━━━━━━━━━━━━━━━━━━`;

alert(stats);
    }

toggleMinimize() {
      if (!this.logWindow) return;

const content = this.logWindow.querySelector('pre');
      const controls = this.logWindow.querySelector('div:last-child');

if (!content || !controls) return;

if (content.style.display === 'none') {
        content.style.display = 'block';
        controls.style.display = 'flex';
        this.logWindow.style.height = 'auto';
      } else {
        content.style.display = 'none';
        controls.style.display = 'none';
        this.logWindow.style.height = 'auto';
      }
    }

toggleVisibility() {
      if (!this.logWindow) return;
      this.logWindow.style.display = this.logWindow.style.display === 'none' ? 'flex' : 'none';
    }

updateStatistics(key, value = 1) {
      if (this.statistics.hasOwnProperty(key)) {
        this.statistics[key] += value;
        // 保存统计数据到存储
        GM_setValue('statistics', this.statistics);
      }
    }

// 重置统计数据
    resetStatistics() {
      this.statistics = {
        totalActions: 0,
        totalReadTime: 0,
        topicsRead: 0,
        likesGiven: 0,
        errorsCount: 0,
        startTime: Date.now()
      };
      GM_setValue('statistics', this.statistics);
      this.log('统计数据已重置', 'info');
    }
  }

// ===== 配置面板类 =====
  class ConfigPanel {
    constructor(config, logger) {
      this.config = config;
      this.logger = logger;
      this.panel = null;
      this.isVisible = false;
    }

create() {
      if (this.panel) return;

const isDark = this.config.get('theme') === 'dark';

this.panel = document.createElement('div');
      this.panel.id = 'forum-assistant-config';
      Object.assign(this.panel.style, {
        position: 'fixed',
        top: '50%',
        left: '50%',
        transform: 'translate(-50%, -50%)',
        width: '600px',
        maxHeight: '80vh',
        backgroundColor: isDark ? '#2d3748' : '#ffffff',
        color: isDark ? '#e2e8f0' : '#2d3748',
        border: `1px solid ${isDark ? '#4a5568' : '#e2e8f0'}`,
        borderRadius: '12px',
        boxShadow: '0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04)',
        zIndex: '10001',
        display: 'none',
        flexDirection: 'column',
        fontFamily: "'Segoe UI', Tahoma, Geneva, Verdana, sans-serif",
        backdropFilter: 'blur(10px)'
      });

this.createHeader();
      this.createContent();
      this.createFooter();

document.body.appendChild(this.panel);
      this.createOverlay();
    }

createHeader() {
      const header = document.createElement('div');
      Object.assign(header.style, {
        padding: '20px',
        borderBottom: `1px solid ${this.config.get('theme') === 'dark' ? '#4a5568' : '#e2e8f0'}`,
        display: 'flex',
        justifyContent: 'space-between',
        alignItems: 'center'
      });

const title = document.createElement('h2');
      title.textContent = '🛠️ 高级配置';
      title.style.margin = '0';
      title.style.fontSize = '20px';
      title.style.fontWeight = '600';

const closeBtn = document.createElement('button');
      closeBtn.innerHTML = '✕';
      Object.assign(closeBtn.style, {
        background: 'none',
        border: 'none',
        fontSize: '18px',
        cursor: 'pointer',
        color: 'inherit',
        padding: '5px',
        borderRadius: '4px'
      });
      closeBtn.addEventListener('click', () => this.hide());

header.appendChild(title);
      header.appendChild(closeBtn);
      this.panel.appendChild(header);
    }

createContent() {
      const content = document.createElement('div');
      Object.assign(content.style, {
        padding: '20px',
        overflowY: 'auto',
        flex: '1'
      });

// 创建标签页
      const tabs = this.createTabs();
      content.appendChild(tabs);

// 创建配置区域
      const configArea = document.createElement('div');
      configArea.id = 'config-area';
      content.appendChild(configArea);

this.panel.appendChild(content);

// 默认显示基础配置
      this.showBasicConfig();
    }

createTabs() {
      const tabContainer = document.createElement('div');
      Object.assign(tabContainer.style, {
        display: 'flex',
        marginBottom: '20px',
        borderBottom: `1px solid ${this.config.get('theme') === 'dark' ? '#4a5568' : '#e2e8f0'}`
      });

const tabs = [
        { id: 'basic', name: '基础设置', icon: '⚙️' },
        { id: 'behavior', name: '行为配置', icon: '🤖' },
        { id: 'advanced', name: '高级功能', icon: '🚀' },
        { id: 'ui', name: '界面设置', icon: '🎨' },
        { id: 'data', name: '数据管理', icon: '📊' }
      ];

tabs.forEach(tab => {
        const tabBtn = document.createElement('button');
        tabBtn.innerHTML = `${tab.icon} ${tab.name}`;
        Object.assign(tabBtn.style, {
          padding: '10px 15px',
          border: 'none',
          background: 'none',
          color: 'inherit',
          cursor: 'pointer',
          borderBottom: '2px solid transparent',
          fontSize: '14px',
          fontWeight: '500'
        });

tabBtn.addEventListener('click', () => {
          // 移除所有活动状态
          tabContainer.querySelectorAll('button').forEach(btn => {
            btn.style.borderBottomColor = 'transparent';
            btn.style.opacity = '0.7';
          });

// 设置当前活动状态
          tabBtn.style.borderBottomColor = '#3182ce';
          tabBtn.style.opacity = '1';

// 显示对应配置
          this.showConfigSection(tab.id);
        });

tabContainer.appendChild(tabBtn);
      });

// 默认激活第一个标签
      tabContainer.firstChild.click();

return tabContainer;
    }

showConfigSection(sectionId) {
      const configArea = document.getElementById('config-area');
      if (!configArea) {
        console.error('配置区域元素未找到');
        return;
      }

configArea.innerHTML = '';

switch (sectionId) {
        case 'basic':
          this.showBasicConfig();
          break;
        case 'behavior':
          this.showBehaviorConfig();
          break;
        case 'advanced':
          this.showAdvancedConfig();
          break;
        case 'ui':
          this.showUIConfig();
          break;
        case 'data':
          this.showDataConfig();
          break;
      }
    }

showBasicConfig() {
      const configArea = document.getElementById('config-area');
      if (!configArea) {
        console.error('配置区域元素未找到 (showBasicConfig)');
        return;
      }

const basicConfigs = [
        { key: 'commentLimit', label: '评论数限制', type: 'number', min: 100, max: 5000, step: 100, desc: '跳过评论数超过此值的帖子' },
        { key: 'topicListLimit', label: '话题缓存数量', type: 'number', min: 50, max: 500, step: 50, desc: '一次获取并缓存的话题数量' },
        { key: 'likeLimit', label: '每日点赞限制', type: 'number', min: 10, max: 200, step: 5, desc: '每日自动点赞的最大次数' },
        { key: 'minReadTimeLower', label: '最小阅读时间(秒)', type: 'number', min: 30, max: 300, step: 5, desc: '每个帖子的最小阅读时间', transform: v => v / 1000, reverseTransform: v => v * 1000 },
        { key: 'minReadTimeUpper', label: '最大阅读时间(秒)', type: 'number', min: 60, max: 600, step: 10, desc: '每个帖子的最大阅读时间', transform: v => v / 1000, reverseTransform: v => v * 1000 },
        { key: 'stuckTimeout', label: '卡住检测超时(秒)', type: 'number', min: 5, max: 60, step: 5, desc: '检测页面卡住的超时时间', transform: v => v / 1000, reverseTransform: v => v * 1000 }
      ];

basicConfigs.forEach(config => {
        const group = this.createConfigGroup(config);
        if (group && configArea) {
          configArea.appendChild(group);
        }
      });
    }

showBehaviorConfig() {
      const configArea = document.getElementById('config-area');
      if (!configArea) {
        console.error('配置区域元素未找到 (showBehaviorConfig)');
        return;
      }

const behaviorConfigs = [
        { key: 'scrollSegmentDistanceMin', label: '滚动最小距离(px)', type: 'number', min: 100, max: 1000, step: 50, desc: '每段滚动的最小距离' },
        { key: 'scrollSegmentDistanceMax', label: '滚动最大距离(px)', type: 'number', min: 500, max: 2000, step: 100, desc: '每段滚动的最大距离' },
        { key: 'scrollSegmentDurationMin', label: '滚动最小时长(ms)', type: 'number', min: 1000, max: 5000, step: 250, desc: '每段滚动的最小持续时间' },
        { key: 'scrollSegmentDurationMax', label: '滚动最大时长(ms)', type: 'number', min: 3000, max: 10000, step: 500, desc: '每段滚动的最大持续时间' },
        { key: 'randomPauseProbability', label: '随机暂停概率', type: 'range', min: 0, max: 1, step: 0.05, desc: '滚动过程中随机暂停的概率' },
        { key: 'minTopicChangeDelay', label: '话题切换最小延迟(ms)', type: 'number', min: 1000, max: 10000, step: 500, desc: '切换话题的最小延迟时间' },
        { key: 'maxTopicChangeDelay', label: '话题切换最大延迟(ms)', type: 'number', min: 3000, max: 20000, step: 1000, desc: '切换话题的最大延迟时间' }
      ];

behaviorConfigs.forEach(config => {
        const group = this.createConfigGroup(config);
        if (group && configArea) {
          configArea.appendChild(group);
        }
      });
    }

showAdvancedConfig() {
      const configArea = document.getElementById('config-area');
      if (!configArea) {
        console.error('配置区域元素未找到 (showAdvancedConfig)');
        return;
      }

const advancedConfigs = [
        { key: 'enableMouseSimulation', label: '启用鼠标模拟', type: 'checkbox', desc: '模拟真实的鼠标移动轨迹' },
        { key: 'enableAdvancedBehavior', label: '启用高级行为', type: 'checkbox', desc: '包括随机停留、页面交互等' },
        { key: 'enableDataAnalysis', label: '启用数据分析', type: 'checkbox', desc: '收集和分析使用统计数据' },
        { key: 'enableSafetyFeatures', label: '启用安全功能', type: 'checkbox', desc: '包括请求头随机化、行为混淆等' },
        { key: 'autoReplyEnabled', label: '启用自动回复', type: 'checkbox', desc: '自动回复特定类型的帖子' },
        { key: 'keywordMonitoring', label: '关键词监控', type: 'checkbox', desc: '监控特定关键词并执行操作' },
        { key: 'proxyEnabled', label: '启用代理', type: 'checkbox', desc: '通过代理服务器发送请求' }
      ];

advancedConfigs.forEach(config => {
        const group = this.createConfigGroup(config);
        if (group && configArea) {
          configArea.appendChild(group);
        }
      });

// 添加关键词设置区域
      if (this.config.get('keywordMonitoring')) {
        const keywordSection = this.createKeywordSection();
        if (keywordSection && configArea) {
          configArea.appendChild(keywordSection);
        }
      }
    }

showUIConfig() {
      const configArea = document.getElementById('config-area');
      if (!configArea) {
        console.error('配置区域元素未找到 (showUIConfig)');
        return;
      }

const uiConfigs = [
        { key: 'theme', label: '主题', type: 'select', options: [
          { value: 'light', label: '浅色主题' },
          { value: 'dark', label: '深色主题' },
          { value: 'auto', label: '跟随系统' }
        ], desc: '选择界面主题' },
        { key: 'language', label: '语言', type: 'select', options: [
          { value: 'zh-CN', label: '简体中文' },
          { value: 'zh-TW', label: '繁体中文' },
          { value: 'en-US', label: 'English' }
        ], desc: '选择界面语言' },
        { key: 'showStatistics', label: '显示统计信息', type: 'checkbox', desc: '在界面中显示运行统计' },
        { key: 'compactMode', label: '紧凑模式', type: 'checkbox', desc: '使用更紧凑的界面布局' },
        { key: 'maxLogEntries', label: '最大日志条目', type: 'number', min: 50, max: 1000, step: 50, desc: '日志窗口保留的最大条目数' }
      ];

uiConfigs.forEach(config => {
        const group = this.createConfigGroup(config);
        if (group && configArea) {
          configArea.appendChild(group);
        }
      });
    }

showDataConfig() {
      const configArea = document.getElementById('config-area');
      if (!configArea) {
        console.error('配置区域元素未找到 (showDataConfig)');
        return;
      }

// 数据管理区域
      const dataSection = document.createElement('div');
      if (!dataSection) {
        console.error('无法创建数据管理区域');
        return;
      }

dataSection.innerHTML = `
        <h3 style="margin-top: 0; color: inherit;">📊 数据管理</h3>
        <div style="display: grid; gap: 15px;">
          <div style="padding: 15px; border: 1px solid currentColor; border-radius: 8px; opacity: 0.8;">
            <h4 style="margin: 0 0 10px 0;">配置管理</h4>
            <div style="display: flex; gap: 10px; flex-wrap: wrap;">
              <button id="export-config" style="padding: 8px 16px; border: 1px solid currentColor; background: transparent; color: inherit; border-radius: 4px; cursor: pointer;">导出配置</button>
              <button id="import-config" style="padding: 8px 16px; border: 1px solid currentColor; background: transparent; color: inherit; border-radius: 4px; cursor: pointer;">导入配置</button>
              <button id="reset-config" style="padding: 8px 16px; border: 1px solid #dc3545; background: transparent; color: #dc3545; border-radius: 4px; cursor: pointer;">重置配置</button>
            </div>
          </div>
          <div style="padding: 15px; border: 1px solid currentColor; border-radius: 8px; opacity: 0.8;">
            <h4 style="margin: 0 0 10px 0;">数据清理</h4>
            <div style="display: flex; gap: 10px; flex-wrap: wrap;">
              <button id="clear-logs" style="padding: 8px 16px; border: 1px solid currentColor; background: transparent; color: inherit; border-radius: 4px; cursor: pointer;">清空日志</button>
              <button id="clear-cache" style="padding: 8px 16px; border: 1px solid currentColor; background: transparent; color: inherit; border-radius: 4px; cursor: pointer;">清空缓存</button>
              <button id="clear-all" style="padding: 8px 16px; border: 1px solid #dc3545; background: transparent; color: #dc3545; border-radius: 4px; cursor: pointer;">清空所有数据</button>
            </div>
          </div>
        </div>
      `;

try {
        configArea.appendChild(dataSection);
        // 绑定事件
        this.bindDataManagementEvents();
      } catch (e) {
        console.error('添加数据管理区域失败:', e);
      }
    }

createConfigGroup(config) {
      const group = document.createElement('div');
      Object.assign(group.style, {
        marginBottom: '20px',
        padding: '15px',
        border: `1px solid ${this.config.get('theme') === 'dark' ? '#4a5568' : '#e2e8f0'}`,
        borderRadius: '8px',
        backgroundColor: this.config.get('theme') === 'dark' ? '#374151' : '#f8fafc'
      });

let input;
      const currentValue = config.transform ? config.transform(this.config.get(config.key)) : this.config.get(config.key);

switch (config.type) {
        case 'number':
          input = document.createElement('input');
          input.type = 'number';
          input.min = config.min;
          input.max = config.max;
          input.step = config.step;
          input.value = currentValue;
          break;

case 'range':
          const container = document.createElement('div');
          container.style.display = 'flex';
          container.style.alignItems = 'center';
          container.style.gap = '10px';

input = document.createElement('input');
          input.type = 'range';
          input.min = config.min;
          input.max = config.max;
          input.step = config.step;
          input.value = currentValue;

const valueDisplay = document.createElement('span');
          valueDisplay.textContent = currentValue;
          valueDisplay.style.minWidth = '50px';
          valueDisplay.style.textAlign = 'center';
          valueDisplay.style.fontSize = '14px';

input.addEventListener('input', () => {
            valueDisplay.textContent = input.value;
          });

container.appendChild(input);
          container.appendChild(valueDisplay);
          group.appendChild(label);
          group.appendChild(container);

input.addEventListener('change', () => {
            this.config.set(config.key, parseFloat(input.value));
            this.logger.log(`配置已更新: ${config.label} = ${input.value}`, 'action');
          });

return group;

case 'checkbox':
          input = document.createElement('input');
          input.type = 'checkbox';
          input.checked = currentValue;
          input.style.marginRight = '8px';

const checkboxLabel = document.createElement('label');
          checkboxLabel.style.display = 'flex';
          checkboxLabel.style.alignItems = 'center';
          checkboxLabel.style.cursor = 'pointer';
          checkboxLabel.appendChild(input);
          checkboxLabel.appendChild(document.createTextNode(config.label));

if (config.desc) {
            const desc = document.createElement('div');
            desc.style.fontSize = '12px';
            desc.style.opacity = '0.7';
            desc.style.marginTop = '4px';
            desc.textContent = config.desc;
            group.appendChild(checkboxLabel);
            group.appendChild(desc);
          } else {
            group.appendChild(checkboxLabel);
          }

input.addEventListener('change', () => {
            this.config.set(config.key, input.checked);
            this.logger.log(`配置已更新: ${config.label} = ${input.checked}`, 'action');

// 特殊处理某些配置变更
            if (config.key === 'theme') {
              this.applyTheme();
            }
          });

return group;

case 'select':
          input = document.createElement('select');
          config.options.forEach(option => {
            const optionElement = document.createElement('option');
            optionElement.value = option.value;
            optionElement.textContent = option.label;
            optionElement.selected = option.value === currentValue;
            input.appendChild(optionElement);
          });
          break;

default:
          input = document.createElement('input');
          input.type = 'text';
          input.value = currentValue;
      }

// 通用样式
      if (input && config.type !== 'checkbox') {
        Object.assign(input.style, {
          width: '100%',
          padding: '8px 12px',
          border: `1px solid ${this.config.get('theme') === 'dark' ? '#4a5568' : '#d1d5db'}`,
          borderRadius: '6px',
          backgroundColor: this.config.get('theme') === 'dark' ? '#1f2937' : '#ffffff',
          color: 'inherit',
          fontSize: '14px'
        });

// 通用事件处理
        input.addEventListener('change', () => {
          let value = input.value;
          if (config.type === 'number') {
            value = parseFloat(value);
            if (config.reverseTransform) {
              value = config.reverseTransform(value);
            }
          }
          this.config.set(config.key, value);
          this.logger.log(`配置已更新: ${config.label} = ${input.value}`, 'action');

// 特殊处理
          if (config.key === 'theme') {
            this.applyTheme();
          }
        });
      }

if (config.type !== 'checkbox') {
        group.appendChild(label);
        group.appendChild(input);
      }

return group;
    }

bindDataManagementEvents() {
      // 导出配置
      document.getElementById('export-config')?.addEventListener('click', () => {
        const configStr = this.config.exportConfig();
        const blob = new Blob([configStr], { type: 'application/json' });
        const url = URL.createObjectURL(blob);
        const a = document.createElement('a');
        a.href = url;
        a.download = `forum-assistant-config-${new Date().toISOString().split('T')[0]}.json`;
        document.body.appendChild(a);
        a.click();
        document.body.removeChild(a);
        URL.revokeObjectURL(url);
        this.logger.log('配置已导出', 'success');
      });

// 导入配置
      document.getElementById('import-config')?.addEventListener('click', () => {
        const input = document.createElement('input');
        input.type = 'file';
        input.accept = '.json';
        input.addEventListener('change', (e) => {
          const file = e.target.files[0];
          if (file) {
            const reader = new FileReader();
            reader.onload = (e) => {
              try {
                const success = this.config.importConfig(e.target.result);
                if (success) {
                  this.logger.log('配置导入成功', 'success');
                  this.hide();
                  setTimeout(() => location.reload(), 1000);
                } else {
                  this.logger.log('配置导入失败', 'error');
                }
              } catch (error) {
                this.logger.log(`配置导入错误: ${error.message}`, 'error');
              }
            };
            reader.readAsText(file);
          }
        });
        input.click();
      });

// 重置配置
      document.getElementById('reset-config')?.addEventListener('click', () => {
        if (confirm('确定要重置所有配置吗？此操作不可撤销。')) {
          this.config.reset();
          this.logger.log('配置已重置', 'action');
          this.hide();
          setTimeout(() => location.reload(), 1000);
        }
      });

// 清空日志
      document.getElementById('clear-logs')?.addEventListener('click', () => {
        this.logger.clear();
      });

// 清空缓存
      document.getElementById('clear-cache')?.addEventListener('click', () => {
        if (confirm('确定要清空所有缓存数据吗？')) {
          GM_listValues().forEach(key => {
            if (key.startsWith('topicList') || key.startsWith('latestPage')) {
              GM_deleteValue(key);
            }
          });
          this.logger.log('缓存已清空', 'action');
        }
      });

// 清空所有数据
      document.getElementById('clear-all')?.addEventListener('click', () => {
        if (confirm('确定要清空所有数据吗？这将删除所有配置、日志和缓存数据。')) {
          GM_listValues().forEach(key => GM_deleteValue(key));
          this.logger.log('所有数据已清空', 'action');
          setTimeout(() => location.reload(), 1000);
        }
      });
    }

createKeywordSection() {
      const section = document.createElement('div');
      section.style.marginTop = '20px';
      section.innerHTML = `
        <h4 style="margin: 0 0 15px 0; color: inherit;">🔍 关键词监控设置</h4>
        <div style="display: grid; gap: 10px;">
          <div>
            <label style="display: block; margin-bottom: 5px; font-weight: 500;">监控关键词 (每行一个):</label>
            <textarea id="keywords-input" style="width: 100%; height: 100px; padding: 8px; border: 1px solid currentColor; border-radius: 4px; background: transparent; color: inherit; resize: vertical;" placeholder="输入要监控的关键词，每行一个"></textarea>
          </div>
          <div>
            <label style="display: block; margin-bottom: 5px; font-weight: 500;">触发动作:</label>
            <select id="keyword-action" style="width: 100%; padding: 8px; border: 1px solid currentColor; border-radius: 4px; background: transparent; color: inherit;">
              <option value="like">自动点赞</option>
              <option value="reply">自动回复</option>
              <option value="notify">仅通知</option>
              <option value="collect">收藏帖子</option>
            </select>
          </div>
        </div>
      `;

// 加载已保存的关键词
      const savedKeywords = this.config.get('monitorKeywords') || [];
      const keywordsInput = section.querySelector('#keywords-input');
      keywordsInput.value = savedKeywords.join('\n');

// 保存关键词
      keywordsInput.addEventListener('blur', () => {
        const keywords = keywordsInput.value.split('\n').filter(k => k.trim());
        this.config.set('monitorKeywords', keywords);
        this.logger.log(`关键词已更新: ${keywords.length} 个`, 'action');
      });

return section;
    }

createFooter() {
      const footer = document.createElement('div');
      Object.assign(footer.style, {
        padding: '20px',
        borderTop: `1px solid ${this.config.get('theme') === 'dark' ? '#4a5568' : '#e2e8f0'}`,
        display: 'flex',
        justifyContent: 'space-between',
        alignItems: 'center'
      });

const version = document.createElement('span');
      version.textContent = 'v2.0.0';
      version.style.opacity = '0.6';
      version.style.fontSize = '12px';

const buttons = document.createElement('div');
      buttons.style.display = 'flex';
      buttons.style.gap = '10px';

const saveBtn = document.createElement('button');
      saveBtn.textContent = '保存设置';
      Object.assign(saveBtn.style, {
        padding: '8px 16px',
        backgroundColor: '#3182ce',
        color: 'white',
        border: 'none',
        borderRadius: '6px',
        cursor: 'pointer',
        fontSize: '14px',
        fontWeight: '500'
      });
      saveBtn.addEventListener('click', () => {
        this.config.saveConfig();
        this.logger.log('配置已保存', 'success');
        this.hide();
      });

const cancelBtn = document.createElement('button');
      cancelBtn.textContent = '取消';
      Object.assign(cancelBtn.style, {
        padding: '8px 16px',
        backgroundColor: 'transparent',
        color: 'inherit',
        border: '1px solid currentColor',
        borderRadius: '6px',
        cursor: 'pointer',
        fontSize: '14px'
      });
      cancelBtn.addEventListener('click', () => this.hide());

buttons.appendChild(cancelBtn);
      buttons.appendChild(saveBtn);
      footer.appendChild(version);
      footer.appendChild(buttons);
      this.panel.appendChild(footer);
    }

createOverlay() {
      this.overlay = document.createElement('div');
      Object.assign(this.overlay.style, {
        position: 'fixed',
        top: '0',
        left: '0',
        width: '100%',
        height: '100%',
        backgroundColor: 'rgba(0, 0, 0, 0.5)',
        zIndex: '10000',
        display: 'none'
      });
      this.overlay.addEventListener('click', () => this.hide());
      document.body.appendChild(this.overlay);
    }

show() {
      if (!this.panel) this.create();
      this.panel.style.display = 'flex';
      this.overlay.style.display = 'block';
      this.isVisible = true;
    }

hide() {
      if (this.panel) this.panel.style.display = 'none';
      if (this.overlay) this.overlay.style.display = 'none';
      this.isVisible = false;
    }

toggle() {
      if (this.isVisible) {
        this.hide();
      } else {
        this.show();
      }
    }

applyTheme() {
      // 重新创建面板以应用新主题
      if (this.panel) {
        this.panel.remove();
        this.panel = null;
      }
      if (this.isVisible) {
        this.create();
        this.show();
      }
    }
  }

// ===== 统计面板类 =====
  class StatisticsPanel {
    constructor(config, logger) {
      this.config = config;
      this.logger = logger;
      this.panel = null;
      this.isVisible = false;
      this.updateInterval = null;
      this.energyValue = '加载中...';
    }

create() {
      if (this.panel) return;

const isDark = this.config.get('theme') === 'dark';

this.panel = document.createElement('div');
      this.panel.id = 'forum-assistant-stats';
      Object.assign(this.panel.style, {
        position: 'fixed',
        bottom: '10px',
        left: '10px',
        width: '280px',
        backgroundColor: isDark ? '#2d3748' : '#ffffff',
        color: isDark ? '#e2e8f0' : '#2d3748',
        border: `1px solid ${isDark ? '#4a5568' : '#e2e8f0'}`,
        borderRadius: '8px',
        boxShadow: '0 4px 12px rgba(0,0,0,0.15)',
        zIndex: '9999',
        display: 'none',
        flexDirection: 'column',
        fontFamily: "'Segoe UI', Tahoma, Geneva, Verdana, sans-serif",
        fontSize: '12px',
        backdropFilter: 'blur(10px)'
      });

this.createHeader();
      this.createContent();

document.body.appendChild(this.panel);
    }

const title = document.createElement('span');
      title.textContent = '📊 运行统计';

const toggleBtn = document.createElement('button');
      toggleBtn.innerHTML = '−';
      Object.assign(toggleBtn.style, {
        background: 'none',
        border: 'none',
        color: 'inherit',
        cursor: 'pointer',
        fontSize: '16px',
        padding: '2px 6px',
        borderRadius: '3px'
      });
      toggleBtn.addEventListener('click', () => this.toggleMinimize());

header.appendChild(title);
      header.appendChild(toggleBtn);
      this.panel.appendChild(header);
    }

createContent() {
      this.content = document.createElement('div');
      Object.assign(this.content.style, {
        padding: '12px',
        display: 'grid',
        gap: '8px'
      });

this.panel.appendChild(this.content);
      this.updateContent();
    }

updateContent() {
      if (!this.content) {
        console.warn('统计内容元素不存在');
        return;
      }

try {
        const stats = this.logger.statistics;
        const runtime = Date.now() - stats.startTime;

const items = [
          { label: '⏱️ 运行时间', value: Utils.formatTime(runtime) },
          { label: '📖 已读话题', value: stats.topicsRead },
          { label: '👍 点赞数量', value: stats.likesGiven },
          { label: '🔄 总操作数', value: stats.totalActions },
          { label: '❌ 错误次数', value: stats.errorsCount },
          { label: '📈 阅读效率', value: `${(stats.topicsRead / Math.max(runtime / 3600000, 0.1)).toFixed(1)} 话题/小时` }
        ];

this.content.innerHTML = items.map(item => `
          <div style="display: flex; justify-content: space-between; align-items: center; padding: 4px 0;">
            <span style="opacity: 0.8;">${item.label}</span>
            <span style="font-weight: 600;">${item.value}</span>
          </div>
        `).join('') + `
          <div style="display: flex; justify-content: space-between; align-items: center; padding: 4px 0;">
            <span style="opacity: 0.8;">⚡ 能量值</span>
            <span style="font-weight: 600;">${this.energyValue}</span>
          </div>
          <div style="margin-top: 8px; padding-top: 8px; border-top: 1px solid rgba(255,255,255,0.1);">
            <button id="reset-stats" style="width: 100%; padding: 6px 12px; border: 1px solid #dc3545;
                    background: #dc3545; color: white; border-radius: 4px; cursor: pointer; font-size: 11px;">
              🔄 重置统计
            </button>
          </div>
        `;
      } catch (e) {
        console.error('更新统计内容失败:', e);
      }
    }

// 更新能量显示
    updateEnergyDisplay() {
      if (window.location.hostname !== 'nodeloc.cc') {
        this.energyValue = 'N/A';
        return;
      }

GM_xmlhttpRequest({
        method: 'GET',
        url: 'https://nodeloc.cc/leaderboard/1.json',
        onload: (response) => {
          try {
            const data = JSON.parse(response.responseText);
            let energy = '--';
            if (data && data.personal && data.personal.user && typeof data.personal.user.total_score !== 'undefined') {
              energy = data.personal.user.total_score.toLocaleString();
            }
            this.energyValue = energy;
          } catch (e) {
            this.energyValue = '错误';
            console.error('[Energy Display] Error parsing data:', e);
          }
        },
        onerror: (error) => {
          this.energyValue = '失败';
          console.error('[Energy Display] Error fetching data:', error);
        }
      });
    }

show() {
      if (!this.panel) this.create();
      this.panel.style.display = 'flex';
      this.isVisible = true;

// 立即更新一次
      this.updateContent();
      this.updateEnergyDisplay();

// 设置定时器
      if (this.updateInterval) clearInterval(this.updateInterval);
      this.updateInterval = setInterval(() => {
        this.updateContent();
        this.updateEnergyDisplay();
      }, 5000); // 5秒刷新一次

// 绑定重置按钮事件
      setTimeout(() => {
        const resetBtn = document.getElementById('reset-stats');
        if (resetBtn) {
          resetBtn.addEventListener('click', () => {
            if (confirm('确定要重置所有统计数据吗？此操作不可撤销。')) {
              this.logger.resetStatistics();
              this.updateContent();
            }
          });
        }
      }, 100);
    }

hide() {
      if (this.panel) this.panel.style.display = 'none';
      this.isVisible = false;

// 停止更新
      if (this.updateInterval) {
        clearInterval(this.updateInterval);
        this.updateInterval = null;
      }
    }

toggle() {
      if (this.isVisible) {
        this.hide();
      } else {
        this.show();
      }
    }

toggleMinimize() {
      if (!this.content || !this.panel) return;

const toggleBtn = this.panel.querySelector('button');
      if (!toggleBtn) return;

if (this.content.style.display === 'none') {
        this.content.style.display = 'grid';
        toggleBtn.innerHTML = '−';
      } else {
        this.content.style.display = 'none';
        toggleBtn.innerHTML = '+';
      }
    }
  }

// ===== 升级进度面板类 =====
  class UpgradeProgressPanel {
    constructor(config, logger) {
      this.config = config;
      this.logger = logger;
      this.panel = null;
      this.isVisible = false;
      this.updateInterval = null;
      this.upgradeProgress = '加载中...';
      this.unmetConditions = null;
      this.customUsername = GM_getValue('customUsername', '');
      this.currentUsername = null;
    }

create() {
      if (this.panel) return;

const isDark = this.config.get('theme') === 'dark';

this.panel = document.createElement('div');
      this.panel.id = 'forum-assistant-upgrade';

// 获取保存的位置，默认为左上角
      const savedPosition = GM_getValue('upgradeProgressPosition', { top: '10px', left: '10px' });

Object.assign(this.panel.style, {
        position: 'fixed',
        top: savedPosition.top,
        left: savedPosition.left,
        width: '300px',
        backgroundColor: isDark ? '#2d3748' : '#ffffff',
        color: isDark ? '#e2e8f0' : '#2d3748',
        border: `1px solid ${isDark ? '#4a5568' : '#e2e8f0'}`,
        borderRadius: '8px',
        boxShadow: '0 4px 12px rgba(0,0,0,0.15)',
        zIndex: '9998',
        display: 'none',
        flexDirection: 'column',
        fontFamily: "'Segoe UI', Tahoma, Geneva, Verdana, sans-serif",
        fontSize: '12px',
        backdropFilter: 'blur(10px)'
      });

this.createHeader();
      this.createContent();

document.body.appendChild(this.panel);
    }

createHeader() {
      const header = document.createElement('div');
      Object.assign(header.style, {
        padding: '10px 12px',
        borderBottom: `1px solid ${this.config.get('theme') === 'dark' ? '#4a5568' : '#e2e8f0'}`,
        display: 'flex',
        justifyContent: 'space-between',
        alignItems: 'center',
        fontWeight: '600',
        cursor: 'move',
        userSelect: 'none',
        background: this.config.get('theme') === 'dark' ? 'rgba(255,255,255,0.05)' : 'rgba(0,0,0,0.02)'
      });

const title = document.createElement('span');
      title.textContent = '📈 升级进度';

header.appendChild(title);
      header.appendChild(toggleBtn);
      this.panel.appendChild(header);

// 使窗口可拖拽
      this.makeDraggable(header);
    }

createContent() {
      this.content = document.createElement('div');
      Object.assign(this.content.style, {
        padding: '15px',
        display: 'flex',
        flexDirection: 'column',
        gap: '12px'
      });

this.panel.appendChild(this.content);
      this.updateContent();
    }

updateContent() {
      if (!this.content) return;

const username = this.getEffectiveUsername();

this.content.innerHTML = `
        <div style="display: flex; justify-content: space-between; align-items: center;">
          <span style="opacity: 0.8;">👤 用户名:</span>
          <span style="font-weight: 600;">${username || '未设置'}</span>
        </div>
        <div style="display: flex; justify-content: space-between; align-items: center;">
          <span style="opacity: 0.8;">📊 当前进度:</span>
          <span style="font-weight: 600;">${this.upgradeProgress}</span>
        </div>
        ${this.unmetConditions ? `
        <div style="margin-top: 8px; padding: 8px; background: rgba(255,193,7,0.1); border-radius: 4px; border-left: 3px solid #ffc107;">
          <div style="font-size: 11px; font-weight: 600; margin-bottom: 4px; color: #f59e0b;">⚠️ 未完成条件:</div>
          <div style="font-size: 10px; line-height: 1.4; opacity: 0.9;">
            ${this.unmetConditions.map(condition => `• ${condition}`).join('<br>')}
          </div>
        </div>
        ` : ''}
        <div style="margin-top: 8px;">
          <input type="text" id="custom-username" placeholder="输入自定义用户名"
                 value="${this.customUsername}"
                 style="width: 100%; padding: 6px 8px; border: 1px solid currentColor; border-radius: 4px;
                        background: transparent; color: inherit; font-size: 12px;">
        </div>
        <div style="margin-top: 8px; display: flex; gap: 8px;">
          <button id="save-username" style="flex: 1; padding: 6px 12px; border: 1px solid #3182ce;
                  background: #3182ce; color: white; border-radius: 4px; cursor: pointer; font-size: 11px;">
            保存用户名
          </button>
          <button id="refresh-progress" style="flex: 1; padding: 6px 12px; border: 1px solid currentColor;
                  background: transparent; color: inherit; border-radius: 4px; cursor: pointer; font-size: 11px;">
            刷新进度
          </button>
        </div>
        <div style="margin-top: 8px; display: flex; gap: 8px;">
          <button id="test-api" style="flex: 1; padding: 6px 12px; border: 1px solid #e53e3e;
                  background: #e53e3e; color: white; border-radius: 4px; cursor: pointer; font-size: 11px;">
            🔧 测试API
          </button>
          <button id="reset-position" style="flex: 1; padding: 6px 12px; border: 1px solid #6b7280;
                  background: #6b7280; color: white; border-radius: 4px; cursor: pointer; font-size: 11px;">
            📍 重置位置
          </button>
        </div>
      `;

// 绑定事件
      this.bindEvents();
    }

bindEvents() {
      const saveBtn = this.content.querySelector('#save-username');
      const refreshBtn = this.content.querySelector('#refresh-progress');
      const testBtn = this.content.querySelector('#test-api');
      const resetPosBtn = this.content.querySelector('#reset-position');
      const usernameInput = this.content.querySelector('#custom-username');

if (saveBtn) {
        saveBtn.addEventListener('click', () => {
          const username = usernameInput.value.trim();
          this.customUsername = username;
          GM_setValue('customUsername', username);
          this.logger.log(`自定义用户名已保存: ${username || '(清空)'}`, 'success');
          this.updateContent();
          this.updateUpgradeProgress();
        });
      }

if (refreshBtn) {
        refreshBtn.addEventListener('click', () => {
          this.updateUpgradeProgress();
          this.logger.log('手动刷新升级进度', 'action');
        });
      }

if (testBtn) {
        testBtn.addEventListener('click', () => {
          this.testApiConnection();
        });
      }

if (resetPosBtn) {
        resetPosBtn.addEventListener('click', () => {
          this.resetPosition();
        });
      }
    }

makeDraggable(header) {
      if (!header || !this.panel) return;

let isDragging = false;
      let currentX, currentY, initialX, initialY;

header.addEventListener("mousedown", (e) => {
        if (!this.panel) return;
        isDragging = true;
        initialX = e.clientX - this.panel.offsetLeft;
        initialY = e.clientY - this.panel.offsetTop;
        header.style.cursor = 'grabbing';
      });

document.addEventListener("mousemove", (e) => {
        if (isDragging && this.panel) {
          e.preventDefault();
          currentX = e.clientX - initialX;
          currentY = e.clientY - initialY;

// 限制在屏幕范围内
          const maxX = window.innerWidth - this.panel.offsetWidth;
          const maxY = window.innerHeight - this.panel.offsetHeight;

currentX = Math.max(0, Math.min(currentX, maxX));
          currentY = Math.max(0, Math.min(currentY, maxY));

this.panel.style.left = currentX + "px";
          this.panel.style.top = currentY + "px";
          this.panel.style.right = "auto";
          this.panel.style.bottom = "auto";
        }
      });

document.addEventListener("mouseup", () => {
        if (isDragging && this.panel) {
          isDragging = false;
          header.style.cursor = 'move';

// 保存当前位置
          const position = {
            top: this.panel.style.top,
            left: this.panel.style.left
          };
          GM_setValue('upgradeProgressPosition', position);
          console.log('[Upgrade Progress] 位置已保存:', position);
        }
      });
    }

getEffectiveUsername() {
      // 优先使用自定义用户名
      if (this.customUsername) {
        return this.customUsername;
      }

// 其次使用自动检测的用户名
      if (!this.currentUsername) {
        this.currentUsername = this.getCurrentUsername();
      }

return this.currentUsername;
    }

resetPosition() {
      // 重置到默认位置（左上角）
      const defaultPosition = { top: '10px', left: '10px' };

if (this.panel) {
        this.panel.style.top = defaultPosition.top;
        this.panel.style.left = defaultPosition.left;
        this.panel.style.right = 'auto';
        this.panel.style.bottom = 'auto';
      }

// 保存重置后的位置
      GM_setValue('upgradeProgressPosition', defaultPosition);
      this.logger.log('升级进度窗口位置已重置到左上角', 'success');
    }

testApiConnection() {
      const username = this.getEffectiveUsername();
      if (!username) {
        alert('请先设置用户名');
        return;
      }

this.logger.log('开始测试API连接...', 'action');

// 测试基本的用户信息API
      GM_xmlhttpRequest({
        method: 'GET',
        url: `https://nodeloc.cc/u/${username}.json`,
        headers: {
          'Accept': 'application/json',
          'X-Requested-With': 'XMLHttpRequest',
          'Referer': window.location.href
        },
        onload: (response) => {
          console.log(`[API Test] 用户信息API响应状态: ${response.status}`);
          console.log(`[API Test] 用户信息API响应内容:`, response.responseText);

if (response.status === 200) {
            try {
              const data = JSON.parse(response.responseText);
              if (data.user) {
                this.logger.log(`✅ 用户信息API正常，用户ID: ${data.user.id}`, 'success');

// 继续测试升级进度API
                this.testUpgradeProgressApi(username);
              } else {
                this.logger.log('❌ 用户信息API返回数据异常', 'error');
              }
            } catch (e) {
              this.logger.log('❌ 用户信息API数据解析失败', 'error');
            }
          } else {
            this.logger.log(`❌ 用户信息API请求失败 (${response.status})`, 'error');
          }
        },
        onerror: (error) => {
          this.logger.log('❌ 用户信息API网络错误', 'error');
          console.error('[API Test] 用户信息API网络错误:', error);
        }
      });
    }

testUpgradeProgressApi(username) {
      GM_xmlhttpRequest({
        method: 'GET',
        url: `https://nodeloc.cc/u/${username}/upgrade-progress.json`,
        headers: {
          'Accept': 'application/json, text/javascript, */*; q=0.01',
          'X-Requested-With': 'XMLHttpRequest',
          'Referer': window.location.href
        },
        onload: (response) => {
          console.log(`[API Test] 升级进度API响应状态: ${response.status}`);
          console.log(`[API Test] 升级进度API响应内容:`, response.responseText);

if (response.status === 200) {
            try {
              const data = JSON.parse(response.responseText);
              console.log('[API Test] 升级进度API完整响应:', JSON.stringify(data, null, 2));

if (data) {
                if (data.next_level) {
                  const nextLevel = data.next_level;
                  const nextLevelKeys = Object.keys(nextLevel);
                  this.logger.log(`✅ 升级进度API正常，next_level字段: ${nextLevelKeys.join(', ')}`, 'success');
                  console.log('[API Test] next_level详细数据:', nextLevel);
                  console.log('[API Test] next_level类型:', typeof nextLevel);

// 分析next_level的具体内容
                  if (typeof nextLevel === 'object') {
                    Object.entries(nextLevel).forEach(([key, value]) => {
                      console.log(`[API Test] next_level.${key}:`, value, `(类型: ${typeof value})`);
                    });
                  }
                } else {
                  const keys = Object.keys(data);
                  this.logger.log(`⚠️ 升级进度API无next_level，可用字段: ${keys.join(', ')}`, 'warning');
                  console.log('[API Test] 可用数据字段:', keys);
                  console.log('[API Test] 完整数据:', data);
                }
              } else {
                this.logger.log('❌ 升级进度API返回空数据', 'error');
              }
            } catch (e) {
              this.logger.log('❌ 升级进度API数据解析失败', 'error');
              console.error('[API Test] 解析错误:', e);
              console.error('[API Test] 原始响应:', response.responseText);
            }
          } else if (response.status === 403) {
            this.logger.log('❌ 升级进度API权限不足，可能需要登录', 'error');
          } else if (response.status === 404) {
            this.logger.log('❌ 升级进度API不存在或用户不存在', 'error');
          } else {
            this.logger.log(`❌ 升级进度API请求失败 (${response.status})`, 'error');
          }
        },
        onerror: (error) => {
          this.logger.log('❌ 升级进度API网络错误', 'error');
          console.error('[API Test] 升级进度API网络错误:', error);
        }
      });
    }

getCurrentUsername() {
      // 方法1: 从用户菜单按钮获取
      const userMenuButton = document.querySelector('.header-dropdown-toggle.current-user');
      if (userMenuButton) {
        const img = userMenuButton.querySelector('img');
        if (img && img.alt) {
          console.log(`[Username] 从用户菜单获取到用户名: ${img.alt}`);
          return img.alt;
        }
      }

// 方法2: 从用户链接获取
      const userLinks = document.querySelectorAll('a[href*="/u/"]');
      for (const userLink of userLinks) {
        const match = userLink.href.match(/\/u\/([^\/]+)/);
        if (match && match[1]) {
          console.log(`[Username] 从用户链接获取到用户名: ${match[1]}`);
          return match[1];
        }
      }

// 方法3: 从当前页面URL获取（如果在用户页面）
      if (window.location.pathname.includes('/u/')) {
        const match = window.location.pathname.match(/\/u\/([^\/]+)/);
        if (match && match[1]) {
          console.log(`[Username] 从URL获取到用户名: ${match[1]}`);
          return match[1];
        }
      }

// 方法4: 从页面标题获取
      const titleMatch = document.title.match(/(.+?)\s*-\s*NodeLoc/);
      if (titleMatch && titleMatch[1] && !titleMatch[1].includes('NodeLoc')) {
        console.log(`[Username] 从页面标题获取到用户名: ${titleMatch[1]}`);
        return titleMatch[1];
      }

// 方法5: 从meta标签获取
      const metaUser = document.querySelector('meta[name="discourse-username"]');
      if (metaUser && metaUser.content) {
        console.log(`[Username] 从meta标签获取到用户名: ${metaUser.content}`);
        return metaUser.content;
      }

console.log('[Username] 无法自动获取用户名');
      return null;
    }

updateUpgradeProgress() {
      if (window.location.hostname !== 'nodeloc.cc') {
        this.upgradeProgress = 'N/A (非NodeLoc站点)';
        this.updateContent();
        return;
      }

const username = this.getEffectiveUsername();
      if (!username) {
        this.upgradeProgress = '未设置用户名';
        this.updateContent();
        return;
      }

this.upgradeProgress = '获取中...';
      this.updateContent();

console.log(`[Upgrade Progress] 正在获取用户 ${username} 的升级进度`);

GM_xmlhttpRequest({
        method: 'GET',
        url: `https://nodeloc.cc/u/${username}/upgrade-progress.json`,
        headers: {
          'Accept': 'application/json, text/javascript, */*; q=0.01',
          'X-Requested-With': 'XMLHttpRequest',
          'Referer': window.location.href
        },
        onload: (response) => {
          console.log(`[Upgrade Progress] 响应状态: ${response.status}`);
          console.log(`[Upgrade Progress] 响应内容:`, response.responseText);

try {
            if (response.status === 200) {
              const data = JSON.parse(response.responseText);
              let progress = '获取不到信息';

console.log(`[Upgrade Progress] 解析的数据:`, data);

// 检查数据结构
              if (data) {
                console.log(`[Upgrade Progress] 完整数据结构:`, JSON.stringify(data, null, 2));

// 方案1: 检查升级进度数据（基于真实的NodeLoc API结构）
                if (data.next_level !== undefined && data.next_level_name && data.met_count !== undefined && data.total_conditions !== undefined) {
                  // NodeLoc的真实数据结构
                  const nextLevelName = data.next_level_name;
                  const metCount = data.met_count;
                  const totalConditions = data.total_conditions;
                  const percentage = Math.round((metCount / totalConditions) * 100);

progress = `${nextLevelName} ${percentage}% (${metCount}/${totalConditions})`;

// 保存未完成条件
                  if (data.unmet_conditions && Array.isArray(data.unmet_conditions)) {
                    this.unmetConditions = data.unmet_conditions;
                  } else {
                    this.unmetConditions = null;
                  }

console.log(`[Upgrade Progress] 解析成功: ${progress}`);
                }
                // 方案2: 如果有next_level但结构不同
                else if (data.next_level) {
                  const nextLevel = data.next_level;
                  console.log(`[Upgrade Progress] next_level详细信息:`, nextLevel);
                  console.log(`[Upgrade Progress] next_level类型:`, typeof nextLevel);

if (typeof nextLevel === 'number') {
                    // next_level是数字，查找等级名称
                    if (data.next_level_name) {
                      progress = `下一等级: ${data.next_level_name} (等级${nextLevel})`;
                    } else {
                      const levelNames = ['新手', '基础会员', '会员', '资深会员', '钻石会员', '领导者'];
                      progress = `下一等级: ${levelNames[nextLevel] || `等级${nextLevel}`}`;
                    }
                  }
                  else if (typeof nextLevel === 'object') {
                    // 检查各种可能的字段组合
                    if (nextLevel.name && nextLevel.progress !== undefined && nextLevel.total !== undefined) {
                      const percentage = Math.round((nextLevel.progress / nextLevel.total) * 100);
                      progress = `${nextLevel.name} ${percentage}%`;
                    }
                    else if (nextLevel.name && nextLevel.current !== undefined && nextLevel.required !== undefined) {
                      const percentage = Math.round((nextLevel.current / nextLevel.required) * 100);
                      progress = `${nextLevel.name} ${percentage}%`;
                    }
                    else if (nextLevel.name) {
                      progress = `下一等级: ${nextLevel.name}`;
                    }
                    else {
                      // 显示对象的所有键值对
                      const entries = Object.entries(nextLevel).map(([key, value]) => `${key}: ${value}`);
                      progress = `next_level: {${entries.join(', ')}}`;
                    }
                  }
                  else if (typeof nextLevel === 'string') {
                    progress = `下一等级: ${nextLevel}`;
                  }
                  else {
                    progress = `next_level: ${JSON.stringify(nextLevel)}`;
                  }
                }
                // 方案2: 检查用户信任等级
                else if (data.user && data.user.trust_level !== undefined) {
                  const trustLevel = data.user.trust_level;
                  const levelNames = ['新手', '基础会员', '会员', '资深会员', '领导者'];
                  progress = `信任等级 ${trustLevel} (${levelNames[trustLevel] || '未知'})`;
                }
                // 方案3: 检查其他可能的数据结构
                else if (data.upgrade_progress) {
                  progress = `进度: ${JSON.stringify(data.upgrade_progress)}`;
                }
                else if (data.level_info) {
                  progress = `等级信息: ${JSON.stringify(data.level_info)}`;
                }
                else if (data.progress) {
                  progress = `进度: ${JSON.stringify(data.progress)}`;
                }
                // 方案4: 显示所有可用的键
                else {
                  const keys = Object.keys(data);
                  progress = `可用字段: ${keys.join(', ')}`;
                  console.warn('[Upgrade Progress] 未识别的数据结构，可用字段:', keys);
                  console.warn('[Upgrade Progress] 完整数据:', data);
                }
              } else {
                progress = '数据为空';
              }

this.upgradeProgress = progress;
            } else if (response.status === 403) {
              this.upgradeProgress = '权限不足';
            } else if (response.status === 404) {
              this.upgradeProgress = '用户不存在';
            } else {
              this.upgradeProgress = `请求失败 (${response.status})`;
            }

this.updateContent();
          } catch (e) {
            this.upgradeProgress = '数据解析错误';
            this.updateContent();
            console.error('[Upgrade Progress] 解析错误:', e);
            console.error('[Upgrade Progress] 原始响应:', response.responseText);
          }
        },
        onerror: (error) => {
          this.upgradeProgress = '网络请求失败';
          this.updateContent();
          console.error('[Upgrade Progress] 网络错误:', error);
        },
        ontimeout: () => {
          this.upgradeProgress = '请求超时';
          this.updateContent();
          console.error('[Upgrade Progress] 请求超时');
        },
        timeout: 10000 // 10秒超时
      });
    }

show() {
      if (!this.panel) this.create();
      this.panel.style.display = 'flex';
      this.isVisible = true;

// 保存显示状态
      GM_setValue('upgradeProgressVisible', true);

// 立即更新一次
      this.updateContent();
      this.updateUpgradeProgress();

// 设置定时器
      if (this.updateInterval) clearInterval(this.updateInterval);
      this.updateInterval = setInterval(() => {
        this.updateUpgradeProgress();
      }, 10000); // 10秒刷新一次
    }

hide() {
      if (this.panel) this.panel.style.display = 'none';
      this.isVisible = false;

// 保存隐藏状态
      GM_setValue('upgradeProgressVisible', false);

// 停止更新
      if (this.updateInterval) {
        clearInterval(this.updateInterval);
        this.updateInterval = null;
      }
    }

toggle() {
      if (this.isVisible) {
        this.hide();
      } else {
        this.show();
      }
    }
  }

// ===== 控制面板类 =====
  class ControlPanel {
    constructor(config, logger, statsPanel, configPanel, upgradePanel) {
      this.config = config;
      this.logger = logger;
      this.statsPanel = statsPanel;
      this.configPanel = configPanel;
      this.upgradePanel = upgradePanel;
      this.panel = null;
      this.buttons = {};
    }

create() {
      if (this.panel) return;

const isDark = this.config.get('theme') === 'dark';

this.panel = document.createElement('div');
      this.panel.id = 'forum-assistant-controls';
      Object.assign(this.panel.style, {
        position: 'fixed',
        bottom: '10px',
        right: '10px',
        display: 'flex',
        flexDirection: 'column',
        gap: '8px',
        zIndex: '9999'
      });

// 创建控制按钮
      this.createControlButtons();

document.body.appendChild(this.panel);
    }

createControlButtons() {
      const buttons = [
        { id: 'toggle-reading', text: '开始阅读', icon: '📖', action: () => this.toggleReading() },
        { id: 'toggle-like', text: '启用点赞', icon: '👍', action: () => this.toggleAutoLike() },
        { id: 'show-stats', text: '显示统计', icon: '📊', action: () => this.statsPanel.toggle() },
        { id: 'show-upgrade', text: '升级进度', icon: '📈', action: () => this.toggleUpgradeProgress() },
        { id: 'show-config', text: '打开设置', icon: '⚙️', action: () => this.configPanel.toggle() },
        { id: 'show-logs', text: '显示日志', icon: '📋', action: () => this.logger.toggleVisibility() }
      ];

buttons.forEach(btn => {
        const button = this.createButton(btn);
        this.buttons[btn.id] = button;
        this.panel.appendChild(button);
      });

this.updateButtonStates();
    }

createButton(config) {
      const isDark = this.config.get('theme') === 'dark';

button.addEventListener('click', config.action);

// 悬停效果
      button.addEventListener('mouseenter', () => {
        button.style.transform = 'translateY(-1px)';
        button.style.boxShadow = '0 4px 8px rgba(0,0,0,0.15)';
      });

button.addEventListener('mouseleave', () => {
        button.style.transform = 'translateY(0)';
        button.style.boxShadow = '0 2px 4px rgba(0,0,0,0.1)';
      });

return button;
    }

toggleReading() {
      const isReading = GM_getValue('isReading', false);
      GM_setValue('isReading', !isReading);

this.updateButtonStates();

if (!isReading) {
        this.logger.log('开始自动阅读', 'action');
        // 调用主程序的开始阅读逻辑
        if (window.forumAssistant && typeof window.forumAssistant.start === 'function') {
          window.forumAssistant.start();
        }
      } else {
        this.logger.log('停止自动阅读', 'action');
        // 调用主程序的停止阅读逻辑
        if (window.forumAssistant && typeof window.forumAssistant.stop === 'function') {
          window.forumAssistant.stop();
        }
      }
    }

toggleAutoLike() {
      const rateLimitInfo = GM_getValue('rateLimitInfo', null);

// 检查是否仍在限制期内
      if (rateLimitInfo && this.isRateLimitActive(rateLimitInfo)) {
        const remainingTime = this.getRemainingTime(rateLimitInfo);
        const canLikeTime = this.getCanLikeTime(rateLimitInfo);

this.logger.log(`点赞仍在限制期内，剩余时间: ${remainingTime}`, 'warning');
        this.logger.log(`📅 预计可点赞时间: ${canLikeTime}`, 'info');
        this.logger.showNotification(`点赞受限，剩余时间: ${remainingTime}`, 'warning');
        return;
      }

// 如果限制已过期，清除限制信息
      if (rateLimitInfo && !this.isRateLimitActive(rateLimitInfo)) {
        GM_setValue('rateLimitInfo', null);
        this.logger.log('点赞限制已过期，已清除限制信息', 'success');
      }

const isEnabled = GM_getValue('autoLikeEnabled', false);
      const newState = !isEnabled;
      GM_setValue('autoLikeEnabled', newState);

this.updateButtonStates();

if (newState) {
        // 启用时显示详细信息
        this.logger.log(`🎯 自动点赞已启用`, 'success');
        this.showLikeStatusInfo();
      } else {
        this.logger.log(`⏸️ 自动点赞已禁用`, 'action');
      }
    }

// 显示点赞状态信息
    showLikeStatusInfo() {
      const rateLimitInfo = GM_getValue('rateLimitInfo', null);

if (rateLimitInfo && this.isRateLimitActive(rateLimitInfo)) {
        // 仍在限制期内
        const remainingTime = this.getRemainingTime(rateLimitInfo);
        const canLikeTime = this.getCanLikeTime(rateLimitInfo);

this.logger.log(`⚠️ 当前状态: 点赞受限`, 'warning');
        this.logger.log(`⏰ 剩余等待时间: ${remainingTime}`, 'warning');
        this.logger.log(`📅 预计可点赞时间: ${canLikeTime}`, 'info');
        this.logger.log(`💡 限制原因: ${rateLimitInfo.message || '未知'}`, 'info');
      } else {
        // 可以正常点赞
        const currentTime = new Date().toLocaleString('zh-CN');
        this.logger.log(`✅ 当前状态: 可以正常点赞`, 'success');
        this.logger.log(`🕐 当前时间: ${currentTime}`, 'info');

// 显示今日点赞统计
        const dailyLikeCount = GM_getValue('dailyLikeCount', 0);
        const maxLikes = this.siteAdapter?.getLimit('maxLikes') || 100;
        this.logger.log(`📊 今日点赞: ${dailyLikeCount}/${maxLikes}`, 'info');

if (dailyLikeCount >= maxLikes) {
          this.logger.log(`⚠️ 今日点赞已达上限`, 'warning');
        } else {
          const remaining = maxLikes - dailyLikeCount;
          this.logger.log(`💪 剩余可点赞: ${remaining} 次`, 'success');
        }
      }
    }

// 获取可以点赞的具体时间
    getCanLikeTime(rateLimitInfo) {
      if (!rateLimitInfo || !rateLimitInfo.waitSeconds || !rateLimitInfo.timestamp) {
        return '未知';
      }

const canLikeTimestamp = rateLimitInfo.timestamp + (rateLimitInfo.waitSeconds * 1000);
      const canLikeDate = new Date(canLikeTimestamp);

return canLikeDate.toLocaleString('zh-CN', {
        year: 'numeric',
        month: '2-digit',
        day: '2-digit',
        hour: '2-digit',
        minute: '2-digit',
        second: '2-digit'
      });
    }

// 获取剩余限制时间
    getRemainingTime(rateLimitInfo) {
      if (!rateLimitInfo || !rateLimitInfo.waitSeconds || !rateLimitInfo.timestamp) {
        return '未知';
      }

const now = Date.now();
      const limitEndTime = rateLimitInfo.timestamp + (rateLimitInfo.waitSeconds * 1000);
      const remainingMs = limitEndTime - now;

if (remainingMs <= 0) {
        return '已过期';
      }

const hours = Math.floor(remainingMs / (1000 * 60 * 60));
      const minutes = Math.floor((remainingMs % (1000 * 60 * 60)) / (1000 * 60));

if (hours > 0) {
        return `${hours}小时${minutes}分钟`;
      } else {
        return `${minutes}分钟`;
      }
    }

toggleUpgradeProgress() {
      this.upgradePanel.toggle();
      this.updateButtonStates();
      this.logger.log(`升级进度面板已${this.upgradePanel.isVisible ? '显示' : '隐藏'}`, 'action');
    }

updateButtonStates() {
      const isReading = GM_getValue('isReading', false);
      const isLikeEnabled = GM_getValue('autoLikeEnabled', false);
      const isUpgradeVisible = this.upgradePanel.isVisible;
      const rateLimitInfo = GM_getValue('rateLimitInfo', null);

if (this.buttons && this.buttons['toggle-reading']) {
        const btn = this.buttons['toggle-reading'];
        if (btn) {
          btn.innerHTML = `📖 ${isReading ? '停止阅读' : '开始阅读'}`;
          btn.style.backgroundColor = isReading ? '#dc3545' : (this.config.get('theme') === 'dark' ? '#4a5568' : '#ffffff');
          btn.style.color = isReading ? '#ffffff' : (this.config.get('theme') === 'dark' ? '#e2e8f0' : '#2d3748');
        }
      }

if (this.buttons && this.buttons['toggle-like']) {
        const btn = this.buttons['toggle-like'];
        if (btn) {
          // 检查是否有限制信息
          if (rateLimitInfo && this.isRateLimitActive(rateLimitInfo)) {
            btn.innerHTML = `🚫 点赞受限`;
            btn.style.backgroundColor = '#dc3545';
            btn.style.color = '#ffffff';
            btn.title = `点赞已达限制，剩余等待时间: ${rateLimitInfo.timeLeft}`;
          } else {
            btn.innerHTML = `👍 ${isLikeEnabled ? '禁用点赞' : '启用点赞'}`;
            btn.style.backgroundColor = isLikeEnabled ? '#28a745' : (this.config.get('theme') === 'dark' ? '#4a5568' : '#ffffff');
            btn.style.color = isLikeEnabled ? '#ffffff' : (this.config.get('theme') === 'dark' ? '#e2e8f0' : '#2d3748');
            btn.title = isLikeEnabled ? '点击禁用自动点赞' : '点击启用自动点赞';
          }
        }
      }

if (this.buttons && this.buttons['show-upgrade']) {
        const btn = this.buttons['show-upgrade'];
        if (btn) {
          btn.innerHTML = `📈 ${isUpgradeVisible ? '隐藏进度' : '升级进度'}`;
          btn.style.backgroundColor = isUpgradeVisible ? '#8b5cf6' : (this.config.get('theme') === 'dark' ? '#4a5568' : '#ffffff');
          btn.style.color = isUpgradeVisible ? '#ffffff' : (this.config.get('theme') === 'dark' ? '#e2e8f0' : '#2d3748');
        }
      }
    }

// 检查限制是否仍然有效
    isRateLimitActive(rateLimitInfo) {
      if (!rateLimitInfo || !rateLimitInfo.waitSeconds || !rateLimitInfo.timestamp) {
        return false;
      }

const now = Date.now();
      const limitEndTime = rateLimitInfo.timestamp + (rateLimitInfo.waitSeconds * 1000);

return now < limitEndTime;
    }

show() {
      if (!this.panel) this.create();
      this.panel.style.display = 'flex';
    }

hide() {
      if (this.panel) this.panel.style.display = 'none';
    }
  }

// ===== 状态指示器类 =====
  class StatusIndicator {
    constructor(config, logger) {
      this.config = config;
      this.logger = logger;
      this.indicator = null;
      this.statusText = null;
      this.progressBar = null;
    }

create() {
      if (this.indicator) return;

const isDark = this.config.get('theme') === 'dark';

this.indicator = document.createElement('div');
      this.indicator.id = 'forum-assistant-status';
      Object.assign(this.indicator.style, {
        position: 'fixed',
        top: '10px',
        left: '50%',
        transform: 'translateX(-50%)',
        backgroundColor: isDark ? '#2d3748' : '#ffffff',
        color: isDark ? '#e2e8f0' : '#2d3748',
        border: `1px solid ${isDark ? '#4a5568' : '#e2e8f0'}`,
        borderRadius: '20px',
        padding: '8px 16px',
        fontSize: '12px',
        fontWeight: '500',
        zIndex: '9998',
        display: 'none',
        alignItems: 'center',
        gap: '8px',
        boxShadow: '0 2px 8px rgba(0,0,0,0.1)',
        backdropFilter: 'blur(10px)',
        minWidth: '200px',
        justifyContent: 'center'
      });

// 状态图标
      this.statusIcon = document.createElement('span');
      this.statusIcon.textContent = '⏸️';

// 状态文本
      this.statusText = document.createElement('span');
      this.statusText.textContent = '待机中';

// 进度条容器
      const progressContainer = document.createElement('div');
      Object.assign(progressContainer.style, {
        width: '60px',
        height: '4px',
        backgroundColor: isDark ? '#4a5568' : '#e2e8f0',
        borderRadius: '2px',
        overflow: 'hidden'
      });

// 进度条
      this.progressBar = document.createElement('div');
      Object.assign(this.progressBar.style, {
        width: '0%',
        height: '100%',
        backgroundColor: '#3182ce',
        borderRadius: '2px',
        transition: 'width 0.3s ease'
      });

progressContainer.appendChild(this.progressBar);

this.indicator.appendChild(this.statusIcon);
      this.indicator.appendChild(this.statusText);
      this.indicator.appendChild(progressContainer);

document.body.appendChild(this.indicator);
    }

updateStatus(status, progress = 0) {
      if (!this.indicator) this.create();

const statusConfig = {
        idle: { icon: '⏸️', text: '待机中', color: '#6b7280' },
        reading: { icon: '📖', text: '阅读中', color: '#3182ce' },
        scrolling: { icon: '🔄', text: '滚动中', color: '#10b981' },
        liking: { icon: '👍', text: '点赞中', color: '#f59e0b' },
        switching: { icon: '🔀', text: '切换话题', color: '#8b5cf6' },
        error: { icon: '❌', text: '出现错误', color: '#dc3545' },
        loading: { icon: '⏳', text: '加载中', color: '#6366f1' }
      };

const config = statusConfig[status] || statusConfig.idle;

if (this.statusIcon) this.statusIcon.textContent = config.icon;
      if (this.statusText) this.statusText.textContent = config.text;
      if (this.progressBar) {
        this.progressBar.style.backgroundColor = config.color;
        this.progressBar.style.width = `${Math.max(0, Math.min(100, progress))}%`;
      }

// 自动显示/隐藏
      if (status !== 'idle') {
        this.show();
      } else {
        setTimeout(() => this.hide(), 2000);
      }
    }

show() {
      if (!this.indicator) this.create();
      this.indicator.style.display = 'flex';
    }

hide() {
      if (this.indicator) this.indicator.style.display = 'none';
    }
  }

// ===== 智能行为模拟类 =====
  class BehaviorSimulator {
    constructor(config, logger, statusIndicator) {
      this.config = config;
      this.logger = logger;
      this.statusIndicator = statusIndicator;
      this.mouseTracker = null;
      this.behaviorQueue = [];
      this.isSimulating = false;
    }

// 鼠标移动模拟
    simulateMouseMovement() {
      if (!this.config.get('enableMouseSimulation')) return;

const startX = Math.random() * window.innerWidth;
      const startY = Math.random() * window.innerHeight;
      const endX = Math.random() * window.innerWidth;
      const endY = Math.random() * window.innerHeight;

const duration = Utils.getRandomInt(1000, 3000);
      const steps = 30;
      const stepDuration = duration / steps;

let currentStep = 0;
      const moveInterval = setInterval(() => {
        if (currentStep >= steps) {
          clearInterval(moveInterval);
          return;
        }

const progress = currentStep / steps;
        const easeProgress = this.easeInOutCubic(progress);

const currentX = startX + (endX - startX) * easeProgress;
        const currentY = startY + (endY - startY) * easeProgress;

// 创建鼠标移动事件
        const event = new MouseEvent('mousemove', {
          clientX: currentX,
          clientY: currentY,
          bubbles: true
        });
        document.dispatchEvent(event);

currentStep++;
      }, stepDuration);
    }

// 随机页面交互
    async simulatePageInteraction() {
      if (!this.config.get('enableAdvancedBehavior')) return;

const interactions = [
        () => this.simulateTextSelection(),
        () => this.simulateScrollPause(),
        () => this.simulateElementHover(),
        () => this.simulateKeyboardActivity(),
        () => this.simulateWindowResize()
      ];

const randomInteraction = interactions[Math.floor(Math.random() * interactions.length)];
      await randomInteraction();
    }

// 文本选择模拟
    simulateTextSelection() {
      const textElements = document.querySelectorAll('p, div, span, h1, h2, h3, h4, h5, h6');
      if (textElements.length === 0) return;

const randomElement = textElements[Math.floor(Math.random() * textElements.length)];
      const text = randomElement.textContent;

if (text.length > 10) {
        const startIndex = Math.floor(Math.random() * (text.length - 10));
        const endIndex = startIndex + Utils.getRandomInt(5, 20);

try {
          const range = document.createRange();
          const textNode = randomElement.firstChild;
          if (textNode && textNode.nodeType === Node.TEXT_NODE) {
            range.setStart(textNode, Math.min(startIndex, textNode.textContent.length));
            range.setEnd(textNode, Math.min(endIndex, textNode.textContent.length));

const selection = window.getSelection();
            selection.removeAllRanges();
            selection.addRange(range);

// 短暂保持选择状态
            setTimeout(() => {
              selection.removeAllRanges();
            }, Utils.getRandomInt(500, 2000));

this.logger.log('模拟文本选择', 'action');
          }
        } catch (e) {
          // 忽略选择错误
        }
      }
    }

// 滚动暂停模拟
    async simulateScrollPause() {
      const pauseDuration = Utils.getRandomInt(1000, 5000);
      this.statusIndicator.updateStatus('reading', 50);

await Utils.sleep(pauseDuration);
      this.logger.log(`模拟阅读暂停 ${pauseDuration}ms`, 'action');
    }

// 元素悬停模拟
    simulateElementHover() {
      const hoverableElements = document.querySelectorAll('a, button, .btn, [role="button"]');
      if (hoverableElements.length === 0) return;

const randomElement = hoverableElements[Math.floor(Math.random() * hoverableElements.length)];

// 触发悬停事件
      const mouseEnter = new MouseEvent('mouseenter', { bubbles: true });
      const mouseOver = new MouseEvent('mouseover', { bubbles: true });

randomElement.dispatchEvent(mouseEnter);
      randomElement.dispatchEvent(mouseOver);

// 短暂悬停后移开
      setTimeout(() => {
        const mouseLeave = new MouseEvent('mouseleave', { bubbles: true });
        const mouseOut = new MouseEvent('mouseout', { bubbles: true });

randomElement.dispatchEvent(mouseLeave);
        randomElement.dispatchEvent(mouseOut);
      }, Utils.getRandomInt(500, 2000));

this.logger.log('模拟元素悬停', 'action');
    }

// 键盘活动模拟
    simulateKeyboardActivity() {
      const keys = ['ArrowDown', 'ArrowUp', 'PageDown', 'PageUp', 'Home', 'End'];
      const randomKey = keys[Math.floor(Math.random() * keys.length)];

const keyEvent = new KeyboardEvent('keydown', {
        key: randomKey,
        code: randomKey,
        bubbles: true
      });

document.dispatchEvent(keyEvent);
      this.logger.log(`模拟按键: ${randomKey}`, 'action');
    }

// 窗口大小调整模拟
    simulateWindowResize() {
      // 模拟窗口大小变化事件
      const resizeEvent = new Event('resize');
      window.dispatchEvent(resizeEvent);
      this.logger.log('模拟窗口调整', 'action');
    }

// 随机行为触发
    async triggerRandomBehavior() {
      if (!this.isSimulating) return;

const behaviors = [
        { action: () => this.simulateMouseMovement(), weight: 3 },
        { action: () => this.simulatePageInteraction(), weight: 2 },
        { action: () => this.simulateScrollPause(), weight: 1 }
      ];

// 权重随机选择
      const totalWeight = behaviors.reduce((sum, b) => sum + b.weight, 0);
      let random = Math.random() * totalWeight;

for (const behavior of behaviors) {
        random -= behavior.weight;
        if (random <= 0) {
          await behavior.action();
          break;
        }
      }

// 随机间隔后再次触发
      const nextDelay = Utils.getRandomInt(5000, 15000);
      setTimeout(() => this.triggerRandomBehavior(), nextDelay);
    }

// 缓动函数
    easeInOutCubic(t) {
      return t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
    }

// 开始行为模拟
    start() {
      if (this.isSimulating) return;

this.isSimulating = true;
      this.logger.log('开始智能行为模拟', 'action');

// 启动随机行为
      setTimeout(() => this.triggerRandomBehavior(), Utils.getRandomInt(2000, 5000));
    }

// 停止行为模拟
    stop() {
      this.isSimulating = false;
      this.logger.log('停止智能行为模拟', 'action');
    }
  }

// ===== 增强滚动系统类 =====
  class EnhancedScrollSystem {
    constructor(config, logger, statusIndicator, behaviorSimulator) {
      this.config = config;
      this.logger = logger;
      this.statusIndicator = statusIndicator;
      this.behaviorSimulator = behaviorSimulator;

this.scrollInterval = null;
      this.checkScrollTimeout = null;
      this.lastScrollY = 0;
      this.scrollDirection = 'down';
      this.isScrolling = false;
      this.scrollStartTime = 0;
    }

// 贝塞尔曲线分段滚动 (向下)
    async scrollWithBezier() {
      if (this.scrollInterval !== null) {
        clearInterval(this.scrollInterval);
      }

const startY = window.scrollY;
      const documentHeight = Math.max(document.body.scrollHeight, document.documentElement.scrollHeight);
      const windowHeight = window.innerHeight;
      const pageBottom = documentHeight - windowHeight;

// 检查是否已接近底部
      if (startY >= pageBottom - 10) {
        this.logger.log("已接近页面底部，停止向下滚动", 'info');
        this.statusIndicator.updateStatus('idle');
        return false;
      }

this.isScrolling = true;
      this.scrollStartTime = Date.now();
      this.statusIndicator.updateStatus('scrolling', 0);

// 计算滚动参数
      const segmentDistance = Utils.getRandomInt(
        this.config.get('scrollSegmentDistanceMin'),
        this.config.get('scrollSegmentDistanceMax')
      );
      const targetY = Math.min(startY + segmentDistance, pageBottom);
      const totalDuration = Utils.getRandomInt(
        this.config.get('scrollSegmentDurationMin'),
        this.config.get('scrollSegmentDurationMax')
      );
      const steps = Math.max(20, Math.round(totalDuration / 50));
      const stepDuration = totalDuration / steps;

// 随机贝塞尔控制点
      const p0 = 0, p3 = 1;
      const p1 = Utils.getRandomFloat(this.config.get('bezierP1Min'), this.config.get('bezierP1Max'));
      const p2 = Utils.getRandomFloat(this.config.get('bezierP2Min'), this.config.get('bezierP2Max'));

this.logger.log(`向下滚动: ${Math.round(startY)} → ${Math.round(targetY)} (${Math.round(targetY - startY)}px, ${totalDuration}ms)`, 'action');

let currentStep = 0;

return new Promise((resolve) => {
        this.scrollInterval = setInterval(async () => {
          if (currentStep >= steps) {
            clearInterval(this.scrollInterval);
            this.scrollInterval = null;
            this.isScrolling = false;

window.scrollTo(0, targetY);
            this.statusIndicator.updateStatus('idle');
            this.logger.log("向下滚动完成", 'success');

// 随机触发行为模拟
            if (Math.random() < 0.3) {
              await this.behaviorSimulator.simulatePageInteraction();
            }

resolve(true);
            return;
          }

const t = currentStep / steps;
          const progress = Utils.cubicBezier(t, p0, p1, p2, p3);
          const scrollPosition = startY + (targetY - startY) * progress;

window.scrollTo(0, scrollPosition);

// 更新进度
          const scrollProgress = (currentStep / steps) * 100;
          this.statusIndicator.updateStatus('scrolling', scrollProgress);

currentStep++;

// 随机暂停
          if (Math.random() < this.config.get('randomPauseProbability')) {
            const pauseDuration = Utils.getRandomInt(
              this.config.get('randomPauseDurationMin'),
              this.config.get('randomPauseDurationMax')
            );
            await Utils.sleep(pauseDuration);
          }
        }, stepDuration);
      });
    }

// 贝塞尔曲线分段滚动 (向上)
    async scrollUpWithBezier() {
      if (this.scrollInterval !== null) {
        clearInterval(this.scrollInterval);
      }

const startY = window.scrollY;

// 检查是否已接近顶部
      if (startY <= 10) {
        this.logger.log("已接近页面顶部，停止向上滚动", 'info');
        this.statusIndicator.updateStatus('idle');
        return false;
      }

this.isScrolling = true;
      this.scrollStartTime = Date.now();
      this.statusIndicator.updateStatus('scrolling', 0);

// 计算滚动参数
      const segmentDistance = Utils.getRandomInt(
        this.config.get('scrollSegmentDistanceMin'),
        this.config.get('scrollSegmentDistanceMax')
      );
      const targetY = Math.max(startY - segmentDistance, 0);
      const totalDuration = Utils.getRandomInt(
        this.config.get('scrollSegmentDurationMin'),
        this.config.get('scrollSegmentDurationMax')
      );
      const steps = Math.max(20, Math.round(totalDuration / 50));
      const stepDuration = totalDuration / steps;

this.logger.log(`向上滚动: ${Math.round(startY)} → ${Math.round(targetY)} (${Math.round(startY - targetY)}px, ${totalDuration}ms)`, 'action');

let currentStep = 0;

window.scrollTo(0, targetY);
            this.statusIndicator.updateStatus('idle');
            this.logger.log("向上滚动完成", 'success');

// 随机触发行为模拟
            if (Math.random() < 0.3) {
              await this.behaviorSimulator.simulatePageInteraction();
            }

resolve(true);
            return;
          }

const t = currentStep / steps;
          const progress = Utils.cubicBezier(t, p0, p1, p2, p3);
          const scrollPosition = startY - (startY - targetY) * progress;

window.scrollTo(0, scrollPosition);

// 更新进度
          const scrollProgress = (currentStep / steps) * 100;
          this.statusIndicator.updateStatus('scrolling', scrollProgress);

currentStep++;

// 智能滚动决策
    async performIntelligentScroll() {
      if (this.isScrolling) return false;

const documentHeight = Math.max(document.body.scrollHeight, document.documentElement.scrollHeight);
      const windowHeight = window.innerHeight;
      const currentY = window.scrollY;
      const isAtBottom = currentY + windowHeight >= documentHeight - 10;
      const isAtTop = currentY <= 10;

let scrollSuccess = false;

if (this.scrollDirection === 'down') {
        if (isAtBottom) {
          this.logger.log("到达底部，切换为向上滚动", 'info');
          this.scrollDirection = 'up';
          scrollSuccess = await this.scrollUpWithBezier();
        } else {
          scrollSuccess = await this.scrollWithBezier();
        }
      } else { // scrollDirection === 'up'
        if (isAtTop) {
          this.logger.log("到达顶部，切换为向下滚动", 'info');
          this.scrollDirection = 'down';
          scrollSuccess = await this.scrollWithBezier();
        } else {
          scrollSuccess = await this.scrollUpWithBezier();
        }
      }

return scrollSuccess;
    }

// 停止所有滚动
    stopScrolling() {
      if (this.scrollInterval) {
        clearInterval(this.scrollInterval);
        this.scrollInterval = null;
      }
      if (this.checkScrollTimeout) {
        clearTimeout(this.checkScrollTimeout);
        this.checkScrollTimeout = null;
      }
      this.isScrolling = false;
      this.statusIndicator.updateStatus('idle');
    }

// 检查是否卡住
    isStuck() {
      const currentScrollY = window.scrollY;
      const scrollDelta = Math.abs(currentScrollY - this.lastScrollY);
      const timeSinceLastScroll = Date.now() - this.scrollStartTime;

const isStuck = !this.isScrolling &&
                     scrollDelta < this.config.get('minScrollDelta') &&
                     timeSinceLastScroll > this.config.get('stuckTimeout');

if (!this.isScrolling) {
        this.lastScrollY = currentScrollY;
      }

return isStuck;
    }
  }

// ===== 数据分析类 =====
  class DataAnalyzer {
    constructor(config, logger) {
      this.config = config;
      this.logger = logger;
      this.sessionData = {
        startTime: Date.now(),
        topicsVisited: [],
        scrollEvents: [],
        likeEvents: [],
        errorEvents: [],
        behaviorEvents: []
      };
      this.historicalData = this.loadHistoricalData();
    }

// 加载历史数据
    loadHistoricalData() {
      try {
        const data = GM_getValue('analyticsData', null);
        const parsedData = data ? JSON.parse(data) : {};
        const defaults = {
          totalSessions: 0,
          totalTopicsRead: 0,
          totalLikesGiven: 0,
          totalReadingTime: 0,
          dailyStats: {},
          weeklyStats: {},
          monthlyStats: {},
          topicCategories: {},
          readingPatterns: [],
          efficiencyMetrics: []
        };
        return { ...defaults, ...parsedData };
      } catch (e) {
        return {
          totalSessions: 0,
          totalTopicsRead: 0,
          totalLikesGiven: 0,
          totalReadingTime: 0,
          dailyStats: {},
          weeklyStats: {},
          monthlyStats: {},
          topicCategories: {},
          readingPatterns: [],
          efficiencyMetrics: []
        };
      }
    }

// 保存历史数据
    saveHistoricalData() {
      try {
        GM_setValue('analyticsData', JSON.stringify(this.historicalData));
      } catch (e) {
        this.logger.log('保存分析数据失败', 'error');
      }
    }

// 记录话题访问
    recordTopicVisit(topicId, topicTitle, category, readTime) {
      const visitData = {
        topicId,
        topicTitle,
        category: category || 'unknown',
        readTime,
        timestamp: Date.now(),
        scrollCount: this.sessionData.scrollEvents.length,
        likeGiven: this.sessionData.likeEvents.some(e => e.topicId === topicId)
      };

this.sessionData.topicsVisited.push(visitData);
      this.updateHistoricalStats(visitData);
      this.logger.log(`记录话题访问: ${topicTitle} (${Utils.formatTime(readTime)})`, 'action');
    }

// 记录滚动事件
    recordScrollEvent(direction, distance, duration) {
      const scrollData = {
        direction,
        distance,
        duration,
        timestamp: Date.now(),
        scrollSpeed: distance / duration
      };

this.sessionData.scrollEvents.push(scrollData);
    }

// 记录点赞事件
    recordLikeEvent(topicId, postId) {
      const likeData = {
        topicId,
        postId,
        timestamp: Date.now()
      };

this.sessionData.likeEvents.push(likeData);
      this.historicalData.totalLikesGiven++;
    }

// 记录错误事件
    recordErrorEvent(errorType, errorMessage, context) {
      const errorData = {
        type: errorType,
        message: errorMessage,
        context,
        timestamp: Date.now()
      };

this.sessionData.errorEvents.push(errorData);
    }

// 记录行为事件
    recordBehaviorEvent(behaviorType, details) {
      const behaviorData = {
        type: behaviorType,
        details,
        timestamp: Date.now()
      };

this.sessionData.behaviorEvents.push(behaviorData);
    }

// 更新历史统计
    updateHistoricalStats(visitData) {
      const today = new Date().toISOString().split('T')[0];
      const thisWeek = this.getWeekKey(new Date());
      const thisMonth = new Date().toISOString().substring(0, 7);

// 更新总计
      this.historicalData.totalTopicsRead++;
      this.historicalData.totalReadingTime += visitData.readTime;

// 更新日统计
      if (!this.historicalData.dailyStats[today]) {
        this.historicalData.dailyStats[today] = {
          topicsRead: 0,
          readingTime: 0,
          likesGiven: 0,
          categories: {}
        };
      }
      this.historicalData.dailyStats[today].topicsRead++;
      this.historicalData.dailyStats[today].readingTime += visitData.readTime;

// 更新周统计
      if (!this.historicalData.weeklyStats[thisWeek]) {
        this.historicalData.weeklyStats[thisWeek] = {
          topicsRead: 0,
          readingTime: 0,
          likesGiven: 0
        };
      }
      this.historicalData.weeklyStats[thisWeek].topicsRead++;
      this.historicalData.weeklyStats[thisWeek].readingTime += visitData.readTime;

// 更新月统计
      if (!this.historicalData.monthlyStats[thisMonth]) {
        this.historicalData.monthlyStats[thisMonth] = {
          topicsRead: 0,
          readingTime: 0,
          likesGiven: 0
        };
      }
      this.historicalData.monthlyStats[thisMonth].topicsRead++;
      this.historicalData.monthlyStats[thisMonth].readingTime += visitData.readTime;

// 更新分类统计
      if (!this.historicalData.topicCategories[visitData.category]) {
        this.historicalData.topicCategories[visitData.category] = {
          count: 0,
          totalTime: 0,
          avgTime: 0
        };
      }
      const categoryStats = this.historicalData.topicCategories[visitData.category];
      if (!categoryStats) {
        this.historicalData.topicCategories[visitData.category] = {
          count: 0,
          totalTime: 0,
          avgTime: 0
        };
      }
      categoryStats.count++;
      categoryStats.totalTime += visitData.readTime;
      categoryStats.avgTime = categoryStats.totalTime / categoryStats.count;
    }

// 生成效率报告
    generateEfficiencyReport() {
      const sessionDuration = Date.now() - this.sessionData.startTime;
      const topicsPerHour = (this.sessionData.topicsVisited.length / (sessionDuration / 3600000)).toFixed(2);
      const avgReadTime = this.sessionData.topicsVisited.length > 0
        ? this.sessionData.topicsVisited.reduce((sum, t) => sum + t.readTime, 0) / this.sessionData.topicsVisited.length
        : 0;

const report = {
        session: {
          duration: sessionDuration,
          topicsRead: this.sessionData.topicsVisited.length,
          topicsPerHour: parseFloat(topicsPerHour),
          avgReadTime,
          scrollEvents: this.sessionData.scrollEvents.length,
          likeEvents: this.sessionData.likeEvents.length,
          errorEvents: this.sessionData.errorEvents.length
        },
        historical: {
          totalSessions: this.historicalData.totalSessions,
          totalTopicsRead: this.historicalData.totalTopicsRead,
          totalReadingTime: this.historicalData.totalReadingTime,
          avgTopicsPerSession: this.historicalData.totalSessions > 0
            ? (this.historicalData.totalTopicsRead / this.historicalData.totalSessions).toFixed(2)
            : 0
        },
        trends: this.analyzeTrends(),
        recommendations: this.generateRecommendations()
      };

return report;
    }

// 分析趋势
    analyzeTrends() {
      const recentDays = Object.keys(this.historicalData.dailyStats)
        .sort()
        .slice(-7);

if (recentDays.length < 2) return null;

const firstDay = this.historicalData.dailyStats[recentDays[0]];
      const lastDay = this.historicalData.dailyStats[recentDays[recentDays.length - 1]];

return {
        topicsReadTrend: lastDay.topicsRead - firstDay.topicsRead,
        readingTimeTrend: lastDay.readingTime - firstDay.readingTime,
        period: `${recentDays[0]} 到 ${recentDays[recentDays.length - 1]}`
      };
    }

// 生成建议
    generateRecommendations() {
      const recommendations = [];
      const avgReadTime = this.sessionData.topicsVisited.length > 0
        ? this.sessionData.topicsVisited.reduce((sum, t) => sum + t.readTime, 0) / this.sessionData.topicsVisited.length
        : 0;

if (avgReadTime < 30000) {
        recommendations.push('建议增加每个话题的阅读时间，提高内容理解度');
      }

if (this.sessionData.errorEvents.length > 5) {
        recommendations.push('检测到较多错误，建议检查网络连接或调整配置');
      }

const scrollToReadRatio = this.sessionData.scrollEvents.length / Math.max(this.sessionData.topicsVisited.length, 1);
      if (scrollToReadRatio > 20) {
        recommendations.push('滚动频率较高，建议调整滚动参数以提高效率');
      }

return recommendations;
    }

// 获取周键
    getWeekKey(date) {
      const year = date.getFullYear();
      const week = this.getWeekNumber(date);
      return `${year}-W${week.toString().padStart(2, '0')}`;
    }

// 获取周数
    getWeekNumber(date) {
      const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
      const dayNum = d.getUTCDay() || 7;
      d.setUTCDate(d.getUTCDate() + 4 - dayNum);
      const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
      return Math.ceil((((d - yearStart) / 86400000) + 1) / 7);
    }

// 结束会话
    endSession() {
      this.historicalData.totalSessions++;
      this.saveHistoricalData();

const report = this.generateEfficiencyReport();
      this.logger.log(`会话结束 - 阅读 ${report.session.topicsRead} 个话题，用时 ${Utils.formatTime(report.session.duration)}`, 'success');

return report;
    }

// 导出分析数据
    exportAnalyticsData() {
      const exportData = {
        sessionData: this.sessionData,
        historicalData: this.historicalData,
        report: this.generateEfficiencyReport(),
        exportTime: new Date().toISOString()
      };

const blob = new Blob([JSON.stringify(exportData, null, 2)], {
        type: 'application/json'
      });

const url = URL.createObjectURL(blob);
      const a = document.createElement('a');
      a.href = url;
      a.download = `forum-assistant-analytics-${new Date().toISOString().split('T')[0]}.json`;
      document.body.appendChild(a);
      a.click();
      document.body.removeChild(a);
      URL.revokeObjectURL(url);

this.logger.log('分析数据已导出', 'success');
    }
  }

// ===== 安全和隐私增强类 =====
  class SecurityManager {
    constructor(config, logger) {
      this.config = config;
      this.logger = logger;
      this.userAgents = [
        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36',
        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15'
      ];
      this.proxyList = [];
      this.currentFingerprint = this.generateFingerprint();
    }

// 生成随机指纹
    generateFingerprint() {
      return {
        userAgent: this.getRandomUserAgent(),
        language: this.getRandomLanguage(),
        timezone: this.getRandomTimezone(),
        screen: this.getRandomScreen(),
        colorDepth: this.getRandomColorDepth(),
        platform: this.getRandomPlatform()
      };
    }

// 获取随机User-Agent
    getRandomUserAgent() {
      return this.userAgents[Math.floor(Math.random() * this.userAgents.length)];
    }

// 获取随机语言
    getRandomLanguage() {
      const languages = ['zh-CN', 'zh-TW', 'en-US', 'en-GB', 'ja-JP', 'ko-KR'];
      return languages[Math.floor(Math.random() * languages.length)];
    }

// 获取随机时区
    getRandomTimezone() {
      const timezones = [
        'Asia/Shanghai', 'Asia/Hong_Kong', 'Asia/Taipei',
        'Asia/Tokyo', 'Asia/Seoul', 'America/New_York',
        'Europe/London', 'Australia/Sydney'
      ];
      return timezones[Math.floor(Math.random() * timezones.length)];
    }

// 获取随机屏幕分辨率
    getRandomScreen() {
      const screens = [
        { width: 1920, height: 1080 },
        { width: 1366, height: 768 },
        { width: 1440, height: 900 },
        { width: 1536, height: 864 },
        { width: 2560, height: 1440 }
      ];
      return screens[Math.floor(Math.random() * screens.length)];
    }

// 获取随机颜色深度
    getRandomColorDepth() {
      const depths = [24, 32];
      return depths[Math.floor(Math.random() * depths.length)];
    }

// 获取随机平台
    getRandomPlatform() {
      const platforms = ['Win32', 'MacIntel', 'Linux x86_64'];
      return platforms[Math.floor(Math.random() * platforms.length)];
    }

// 随机化请求头
    randomizeHeaders(baseHeaders = {}) {
      const randomHeaders = {
        'User-Agent': this.currentFingerprint.userAgent,
        'Accept-Language': `${this.currentFingerprint.language},en;q=0.9`,
        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
        'Accept-Encoding': 'gzip, deflate, br',
        'DNT': Math.random() > 0.5 ? '1' : '0',
        'Connection': 'keep-alive',
        'Upgrade-Insecure-Requests': '1',
        'Sec-Fetch-Dest': 'document',
        'Sec-Fetch-Mode': 'navigate',
        'Sec-Fetch-Site': 'none',
        'Cache-Control': Math.random() > 0.5 ? 'no-cache' : 'max-age=0'
      };

// 随机添加一些可选头
      if (Math.random() > 0.7) {
        randomHeaders['Sec-CH-UA'] = this.generateSecChUa();
      }

if (Math.random() > 0.8) {
        randomHeaders['Sec-CH-UA-Mobile'] = '?0';
        randomHeaders['Sec-CH-UA-Platform'] = `"${this.currentFingerprint.platform}"`;
      }

return { ...randomHeaders, ...baseHeaders };
    }

// 生成Sec-CH-UA头
    generateSecChUa() {
      const brands = [
        '"Google Chrome";v="120", "Chromium";v="120", "Not_A Brand";v="99"',
        '"Google Chrome";v="119", "Chromium";v="119", "Not_A Brand";v="99"',
        '"Microsoft Edge";v="120", "Chromium";v="120", "Not_A Brand";v="99"'
      ];
      return brands[Math.floor(Math.random() * brands.length)];
    }

// 增强的fetch请求
    async secureRequest(url, options = {}) {
      if (!this.config.get('enableSafetyFeatures')) {
        return fetch(url, options);
      }

// 随机延迟
      const delay = Utils.getRandomInt(100, 500);
      await Utils.sleep(delay);

// 随机化请求头
      const secureHeaders = this.randomizeHeaders(options.headers || {});

const secureOptions = {
        ...options,
        headers: secureHeaders
      };

// 如果启用代理
      if (this.config.get('proxyEnabled') && this.proxyList.length > 0) {
        // 这里可以添加代理逻辑
        this.logger.log('使用代理发送请求', 'action');
      }

try {
        const response = await fetch(url, secureOptions);

// 记录请求
        this.logger.log(`安全请求: ${url.substring(0, 50)}...`, 'action');

return response;
      } catch (error) {
        this.logger.log(`安全请求失败: ${error.message}`, 'error');
        throw error;
      }
    }

// 行为指纹混淆
    obfuscateBehavior() {
      if (!this.config.get('enableSafetyFeatures')) return;

// 随机改变指纹
      if (Math.random() < 0.1) {
        this.currentFingerprint = this.generateFingerprint();
        this.logger.log('更新行为指纹', 'action');
      }

// 随机添加噪声事件
      this.addNoiseEvents();
    }

// 添加噪声事件
    addNoiseEvents() {
      const noiseEvents = [
        () => this.simulateRandomClick(),
        () => this.simulateRandomKeyPress(),
        () => this.simulateRandomMouseMove(),
        () => this.simulateRandomScroll()
      ];

// 随机执行1-2个噪声事件
      const eventCount = Utils.getRandomInt(1, 2);
      for (let i = 0; i < eventCount; i++) {
        const randomEvent = noiseEvents[Math.floor(Math.random() * noiseEvents.length)];
        setTimeout(randomEvent, Utils.getRandomInt(100, 1000));
      }
    }

// 模拟随机点击
    simulateRandomClick() {
      const x = Math.random() * window.innerWidth;
      const y = Math.random() * window.innerHeight;

const clickEvent = new MouseEvent('click', {
        clientX: x,
        clientY: y,
        bubbles: false // 不冒泡，避免触发实际功能
      });

// 创建一个不可见的元素来接收点击
      const dummyElement = document.createElement('div');
      dummyElement.style.position = 'absolute';
      dummyElement.style.left = x + 'px';
      dummyElement.style.top = y + 'px';
      dummyElement.style.width = '1px';
      dummyElement.style.height = '1px';
      dummyElement.style.opacity = '0';
      dummyElement.style.pointerEvents = 'none';

document.body.appendChild(dummyElement);
      dummyElement.dispatchEvent(clickEvent);

setTimeout(() => {
        document.body.removeChild(dummyElement);
      }, 100);
    }

// 模拟随机按键
    simulateRandomKeyPress() {
      const keys = ['Tab', 'Shift', 'Control', 'Alt'];
      const randomKey = keys[Math.floor(Math.random() * keys.length)];

const keyEvent = new KeyboardEvent('keydown', {
        key: randomKey,
        bubbles: false
      });

document.dispatchEvent(keyEvent);
    }

// 模拟随机鼠标移动
    simulateRandomMouseMove() {
      const x = Math.random() * window.innerWidth;
      const y = Math.random() * window.innerHeight;

const moveEvent = new MouseEvent('mousemove', {
        clientX: x,
        clientY: y,
        bubbles: false
      });

document.dispatchEvent(moveEvent);
    }

// 模拟随机滚动
    simulateRandomScroll() {
      const scrollEvent = new WheelEvent('wheel', {
        deltaY: Utils.getRandomInt(-100, 100),
        bubbles: false
      });

document.dispatchEvent(scrollEvent);
    }

// 检测反爬虫机制
    detectAntiBot() {
      const indicators = [];

// 检测常见的反爬虫脚本
      if (window.navigator.webdriver) {
        indicators.push('webdriver detected');
      }

if (window.chrome && window.chrome.runtime && window.chrome.runtime.onConnect) {
        // 可能是自动化浏览器
        indicators.push('automation detected');
      }

// 检测异常的性能指标
      if (performance.timing) {
        const loadTime = performance.timing.loadEventEnd - performance.timing.navigationStart;
        if (loadTime < 100) {
          indicators.push('suspicious load time');
        }
      }

if (indicators.length > 0) {
        this.logger.log(`检测到反爬虫指标: ${indicators.join(', ')}`, 'warn');
        return true;
      }

return false;
    }

// 启动安全监控
    startSecurityMonitoring() {
      if (!this.config.get('enableSafetyFeatures')) return;

// 定期检测反爬虫
      setInterval(() => {
        if (this.detectAntiBot()) {
          this.obfuscateBehavior();
        }
      }, 30000);

// 定期混淆行为
      setInterval(() => {
        this.obfuscateBehavior();
      }, Utils.getRandomInt(60000, 120000));

this.logger.log('安全监控已启动', 'success');
    }

// 清理痕迹
    cleanupTraces() {
      try {
        // 清理localStorage中的敏感数据
        const sensitiveKeys = ['topicList', 'latestPage', 'clickCounter'];
        sensitiveKeys.forEach(key => {
          if (Math.random() < 0.1) { // 10%概率清理
            localStorage.removeItem(key);
          }
        });

// 清理sessionStorage
        if (Math.random() < 0.05) { // 5%概率清理
          sessionStorage.clear();
        }

this.logger.log('执行痕迹清理', 'action');
      } catch (e) {
        // 忽略清理错误
      }
    }
  }

// ===== 多站点适配器类 =====
  class SiteAdapter {
    constructor(config, logger) {
      this.config = config;
      this.logger = logger;
      this.currentSite = this.detectSite();
      this.siteConfigs = this.initializeSiteConfigs();
    }

// 检测当前站点
    detectSite() {
      const url = window.location.href;
      const hostname = window.location.hostname;

const siteMap = {
        'linux.do': 'linuxdo',
        'meta.discourse.org': 'discourse-meta',
        'meta.appinn.net': 'appinn',
        'community.openai.com': 'openai',
        'nodeloc.cc': 'nodeloc',
        'bbs.tampermonkey.net.cn': 'tampermonkey',
        'greasyfork.org': 'greasyfork'
      };

for (const [domain, siteId] of Object.entries(siteMap)) {
        if (hostname.includes(domain)) {
          this.logger.log(`检测到站点: ${siteId}`, 'info');
          return siteId;
        }
      }

// 尝试检测Discourse论坛
      if (this.isDiscourse()) {
        this.logger.log('检测到Discourse论坛', 'info');
        return 'discourse-generic';
      }

this.logger.log('未知站点类型', 'warn');
      return 'unknown';
    }

// 检测是否为Discourse论坛
    isDiscourse() {
      return !!(
        document.querySelector('meta[name="discourse_theme_ids"]') ||
        document.querySelector('meta[name="discourse_current_homepage"]') ||
        document.querySelector('#discourse-modal') ||
        window.Discourse ||
        document.body.classList.contains('discourse')
      );
    }

// 初始化站点配置
    initializeSiteConfigs() {
      return {
        'linuxdo': {
          name: 'Linux.do',
          type: 'discourse',
          apiEndpoint: '/latest.json',
          topicUrlPattern: '/t/topic/{id}/{post}',
          selectors: {
            likeButton: '.discourse-reactions-reaction-button:not(.my-reaction)',
            topicTitle: '.fancy-title',
            postContent: '.cooked',
            userAvatar: '.avatar',
            replyButton: '.reply'
          },
          features: {
            reactions: true,
            categories: true,
            tags: true,
            privateMessages: true
          },
          limits: {
            maxComments: 1000,
            maxLikes: 50,
            readTimeMin: 45000,
            readTimeMax: 120000
          }
        },

'nodeloc': {
          name: 'NodeLoc',
          type: 'discourse',
          apiEndpoint: '/latest.json',
          topicUrlPattern: '/t/topic/{id}/{post}',
          selectors: {
            likeButton: '.discourse-reactions-reaction-button:not(.my-reaction)',
            topicTitle: '.fancy-title',
            postContent: '.cooked'
          },
          features: {
            reactions: true,
            categories: true
          },
          limits: {
            maxComments: 800,
            maxLikes: 40,
            readTimeMin: 30000,
            readTimeMax: 90000
          }
        },

'discourse-meta': {
          name: 'Discourse Meta',
          type: 'discourse',
          apiEndpoint: '/latest.json',
          topicUrlPattern: '/t/{slug}/{id}/{post}',
          selectors: {
            likeButton: '.like-button:not(.has-like)',
            topicTitle: '.fancy-title',
            postContent: '.cooked'
          },
          features: {
            likes: true,
            categories: true,
            tags: true
          },
          limits: {
            maxComments: 1500,
            maxLikes: 60,
            readTimeMin: 60000,
            readTimeMax: 150000
          }
        },

'greasyfork': {
          name: 'Greasy Fork',
          type: 'custom',
          apiEndpoint: null,
          selectors: {
            scriptLink: 'a[href*="/scripts/"]',
            scriptTitle: '.script-name',
            scriptDescription: '.script-description'
          },
          features: {
            scripts: true,
            reviews: true
          },
          limits: {
            maxScripts: 100,
            readTimeMin: 20000,
            readTimeMax: 60000
          }
        },

'unknown': {
          name: 'Unknown Site',
          type: 'generic',
          apiEndpoint: null,
          selectors: {
            likeButton: '.like, .upvote, [data-action="like"]',
            content: 'article, .post, .content'
          },
          features: {},
          limits: {
            maxComments: 500,
            maxLikes: 20,
            readTimeMin: 30000,
            readTimeMax: 90000
          }
        }
      };
    }

// 获取当前站点配置
    getSiteConfig() {
      return this.siteConfigs[this.currentSite] || this.siteConfigs['unknown'];
    }

// 获取API端点
    getApiEndpoint(endpoint) {
      const siteConfig = this.getSiteConfig();
      const baseUrl = `${window.location.protocol}//${window.location.hostname}`;

switch (endpoint) {
        case 'latest':
          return siteConfig.apiEndpoint ? `${baseUrl}${siteConfig.apiEndpoint}` : null;
        case 'topics':
          return `${baseUrl}/topics.json`;
        case 'categories':
          return `${baseUrl}/categories.json`;
        default:
          return null;
      }
    }

// 构建话题URL
    buildTopicUrl(topicId, postNumber = 1) {
      const siteConfig = this.getSiteConfig();
      const baseUrl = `${window.location.protocol}//${window.location.hostname}`;

if (siteConfig.topicUrlPattern) {
        return `${baseUrl}${siteConfig.topicUrlPattern
          .replace('{id}', topicId)
          .replace('{post}', postNumber)
          .replace('{slug}', 'topic')}`;
      }

return `${baseUrl}/t/${topicId}`;
    }

// 获取选择器
    getSelector(type) {
      const siteConfig = this.getSiteConfig();
      return siteConfig.selectors[type] || null;
    }

// 检查功能支持
    hasFeature(feature) {
      const siteConfig = this.getSiteConfig();
      return siteConfig.features[feature] || false;
    }

// 获取限制配置
    getLimit(type) {
      const siteConfig = this.getSiteConfig();
      return siteConfig.limits[type] || 0;
    }

// 站点特定的话题获取
    async fetchTopics(page = 0) {
      const apiUrl = this.getApiEndpoint('latest');
      if (!apiUrl) {
        this.logger.log('当前站点不支持API获取话题', 'warn');
        return [];
      }

try {
        const url = `${apiUrl}?no_definitions=true&page=${page}`;
        const response = await fetch(url);

if (!response.ok) {
          throw new Error(`HTTP ${response.status}`);
        }

const data = await response.json();
        const topics = data?.topic_list?.topics || [];

// 站点特定的过滤逻辑
        return this.filterTopics(topics);

} catch (error) {
        this.logger.log(`获取话题失败: ${error.message}`, 'error');
        return [];
      }
    }

// 过滤话题
    filterTopics(topics) {
      const maxComments = this.getLimit('maxComments');

return topics.filter(topic => {
        if (!topic || !topic.id) return false;
        if (topic.posts_count > maxComments) return false;
        if (topic.closed || topic.archived) return false;

// 站点特定过滤
        switch (this.currentSite) {
          case 'linuxdo':
            // 过滤掉某些分类
            if (topic.category_id && [1, 2].includes(topic.category_id)) return false;
            break;
          case 'nodeloc':
            // 只保留特定分类
            if (topic.category_id && ![5, 6, 7].includes(topic.category_id)) return false;
            break;
        }

return true;
      });
    }

// 站点特定的点赞逻辑
    async performLike(element) {
      const siteConfig = this.getSiteConfig();

if (!this.hasFeature('reactions') && !this.hasFeature('likes')) {
        return false;
      }

try {
        // 检查元素是否可点击
        if (element.classList.contains('my-reaction') ||
            element.classList.contains('has-like') ||
            element.disabled) {
          return false;
        }

// 模拟点击
        const event = new MouseEvent('click', {
          bubbles: true,
          cancelable: true
        });

element.dispatchEvent(event);

// 等待响应
        await Utils.sleep(Utils.getRandomInt(500, 1500));

return true;

} catch (error) {
        this.logger.log(`点赞失败: ${error.message}`, 'error');
        return false;
      }
    }

// 获取页面信息
    getPageInfo() {
      const siteConfig = this.getSiteConfig();

return {
        site: this.currentSite,
        siteName: siteConfig.name,
        type: siteConfig.type,
        url: window.location.href,
        title: document.title,
        isTopicPage: this.isTopicPage(),
        topicId: this.extractTopicId(),
        hasLikeButtons: this.hasLikeButtons()
      };
    }

// 检查是否为话题页面
    isTopicPage() {
      const patterns = [
        /\/t\/[^/]+\/\d+/,  // Discourse pattern
        /\/topic\/\d+/,     // Generic topic pattern
        /\/thread\/\d+/,    // Forum thread pattern
        /\/scripts\/\d+/    // Greasyfork script pattern
      ];

return patterns.some(pattern => pattern.test(window.location.pathname));
    }

// 提取话题ID
    extractTopicId() {
      const path = window.location.pathname;
      const matches = path.match(/\/(?:t|topic|thread|scripts)\/(?:[^/]+\/)?(\d+)/);
      return matches ? parseInt(matches[1]) : null;
    }

// 检查是否有点赞按钮
    hasLikeButtons() {
      const selector = this.getSelector('likeButton');
      return selector ? document.querySelectorAll(selector).length > 0 : false;
    }
  }

// ===== 主程序类 =====
  class ForumAssistant {
    constructor() {
      this.config = new ConfigManager();
      this.logger = new LogManager(this.config);
      this.statusIndicator = new StatusIndicator(this.config, this.logger);
      this.behaviorSimulator = new BehaviorSimulator(this.config, this.logger, this.statusIndicator);
      this.scrollSystem = new EnhancedScrollSystem(this.config, this.logger, this.statusIndicator, this.behaviorSimulator);
      this.dataAnalyzer = new DataAnalyzer(this.config, this.logger);
      this.securityManager = new SecurityManager(this.config, this.logger);
      this.siteAdapter = new SiteAdapter(this.config, this.logger);
      this.automationEngine = new AutomationEngine(this.config, this.logger, this.siteAdapter);

// UI组件
      this.statsPanel = new StatisticsPanel(this.config, this.logger);
      this.configPanel = new ConfigPanel(this.config, this.logger);
      this.upgradePanel = new UpgradeProgressPanel(this.config, this.logger);
      this.controlPanel = new ControlPanel(this.config, this.logger, this.statsPanel, this.configPanel, this.upgradePanel);

// 状态变量
      this.isRunning = false;
      this.currentTopic = null;
      this.topicStartTime = Date.now();
      this.requiredReadTime = 0;
      this.mainLoop = null;
      this.stuckCheckInterval = null;

this.initialize();
    }

// 初始化
    async initialize() {
      try {
        this.logger.log('智能论坛助手 Pro 初始化中...', 'info');

// 等待DOM完全准备好
        await this.waitForDOM();

// 创建UI (使用延迟确保DOM稳定)
        setTimeout(() => {
          try {
            this.logger.createLogWindow();
            this.statusIndicator.create();
            this.controlPanel.create();

if (this.config.get('showStatistics')) {
              this.statsPanel.show();
            }

// 恢复升级进度窗口状态
            const upgradeProgressVisible = GM_getValue('upgradeProgressVisible', false);
            if (upgradeProgressVisible) {
              this.upgradePanel.show();
            }
          } catch (uiError) {
            console.error('UI创建失败:', uiError);
            this.logger.log(`UI创建失败: ${uiError.message}`, 'error');
          }
        }, 500);

// 启动安全监控
        this.securityManager.startSecurityMonitoring();

// 启动弹窗监控
      this.startPopupMonitoring();

// 启动网络请求监控
      this.startNetworkMonitoring();

// 检查站点兼容性
        const pageInfo = this.siteAdapter.getPageInfo();
        this.logger.log(`当前站点: ${pageInfo.siteName} (${pageInfo.type})`, 'info');

// 恢复运行状态
        const wasRunning = GM_getValue('isReading', false);
        if (wasRunning) {
          await Utils.sleep(2000); // 等待页面完全加载
          this.start();
        }

this.logger.log('初始化完成', 'success');

this.setupNavigationListener();

} catch (error) {
        console.error('初始化错误:', error);
        this.logger.log(`初始化失败: ${error.message}`, 'error');
      }
    }

// 设置导航监听器
    setupNavigationListener() {
        this.lastUrl = window.location.href;

const observer = new MutationObserver(() => {
            const currentUrl = window.location.href;
            if (currentUrl !== this.lastUrl) {
                this.handleUrlChange(currentUrl);
            }
        });

observer.observe(document.body, {
            childList: true,
            subtree: true
        });

window.addEventListener('popstate', () => {
            this.handleUrlChange(window.location.href);
        });

this.logger.log('导航监听器已设置', 'info');
    }

// 处理URL变化
    handleUrlChange(newUrl) {
        const newPath = new URL(newUrl).pathname;
        const oldPath = new URL(this.lastUrl).pathname;

// 只有当pathname的主体部分发生变化时，才认为是真正的导航
        const newPathBase = newPath.split('/').slice(0, 3).join('/');
        const oldPathBase = oldPath.split('/').slice(0, 3).join('/');

if (newPathBase !== oldPathBase) {
            this.logger.log(`URL 路径发生变化: ${newPath}`, 'info');
            this.lastUrl = newUrl;

// 停止当前的活动
            if (this.isRunning) {
                this.stop();
            }

// 延迟后重新启动，以确保页面内容已加载
            setTimeout(() => {
                const pageInfo = this.siteAdapter.getPageInfo();
                if (pageInfo.isTopicPage) {
                    this.start();
                } else {
                    this.navigateToNextTopic();
                }
            }, 2000);
        }
    }

// 等待DOM准备就绪
    async waitForDOM() {
      return new Promise((resolve) => {
        if (document.body && document.head) {
          resolve();
          return;
        }

const observer = new MutationObserver(() => {
          if (document.body && document.head) {
            observer.disconnect();
            resolve();
          }
        });

observer.observe(document.documentElement, {
          childList: true,
          subtree: true
        });

// 超时保护
        setTimeout(() => {
          observer.disconnect();
          resolve();
        }, 5000);
      });
    }

// 开始运行
    async start() {
      if (this.isRunning) return;

this.isRunning = true;
      GM_setValue('isReading', true);

// 安全更新控制面板状态
      try {
        if (this.controlPanel && typeof this.controlPanel.updateButtonStates === 'function') {
          this.controlPanel.updateButtonStates();
        }
      } catch (e) {
        console.error('更新按钮状态失败:', e);
      }

this.logger.log('开始自动阅读', 'success');
      this.statusIndicator.updateStatus('loading');

// 启动行为模拟
      if (this.config.get('enableAdvancedBehavior')) {
        this.behaviorSimulator.start();
      }

// 启动自动化引擎
      if (this.config.get('autoReplyEnabled') || this.config.get('keywordMonitoring')) {
        this.automationEngine.start();
      }

// 开始主循环
      this.startMainLoop();

// 启动卡住检测
      this.startStuckDetection();

// 如果不在话题页面，导航到话题
      const pageInfo = this.siteAdapter.getPageInfo();
      if (!pageInfo.isTopicPage) {
        await this.navigateToNextTopic();
      } else {
        this.startTopicReading();
      }
    }

// 停止运行
    stop() {
      if (!this.isRunning) return;

this.isRunning = false;
      GM_setValue('isReading', false);

this.logger.log('停止自动阅读', 'action');
      this.statusIndicator.updateStatus('idle');

// 停止所有组件
      this.scrollSystem.stopScrolling();
      this.behaviorSimulator.stop();
      this.automationEngine.stop();

// 清理定时器
      if (this.mainLoop) {
        clearTimeout(this.mainLoop);
        this.mainLoop = null;
      }

if (this.stuckCheckInterval) {
        clearInterval(this.stuckCheckInterval);
        this.stuckCheckInterval = null;
      }

// 结束会话分析
      try {
        const report = this.dataAnalyzer.endSession();
        this.logger.log(`会话报告: 阅读${report.session.topicsRead}个话题`, 'info');
      } catch (e) {
        console.error('生成会话报告失败:', e);
      }
    }

// 开始主循环
    startMainLoop() {
      const checkInterval = 3000; // 3秒检查一次

const mainCheck = async () => {
        if (!this.isRunning) return;

try {
          await this.performMainCheck();
        } catch (error) {
          this.logger.log(`主循环错误: ${error.message}`, 'error');
          this.dataAnalyzer.recordErrorEvent('main_loop', error.message, 'main_check');
        }

// 安排下次检查
        this.mainLoop = setTimeout(mainCheck, checkInterval);
      };

mainCheck();
    }

// 执行主要检查
    async performMainCheck() {
      const now = Date.now();
      const readDuration = now - this.topicStartTime;
      const maxIdleTime = Math.max(this.config.get('maxIdleTime'), this.requiredReadTime);

// 检查是否需要切换话题
      if (this.shouldSwitchTopic(readDuration, maxIdleTime)) {
        await this.navigateToNextTopic();
        return;
      }

// 执行滚动
      if (!this.scrollSystem.isScrolling) {
        const scrollSuccess = await this.scrollSystem.performIntelligentScroll();
        if (scrollSuccess) {
          this.dataAnalyzer.recordScrollEvent(
            this.scrollSystem.scrollDirection,
            this.config.get('scrollSegmentDistanceMin'),
            this.config.get('scrollSegmentDurationMin')
          );
        }
      }

// 执行点赞
      if (GM_getValue('autoLikeEnabled', false)) {
        await this.performAutoLike();
      }

// 安全混淆
      if (Math.random() < 0.1) {
        this.securityManager.obfuscateBehavior();
      }
    }

// 判断是否应该切换话题
    shouldSwitchTopic(readDuration, maxIdleTime) {
      const documentHeight = Math.max(document.body.scrollHeight, document.documentElement.scrollHeight);
      const windowHeight = window.innerHeight;
      const currentY = window.scrollY;
      const isAtBottom = currentY + windowHeight >= documentHeight - 10;
      const isAtTop = currentY <= 10;

// 超时切换
      if (readDuration > maxIdleTime) {
        this.logger.log(`阅读超时 (${Utils.formatTime(readDuration)})，切换话题`, 'info');
        return true;
      }

// 达到最小阅读时间且在页面边界
      if (readDuration >= this.requiredReadTime && (isAtBottom || isAtTop)) {
        this.logger.log(`阅读完成 (${Utils.formatTime(readDuration)})，切换话题`, 'info');
        return true;
      }

return false;
    }

// 导航到下一个话题
    async navigateToNextTopic() {
      this.statusIndicator.updateStatus('switching');

try {
        // 记录当前话题的阅读数据
        if (this.currentTopic) {
          const readTime = Date.now() - this.topicStartTime;
          this.dataAnalyzer.recordTopicVisit(
            this.currentTopic.id,
            this.currentTopic.title || document.title,
            this.currentTopic.category,
            readTime
          );
          this.logger.updateStatistics('topicsRead');
        }

// 获取下一个话题
        const nextTopic = await this.getNextTopic();
        if (!nextTopic) {
          this.logger.log('没有更多话题，停止运行', 'warn');
          this.stop();
          return;
        }

// 随机延迟
        const delay = Utils.getRandomInt(
          this.config.get('minTopicChangeDelay'),
          this.config.get('maxTopicChangeDelay')
        );

this.logger.log(`等待 ${Utils.formatTime(delay)} 后切换到话题: ${nextTopic.title || nextTopic.id}`, 'info');
        await Utils.sleep(delay);

// 导航到新话题
        const topicUrl = this.siteAdapter.buildTopicUrl(nextTopic.id, nextTopic.last_read_post_number || 1);

// 在当前标签页中导航
        window.location.href = topicUrl;

} catch (error) {
        this.logger.log(`话题切换失败: ${error.message}`, 'error');
        this.dataAnalyzer.recordErrorEvent('topic_switch', error.message, 'navigation');

// 重试
        setTimeout(() => this.navigateToNextTopic(), 10000);
      }
    }

// 开始话题阅读
    startTopicReading() {
      const pageInfo = this.siteAdapter.getPageInfo();
      this.currentTopic = {
        id: pageInfo.topicId,
        title: pageInfo.title,
        url: pageInfo.url
      };

this.topicStartTime = Date.now();
      this.requiredReadTime = Utils.getRandomInt(
        this.config.get('minReadTimeLower'),
        this.config.get('minReadTimeUpper')
      );

this.scrollSystem.scrollDirection = 'down';
      this.statusIndicator.updateStatus('reading');

this.logger.log(`开始阅读话题: ${this.currentTopic.title} (需要 ${Utils.formatTime(this.requiredReadTime)})`, 'info');
    }

// 获取下一个话题
    async getNextTopic() {
      // 尝试从缓存获取
      let topicList = GM_getValue('topicList', '[]');
      try {
        topicList = JSON.parse(topicList);
      } catch (e) {
        topicList = [];
      }

if (topicList.length === 0) {
        // 获取新话题
        this.logger.log('话题列表为空，获取新话题...', 'info');
        const newTopics = await this.fetchTopics();
        if (newTopics.length === 0) {
          return null;
        }
        topicList = newTopics;
        GM_setValue('topicList', JSON.stringify(topicList));
      }

// 返回第一个话题并从列表中移除
      const nextTopic = topicList.shift();
      GM_setValue('topicList', JSON.stringify(topicList));

return nextTopic;
    }

// 获取话题列表
    async fetchTopics() {
      const topics = [];
      const maxRetries = 3;
      let page = GM_getValue('latestPage', 0);

for (let retry = 0; retry < maxRetries; retry++) {
        try {
          page++;
          const pageTopics = await this.siteAdapter.fetchTopics(page);

if (pageTopics.length > 0) {
            topics.push(...pageTopics);
            GM_setValue('latestPage', page);

if (topics.length >= this.config.get('topicListLimit')) {
              break;
            }
          } else {
            // 没有更多话题，重置页码
            GM_setValue('latestPage', 0);
            break;
          }
        } catch (error) {
          this.logger.log(`获取话题失败 (页面 ${page}): ${error.message}`, 'error');
          await Utils.sleep(1000);
        }
      }

this.logger.log(`获取到 ${topics.length} 个话题`, 'success');
      return topics.slice(0, this.config.get('topicListLimit'));
    }

// 检测是否有弹窗出现
    checkForPopups() {
      // 需要忽略的弹窗类型（信息性弹窗，不应停止点赞）
      const ignoredPopupSelectors = [
        '.user-card',           // 用户信息卡片
        '.user-tooltip',        // 用户提示框
        '.topic-entrance',      // 话题入口
        '.quote-button',        // 引用按钮
        '.post-menu',          // 帖子菜单
        '.dropdown-menu',      // 下拉菜单
        '.autocomplete',       // 自动完成
        '.suggestion-menu',    // 建议菜单
        '.emoji-picker',       // 表情选择器
        '.preview-popup'       // 预览弹窗
      ];

// 需要检测的弹窗选择器（会阻止操作的弹窗）
      const criticalPopupSelectors = [
        '.modal', '.popup', '.dialog', '.overlay',
        '.alert', '.notification', '.toast',
        '[role="dialog"]', '[role="alertdialog"]',
        '.swal2-container', '.sweetalert2-container',
        '.layui-layer', '.layer-shade',
        '.ant-modal', '.el-dialog',
        '.v-dialog', '.q-dialog',
        // NodeLoc 特定的重要弹窗
        '.fancybox-container', '.fancybox-overlay',
        '.ui-dialog', '.ui-widget-overlay',
        '.bootbox', '.confirm-dialog',
        '.error-dialog', '.warning-dialog'
      ];

// 首先检查是否是应该忽略的弹窗
      for (const selector of ignoredPopupSelectors) {
        const popup = document.querySelector(selector);
        if (popup && this.isElementVisible(popup)) {
          // 这是信息性弹窗，不需要停止点赞
          return null;
        }
      }

// 检查关键弹窗
      for (const selector of criticalPopupSelectors) {
        const popup = document.querySelector(selector);
        if (popup && this.isElementVisible(popup)) {
          return popup;
        }
      }

// 检查是否有遮罩层（但排除用户卡片相关的）
      const overlays = document.querySelectorAll('div[style*="position: fixed"], div[style*="position:fixed"]');
      for (const overlay of overlays) {
        // 跳过用户卡片相关的遮罩
        if (overlay.id === 'user-card' ||
            overlay.classList.contains('user-card') ||
            overlay.closest('.user-card')) {
          continue;
        }

const style = getComputedStyle(overlay);
        if (style.zIndex > 1000 &&
            (style.backgroundColor !== 'rgba(0, 0, 0, 0)' ||
             style.background !== 'none')) {
          return overlay;
        }
      }

return null;
    }

// 检查元素是否可见
    isElementVisible(element) {
      if (!element) return false;

const style = getComputedStyle(element);
      return element.style.display !== 'none' &&
             style.display !== 'none' &&
             style.visibility !== 'hidden' &&
             style.opacity !== '0';
    }

// 启动弹窗监控
    startPopupMonitoring() {
      // 使用 MutationObserver 监控 DOM 变化
      const observer = new MutationObserver((mutations) => {
        mutations.forEach((mutation) => {
          mutation.addedNodes.forEach((node) => {
            if (node.nodeType === Node.ELEMENT_NODE) {
              this.checkNewElementForPopup(node);
            }
          });
        });
      });

observer.observe(document.body, {
        childList: true,
        subtree: true
      });

// 定期检查弹窗
      setInterval(() => {
        this.performPopupCheck();
      }, 3000); // 每3秒检查一次

this.logger.log('弹窗监控已启动', 'info');
    }

// 检查新元素是否为弹窗
    checkNewElementForPopup(element) {
      const popupClasses = [
        'modal', 'popup', 'dialog', 'overlay', 'alert', 'notification', 'toast',
        'swal2-container', 'sweetalert2-container', 'layui-layer', 'layer-shade',
        'ant-modal', 'el-dialog', 'v-dialog', 'q-dialog',
        'fancybox-container', 'fancybox-overlay', 'ui-dialog', 'ui-widget-overlay'
      ];

const hasPopupClass = popupClasses.some(className =>
        element.classList && element.classList.contains(className)
      );

const hasPopupRole = element.getAttribute &&
        (element.getAttribute('role') === 'dialog' ||
         element.getAttribute('role') === 'alertdialog');

if (hasPopupClass || hasPopupRole) {
        setTimeout(() => {
          this.handlePopupDetected(element);
        }, 500); // 延迟500ms确保弹窗完全显示
      }
    }

// 定期执行弹窗检查
    performPopupCheck() {
      const popup = this.checkForPopups();
      if (popup) {
        this.handlePopupDetected(popup);
      }
    }

// 处理检测到的弹窗
    handlePopupDetected(popup) {
      const isLikeEnabled = GM_getValue('autoLikeEnabled', false);

if (isLikeEnabled) {
        this.logger.log('🚨 检测到弹窗，自动停止点赞功能', 'warning');
        GM_setValue('autoLikeEnabled', false);

// 更新控制面板按钮状态
        if (this.controlPanel && typeof this.controlPanel.updateButtonStates === 'function') {
          this.controlPanel.updateButtonStates();
        }

// 显示通知
        this.logger.showNotification('检测到弹窗，已自动停止点赞功能', 'warning');

// 记录弹窗信息
        const popupInfo = {
          className: popup.className || '',
          id: popup.id || '',
          tagName: popup.tagName || '',
          timestamp: new Date().toLocaleString()
        };

this.logger.log(`弹窗详情: ${JSON.stringify(popupInfo)}`, 'info');
      }
    }

// 启动网络请求监控
    startNetworkMonitoring() {
      // 监控 XMLHttpRequest
      const originalXHROpen = XMLHttpRequest.prototype.open;
      const originalXHRSend = XMLHttpRequest.prototype.send;

XMLHttpRequest.prototype.open = function(method, url, ...args) {
        this._method = method;
        this._url = url;
        return originalXHROpen.apply(this, [method, url, ...args]);
      };

XMLHttpRequest.prototype.send = function(data) {
        const xhr = this;

// 监听响应
        xhr.addEventListener('readystatechange', () => {
          if (xhr.readyState === 4) {
            this.handleNetworkResponse(xhr._method, xhr._url, xhr.status, xhr.responseText);
          }
        });

return originalXHRSend.apply(this, [data]);
      }.bind(this);

// 监控 fetch 请求
      const originalFetch = window.fetch;
      window.fetch = async function(url, options = {}) {
        const method = options.method || 'GET';

try {
          const response = await originalFetch.apply(this, [url, options]);

// 检查响应
          if (response.status === 429) {
            const responseText = await response.clone().text();
            this.handleNetworkResponse(method, url, response.status, responseText);
          }

return response;
        } catch (error) {
          return Promise.reject(error);
        }
      }.bind(this);

this.logger.log('网络请求监控已启动', 'info');
    }

// 处理网络响应
    handleNetworkResponse(method, url, status, responseText) {
      // 检查是否是点赞相关的请求
      const isLikeRequest = url && (
        url.includes('discourse-reactions') ||
        url.includes('custom-reactions') ||
        url.includes('/like') ||
        url.includes('/heart') ||
        url.includes('/toggle')
      );

if (isLikeRequest && status === 429) {
        this.handleRateLimitError(responseText);
      }
    }

// 处理点赞限制错误
    handleRateLimitError(responseText) {
      try {
        const errorData = JSON.parse(responseText);

if (errorData.errors && errorData.errors.length > 0) {
          const errorMessage = errorData.errors[0];
          const timeLeft = errorData.extras?.time_left || '未知';
          const waitSeconds = errorData.extras?.wait_seconds || 0;

this.logger.log(`🚫 点赞限制触发`, 'error');
          this.logger.log(`📝 限制详情: ${errorMessage}`, 'error');
          this.logger.log(`⏰ 剩余等待时间: ${timeLeft}`, 'warning');

// 计算具体可点赞时间
          if (waitSeconds > 0) {
            const canLikeTimestamp = Date.now() + (waitSeconds * 1000);
            const canLikeTime = new Date(canLikeTimestamp).toLocaleString('zh-CN', {
              year: 'numeric',
              month: '2-digit',
              day: '2-digit',
              hour: '2-digit',
              minute: '2-digit',
              second: '2-digit'
            });
            this.logger.log(`📅 预计可点赞时间: ${canLikeTime}`, 'info');
          }

// 自动停止点赞功能
          GM_setValue('autoLikeEnabled', false);

// 保存限制信息
          const rateLimitInfo = {
            message: errorMessage,
            timeLeft: timeLeft,
            waitSeconds: waitSeconds,
            timestamp: Date.now()
          };
          GM_setValue('rateLimitInfo', rateLimitInfo);

// 更新控制面板状态
          if (this.controlPanel && typeof this.controlPanel.updateButtonStates === 'function') {
            this.controlPanel.updateButtonStates();
          }

// 显示通知
          this.logger.showNotification(`点赞已达限制，需等待 ${timeLeft}`, 'error');

this.logger.log('🛑 已自动停止点赞功能，避免继续触发限制', 'action');

// 显示详细的限制信息摘要
          this.showRateLimitSummary(rateLimitInfo);
        }
      } catch (parseError) {
        this.logger.log('解析限制错误信息失败', 'error');

// 即使解析失败，也要停止点赞
        GM_setValue('autoLikeEnabled', false);
        if (this.controlPanel && typeof this.controlPanel.updateButtonStates === 'function') {
          this.controlPanel.updateButtonStates();
        }
        this.logger.showNotification('检测到点赞限制，已自动停止', 'warning');
      }
    }

// 显示限制信息摘要
    showRateLimitSummary(rateLimitInfo) {
      this.logger.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', 'info');
      this.logger.log('📊 点赞限制信息摘要', 'info');
      this.logger.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', 'info');

const currentTime = new Date().toLocaleString('zh-CN');
      this.logger.log(`🕐 触发时间: ${currentTime}`, 'info');

if (rateLimitInfo.waitSeconds > 0) {
        const canLikeTime = this.getCanLikeTime(rateLimitInfo);
        this.logger.log(`📅 恢复时间: ${canLikeTime}`, 'info');

// 计算具体的小时和分钟
        const hours = Math.floor(rateLimitInfo.waitSeconds / 3600);
        const minutes = Math.floor((rateLimitInfo.waitSeconds % 3600) / 60);

if (hours > 0) {
          this.logger.log(`⏳ 等待时长: ${hours}小时${minutes}分钟`, 'info');
        } else {
          this.logger.log(`⏳ 等待时长: ${minutes}分钟`, 'info');
        }
      }

this.logger.log(`💡 建议: 请在恢复时间后重新启用点赞功能`, 'info');
      this.logger.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', 'info');
    }

// 获取可以点赞的具体时间
    getCanLikeTime(rateLimitInfo) {
      if (!rateLimitInfo || !rateLimitInfo.waitSeconds || !rateLimitInfo.timestamp) {
        return '未知';
      }

const canLikeTimestamp = rateLimitInfo.timestamp + (rateLimitInfo.waitSeconds * 1000);
      const canLikeDate = new Date(canLikeTimestamp);

// 执行自动点赞
    async performAutoLike() {
      if (!this.siteAdapter.hasFeature('reactions') && !this.siteAdapter.hasFeature('likes')) {
        return;
      }

// 检查是否启用了自动点赞
      if (!GM_getValue('autoLikeEnabled', false)) {
        return;
      }

// 检查是否在限制期内
      const rateLimitInfo = GM_getValue('rateLimitInfo', null);
      if (rateLimitInfo && this.controlPanel.isRateLimitActive(rateLimitInfo)) {
        this.logger.log('点赞仍在限制期内，跳过自动点赞', 'warning');
        return;
      }

// 检查是否有弹窗出现
      const popup = this.checkForPopups();
      if (popup) {
        this.logger.log('检测到弹窗，自动停止点赞功能', 'warning');
        GM_setValue('autoLikeEnabled', false);

// 更新控制面板按钮状态
        if (this.controlPanel && typeof this.controlPanel.updateButtonStates === 'function') {
          this.controlPanel.updateButtonStates();
        }

return;
      }

const likeSelector = this.siteAdapter.getSelector('likeButton');
      if (!likeSelector) return;

const likeButtons = document.querySelectorAll(likeSelector);
      const maxLikes = this.siteAdapter.getLimit('maxLikes');
      const currentLikes = GM_getValue('dailyLikeCount', 0);

if (currentLikes >= maxLikes) {
        return;
      }

for (const button of likeButtons) {
        if (currentLikes >= maxLikes) break;

// 在每次点赞前再次检查弹窗
        const popupCheck = this.checkForPopups();
        if (popupCheck) {
          this.logger.log('点赞过程中检测到弹窗，停止点赞', 'warning');
          GM_setValue('autoLikeEnabled', false);

// 更新控制面板按钮状态
          if (this.controlPanel && typeof this.controlPanel.updateButtonStates === 'function') {
            this.controlPanel.updateButtonStates();
          }

break;
        }

const success = await this.siteAdapter.performLike(button);
        if (success) {
          GM_setValue('dailyLikeCount', currentLikes + 1);
          this.dataAnalyzer.recordLikeEvent(this.currentTopic?.id, null);
          this.logger.updateStatistics('likesGiven');
          this.logger.log(`点赞成功 (${currentLikes + 1}/${maxLikes})`, 'success');

// 随机延迟
          await Utils.sleep(Utils.getRandomInt(2000, 5000));
        }
      }
    }

// 启动卡住检测
    startStuckDetection() {
      this.stuckCheckInterval = setInterval(() => {
        if (!this.isRunning) return;

if (this.scrollSystem.isStuck()) {
          this.logger.log('检测到页面卡住，强制切换话题', 'warn');
          this.navigateToNextTopic();
        }
      }, this.config.get('stuckTimeout'));
    }
  }

// ===== 自动化引擎类 =====
  class AutomationEngine {
    constructor(config, logger, siteAdapter) {
      this.config = config;
      this.logger = logger;
      this.siteAdapter = siteAdapter;
      this.isRunning = false;
      this.keywordPatterns = [];
      this.autoReplyTemplates = [];
      this.monitoringInterval = null;
      this.initializeTemplates();
    }

// 初始化模板
    initializeTemplates() {
      this.autoReplyTemplates = [
        {
          trigger: ['谢谢', '感谢', 'thanks', 'thank you'],
          responses: ['不客气！', '很高兴能帮到你！', '互相帮助！', '🤝'],
          weight: 0.3
        },
        {
          trigger: ['问题', '求助', 'help', 'question'],
          responses: ['我来看看能不能帮到你', '这个问题很有意思', '让我想想...', '可以详细说说吗？'],
          weight: 0.2
        },
        {
          trigger: ['好的', '不错', 'good', 'nice', '赞'],
          responses: ['👍', '同感！', '确实如此', '说得对'],
          weight: 0.4
        },
        {
          trigger: ['教程', 'tutorial', '指南', 'guide'],
          responses: ['很实用的教程！', '学到了，感谢分享', '收藏了！', '这个教程很详细'],
          weight: 0.5
        }
      ];

// 加载用户自定义关键词
      const customKeywords = this.config.get('monitorKeywords') || [];
      this.keywordPatterns = customKeywords.map(keyword => ({
        pattern: new RegExp(keyword, 'i'),
        keyword: keyword,
        action: this.config.get('keywordAction') || 'notify'
      }));
    }

// 启动自动化引擎
    start() {
      if (this.isRunning) return;

this.isRunning = true;
      this.logger.log('自动化引擎已启动', 'success');

// 启动关键词监控
      if (this.config.get('keywordMonitoring')) {
        this.startKeywordMonitoring();
      }

// 启动自动回复监控
      if (this.config.get('autoReplyEnabled')) {
        this.startAutoReplyMonitoring();
      }
    }

// 停止自动化引擎
    stop() {
      if (!this.isRunning) return;

this.isRunning = false;
      this.logger.log('自动化引擎已停止', 'action');

if (this.monitoringInterval) {
        clearInterval(this.monitoringInterval);
        this.monitoringInterval = null;
      }
    }

// 启动关键词监控
    startKeywordMonitoring() {
      this.monitoringInterval = setInterval(() => {
        this.scanForKeywords();
      }, 5000); // 每5秒扫描一次

this.logger.log(`关键词监控已启动，监控 ${this.keywordPatterns.length} 个关键词`, 'info');
    }

// 扫描关键词
    scanForKeywords() {
      if (!this.isRunning || this.keywordPatterns.length === 0) return;

// 获取页面文本内容
      const contentSelector = this.siteAdapter.getSelector('postContent') || 'article, .post, .content';
      const contentElements = document.querySelectorAll(contentSelector);

contentElements.forEach((element, index) => {
        // 避免重复扫描
        if (element.dataset.scanned) return;
        element.dataset.scanned = 'true';

const text = element.textContent.toLowerCase();

this.keywordPatterns.forEach(({ pattern, keyword, action }) => {
          if (pattern.test(text)) {
            this.handleKeywordMatch(keyword, action, element, text);
          }
        });
      });
    }

// 处理关键词匹配
    async handleKeywordMatch(keyword, action, element, text) {
      this.logger.log(`检测到关键词: ${keyword}`, 'success');

switch (action) {
        case 'like':
          await this.performAutoLike(element);
          break;
        case 'reply':
          await this.performAutoReply(element, keyword);
          break;
        case 'notify':
          this.showKeywordNotification(keyword, text.substring(0, 100));
          break;
        case 'collect':
          await this.collectPost(element);
          break;
      }
    }

// 执行自动点赞（关键词触发）
    async performAutoLike(element) {
      // 检查是否启用了自动点赞
      if (!GM_getValue('autoLikeEnabled', false)) {
        return;
      }

// 检查是否有弹窗出现
      const popup = this.checkForPopups();
      if (popup) {
        this.logger.log('检测到弹窗，停止关键词触发的点赞', 'warning');
        GM_setValue('autoLikeEnabled', false);

// 更新控制面板按钮状态
        if (this.controlPanel && typeof this.controlPanel.updateButtonStates === 'function') {
          this.controlPanel.updateButtonStates();
        }

return;
      }

const likeButton = element.querySelector(this.siteAdapter.getSelector('likeButton'));
      if (likeButton) {
        const success = await this.siteAdapter.performLike(likeButton);
        if (success) {
          this.logger.log('关键词触发自动点赞', 'success');
        }
      }
    }

// 检测是否有弹窗出现（AutomationEngine版本）
    checkForPopups() {
      // 需要忽略的弹窗类型（信息性弹窗，不应停止点赞）
      const ignoredPopupSelectors = [
        '.user-card',           // 用户信息卡片
        '.user-tooltip',        // 用户提示框
        '.topic-entrance',      // 话题入口
        '.quote-button',        // 引用按钮
        '.post-menu',          // 帖子菜单
        '.dropdown-menu',      // 下拉菜单
        '.autocomplete',       // 自动完成
        '.suggestion-menu',    // 建议菜单
        '.emoji-picker',       // 表情选择器
        '.preview-popup'       // 预览弹窗
      ];

return null;
    }

// 检查元素是否可见
    isElementVisible(element) {
      if (!element) return false;

// 执行自动回复
    async performAutoReply(element, keyword) {
      if (!this.siteAdapter.hasFeature('replies')) return;

const replyButton = element.querySelector(this.siteAdapter.getSelector('replyButton'));
      if (!replyButton) return;

// 生成回复内容
      const replyContent = this.generateReplyContent(keyword);
      if (!replyContent) return;

try {
        // 点击回复按钮
        replyButton.click();

// 等待回复框出现
        await Utils.sleep(1000);

// 查找回复输入框
        const replyInput = document.querySelector('textarea[placeholder*="回复"], .reply-area textarea, .composer-input');
        if (replyInput) {
          // 模拟输入
          await this.simulateTyping(replyInput, replyContent);

// 查找发送按钮
          const sendButton = document.querySelector('.btn-primary[title*="发送"], .submit-reply, .create');
          if (sendButton && !sendButton.disabled) {
            // 随机延迟后发送
            await Utils.sleep(Utils.getRandomInt(2000, 5000));
            sendButton.click();

this.logger.log(`自动回复: ${replyContent}`, 'success');
          }
        }
      } catch (error) {
        this.logger.log(`自动回复失败: ${error.message}`, 'error');
      }
    }

// 生成回复内容
    generateReplyContent(keyword) {
      const matchingTemplates = this.autoReplyTemplates.filter(template =>
        template.trigger.some(trigger => keyword.toLowerCase().includes(trigger.toLowerCase()))
      );

if (matchingTemplates.length === 0) {
        // 使用通用回复
        const genericReplies = ['👍', '有道理', '学习了', '感谢分享'];
        return genericReplies[Math.floor(Math.random() * genericReplies.length)];
      }

// 根据权重选择模板
      const totalWeight = matchingTemplates.reduce((sum, t) => sum + t.weight, 0);
      let random = Math.random() * totalWeight;

for (const template of matchingTemplates) {
        random -= template.weight;
        if (random <= 0) {
          const responses = template.responses;
          return responses[Math.floor(Math.random() * responses.length)];
        }
      }

return null;
    }

// 模拟打字
    async simulateTyping(input, text) {
      input.focus();
      input.value = '';

// 逐字符输入
      for (let i = 0; i < text.length; i++) {
        input.value += text[i];

// 触发输入事件
        const inputEvent = new Event('input', { bubbles: true });
        input.dispatchEvent(inputEvent);

// 随机延迟
        await Utils.sleep(Utils.getRandomInt(50, 150));
      }

// 触发最终事件
      const changeEvent = new Event('change', { bubbles: true });
      input.dispatchEvent(changeEvent);
    }

// 显示关键词通知
    showKeywordNotification(keyword, context) {
      if (typeof GM_notification !== 'undefined') {
        GM_notification({
          text: `检测到关键词: ${keyword}\n${context}...`,
          title: '智能论坛助手',
          timeout: 5000,
          onclick: () => {
            window.focus();
          }
        });
      }
    }

// 收藏帖子
    async collectPost(element) {
      // 查找收藏按钮
      const bookmarkButton = element.querySelector('.bookmark, [title*="收藏"], [data-action="bookmark"]');
      if (bookmarkButton && !bookmarkButton.classList.contains('bookmarked')) {
        bookmarkButton.click();
        this.logger.log('自动收藏帖子', 'success');
        await Utils.sleep(1000);
      }
    }

// 启动自动回复监控
    startAutoReplyMonitoring() {
      // 监控新帖子
      const observer = new MutationObserver((mutations) => {
        mutations.forEach((mutation) => {
          mutation.addedNodes.forEach((node) => {
            if (node.nodeType === Node.ELEMENT_NODE) {
              this.scanNewContent(node);
            }
          });
        });
      });

observer.observe(document.body, {
        childList: true,
        subtree: true
      });

this.logger.log('自动回复监控已启动', 'info');
    }

// 扫描新内容
    scanNewContent(element) {
      if (!this.isRunning) return;

// 检查是否为帖子内容
      const postSelectors = ['.post', '.topic-post', '.cooked', 'article'];
      const isPost = postSelectors.some(selector =>
        element.matches && element.matches(selector)
      );

if (isPost) {
        const text = element.textContent.toLowerCase();

// 检查是否应该自动回复
        const shouldReply = this.autoReplyTemplates.some(template =>
          template.trigger.some(trigger => text.includes(trigger.toLowerCase()))
        );

if (shouldReply && Math.random() < 0.3) { // 30%概率回复
          setTimeout(() => {
            this.performAutoReply(element, text);
          }, Utils.getRandomInt(5000, 15000)); // 5-15秒后回复
        }
      }
    }

// 智能互动
    async performSmartInteraction() {
      const interactions = [
        () => this.likeRandomPosts(),
        () => this.followInterestingUsers(),
        () => this.bookmarkUsefulContent(),
        () => this.shareContent()
      ];

const randomInteraction = interactions[Math.floor(Math.random() * interactions.length)];
      await randomInteraction();
    }

// 点赞随机帖子
    async likeRandomPosts() {
      // 检查是否启用了自动点赞
      if (!GM_getValue('autoLikeEnabled', false)) {
        return;
      }

// 检查是否有弹窗出现
      const popup = this.checkForPopups();
      if (popup) {
        this.logger.log('检测到弹窗，停止随机点赞', 'warning');
        GM_setValue('autoLikeEnabled', false);

// 更新控制面板按钮状态
        if (this.controlPanel && typeof this.controlPanel.updateButtonStates === 'function') {
          this.controlPanel.updateButtonStates();
        }

return;
      }

const likeButtons = document.querySelectorAll(this.siteAdapter.getSelector('likeButton'));
      const maxLikes = Math.min(3, likeButtons.length);

for (let i = 0; i < maxLikes; i++) {
        // 在每次点赞前检查弹窗
        const popupCheck = this.checkForPopups();
        if (popupCheck) {
          this.logger.log('随机点赞过程中检测到弹窗，停止点赞', 'warning');
          GM_setValue('autoLikeEnabled', false);

// 更新控制面板按钮状态
          if (this.controlPanel && typeof this.controlPanel.updateButtonStates === 'function') {
            this.controlPanel.updateButtonStates();
          }

break;
        }

const randomButton = likeButtons[Math.floor(Math.random() * likeButtons.length)];
        if (randomButton) {
          await this.siteAdapter.performLike(randomButton);
          await Utils.sleep(Utils.getRandomInt(2000, 5000));
        }
      }
    }

// 关注有趣的用户
    async followInterestingUsers() {
      const userLinks = document.querySelectorAll('a[href*="/u/"], .user-link');
      if (userLinks.length > 0 && Math.random() < 0.1) { // 10%概率
        const randomUser = userLinks[Math.floor(Math.random() * userLinks.length)];
        // 这里可以添加关注逻辑
        this.logger.log('发现有趣用户', 'info');
      }
    }

// 收藏有用内容
    async bookmarkUsefulContent() {
      const usefulKeywords = ['教程', '指南', '技巧', 'tutorial', 'guide', 'tip'];
      const posts = document.querySelectorAll('.post, .topic-post');

posts.forEach(async (post) => {
        const text = post.textContent.toLowerCase();
        const isUseful = usefulKeywords.some(keyword => text.includes(keyword));

if (isUseful && Math.random() < 0.2) { // 20%概率收藏
          await this.collectPost(post);
        }
      });
    }

// 分享内容
    async shareContent() {
      // 查找分享按钮
      const shareButtons = document.querySelectorAll('.share, [title*="分享"], [data-action="share"]');
      if (shareButtons.length > 0 && Math.random() < 0.05) { // 5%概率分享
        const randomShare = shareButtons[Math.floor(Math.random() * shareButtons.length)];
        randomShare.click();
        this.logger.log('分享有趣内容', 'action');
      }
    }
  }

// ===== 每日任务管理器 =====
  class DailyTaskManager {
    constructor(config, logger, forumAssistant) {
      this.config = config;
      this.logger = logger;
      this.forumAssistant = forumAssistant;
      this.checkInterval = null;
    }

// 启动每日任务检查
    start() {
      // 立即检查一次
      this.checkDailyTasks();

// 每分钟检查一次
      this.checkInterval = setInterval(() => {
        this.checkDailyTasks();
      }, 60000);

this.logger.log('每日任务管理器已启动', 'info');
    }

// 停止每日任务检查
    stop() {
      if (this.checkInterval) {
        clearInterval(this.checkInterval);
        this.checkInterval = null;
      }
    }

// 检查每日任务
    checkDailyTasks() {
      const now = new Date();
      const today = now.toISOString().split('T')[0];
      const lastRunDate = GM_getValue('dailyTaskLastRunDate', '');

// 检查是否为新的一天
      if (lastRunDate !== today) {
        this.resetDailyCounters();
        GM_setValue('dailyTaskLastRunDate', today);
      }

// 检查是否在自动启动时间范围内 (00:10-00:15)
      if (now.getHours() === 0 && now.getMinutes() >= 10 && now.getMinutes() < 15) {
        const autoStarted = GM_getValue('autoStartedToday', false);
        if (!autoStarted) {
          this.performDailyAutoStart();
          GM_setValue('autoStartedToday', true);
        }
      }

// 重置自动启动标志（在非启动时间）
      if (now.getHours() !== 0 || now.getMinutes() < 10 || now.getMinutes() >= 15) {
        GM_setValue('autoStartedToday', false);
      }
    }

// 重置每日计数器
    resetDailyCounters() {
      GM_setValue('dailyLikeCount', 0);
      GM_setValue('dailyTopicsRead', 0);
      GM_setValue('dailyErrors', 0);

this.logger.log('每日计数器已重置', 'action');
    }

// 执行每日自动启动
    performDailyAutoStart() {
      this.logger.log('执行每日自动启动任务', 'success');

try {
        // 启用自动点赞
        GM_setValue('autoLikeEnabled', true);

// 启动论坛助手
        if (!this.forumAssistant.isRunning) {
          setTimeout(() => {
            this.forumAssistant.start();
          }, Utils.getRandomInt(5000, 15000)); // 5-15秒后启动
        }

this.logger.log('每日自动启动完成', 'success');

} catch (error) {
        this.logger.log(`每日自动启动失败: ${error.message}`, 'error');
      }
    }

// 获取每日统计
    getDailyStats() {
      return {
        likesGiven: GM_getValue('dailyLikeCount', 0),
        topicsRead: GM_getValue('dailyTopicsRead', 0),
        errors: GM_getValue('dailyErrors', 0),
        date: new Date().toISOString().split('T')[0]
      };
    }
  }

// ===== 全局变量和初始化 =====
  let forumAssistant = null;
  let dailyTaskManager = null;

// ===== 安全检查函数 =====
  function safeElementAccess(element, property, defaultValue = null) {
    try {
      if (!element || typeof element !== 'object') return defaultValue;
      return element[property] || defaultValue;
    } catch (e) {
      console.warn('安全访问元素属性失败:', e);
      return defaultValue;
    }
  }

// ===== 主初始化函数 =====
  function initializeForumAssistant() {
    // 防止重复初始化
    if (window.forumAssistantInitialized) {
      console.log('智能论坛助手已经初始化，跳过重复初始化');
      return;
    }

try {
      console.log('开始初始化智能论坛助手 Pro...');

// 检查必要的API
      if (typeof GM_getValue === 'undefined') {
        console.warn('GM_getValue 不可用，使用 localStorage 作为备用');
        window.GM_getValue = (key, defaultValue) => {
          try {
            const value = localStorage.getItem('gm_' + key);
            return value !== null ? JSON.parse(value) : defaultValue;
          } catch (e) {
            return defaultValue;
          }
        };
        window.GM_setValue = (key, value) => {
          try {
            localStorage.setItem('gm_' + key, JSON.stringify(value));
          } catch (e) {
            console.error('存储失败:', e);
          }
        };
        window.GM_deleteValue = (key) => {
          try {
            localStorage.removeItem('gm_' + key);
          } catch (e) {
            console.error('删除失败:', e);
          }
        };
        window.GM_listValues = () => {
          try {
            return Object.keys(localStorage).filter(key => key.startsWith('gm_')).map(key => key.substring(3));
          } catch (e) {
            return [];
          }
        };
      }

// 创建主程序实例
      forumAssistant = new ForumAssistant();

// 创建每日任务管理器
      dailyTaskManager = new DailyTaskManager(
        forumAssistant.config,
        forumAssistant.logger,
        forumAssistant
      );

// 启动每日任务管理器
      dailyTaskManager.start();

// 绑定全局事件
      bindGlobalEvents();

// 将实例暴露到全局，供控制面板调用
      window.forumAssistant = forumAssistant;

// 标记初始化完成
      window.forumAssistantInitialized = true;

console.log('智能论坛助手 Pro 初始化完成');

} catch (error) {
      console.error('智能论坛助手初始化失败:', error);

// 显示错误通知
      if (typeof GM_notification !== 'undefined') {
        GM_notification({
          text: `初始化失败: ${error.message}`,
          title: '智能论坛助手',
          timeout: 5000
        });
      } else {
        // 备用通知方式
        setTimeout(() => {
          alert(`智能论坛助手初始化失败: ${error.message}`);
        }, 1000);
      }
    }
  }

// ===== 绑定全局事件 =====
  function bindGlobalEvents() {
    // 页面卸载时保存数据
    window.addEventListener('beforeunload', () => {
      if (forumAssistant && forumAssistant.isRunning) {
        forumAssistant.dataAnalyzer.endSession();
      }
    });

// 页面可见性变化
    document.addEventListener('visibilitychange', () => {
      if (document.hidden) {
        // 页面隐藏时暂停某些功能
        if (forumAssistant) {
          forumAssistant.behaviorSimulator.stop();
        }
      } else {
        // 页面显示时恢复功能
        if (forumAssistant && forumAssistant.isRunning) {
          forumAssistant.behaviorSimulator.start();
        }
      }
    });

// 键盘快捷键
    document.addEventListener('keydown', (e) => {
      // Ctrl+Shift+F: 开启/关闭论坛助手
      if (e.ctrlKey && e.shiftKey && e.key === 'F') {
        e.preventDefault();
        if (forumAssistant) {
          if (forumAssistant.isRunning) {
            forumAssistant.stop();
          } else {
            forumAssistant.start();
          }
        }
      }

// Ctrl+Shift+C: 打开配置面板
      if (e.ctrlKey && e.shiftKey && e.key === 'C') {
        e.preventDefault();
        if (forumAssistant) {
          forumAssistant.configPanel.toggle();
        }
      }

// Ctrl+Shift+S: 显示/隐藏统计面板
      if (e.ctrlKey && e.shiftKey && e.key === 'S') {
        e.preventDefault();
        if (forumAssistant) {
          forumAssistant.statsPanel.toggle();
        }
      }
    });

// 错误处理
    window.addEventListener('error', (e) => {
      try {
        console.error('全局错误捕获:', e.message, e.filename, e.lineno);
        if (forumAssistant && forumAssistant.logger) {
          forumAssistant.logger.log(`全局错误: ${e.message} (${e.filename}:${e.lineno})`, 'error');
          if (forumAssistant.dataAnalyzer) {
            forumAssistant.dataAnalyzer.recordErrorEvent('global', e.message, e.filename);
          }
        }
      } catch (err) {
        console.error('错误处理器本身出错:', err);
      }
    });

// 未处理的Promise拒绝
    window.addEventListener('unhandledrejection', (e) => {
      try {
        console.error('未处理的Promise拒绝:', e.reason);
        if (forumAssistant && forumAssistant.logger) {
          forumAssistant.logger.log(`未处理的Promise拒绝: ${e.reason}`, 'error');
          if (forumAssistant.dataAnalyzer) {
            forumAssistant.dataAnalyzer.recordErrorEvent('promise', e.reason, 'unhandled_rejection');
          }
        }
        // 防止控制台错误
        e.preventDefault();
      } catch (err) {
        console.error('Promise拒绝处理器出错:', err);
      }
    });
  }

// ===== 脚本启动 =====

// 安全启动函数
  function safeInitialize() {
    try {
      // 检查环境
      if (typeof document === 'undefined') {
        console.error('document 对象不可用');
        return;
      }

// 检查是否在支持的页面
      const supportedDomains = ['linux.do', 'meta.discourse.org', 'meta.appinn.net', 'community.openai.com', 'nodeloc.cc', 'bbs.tampermonkey.net.cn', 'greasyfork.org'];
      const currentDomain = window.location.hostname;
      const isSupported = supportedDomains.some(domain => currentDomain.includes(domain));

if (!isSupported) {
        console.log('当前域名不在支持列表中:', currentDomain);
        // 仍然尝试初始化，可能是新的Discourse站点
      }

console.log('开始安全初始化...');
      initializeForumAssistant();

} catch (error) {
      console.error('安全初始化失败:', error);
      // 延迟重试
      setTimeout(() => {
        console.log('尝试重新初始化...');
        initializeForumAssistant();
      }, 3000);
    }
  }

// 多种启动方式确保脚本能够运行
  if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', safeInitialize);
  } else if (document.readyState === 'interactive' || document.readyState === 'complete') {
    // DOM已经加载完成，立即初始化
    setTimeout(safeInitialize, 100);
  }

// 备用启动方式1（window.load事件）
  window.addEventListener('load', () => {
    if (!window.forumAssistantInitialized) {
      console.log('备用启动方式1触发 (window.load)');
      setTimeout(safeInitialize, 1000);
    }
  });

// 备用启动方式2（延迟启动）
  setTimeout(() => {
    if (!window.forumAssistantInitialized) {
      console.log('备用启动方式2触发 (延迟启动)');
      safeInitialize();
    }
  }, 5000);

// 备用启动方式3（用户交互后启动）
  const interactionEvents = ['click', 'scroll', 'keydown'];
  const startOnInteraction = () => {
    if (!window.forumAssistantInitialized) {
      console.log('备用启动方式3触发 (用户交互)');
      safeInitialize();
      // 移除事件监听器
      interactionEvents.forEach(event => {
        document.removeEventListener(event, startOnInteraction);
      });
    }
  };

interactionEvents.forEach(event => {
    document.addEventListener(event, startOnInteraction, { once: true, passive: true });
  });

})();

```

最后修改：2025 年 07 月 06 日

如果觉得我的文章对你有用，请随意赞赏

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

评论 *

私密评论

名称 *

🎲

邮箱 *

地址

在nodeloc.cc上的帖子使用,让chrome浏览器自动向下滑动刷时间

wszx01 • 2025 年 06 月 08 日