// ==UserScript==
// @name         Yande.re 大图预览 显示艺术家 打开原图
// @version      1.6
// @description  Yande.re浏览增强：悬停大图预览，显示艺术家名称,点击跳转主页,右键名称可标记艺术家显示不同颜色,支持双击/键盘翻页,自动显示隐藏图片,替换分辨率标签直接打开原图按钮,显示上传时间
// @description  原脚本已数年未更新,在原作者Joker(Streams)的基础上修改;  konachan有限支持,部分功能可能无法使用
// @author       Cylirix
// @author       Joker
// @author       Streams
// @match        https://yande.re/*
// @icon         https://yande.re/favicon.ico
// @grant        GM_getValue
// @grant        GM_setValue
// @grant        GM_registerMenuCommand
// @namespace https://greasyfork.org/users/467741
// @downloadURL https://update.greasyfork.icu/scripts/545994/Yandere%20%E5%A4%A7%E5%9B%BE%E9%A2%84%E8%A7%88%20%E6%98%BE%E7%A4%BA%E8%89%BA%E6%9C%AF%E5%AE%B6%20%E6%89%93%E5%BC%80%E5%8E%9F%E5%9B%BE.user.js
// @updateURL https://update.greasyfork.icu/scripts/545994/Yandere%20%E5%A4%A7%E5%9B%BE%E9%A2%84%E8%A7%88%20%E6%98%BE%E7%A4%BA%E8%89%BA%E6%9C%AF%E5%AE%B6%20%E6%89%93%E5%BC%80%E5%8E%9F%E5%9B%BE.meta.js
// ==/UserScript==

//const ENABLE_PREVIEW_DEBUG = false;
const ENABLE_PREVIEW_DEBUG = true;

jQuery.noConflict();
jQuery(function ($) {
    // 全局唯一标识系统
    var currentUUID = null;
    var requestController = null;
    var hoverTimer = null;
    var currentHoverItem = null;
    const CACHE_DAYS = 365; // ←←← 这里改缓存时间（天数），7=一周，14=两周，30=一个月
    // 搜索 限制缓存数量 可修改,默认5000条

    // 添加时间显示设置
    var showUploadTime = true; // 默认显示

    var artistStates = {};

    // 用于存储当前页面 script 标签中直接包含的数据
    var pageData = {
        posts: {},
        tagTypes: {}
    };

    function parsePageScriptData() {
        $('script:not([src])').each(function() {
            var content = $(this).html();
            if (!content) return;

            // --- 情况 A: 列表页 Post.register({...}) ---
            var postRegex = /Post\.register\(\s*(\{.*?\})\s*\)/g;
            var match;
            while ((match = postRegex.exec(content)) !== null) {
                try {
                    var postObj = JSON.parse(match[1]);
                    if (postObj && postObj.id) pageData.posts[postObj.id] = postObj;
                } catch (e) {}
            }

            // --- 情况 B: Pool页/图集页 Post.register_resp({...}) ---
            // 匹配 Post.register_resp({ ... });
            var respMatch = content.match(/Post\.register_resp\(\s*(\{.*?\})\s*\);/);
            if (respMatch && respMatch[1]) {
                try {
                    var respData = JSON.parse(respMatch[1]);

                    // 1. 提取标签字典
                    if (respData.tags) {
                        Object.assign(pageData.tagTypes, respData.tags);
                    }

                    // 2. 提取帖子数组
                    if (respData.posts && Array.isArray(respData.posts)) {
                        respData.posts.forEach(function(post) {
                            pageData.posts[post.id] = post;
                        });
                    }
                } catch (e) {
                    console.error("Pool页数据解析失败:", e);
                }
            }

            // --- 提取 Post.register_tags (补充) ---
            var tagsMatch = content.match(/Post\.register_tags\(\s*(\{.*?\})\s*\);/);
            if (tagsMatch && tagsMatch[1]) {
                try {
                    Object.assign(pageData.tagTypes, JSON.parse(tagsMatch[1]));
                } catch (e) {}
            }
        });

        if (ENABLE_PREVIEW_DEBUG) {
            console.log(`[Page Data] 解析完成: ${Object.keys(pageData.posts).length} 帖子`);
        }
    }

    // 立即运行解析
    parsePageScriptData();

    // 从Tampermonkey存储加载数据
    try {
        const savedStates = GM_getValue("artistStates", "{}");
        artistStates = JSON.parse(savedStates);

        // 加载时间显示设置，默认true
        showUploadTime = GM_getValue("showUploadTime", true);
    } catch (e) {
        console.error("Error loading artist states:", e);
    }

    // 右键菜单容器
    const $contextMenu = $('<div id="artist-context-menu">').css({
        position: 'fixed',
        display: 'none',
        background: 'rgba(0,0,0,0.7)',
        borderRadius: '6px',
        zIndex: 10000,
        padding: '5px 5px'
    }).appendTo('body');

    // 状态配置 - 使用字母a、b、c作为ID
    const stateConfig = [
        {id: 'a', text: '已收藏', color: '#ffff00'},
        {id: 'b', text: '已下载', color: '#00ff11'},
        {id: 'c', text: 'ignore', color: '#999'},
        {id: 'clear', text: '清除', color: '#fff'}
    ];

    // 创建菜单项
    stateConfig.forEach(option => {
        $('<div class="menu-item">')
            .text(option.text)
            .css({
            padding: '5px 15px',
            cursor: 'pointer',
            color: option.color,
            fontSize: '12px'
        })
            .data('action', option.id)
            .hover(
            function() { $(this).css('background', '#444'); },
            function() { $(this).css('background', 'transparent'); }
        )
            .appendTo($contextMenu);
    });

    // 预览框容器
    var $zoombox = $('<div id="zoombox">').css({
        position: 'fixed',
        top: 0,
        left: 0,
        'z-index': 9999,
        'pointer-events': 'none',
        display: 'none',
        'overflow': 'hidden',
        'transition': 'width 0.3s, height 0.3s'
    }).appendTo('body');

    // 添加全局样式
    function addGlobalStyle(css) {
        $('<style></style>').html(css).appendTo('head');
    }

    // 动态生成状态样式
    let stateStyles = '';
    stateConfig.forEach(state => {
        if (state.id !== 'clear') {
            // 为每个状态生成链接样式
            stateStyles += `
                .artist-label a.status-${state.id} {
                    color: ${state.color} !important;
                }
            `;

            // 特殊状态样式
            if (state.id === 'c') {
                stateStyles += `
                    .artist-label a.status-c {
                        text-decoration: line-through;
                    }
                `;
            }
        }
    });

    addGlobalStyle(`
        /* 主预览框样式 */
        #zoombox {
            max-width: 100%;
            max-height: 100%;
            border-radius: 4px;
        }

        /* 预览图内部样式 */
        #zoombox img {
            display: block;
            pointer-events: none;
            object-fit: contain;
            transition: opacity 0.3s;
            border-radius: 4px;
        }

        /* 图片容器 */
        .inner {
            position: relative;
        }

        /* 控制容器 - 右上角 */
        .control-box {
            position: absolute;
            top: 0px;
            right: 0px;
            z-index: 1000;
            pointer-events: none;
            text-align: right;
            max-width: 80%;  /* 限制最大宽度 */
            font-size: 11px; /* 统一字体大小 */
            line-height: 1.2;
            display: flex;         /* 使用flex布局 */
            flex-direction: column; /* 垂直排列元素 */
            align-items: flex-end;  /* 内容右对齐 */
        }

        /* 艺术家标签 - 多行显示 */
        .artist-label {
            background: rgba(0,0,0,0.3);
            color: white; /* 默认文字颜色 */
            padding: 2px 5px;
            border-radius: 3px;
            font-weight: bold;
            white-space: normal;   /* 允许多行显示 */
            word-break: break-word; /* 长单词换行 */
            pointer-events: auto;
            margin-bottom: 2px;   /* 与下方按钮间距 */
            max-width: 100%;      /* 宽度限制 */
            text-align: left;     /* 内部文本左对齐 */
            cursor: context-menu; /* 显示右键菜单光标 */
        }

        /* unknown状态特殊样式 */
        .artist-label.unknown {
            color: #aaa !important; /* 更灰暗的颜色 */
            font-style: italic; /* 添加斜体效果 */
        }

        /* 艺术家状态样式 */
        ${stateStyles}

        /* 艺术家链接样式 */
        .artist-label a {
            color: inherit; /* 继承父元素颜色 */
            text-decoration: none;
        }
        .artist-label a:hover {
            text-decoration: underline;
        }

        /* 右键菜单样式 */
        #artist-context-menu {
            font-family: Arial, sans-serif;
        }
        .menu-item {
            transition: background 0.5s;
        }
        /* === 默认显示分辨率 === */
        #post-list-posts li a.directlink span.directlink-info {
            display: none !important;
        }
        #post-list-posts li a.directlink span.directlink-res {
            display: inline !important;
        }

        #post-list-posts li a.directlink.original-link:hover span.directlink-res {
            color: #ff5555 !important; /* 悬停时变为红色 */
        }

        /* 上传时间样式 */
        .time-label {
            position: absolute;
            bottom: 5px;
            right: 5px;
            color: rgba(255, 255, 255, 1);
            font-size: 9px;
            font-style: italic; /* 斜体 */
            text-decoration: none; /* 无下划线 */
            pointer-events: none; /* 不阻挡鼠标点击 */
            z-index: 1001;
            text-shadow: 0 0 5px #000; /* 加一点阴影防止在浅色图上看不清 */
        }
    `);


    // 翻页功能
    function addKey() {
        $(document).dblclick(function (e) {
            var w = document.documentElement.offsetWidth || document.body.offsetWidth;
            if (e.clientX > w / 2) nextPage();
            else previousPage();
        });
        $(document).keydown(function (e) {
            if (e.keyCode == 37) previousPage();
            else if (e.keyCode == 39) nextPage();
        });
        function nextPage() {
            var $nextBtn = $('a.next_page');
            if ($nextBtn.length > 0) $nextBtn[0].click();
        }
        function previousPage() {
            var $preBtn = $('a.previous_page');
            if ($preBtn.length > 0) $preBtn[0].click();
        }
    }

    // 生成唯一标识符
    function generateUUID() {
        return Date.now().toString(36) + Math.random().toString(36).substr(2);
    }


    function setupContextMenu() {
        // 右键点击事件
        $(document).on('contextmenu', '.artist-label a', function(e) {
            e.preventDefault();

            const artistName = $(this).text().trim();
            if (!artistName || artistName === 'unknown') return;

            // === 直接使用视口坐标 ===
            const x = e.clientX;
            const y = e.clientY;

            // 显示菜单
            $contextMenu
                .data('artist', artistName)
                .css({
                display: 'block',
                left: x + 'px',
                top: y + 'px'
            });

            // === 添加边界检查 ===
            setTimeout(() => {
                const menuRect = $contextMenu[0].getBoundingClientRect();
                const windowWidth = window.innerWidth;
                const windowHeight = window.innerHeight;

                let adjustedX = x;
                let adjustedY = y;

                // 检查右边界
                if (menuRect.right > windowWidth) {
                    adjustedX = windowWidth - menuRect.width - 10;
                }

                // 检查下边界
                if (menuRect.bottom > windowHeight) {
                    adjustedY = windowHeight - menuRect.height - 10;
                }

                // 如果需要调整位置
                if (adjustedX !== x || adjustedY !== y) {
                    $contextMenu.css({
                        left: adjustedX + 'px',
                        top: adjustedY + 'px'
                    });
                }
            }, 0);
        });

        // 菜单项点击事件
        $contextMenu.on('click', '.menu-item', function() {
            const action = $(this).data('action');
            const artistName = $contextMenu.data('artist');

            if (action === 'clear') {
                // 清除标记
                delete artistStates[artistName];
            } else {
                // 设置状态
                artistStates[artistName] = action;
            }

            // 保存到Tampermonkey存储
            GM_setValue("artistStates", JSON.stringify(artistStates));

            // 更新所有该艺术家的标签
            $(`.artist-label a:contains('${artistName}')`).each(function() {
                const $link = $(this);

                // 清除所有状态类
                stateConfig.forEach(state => {
                    if (state.id !== 'clear') {
                        $link.removeClass(`status-${state.id}`);
                    }
                });

                // 添加新状态类
                if (action !== 'clear' && artistStates[artistName]) {
                    $link.addClass(`status-${artistStates[artistName]}`);
                }
            });

            // 隐藏菜单
            $contextMenu.hide();
        });

        // 点击其他地方关闭菜单
        $(document).on('click', function(e) {
            if (!$(e.target).closest('#artist-context-menu').length) {
                $contextMenu.hide();
            }
        });

    }

    // ==================== 【新增：本地缓存系统】 ====================

    const CACHE_KEY = "postDataCache";       // 缓存总键名


    // 获取缓存（带过期检查）
    function getCachedPost(postId) {
        try {
            const allCache = JSON.parse(GM_getValue(CACHE_KEY, "{}"));
            const item = allCache[postId];
            if (!item) return null;

            const now = Math.floor(Date.now() / 1000);

            // 检查是否过期
            if (now - item.timestamp < CACHE_DAYS * 24 * 60 * 60) {
                // 检查数据是否包含created_at字段（兼容老旧缓存）
                if (item.data && item.data.created_at === undefined) {
                    // 老旧缓存，缺少时间字段，删除它并返回null（触发重新获取）
                    console.log(`[Cache] 老旧缓存缺少时间字段，删除并重新获取: ${postId}`);
                    delete allCache[postId];
                    GM_setValue(CACHE_KEY, JSON.stringify(allCache));
                    return null;
                }
                return item.data;
            } else {
                // 已过期，删除旧数据
                delete allCache[postId];
                GM_setValue(CACHE_KEY, JSON.stringify(allCache));
                return null;
            }
        } catch (e) {
            console.error("Cache read error:", e);
            return null;
        }
    }

    function setCachedPost(postId, postData, artists) {
        try {
            const allCache = JSON.parse(GM_getValue(CACHE_KEY, "{}"));
            allCache[postId] = {
                timestamp: Math.floor(Date.now() / 1000),
                data: {
                    file_url: postData.file_url,
                    artists: artists,
                    created_at: postData.created_at // 【新增】添加时间字段到缓存
                }
            };
            // 限制缓存数量 5000 条，防止无限增长
            const keys = Object.keys(allCache);
            if (keys.length > 5000) {
                const sorted = keys.sort((a, b) => allCache[a].timestamp - allCache[b].timestamp);
                for (let i = 0; i < 1000; i++) {
                    delete allCache[sorted[i]];
                }
            }
            GM_setValue(CACHE_KEY, JSON.stringify(allCache));
        } catch (e) {
            console.error("Cache write error:", e);
        }
    }

    // 预览逻辑
    function addMouseZoomPreview() {
        // 全局状态管理
        const processedIds = new Set(); // 已完成的ID
        const fetchingIds = new Set();  // 正在请求的ID
        const queue = []; // 等待处理的队列
        const log = ENABLE_PREVIEW_DEBUG ? console.log.bind(console) : () => {};

        // === 改造后的 fetchPostData：优先读页面JS -> 读缓存 -> 请求API ===
        function fetchPostData($item, $inner, postId) {
            // 注意：这里不要先创建 controlBox，交给 renderPostInfo 统一处理
            // 只需要确保 $inner 存在即可

            // ===========================================
            // 策略 1: 检查当前页面 JS 数据
            // ===========================================
            if (pageData.posts[postId]) {
                const post = pageData.posts[postId];

                // 处理标签
                let artists = post.artists;
                if (!artists) {
                    const tagString = post.tags || "";
                    if (typeof tagString === 'string') {
                        const tagList = tagString.split(/\s+/);
                        artists = tagList.filter(tag => pageData.tagTypes[tag] === 'artist');
                    } else {
                        artists = [];
                    }
                    post.artists = artists;
                }

                // 【修复点1】这里传入 $inner，而不是 $controlBox
                renderPostInfo($item.find('.inner'), post);
                processedIds.add(postId);
                return;
            }

            // ===========================================
            // 策略 2: 查缓存
            // ===========================================
            const cached = getCachedPost(postId);
            if (cached) {
                renderPostInfo($inner, {
                    file_url: cached.file_url,
                    artists: cached.artists,
                    created_at: cached.created_at // 确保缓存读取时也尝试读取时间
                });
                processedIds.add(postId);
                return;
            }

            // ===========================================
            // 策略 3: API 请求 (Wiki页/Pool页主要走这里)
            // ===========================================
            if (fetchingIds.has(postId)) return;
            fetchingIds.add(postId);

            // log(`[API Request] postId: ${postId}`); // 调试用

            $.get(`/post.json?api_version=2&include_tags=1&tags=id:${postId}`, function(data) {
                if (data.posts && data.posts.length > 0) {
                    const post = data.posts[0];
                    const tagTypes = data.tags || {};
                    const tags = post.tags.split(' ');
                    const artists = tags.filter(tag => tagTypes[tag] === 'artist');

                    // 构造数据对象
                    const postData = {
                        file_url: post.file_url,
                        artists: artists,
                        created_at: post.created_at // 【修复点3】API返回的数据里包含 created_at
                    };

                    // 写入缓存 (把时间也存进去)
                    setCachedPost(postId, post, artists); // 注意：setCachedPost 函数也需要微调以存储 created_at，或者只依赖 render 时的实时数据

                    // 【修复点4】这里必须传入 $inner
                    renderPostInfo($inner, postData);
                    processedIds.add(postId);
                }
            }).always(function() {
                fetchingIds.delete(postId);
            });
        }

        // 渲染函数：处理艺术家和时间
        function renderPostInfo($container, post) {
            if (!$container || $container.length === 0) return;

            // 找到或创建控制容器
            let $controlBox = $container.find('.control-box');
            if ($controlBox.length === 0) {
                $controlBox = $('<div class="control-box"></div>');
                $container.append($controlBox);
            }

            // --- 1. 添加时间标签（右下角）---
            $container.find('.time-label').remove();

            if (showUploadTime && post.created_at) {
                const date = new Date(post.created_at * 1000);
                const timeStr = date.toLocaleString('zh-CN', {
                    hour12: false,
                    year: 'numeric',
                    month: '2-digit',
                    day: '2-digit',
                    hour: '2-digit',
                    minute: '2-digit'
                });

                const $timeLabel = $('<span class="time-label"></span>').text(timeStr);
                $container.append($timeLabel); // 直接添加到容器，不在control-box内
            }

            // --- 2. 修改分辨率标签为原图链接 ---
            const $directLink = $container.closest('li').find('a.directlink.largeimg');

            if ($directLink.length > 0 && post.file_url) {
                const originalUrl = post.file_url;
                $directLink.attr('href', originalUrl);
                $directLink.addClass('original-link');

                const $resSpan = $directLink.find('.directlink-res');
                const originalText = $resSpan.text();

                $directLink.hover(
                    function() {
                        $resSpan.text('原图: ' + originalText);
                        $directLink.attr('title', '单击打开原图,中键在新标签打开 ');
                    },
                    function() {
                        $resSpan.text(originalText);
                        $directLink.removeAttr('title');
                    }
                );
            }

            // --- 3. 更新艺术家标签 ---
            $controlBox.find('.artist-label').remove();

            const artists = post.artists || [];
            const $artistLabel = $('<div class="artist-label"></div>');

            if (artists.length === 0) {
                $artistLabel.addClass('unknown').text('unknown');
            } else {
                artists.forEach((artistName) => {
                    const $artistLine = $('<div class="artist-line"></div>');
                    const $artistLink = $(`<a href="/post?tags=${encodeURIComponent(artistName)}" target="_blank"></a>`).text(artistName);
                    if (artistStates[artistName]) {
                        $artistLink.addClass(`status-${artistStates[artistName]}`);
                    }
                    $artistLine.append($artistLink);
                    $artistLabel.append($artistLine);
                });
            }
            $controlBox.append($artistLabel);
        }

        // === 辅助函数：猜测 Sample URL (保持秒开预览) ===
        function guessSampleUrl($item, isYandere, isKonachan) {
            let sampleUrl = null;
            const $thumbLink = $item.find('a.thumb');
            const href = $thumbLink.attr('href');

            // 逻辑复用原脚本的猜测部分
            if ($thumbLink.length) {
                const thumbSrc = $thumbLink.find('img').attr('src');
                if (thumbSrc) {
                    // 尝试提取MD5
                    let md5 = null;
                    // 处理不同域名的缩略图格式
                    const md5Match = thumbSrc.match(/\/data\/preview\/([a-f0-9]{32})\.jpg/) || thumbSrc.match(/\/([a-f0-9]{32})\/yande\.re/); // 简单匹配
                    if(!md5) md5 = thumbSrc.split('/').pop().split('.')[0]; // 粗暴匹配

                    if (md5 && md5.length === 32) { // 确保是md5
                        const postId = $item.data('id') || href.match(/\/post\/show\/(\d+)/)[1];
                        if (isYandere) {
                            sampleUrl = `https://files.yande.re/sample/${md5}/yande.re%20${postId}%20sample.jpg`;
                        } else if (isKonachan) {
                            sampleUrl = `https://${window.location.hostname}/sample/${md5}.jpg`;
                        }
                    }
                }
            }

            // 备用方案：Directlink
            if (!sampleUrl) {
                const $directLink = $item.find('a[class*="directlink"]');
                if ($directLink.length) {
                    let url = $directLink.attr('href');
                    if (url && isKonachan) {
                        if (url.includes('/image/')) sampleUrl = url.replace('/image/', '/sample/');
                    }
                }
            }
            return sampleUrl;
        }

        // === 初始化：收集页面元素 ===
        $("#post-list-posts > li, .pool-show .inner").each(function() {
            const $item = $(this);
            const $inner = $item.find('.inner');
            if ($inner.length === 0) return;

            // 获取 ID
            let postId = $item.data('id');
            if (!postId) {
                const href = $inner.find('a.thumb').attr('href');
                const match = href && href.match(/\/post\/show\/(\d+)/);
                if (match) postId = match[1];
            }

            if (postId) {
                // ===============================================
                // 【修改点】 极速模式：检查页面内置数据
                // ===============================================
                if (pageData.posts[postId]) {
                    const post = pageData.posts[postId];

                    // 处理艺术家 (从字符串tags转换)
                    let artists = post.artists; // 如果已经处理过
                    if (!artists) {
                        const tagString = post.tags || "";
                        // 判断是否是对象(API返回)还是字符串(页面JS)
                        if (typeof tagString === 'string') {
                            const tagList = tagString.split(/\s+/);
                            artists = tagList.filter(tag => pageData.tagTypes[tag] === 'artist');
                        } else {
                            artists = [];
                        }
                        // 保存回去以免重复计算
                        post.artists = artists;
                    }

                    // 1. 直接渲染 (无延迟，立即显示时间、艺术家、原图按钮)
                    // 注意：这里传入 $inner 而不是 $controlBox
                    renderPostInfo($inner, { // <--- 传入 $inner
                        file_url: post.file_url,
                        artists: artists,
                        created_at: post.created_at // <--- 记得把时间传进去
                    });
                    // 2. 标记已处理，不再进入 API 队列
                    processedIds.add(postId);

                } else {
                    // 页面内没找到数据 (可能是 /wiki 页等)，加入队列等待后台处理
                    queue.push({ $item, $inner, postId });
                }

                // === 绑定悬停事件 (保持不变) ===
                const $thumbImg = $item.find('img.preview');
                const currentDomain = window.location.hostname;
                const isYandere = currentDomain.includes('yande.re');
                const isKonachan = currentDomain.includes('konachan');
                const cachedSampleUrl = guessSampleUrl($item, isYandere, isKonachan);

                $item.hover(
                    function (e) {
                        currentHoverItem = this;
                        if (hoverTimer) clearTimeout(hoverTimer);
                        hoverTimer = setTimeout(() => {
                            if (currentHoverItem !== this) return;
                            if (cachedSampleUrl) showZoomBox(cachedSampleUrl, $thumbImg, e);

                            // 即使有页面数据，这里保留 fetchPostData 调用作为保险
                            // 因为 fetchPostData 内部有 if (processedIds.has(postId)) return; 检查
                            // 所以不会重复请求，非常安全
                            if (!processedIds.has(postId)) {
                                fetchPostData($item, $inner, postId);
                            }
                        }, 100);
                    },
                    function () {
                        if (hoverTimer) clearTimeout(hoverTimer);
                        hoverTimer = null;
                        currentHoverItem = null;
                        if (requestController) {
                            requestController.abort();
                            requestController = null;
                        }
                        $zoombox.hide().empty();
                    }
                );
            }
        });

        // 先同步处理所有缓存命中的项
        let i = 0;
        while (i < queue.length) {
            const task = queue[i];
            const cached = getCachedPost(task.postId);
            if (cached) {
                log(`[Cache Hit] postId: ${task.postId}`);  // 在这里也添加日志
                renderPostInfo(task.$inner, {
                    file_url: cached.file_url,
                    artists: cached.artists,
                    created_at: cached.created_at // 【新增】传递时间字段
                });
                processedIds.add(task.postId);
                queue.splice(i, 1); // 移除，不进入后台队列
            } else {
                i++;
            }
        }

        // === 后台处理循环 ===
        // 每 550ms 处理队列中的一个，防止 API 速率限制
        // 如果用户鼠标悬停触发了 fetchPostData，processedIds 会更新，这里就会自动跳过
        function processQueueLoop() {
            if (queue.length > 0) {
                // 寻找下一个未处理的项目
                // 简单的 shift() 可能会取到已经由鼠标触发过的项目，所以要检查
                while (queue.length > 0) {
                    const task = queue.shift(); // 取出第一个
                    if (!processedIds.has(task.postId) && !fetchingIds.has(task.postId)) {
                        // 只有未处理的才请求
                        fetchPostData(task.$item, task.$inner, task.postId);
                        break; // 本次循环只发起一个请求
                    }
                    // 如果已处理，while循环继续，直接扔掉这个task取下一个
                }
            }
            // 无限循环，保持心跳
            setTimeout(processQueueLoop, 550);
        }

        // 启动后台循环
        processQueueLoop();

        // === 独立的显示大图函数 ===
        function showZoomBox(initialUrl, $thumbImg, e) {
            if (requestController) requestController.abort();
            const thisUUID = generateUUID();
            currentUUID = thisUUID;
            requestController = new AbortController();

            const postId = $thumbImg.closest('li, .inner').parent().data('id') ||
                  $thumbImg.closest('a.thumb').attr('href')?.match(/\/post\/show\/(\d+)/)?.[1] ||
                  'unknown';

            // 统一debug开关（只判断一次，性能几乎为0）
            const log = ENABLE_PREVIEW_DEBUG ? console.log.bind(console) : () => {};
            const warn = ENABLE_PREVIEW_DEBUG ? console.warn.bind(console) : () => {};
            const error = ENABLE_PREVIEW_DEBUG ? console.error.bind(console) : () => {};

            const thumbWidth = $thumbImg.width();
            const thumbHeight = $thumbImg.height();
            const aspectRatio = thumbWidth / thumbHeight;
            const screenWidth = $(window).width();
            const screenHeight = $(window).height();
            const isVertical = aspectRatio <= 1;

            let initWidth, initHeight;
            if (isVertical) {
                initHeight = screenHeight;
                initWidth = initHeight * aspectRatio;
            } else {
                initWidth = Math.min(screenWidth * 0.5, screenHeight * aspectRatio);
                initHeight = initWidth / aspectRatio;
            }

            const mouseX = e.clientX;
            let posCSS = (mouseX < screenWidth / 2) ? { right: '10px', left: 'auto' } : { left: '10px', right: 'auto' };

            $zoombox.css({
                top: '5px',
                width: initWidth + 'px',
                height: initHeight + 'px',
                ...posCSS
            });

            const $imgContainer = $('<div>').css({
                position: 'relative', overflow: 'hidden', width: '100%', height: '100%'
            });
            const $img = $('<img>').css({
                opacity: 1, width: '100%', height: '100%'
            });

            $imgContainer.append($img);
            $zoombox.empty().append($imgContainer).show();

            requestController.signal.addEventListener('abort', () => {
                if (currentUUID !== thisUUID) return;
                $zoombox.hide().empty();
            });

            $img.attr('src', initialUrl);

            // 成功加载时，打印当前真实src
            $img.on('load', function() {
                if (currentUUID !== thisUUID) return;
                log(`预览成功 [ID:${postId}] 实际加载链接: ${this.src}`);

                const natW = this.naturalWidth;
                const natH = this.naturalHeight;
                const realRatio = natW / natH;
                const isRealVertical = realRatio <= 1;

                if (isRealVertical) {
                    const fH = screenHeight;
                    const fW = fH * realRatio;
                    $zoombox.css({ width: fW + 'px', height: fH + 'px' });
                } else {
                    const fW = screenWidth * 0.5;
                    const fH = fW / realRatio;
                    $zoombox.css({ width: fW + 'px', height: fH + 'px' });
                }
            });

            // 失败时 fallback 并记录新链接
            $img.on('error', function() {
                if (currentUUID !== thisUUID) return;

                warn(`预览失败 [ID:${postId}] Sample链接失效: ${initialUrl}`);

                let fallbackUrl = $(currentHoverItem).find('.original-btn').attr('href');
                if (!fallbackUrl) {
                    fallbackUrl = $(currentHoverItem).find('a.directlink').attr('href');
                }

                if (fallbackUrl) {
                    log(`使用原图fallback [ID:${postId}] 新链接: ${fallbackUrl}`);
                    $(this).off('error');
                    $(this).attr('src', fallbackUrl);
                } else {
                    error(`预览彻底失败 [ID:${postId}] 无可用fallback链接`);
                    $zoombox.hide().empty();
                }
            });
        }
    }

    // 显示隐藏图片
    function showHiddenImage() {
        $("#post-list-posts > li.javascript-hide").removeClass("javascript-hide");
    }

    // 独立函数：禁止图片气泡消息（移除title属性）
    function disableImageTooltips() {
        // 针对列表页的图片缩略图移除title属性
        $("#post-list-posts img.preview[title]").removeAttr("title");
        // 如果有其他可能的图片元素，可以在这里扩展选择器
    }

    // 初始化操作
    $(document).ready(function() {
        setTimeout(function() {
            showHiddenImage();
            addKey();
            addMouseZoomPreview();
            setupContextMenu(); // 初始化右键菜单功能
            disableImageTooltips(); // 禁止气泡消息
        }, 500);

        // 添加Tampermonkey菜单：清除API缓存
        GM_registerMenuCommand("清除API缓存 (不影响艺术家状态)", function() {
            if (confirm("原图链接与艺术家名称会缓存起来,防止频繁调用API \n确定要清除所有API缓存吗？下次加载会重新请求API \n这不会清除艺术家标记状态")) {
                GM_setValue(CACHE_KEY, "{}");
                alert("API缓存已清除，刷新页面后生效");
            }
        });

        // 添加Tampermonkey菜单：切换上传时间显示
        GM_registerMenuCommand("切换上传时间显示 (当前: " + (showUploadTime ? "显示" : "隐藏") + ")", function() {
            showUploadTime = !showUploadTime;
            GM_setValue("showUploadTime", showUploadTime);

            // 立即更新当前页面上的时间标签
            if (showUploadTime) {
                // 显示所有时间标签
                alert("上传时间显示已开启！\n刷新页面显示上传时间。");
            } else {
                // 隐藏所有时间标签
                $('.time-label').remove();
                alert("上传时间显示已隐藏！");
            }
        });
    });
});