goods_user文本复制工具

文本复制器

// ==UserScript==
// @name         PDD Ctrl+F式商品匹配（终极修复版）-2026-02-18
// @namespace    http://tampermonkey.net/
// @version      2025-11-28
// @description  完全修复移动端滚动停止问题
// @match        https://mobile.yangkeduo.com/a*
// @match        https://mobile.yangkeduo.com/b*
// @match        https://mobile.yangkeduo.com/c*
// @match        https://mobile.yangkeduo.com/d*
// @match        https://mobile.yangkeduo.com/e*
// @match        https://mobile.yangkeduo.com/f*
// @match        https://mobile.yangkeduo.com/q*
// @match        https://mobile.yangkeduo.com/w*
// @match        https://mobile.yangkeduo.com/r*
// @match        https://mobile.yangkeduo.com/t*
// @match        https://mobile.yangkeduo.com/y*
// @match        https://mobile.yangkeduo.com/u*
// @match        https://mobile.yangkeduo.com/i*
// @match        https://mobile.yangkeduo.com/o*
// @match        https://mobile.yangkeduo.com/p*
// @match        https://mobile.yangkeduo.com/s*
// @match        https://mobile.yangkeduo.com/h*
// @match        https://mobile.yangkeduo.com/j*
// @match        https://mobile.yangkeduo.com/k*
// @match        https://mobile.yangkeduo.com/l*
// @match        https://mobile.yangkeduo.com/z*
// @match        https://mobile.yangkeduo.com/x*
// @match        https://mobile.yangkeduo.com/v*
// @match        https://mobile.yangkeduo.com/n*
// @match        https://mobile.yangkeduo.com/m*
// @match        https://mobile.yangkeduo.com/garden_*

// @match        https://mobile.yangkeduo.com/Q*
// @match        https://mobile.yangkeduo.com/W*
// @match        https://mobile.yangkeduo.com/E*
// @match        https://mobile.yangkeduo.com/R*
// @match        https://mobile.yangkeduo.com/T*
// @match        https://mobile.yangkeduo.com/Y*
// @match        https://mobile.yangkeduo.com/U*
// @match        https://mobile.yangkeduo.com/I*
// @match        https://mobile.yangkeduo.com/O*
// @match        https://mobile.yangkeduo.com/P*
// @match        https://mobile.yangkeduo.com/A*
// @match        https://mobile.yangkeduo.com/S*
// @match        https://mobile.yangkeduo.com/D*
// @match        https://mobile.yangkeduo.com/F*
// @match        https://mobile.yangkeduo.com/H*
// @match        https://mobile.yangkeduo.com/J*
// @match        https://mobile.yangkeduo.com/K*
// @match        https://mobile.yangkeduo.com/L*
// @match        https://mobile.yangkeduo.com/Z*
// @match        https://mobile.yangkeduo.com/X*
// @match        https://mobile.yangkeduo.com/C*
// @match        https://mobile.yangkeduo.com/V*
// @match        https://mobile.yangkeduo.com/B*
// @match        https://mobile.yangkeduo.com/N*
// @match        https://mobile.yangkeduo.com/M*
// @noframes     
// @inject-into  page          ← 新增这一行，强制单环境
// @icon         https://www.google.com/s2/favicons?sz=64&domain=yangkeduo.com
// @grant        none
// @run-at       document-end
// ==/UserScript==

(function() {
    'use strict';

// ========== 🛡️ 万能防御：同URL只执行一次，切换URL自动重置 ==========
    const SESSION_KEY = 'PDD_LAST_EXEC_URL';
    const currentUrl = window.location.href;
    
    // 从 sessionStorage 读取上次执行的URL
    const lastUrl = sessionStorage.getItem(SESSION_KEY);
    
    // 如果当前URL与上次执行URL相同，说明是二次注入 → 拦截
    if (lastUrl === currentUrl) {
        console.warn('⛔ 拦截同一URL的重复注入（Service Worker 合成文档）');
        return;
    }
    
    // 否则（新URL或首次执行）→ 记录当前URL，放行
    sessionStorage.setItem(SESSION_KEY, currentUrl);
    // =================================================================

// ========== 可选：额外拦截初始空文档（增强保护）==========
    if (document.URL === 'about:blank') {
        console.warn('⛔ 拦截初始空文档注入');
        return;
    }
    // =======================================================

// ====================================================================
    console.log('🔍 PDD Ctrl+F式商品匹配系统启动（终极修复版）');

// ==================== 全局状态管理 ====================
    const STATE = {
        jsonSendState: {
            lastSendTime: 0,
            lastContentHash: null,
            isScrolling: false,
            scrollTimer: null
        },

socketState: {
            socket: null,
            isConnecting: false,
            reconnectCount: 0,
            isDestroyed: false,
            currentProducts: [],
            processedProducts: [],
            searchState: {}
        },

matchState: {
            isMatching: false,
            productIndex: 0,
            searchPosition: 0,
            products: [],
            searcher: null,
            matchHistory: [],
            hasReceivedProducts: false,
            matchedElement: null,
            isAutoStarted: false,
            scrollLock: false,
            stopScrollFlag: true,
            scrollControllers: [],
            isMakingDecision: false,
            isProcessingWebSocket: false,
            isProcessingAutoStart: false,
            lastScrollStopTime: 0, // 记录上次停止时间
            scrollStartAttempts: 0, // 滚动启动尝试次数
            maxScrollStartAttempts: 3 // 最大启动尝试次数
        },

// 独立的滚动控制器
        scrollController: {
            // 滚动状态
            isRunning: false,
            isStopping: false, // 是否正在停止
            direction: 'down',
            distance: 300,
            interval: 2000,
            attempts: 0,
            maxAttempts: 500,

// 定时器
            intervalId: null,
            timeoutIds: [], // 存储所有timeout ID

// 移动端特殊控制
            touchHandlers: [],
            scrollLockElements: [],

// 性能控制
            lastScrollTime: 0,
            minScrollInterval: 500, // 最小滚动间隔

// 停止控制
            stopRequested: false,
            stopCallbacks: []
        },

firstInteraction: {
            hasProducts: false,
            firstProductCount: 0,
            hasMatchedAll: false,
            highMatchFound: false,
            needContinueScroll: false,
            lastMatchCount: 0
        }
    };

// ==================== 滚动控制核心函数 ====================
    // 清除所有定时器和事件处理器
    function clearAllTimersAndHandlers() {
        console.log('⏰ 清除所有定时器和处理器');

// 1. 清除所有interval
        if (STATE.scrollController.intervalId) {
            clearInterval(STATE.scrollController.intervalId);
            STATE.scrollController.intervalId = null;
        }

// 2. 清除所有timeout
        STATE.scrollController.timeoutIds.forEach(timeoutId => {
            clearTimeout(timeoutId);
        });
        STATE.scrollController.timeoutIds = [];

// 3. 清除JSON发送定时器
        if (STATE.jsonSendState.scrollTimer) {
            clearTimeout(STATE.jsonSendState.scrollTimer);
            STATE.jsonSendState.scrollTimer = null;
        }

// 4. 清除所有触摸事件处理器
        STATE.scrollController.touchHandlers.forEach(handlerInfo => {
            try {
                handlerInfo.element.removeEventListener(handlerInfo.type, handlerInfo.handler);
            } catch (e) {}
        });
        STATE.scrollController.touchHandlers = [];

// 5. 恢复滚动锁定元素的样式
        STATE.scrollController.scrollLockElements.forEach(element => {
            element.style.overflow = '';
            element.style.touchAction = '';
        });
        STATE.scrollController.scrollLockElements = [];

// 6. 清除matchState中的定时器
        if (STATE.matchState.autoScrollInterval) {
            clearInterval(STATE.matchState.autoScrollInterval);
            STATE.matchState.autoScrollInterval = null;
        }

if (STATE.matchState.scrollAnimationFrame) {
            cancelAnimationFrame(STATE.matchState.scrollAnimationFrame);
            STATE.matchState.scrollAnimationFrame = null;
        }
    }

// 强力停止滚动 - 终极版本
    function completelyStopAllScrolling() {
        console.log('🚫 强力停止所有滚动');

// 如果已经在停止中，直接返回
        if (STATE.scrollController.isStopping) {
            console.log('⚠️ 已经在停止过程中，跳过');
            return;
        }

STATE.scrollController.isStopping = true;
        STATE.scrollController.stopRequested = true;
        STATE.scrollController.isRunning = false;
        STATE.matchState.stopScrollFlag = true;
        STATE.matchState.lastScrollStopTime = Date.now();

// 记录日志
        console.log('停止前状态:', {
            isRunning: STATE.scrollController.isRunning,
            intervalId: STATE.scrollController.intervalId,
            timeoutIds: STATE.scrollController.timeoutIds.length
        });

// 清除所有定时器
        clearAllTimersAndHandlers();

// 移动端特殊处理
        if (IS_MOBILE) {
            console.log('📱 移动端：彻底停止滚动');

// 立即停止所有滚动动画
            window.scrollTo({
                top: window.scrollY,
                behavior: 'auto'
            });

// 添加临时滚动锁定（不隐藏，只是锁定）
            document.body.style.overflow = 'hidden';
            document.documentElement.style.overflow = 'hidden';

// 记录锁定元素
            STATE.scrollController.scrollLockElements.push(document.body);
            STATE.scrollController.scrollLockElements.push(document.documentElement);

// 立即阻止所有触摸事件
            const preventTouchHandler = (e) => {
                if (STATE.scrollController.stopRequested) {
                    e.preventDefault();
                    e.stopPropagation();
                    return false;
                }
            };

// 立即添加事件处理器
            document.body.addEventListener('touchmove', preventTouchHandler, { passive: false });
            document.documentElement.addEventListener('touchmove', preventTouchHandler, { passive: false });

STATE.scrollController.touchHandlers.push({
                element: document.body,
                type: 'touchmove',
                handler: preventTouchHandler
            });
            STATE.scrollController.touchHandlers.push({
                element: document.documentElement,
                type: 'touchmove',
                handler: preventTouchHandler
            });

// 设置一个定时器，在2秒后恢复触摸
            const restoreTimeout = setTimeout(() => {
                document.body.style.overflow = '';
                document.documentElement.style.overflow = '';

// 移除触摸事件处理器
                STATE.scrollController.touchHandlers.forEach(handlerInfo => {
                    try {
                        handlerInfo.element.removeEventListener(handlerInfo.type, handlerInfo.handler);
                    } catch (e) {}
                });
                STATE.scrollController.touchHandlers = [];
                STATE.scrollController.scrollLockElements = [];

console.log('📱 移动端滚动恢复');
            }, 2000);

STATE.scrollController.timeoutIds.push(restoreTimeout);
        }

// 重置滚动状态
        STATE.scrollController.attempts = 0;
        STATE.scrollController.lastScrollTime = 0;

// 延迟重置停止状态
        const resetTimeout = setTimeout(() => {
            STATE.scrollController.isStopping = false;
            STATE.scrollController.stopRequested = false;
            console.log('✅ 滚动停止完成');
        }, 1000);

STATE.scrollController.timeoutIds.push(resetTimeout);

updateStatus('已完全停止滚动');
        console.log('停止后状态:', {
            isRunning: STATE.scrollController.isRunning,
            intervalId: STATE.scrollController.intervalId,
            timeoutIds: STATE.scrollController.timeoutIds.length
        });
    }

// 安全的延迟执行函数
    function safeSetTimeout(callback, delay) {
        const timeoutId = setTimeout(() => {
            try {
                callback();
            } catch (error) {
                console.error('定时器执行错误:', error);
            }

// 执行后移除ID
            const index = STATE.scrollController.timeoutIds.indexOf(timeoutId);
            if (index > -1) {
                STATE.scrollController.timeoutIds.splice(index, 1);
            }
        }, delay);

STATE.scrollController.timeoutIds.push(timeoutId);
        return timeoutId;
    }

// 启动滚动 - 安全版本
    function startAutoScroll() {
        console.log('🔄 尝试启动自动滚动');

// 检查是否应该停止
        if (!STATE.matchState.isMatching) {
            console.log('⚠️ 匹配未运行，不启动滚动');
            return;
        }

// 检查是否正在停止
        if (STATE.scrollController.isStopping) {
            console.log('⚠️ 滚动正在停止，跳过启动');
            return;
        }

// 检查是否已经在运行
        if (STATE.scrollController.isRunning) {
            console.log('⚠️ 滚动已经在运行，跳过');
            return;
        }

// 检查距离上次停止的时间
        const now = Date.now();
        if (now - STATE.matchState.lastScrollStopTime < 2000) {
            console.log(`⚠️ 距离上次停止仅${now - STATE.matchState.lastScrollStopTime}ms，延迟启动`);

safeSetTimeout(() => {
                if (STATE.matchState.isMatching && !STATE.scrollController.isRunning) {
                    startAutoScroll();
                }
            }, 2000 - (now - STATE.matchState.lastScrollStopTime));
            return;
        }

// 重置启动尝试次数
        STATE.matchState.scrollStartAttempts = 0;

// 真正启动滚动
        internalStartAutoScroll();
    }

function internalStartAutoScroll() {
        console.log('🚀 真正启动滚动');

// 先完全停止任何现有滚动
        completelyStopAllScrolling();

// 等待1秒确保完全停止
        safeSetTimeout(() => {
            // 再次检查条件
            if (STATE.scrollController.isStopping ||
                !STATE.matchState.isMatching ||
                STATE.scrollController.stopRequested) {
                console.log('⚠️ 启动条件不满足，取消启动');
                return;
            }

// 重置滚动控制器状态
            STATE.scrollController.isRunning = true;
            STATE.scrollController.isStopping = false;
            STATE.scrollController.stopRequested = false;
            STATE.matchState.stopScrollFlag = false;
            STATE.scrollController.attempts = 0;

// 设置滚动参数
            STATE.scrollController.direction = 'down';
            STATE.scrollController.distance = IS_MOBILE ? 300 : 500;
            STATE.scrollController.interval = IS_MOBILE ? 2500 : 1800;

console.log('滚动参数:', {
                direction: STATE.scrollController.direction,
                distance: STATE.scrollController.distance,
                interval: STATE.scrollController.interval,
                isMobile: IS_MOBILE
            });

updateStatus('自动滚动中...');

// 启动滚动循环
            startScrollLoop();
        }, 1000);
    }

function startScrollLoop() {
        console.log('🔄 开始滚动循环');

// 清除可能存在的旧定时器
        if (STATE.scrollController.intervalId) {
            clearInterval(STATE.scrollController.intervalId);
            STATE.scrollController.intervalId = null;
        }

// 创建新的滚动定时器
        STATE.scrollController.intervalId = setInterval(() => {
            // 检查停止条件
            if (STATE.scrollController.stopRequested ||
                !STATE.scrollController.isRunning ||
                !STATE.matchState.isMatching ||
                STATE.scrollController.isStopping) {
                console.log('🛑 滚动条件不满足，停止滚动');
                completelyStopAllScrolling();
                return;
            }

// 检查尝试次数
            if (STATE.scrollController.attempts >= STATE.scrollController.maxAttempts) {
                console.log(`⚠️ 达到最大尝试次数 ${STATE.scrollController.maxAttempts}，停止滚动`);
                completelyStopAllScrolling();
                return;
            }

// 执行单次滚动
            performSingleScroll();

STATE.scrollController.attempts++;
            updateStatus(`自动滚动中... (${STATE.scrollController.attempts}/${STATE.scrollController.maxAttempts})`);
        }, STATE.scrollController.interval);

console.log('滚动定时器已创建:', STATE.scrollController.intervalId);
    }

function performSingleScroll() {
        const currentScrollY = window.scrollY;
        const windowHeight = window.innerHeight;
        const documentHeight = document.documentElement.scrollHeight;

// 检查是否到达边界
        const isAtBottom = (windowHeight + currentScrollY) >= documentHeight - 100;
        const isAtTop = currentScrollY <= 10;

// 更新方向
        if (isAtBottom && STATE.scrollController.direction === 'down') {
            STATE.scrollController.direction = 'up';
            STATE.scrollController.distance = IS_MOBILE ? 200 : 300;
            console.log('🔄 改变方向为上');
        } else if (isAtTop && STATE.scrollController.direction === 'up') {
            STATE.scrollController.direction = 'down';
            STATE.scrollController.distance = IS_MOBILE ? 300 : 500;
            console.log('🔄 改变方向为下');
        }

// 计算目标位置
        const targetY = window.scrollY + (STATE.scrollController.direction === 'down' ?
            STATE.scrollController.distance : -STATE.scrollController.distance);

// 执行滚动
        window.scrollTo({
            top: targetY,
            behavior: 'smooth'
        });

STATE.scrollController.lastScrollTime = Date.now();
    }

// ==================== 智能决策 ====================
    function makeScrollDecision() {
        // 防止重复决策
        if (STATE.matchState.isMakingDecision) {
            console.log('📊 决策正在进行中，跳过');
            return;
        }

STATE.matchState.isMakingDecision = true;

// 先停止所有滚动
        completelyStopAllScrolling();

// 等待1.5秒确保完全停止
        safeSetTimeout(() => {
            const products = STATE.socketState.processedProducts;
            const productCount = products.length;

console.log(`📊 智能决策 - 商品数: ${productCount}`);

// 检查匹配状态
            if (!STATE.matchState.isMatching) {
                console.log('📊 匹配已停止，退出决策');
                STATE.matchState.isMakingDecision = false;
                return;
            }

// 情况1：没有商品，需要滚动
            if (productCount === 0) {
                console.log('📊 决策: 没有商品，开始滚动收集');
                STATE.firstInteraction.firstProductCount = 0;

// 等待后开始滚动
                safeSetTimeout(() => {
                    if (STATE.matchState.isMatching && !STATE.scrollController.isRunning) {
                        console.log('🔄 开始滚动收集商品');
                        startAutoScroll();
                    }
                    STATE.matchState.isMakingDecision = false;
                }, 1500);
                return;
            }

// 情况2：首次收到商品
            if (STATE.firstInteraction.firstProductCount === 0) {
                console.log(`📊 决策: 首次收到 ${productCount} 个商品，开始匹配`);
                STATE.firstInteraction.firstProductCount = productCount;
                STATE.firstInteraction.lastMatchCount = productCount;

// 等待后开始匹配
                safeSetTimeout(() => {
                    console.log('📊 开始首次完整匹配');
                    startFullMatch();
                    STATE.matchState.isMakingDecision = false;
                }, 1500);
                return;
            }

// 情况3：商品数量增加
            if (productCount > STATE.firstInteraction.firstProductCount &&
                productCount > STATE.firstInteraction.lastMatchCount) {

console.log(`📊 决策: 商品增加 ${STATE.firstInteraction.lastMatchCount} -> ${productCount}`);
                STATE.firstInteraction.lastMatchCount = productCount;

// 开始新匹配
                safeSetTimeout(() => {
                    console.log('📊 开始新匹配');
                    startFullMatch();
                    STATE.matchState.isMakingDecision = false;
                }, 1500);
                return;
            }

// 情况4：已匹配完成但未找到高匹配度
            if (STATE.firstInteraction.hasMatchedAll &&
                !STATE.firstInteraction.highMatchFound &&
                STATE.firstInteraction.needContinueScroll) {

console.log('📊 决策: 已匹配完成但未找到高匹配度，继续滚动');
                resetForNextMatch();

safeSetTimeout(() => {
                    if (STATE.matchState.isMatching && !STATE.scrollController.isRunning) {
                        console.log('🔄 继续滚动收集新商品');
                        startAutoScroll();
                    }
                    STATE.matchState.isMakingDecision = false;
                }, 1000);
                return;
            }

// 情况5：有商品但还没匹配过
            if (productCount > 0 && STATE.matchState.isMatching && !STATE.firstInteraction.hasMatchedAll) {
                console.log(`📊 决策: 有 ${productCount} 个商品需要匹配`);
                startFullMatch();
                STATE.matchState.isMakingDecision = false;
                return;
            }

console.log('📊 决策: 保持当前状态');
            STATE.matchState.isMakingDecision = false;
        }, 1500);
    }

// ==================== 匹配流程 ====================
    function startFullMatch() {
        console.log(`📊 开始完整匹配 ${STATE.socketState.processedProducts.length} 个商品`);
        updateStatus(`开始匹配 ${STATE.socketState.processedProducts.length} 个商品...`);

// 确保滚动停止
        completelyStopAllScrolling();

// 重置匹配状态
        STATE.matchState.productIndex = 0;
        STATE.matchState.searchPosition = 0;
        STATE.matchState.matchHistory = [];
        STATE.firstInteraction.hasMatchedAll = false;
        STATE.firstInteraction.highMatchFound = false;
        STATE.firstInteraction.needContinueScroll = false;
        STATE.matchState.scrollLock = false;
        STATE.matchState.stopScrollFlag = true;

// 等待后开始匹配
        safeSetTimeout(() => {
            console.log(`📊 真正开始匹配循环`);
            matchNextProduct();
        }, 1500);
    }

function matchNextProduct() {
        if (!STATE.matchState.isMatching) {
            console.log('🛑 匹配已停止');
            return;
        }

const products = STATE.socketState.processedProducts;

if (products.length === 0) {
            console.log('📊 没有商品可匹配');
            safeSetTimeout(matchNextProduct, 1000);
            return;
        }

if (STATE.matchState.productIndex >= products.length) {
            console.log('📊 所有商品匹配完成');
            STATE.firstInteraction.hasMatchedAll = true;

// 检查是否找到高匹配度
            const highMatch = STATE.matchState.matchHistory.find(match => match.matchRate >= 85);
            if (highMatch) {
                STATE.firstInteraction.highMatchFound = true;
                updateStatus('✅ 找到高匹配度商品，任务完成');
                STATE.matchState.isMatching = false;
                return;
            } else {
                STATE.firstInteraction.needContinueScroll = true;
                console.log('📊 没有找到高匹配度商品，需要继续滚动');

// 等待后重新决策
                safeSetTimeout(() => {
                    makeScrollDecision();
                }, 2000);
            }
            return;
        }

const currentProduct = products[STATE.matchState.productIndex];
        const searchText = currentProduct.sales_tip || currentProduct.price_info || currentProduct.name;

if (!searchText || searchText === '未知商品') {
            STATE.matchState.productIndex++;
            safeSetTimeout(matchNextProduct, 500);
            return;
        }

console.log(`📊 匹配商品 ${STATE.matchState.productIndex + 1}/${products.length}: "${searchText.substring(0, 30)}..."`);

// 执行搜索
        STATE.matchState.searcher.search(searchText);
        const matchCount = STATE.matchState.searcher.getMatchCount();

if (matchCount === 0) {
            STATE.matchState.productIndex++;
            safeSetTimeout(matchNextProduct, 1500);
            return;
        }

console.log(`📊 找到 ${matchCount} 个匹配位置`);
        STATE.matchState.searchPosition = 0;

processMatchPositions(currentProduct, searchText, matchCount);
    }

function processMatchPositions(currentProduct, searchText, matchCount) {
        if (!STATE.matchState.isMatching) {
            STATE.matchState.searcher.clearHighlights();
            return;
        }

if (STATE.matchState.searchPosition >= matchCount) {
            STATE.matchState.productIndex++;
            STATE.matchState.searchPosition = 0;
            STATE.matchState.searcher.clearHighlights();

safeSetTimeout(matchNextProduct, 1000);
            return;
        }

const matchResult = STATE.matchState.searcher.goTo(STATE.matchState.searchPosition);
        if (!matchResult) {
            STATE.matchState.searchPosition++;
            safeSetTimeout(() => processMatchPositions(currentProduct, searchText, matchCount), 1000);
            return;
        }

const webProduct = extractProductInfo(matchResult.element);
        if (!webProduct) {
            STATE.matchState.searchPosition++;
            safeSetTimeout(() => processMatchPositions(currentProduct, searchText, matchCount), 1000);
            return;
        }

const matchRate = calculateMatchRate(webProduct, currentProduct);

STATE.matchState.matchHistory.push({
            productIndex: STATE.matchState.productIndex,
            searchText: searchText,
            matchPosition: STATE.matchState.searchPosition,
            totalMatches: matchCount,
            matchRate: matchRate,
            webProduct: webProduct,
            serverProduct: currentProduct,
            timestamp: Date.now()
        });

console.log(`📊 匹配度: ${matchRate}%`);
        updateStatus(`${STATE.matchState.productIndex + 1}/${STATE.socketState.processedProducts.length} - ${STATE.matchState.searchPosition + 1}/${matchCount} - ${matchRate}%`);
        updateUIProgress();

if (matchRate >= 85) {
            console.log('🎉 找到高匹配度商品！');
            STATE.firstInteraction.highMatchFound = true;
            updateStatus(`✅ 找到高匹配度商品！${matchRate}%`, true);

autoClickMatchedElement();
            STATE.matchState.isMatching = false;
            return;
        }

STATE.matchState.searchPosition++;
        safeSetTimeout(() => processMatchPositions(currentProduct, searchText, matchCount), 1000);
    }

// ==================== 其他核心函数 ====================
    function resetForNextMatch() {
        console.log('📊 重置匹配状态');

STATE.matchState.productIndex = 0;
        STATE.matchState.searchPosition = 0;
        STATE.matchState.matchHistory = [];
        STATE.matchState.hasReceivedProducts = false;
        STATE.matchState.scrollLock = false;
        STATE.matchState.stopScrollFlag = true;

if (STATE.matchState.searcher) {
            STATE.matchState.searcher.clearHighlights();
        }
    }

function startMatching() {
        if (STATE.matchState.isMatching) {
            console.log('⚠️ 匹配已在运行，先停止');
            stopMatching();

safeSetTimeout(() => {
                console.log('🚀 重新启动匹配');
                startMatching();
            }, 1000);
            return;
        }

console.log('🚀 用户启动匹配');
        updateStatus('开始匹配流程...');

STATE.matchState.isMatching = true;
        STATE.matchState.isMakingDecision = false;

// 重置所有状态
        STATE.firstInteraction.hasProducts = false;
        STATE.firstInteraction.firstProductCount = 0;
        STATE.firstInteraction.hasMatchedAll = false;
        STATE.firstInteraction.highMatchFound = false;
        STATE.firstInteraction.needContinueScroll = false;
        STATE.firstInteraction.lastMatchCount = 0;

// 重置匹配状态
        STATE.matchState.productIndex = 0;
        STATE.matchState.searchPosition = 0;
        STATE.matchState.matchHistory = [];
        STATE.matchState.scrollLock = false;
        STATE.matchState.stopScrollFlag = true;

if (STATE.matchState.searcher) {
            STATE.matchState.searcher.clearHighlights();
        }

// 完全停止任何滚动
        completelyStopAllScrolling();

// 等待后开始决策
        safeSetTimeout(() => {
            console.log('📊 开始智能决策流程');
            makeScrollDecision();
        }, 1000);
    }

function stopMatching() {
        console.log('🛑 停止匹配');
        STATE.matchState.isMatching = false;
        STATE.matchState.stopScrollFlag = true;
        STATE.matchState.isMakingDecision = false;

if (STATE.matchState.searcher) {
            STATE.matchState.searcher.clearHighlights();
        }

completelyStopAllScrolling();
        updateStatus('已停止');
    }

// ==================== 页面刷新自动开始 ====================
    function autoStartOnPageLoad() {
        if (STATE.matchState.isProcessingAutoStart) {
            console.log('⚠️ 自动开始处理中，跳过');
            return;
        }

STATE.matchState.isProcessingAutoStart = true;

if (!STATE.matchState.isMatching && !STATE.matchState.isAutoStarted) {
            console.log('🚀 页面刷新，准备自动开始');
            STATE.matchState.isAutoStarted = true;

// 等待更长时间
            safeSetTimeout(() => {
                console.log('🎯 执行页面加载自动开始');

STATE.matchState.isMatching = true;

// 重置状态
                STATE.firstInteraction.hasProducts = false;
                STATE.firstInteraction.firstProductCount = 0;
                STATE.firstInteraction.hasMatchedAll = false;
                STATE.firstInteraction.highMatchFound = false;
                STATE.firstInteraction.needContinueScroll = false;
                STATE.firstInteraction.lastMatchCount = 0;

updateStatus('页面加载，自动开始匹配...');

// 等待后再触发决策
                safeSetTimeout(() => {
                    console.log('📊 页面加载触发智能决策');
                    makeScrollDecision();
                    STATE.matchState.isProcessingAutoStart = false;
                }, 2000);
            }, IS_MOBILE ? 4000 : 3000);
        } else {
            STATE.matchState.isProcessingAutoStart = false;
        }
    }

// ==================== 字段映射工具函数 ====================
    function processServerProduct(serverProduct) {
        if (!serverProduct || typeof serverProduct !== 'object') {
            return {
                name: '未知商品',
                price_info: '',
                sales_tip: '',
                image: 'https://picsum.photos/100/100',
                short_name: '未知商品'
            };
        }

return {
            name: serverProduct.short_name || serverProduct.name || '未知商品',
            price_info: serverProduct.price || '',
            sales_tip: serverProduct.sales_tip || '',
            image: serverProduct.image || 'https://picsum.photos/100/100',
            original_name: serverProduct.name || '',
            short_name: serverProduct.short_name || '',
            _raw: serverProduct
        };
    }

function processServerProducts(serverProducts) {
        if (!Array.isArray(serverProducts)) return [];
        return serverProducts.map(processServerProduct);
    }

// ==================== JSON上传功能 ====================
    function getContentHash(str) {
        try {
            let hash = 0;
            for (let i = 0; i < str.length; i++) {
                const char = str.charCodeAt(i);
                hash = ((hash << 5) - hash) + char;
                hash = hash & hash;
            }
            return hash.toString();
        } catch (e) {
            return Date.now().toString();
        }
    }

// ==================== 核心匹配引擎 ====================
    class TextSearcher {
        constructor() {
            this.matches = [];
            this.currentIndex = 0;
            this.searchText = '';
            this.uiContainer = null;
            this.uiContainerId = 'pdd-ctrl-f-matcher';
        }

isOurUIContainer(element) {
            if (!element) return false;
            if (!this.uiContainer) {
                this.uiContainer = document.getElementById(this.uiContainerId);
            }
            if (!this.uiContainer) return false;
            return element === this.uiContainer ||
                   this.uiContainer.contains(element) ||
                   element.contains(this.uiContainer);
        }

isTextNodeInOurUI(node) {
            if (!node || !node.parentElement) return false;
            let current = node.parentElement;
            while (current && current !== document.body) {
                if (this.isOurUIContainer(current)) {
                    return true;
                }
                current = current.parentElement;
            }
            return false;
        }

search(searchText) {
            this.searchText = searchText;
            this.matches = [];
            this.currentIndex = 0;

if (!searchText.trim()) {
                return 0;
            }

console.log(`搜索: "${searchText}"`);
            this.uiContainer = document.getElementById(this.uiContainerId);

const walker = document.createTreeWalker(
                document.body,
                NodeFilter.SHOW_TEXT,
                {
                    acceptNode: (node) => {
                        if (!node.parentElement || node.parentElement.tagName === 'SCRIPT' ||
                            node.parentElement.tagName === 'STYLE' || node.parentElement.tagName === 'NOSCRIPT') {
                            return NodeFilter.FILTER_REJECT;
                        }

if (this.isTextNodeInOurUI(node)) {
                            return NodeFilter.FILTER_REJECT;
                        }

const style = window.getComputedStyle(node.parentElement);
                        if (style.display === 'none' || style.visibility === 'hidden' ||
                            style.opacity === '0' || node.parentElement.offsetParent === null) {
                            return NodeFilter.FILTER_REJECT;
                        }

if (node.textContent && node.textContent.includes(searchText)) {
                            return NodeFilter.FILTER_ACCEPT;
                        }

return NodeFilter.FILTER_SKIP;
                    }
                },
                false
            );

let node;
            while ((node = walker.nextNode())) {
                if (this.isTextNodeInOurUI(node)) {
                    continue;
                }

const text = node.textContent;
                let startIndex = 0;

while ((startIndex = text.indexOf(searchText, startIndex)) !== -1) {
                    const parentElement = this.findRealProductContainer(node.parentElement);
                    if (parentElement && this.isValidProductContainer(parentElement)) {
                        this.matches.push({
                            node: node,
                            startIndex: startIndex,
                            endIndex: startIndex + searchText.length,
                            parentElement: parentElement,
                            text: text.substring(Math.max(0, startIndex - 20), Math.min(text.length, startIndex + searchText.length + 20))
                        });
                    }
                    startIndex += searchText.length;
                }
            }

console.log(`找到 ${this.matches.length} 处匹配`);
            return this.matches.length;
        }

findRealProductContainer(element) {
            if (!element) return null;
            if (this.isOurUIContainer(element)) {
                return null;
            }

const productSelectors = [
                'div._1iyBHIt5',
                'div[class*="goods-item"]',
                'div[class*="product-item"]',
                'div[class*="item-goods"]',
                'div[class*="goods-list-item"]',
                'div[class*="product"]',
                'div[class*="goods"]',
                'div[class*="item"]'
            ];

let current = element;
            let searchDepth = 0;
            const maxDepth = 15;

while (current && current !== document.body && current !== document.documentElement && searchDepth < maxDepth) {
                if (this.isOurUIContainer(current)) {
                    return null;
                }

for (const selector of productSelectors) {
                    if (current.matches && current.matches(selector)) {
                        return current;
                    }
                }

for (const selector of productSelectors) {
                    const child = current.querySelector(selector);
                    if (child && !this.isOurUIContainer(child)) {
                        return child;
                    }
                }

current = current.parentElement;
                searchDepth++;
            }

return this.findNearbyProductContainer(element);
        }

findNearbyProductContainer(element) {
            if (!element) return null;
            let current = element;
            let lastValidDiv = null;

for (let i = 0; i < 10; i++) {
                if (!current || current === document.body) break;
                if (this.isOurUIContainer(current)) {
                    return lastValidDiv;
                }

if (current.tagName === 'DIV') {
                    const text = current.textContent || '';
                    const hasPrice = /¥\s*\d+/.test(text);
                    const hasSales = /已抢|销量|热销/.test(text);
                    const hasProductName = text.length > 20 && text.length < 500;

if (hasPrice || hasSales || hasProductName) {
                        if (!lastValidDiv || current.offsetWidth > lastValidDiv.offsetWidth) {
                            lastValidDiv = current;
                        }
                    }
                }

current = current.parentElement;
            }

return lastValidDiv;
        }

isValidProductContainer(container) {
            if (!container) return false;
            if (this.isOurUIContainer(container)) {
                return false;
            }

const text = container.textContent || '';
            const uiKeywords = [
                'CtrlF', 'ctrl-f', '匹配', '已连接', '开始匹配',
                '停止', '清除高亮', '调试信息', 'pdd-', '服务器商品',
                '商品:', '匹配度:', '位置:', '服务器商品:'
            ];

for (const keyword of uiKeywords) {
                if (text.includes(keyword)) {
                    return false;
                }
            }

const hasPrice = /¥\s*\d+/.test(text);
            const hasSales = /已抢|销量|热销/.test(text);
            const hasProductName = text.length > 20;

return hasPrice || hasSales || hasProductName;
        }

next() {
            if (this.matches.length === 0) return null;
            this.currentIndex = (this.currentIndex + 1) % this.matches.length;
            return this.goTo(this.currentIndex);
        }

prev() {
            if (this.matches.length === 0) return null;
            this.currentIndex = (this.currentIndex - 1 + this.matches.length) % this.matches.length;
            return this.goTo(this.currentIndex);
        }

goTo(index) {
            if (index < 0 || index >= this.matches.length) return null;
            this.currentIndex = index;
            const match = this.matches[index];
            this.highlightMatch(match);

if (match.parentElement) {
                match.parentElement.scrollIntoView({
                    behavior: 'smooth',
                    block: 'center',
                    inline: 'nearest'
                });
            }

return {
                index: index,
                total: this.matches.length,
                element: match.parentElement,
                textNode: match.node,
                position: match.startIndex,
                text: match.text
            };
        }

highlightMatch(match) {
            this.clearHighlights();
            const textNode = match.node;
            const parent = textNode.parentNode;
            const text = textNode.textContent;

const beforeText = document.createTextNode(text.substring(0, match.startIndex));
            const highlightSpan = document.createElement('span');
            highlightSpan.className = 'pdd-ctrlf-highlight';
            highlightSpan.textContent = text.substring(match.startIndex, match.endIndex);
            highlightSpan.style.cssText = `
                background-color: #ffff00;
                color: #000;
                padding: 0 2px;
                border-radius: 2px;
                font-weight: bold;
                animation: pdd-highlight-blink 1s infinite;
            `;

const afterText = document.createTextNode(text.substring(match.endIndex));

parent.insertBefore(beforeText, textNode);
            parent.insertBefore(highlightSpan, textNode);
            parent.insertBefore(afterText, textNode);
            parent.removeChild(textNode);

if (match.parentElement) {
                match.parentElement.style.outline = '3px solid #ff6b6b';
                match.parentElement.style.outlineOffset = '2px';
                match.parentElement.classList.add('pdd-product-highlight');
                STATE.matchState.matchedElement = match.parentElement;
            }
        }

clearHighlights() {
            document.querySelectorAll('.pdd-ctrlf-highlight').forEach(span => {
                const parent = span.parentNode;
                const text = document.createTextNode(span.textContent);
                parent.replaceChild(text, span);
                parent.normalize();
            });

document.querySelectorAll('.pdd-product-highlight').forEach(el => {
                el.style.outline = '';
                el.classList.remove('pdd-product-highlight');
            });

STATE.matchState.matchedElement = null;
        }

getCurrentMatch() {
            if (this.matches.length === 0) return null;
            return this.matches[this.currentIndex];
        }

getMatchCount() {
            return this.matches.length;
        }
    }

// ==================== 商品信息提取 ====================
    function extractProductInfo(container) {
        if (!container) {
            return null;
        }

const uiContainer = document.getElementById('pdd-ctrl-f-matcher');
        if (uiContainer && (container === uiContainer || uiContainer.contains(container) || container.contains(uiContainer))) {
            return null;
        }

const text = container.textContent.trim();

const uiKeywords = [
            'CtrlF', 'ctrl-f', '匹配', '已连接', '开始匹配',
            '停止', '清除高亮', '调试信息', 'pdd-', '服务器商品',
            '商品:', '匹配度:', '位置:', '服务器商品:'
        ];

for (const keyword of uiKeywords) {
            if (text.includes(keyword)) {
                return null;
            }
        }

if (text.length < 10) {
            return null;
        }

const price = extractRealPrice(text);
        const salesTip = extractCompleteSalesTip(text);
        const name = extractProductName(container, text, price, salesTip);

if (!price && !salesTip && name === '未知商品') {
            return null;
        }

return {
            name: name,
            price_info: price,
            sales_tip: salesTip,
            container: container,
            fullText: text.substring(0, 200) + (text.length > 200 ? '...' : '')
        };
    }

function extractRealPrice(text) {
        const pricePatterns = [
            /¥\s*(\d+(?:\.\d+)?)/,
            /券后\s*¥\s*(\d+(?:\.\d+)?)/,
            /(\d+(?:\.\d+)?)\s*[元块]/,
        ];

for (const pattern of pricePatterns) {
            const match = text.match(pattern);
            if (match) {
                let priceNum = match[1] || match[2];
                if (priceNum && isValidPriceSimple(priceNum, text)) {
                    return priceNum;
                }
            }
        }

return '';
    }

function isValidPriceSimple(priceStr, context) {
        if (!priceStr) return false;
        const num = parseFloat(priceStr);
        if (isNaN(num)) return false;
        if (num < 0.1 || num > 100000) {
            return false;
        }
        if (isYearNumber(num, context)) {
            return false;
        }
        if (context && (context.includes('销量') || context.includes('热销') || context.includes('已拼') || context.includes('售出'))) {
            const index = context.indexOf(priceStr);
            const before = context.substring(Math.max(0, index - 10), index);
            const after = context.substring(index + priceStr.length, Math.min(context.length, index + priceStr.length + 10));

if (before.includes('销量') || before.includes('热销') || before.includes('已拼') ||
                after.includes('万+件') || after.includes('人付款') || after.includes('人已拼')) {
                return false;
            }
        }
        return true;
    }

function isYearNumber(num, context) {
        if (num >= 2020 && num <= 2030) {
            if (context && (context.includes('新款') || context.includes('新') || context.includes('季'))) {
                return true;
            }
        }
        return false;
    }

function extractCompleteSalesTip(text) {
        const salesPatterns = [
            /本店已拼[\d\.万\+]+\+?件/,
            /品牌热销[\d\.万\+]+\+?件/,
            /热销[\d\.万\+]+\+?件/,
            /总售[\d\.万\+]+\+?件/,
            /已售[\d\.万\+]+\+?件/,
            /售出[\d\.万\+]+\+?件/,
            /月销[\d\.万\+]+\+?件/,
            /销量[\d\.万\+]+\+?件/,
            /[\d\.万\+]+\+?人付款/,
            /[\d\.万\+]+\+?人已拼/,
            /[\d\.万\+]+\+?人想拼/,
            /[\d\.万\+]+\+?人评价/,
            /已抢[\d\.万\+]+\+?件/
        ];

for (const pattern of salesPatterns) {
            const match = text.match(pattern);
            if (match) {
                return match[0].trim();
            }
        }

return '';
    }

function extractProductName(container, text, price, salesTip) {
        let name = '';

const firstDiv = container.querySelector('div');
        if (firstDiv && firstDiv.textContent) {
            const firstText = firstDiv.textContent.trim();
            const cleanText = firstText.replace(/[]/g, '').trim();
            if (cleanText.length > 5 && cleanText.length < 100) {
                name = cleanText;
            }
        }

if (!name || name.length < 5) {
            const nameSelectors = [
                'div[class*="name"]',
                'div[class*="title"]',
                'div[class*="goods-name"]',
                'span[class*="name"]',
                'span[class*="title"]'
            ];

for (const selector of nameSelectors) {
                const elements = container.querySelectorAll(selector);
                for (const el of elements) {
                    if (el.textContent && el.textContent.trim().length > 5) {
                        const cleanText = el.textContent.trim().replace(/[]/g, '');
                        name = cleanText.substring(0, 100);
                        break;
                    }
                }
                if (name) break;
            }
        }

if (!name || name.length < 5) {
            let cleanText = text;

if (price) {
                cleanText = cleanText.replace(new RegExp(`¥?\\s*${price}`, 'g'), '');
            }

if (salesTip) {
                cleanText = cleanText.replace(salesTip, '');
            }

const commonNonNamePatterns = [
                /预计.*送达/g,
                /正品险/g,
                /极速退款/g,
                /退货包运费/g,
                /假一赔十/g,
                /券后/g,
                /立减/g,
                /满减/g,
                /包邮/g,
                /特价/g,
                /活动/g,
                /促销/g,
                /¥\d+/g,
                /\d+人.*/g,
                /已拼.*件/g,
                /热销.*件/g,
                /已抢.*件/g
            ];

for (const pattern of commonNonNamePatterns) {
                cleanText = cleanText.replace(pattern, '');
            }

name = cleanText.replace(/[]/g, '')
                           .replace(/\s+/g, ' ')
                           .replace(/^[^\u4e00-\u9fa5a-zA-Z]+/, '')
                           .replace(/[^\u4e00-\u9fa5a-zA-Z0-9\s【】\[\]()（）\-]+/g, '')
                           .trim()
                           .substring(0, 100);
        }

return name || '未知商品';
    }

// ==================== 匹配度计算 ====================
    function calculateMatchRate(webProduct, serverProduct) {
        if (!webProduct || !serverProduct) {
            return 0;
        }

let totalRate = 0;
        // 只对比销量和名称，权重各占60%和40%
        const weights = { sales_tip: 0.6, name: 0.4 };

// 销量匹配度
        let salesRate = 0;
        if (webProduct.sales_tip && serverProduct.sales_tip) {
            salesRate = textExactMatch(webProduct.sales_tip, serverProduct.sales_tip);
        } else if (!webProduct.sales_tip && !serverProduct.sales_tip) {
            salesRate = 50;
        } else {
            salesRate = 20;
        }
        totalRate += salesRate * weights.sales_tip;

// 名称匹配度
        let nameRate = 0;
        if (webProduct.name && serverProduct.name) {
            nameRate = fuzzyNameMatch(webProduct.name, serverProduct.name);
        } else if (!webProduct.name && !serverProduct.name) {
            nameRate = 50;
        } else {
            nameRate = 30;
        }
        totalRate += nameRate * weights.name;

// 最终匹配度计算
        let finalRate = Math.min(100, Math.round(totalRate * 100) / 100);

// 如果销量和名称都很高，给一个保底高分
        if (salesRate >= 95 && nameRate >= 95) {
            finalRate = Math.max(finalRate, 95);
        }

return finalRate;
    }

function priceNumberMatch(price1, price2) {
        if (!price1 || !price2) return 0;
        if (price1 === price2) return 100;
        const num1 = parseFloat(price1);
        const num2 = parseFloat(price2);
        if (isNaN(num1) || isNaN(num2)) return 0;
        if (Math.abs(num1 - num2) < 0.01) return 100;
        if (price1.replace(/\.?0+$/, '') === price2.replace(/\.?0+$/, '')) return 100;
        return 0;
    }

function textExactMatch(str1, str2) {
        if (!str1 || !str2) return 0;
        if (str1 === str2) return 100;

const clean1 = str1.replace(/\s/g, '').toLowerCase();
        const clean2 = str2.replace(/\s/g, '').toLowerCase();
        if (clean1 === clean2) return 100;
        if (clean1.includes(clean2) || clean2.includes(clean1)) return 95;

const extractParts = (str) => {
            const numMatch = str.match(/(\d+(?:\.\d+)?)/);
            const unitMatch = str.replace(/\d+(?:\.\d+)?/g, '');
            return {
                num: numMatch ? numMatch[1] : '',
                unit: unitMatch
            };
        };

const parts1 = extractParts(str1);
        const parts2 = extractParts(str2);

if (parts1.num && parts2.num && parts1.num === parts2.num) {
            if (parts1.unit && parts2.unit) {
                if (parts1.unit.includes(parts2.unit) || parts2.unit.includes(parts1.unit)) {
                    return 90;
                }
                const hasSameKeywords = (parts1.unit.includes('万') && parts2.unit.includes('万')) ||
                                      (parts1.unit.includes('件') && parts2.unit.includes('件')) ||
                                      (parts1.unit.includes('已抢') && parts2.unit.includes('已抢'));
                if (hasSameKeywords) return 85;
            }
            return 80;
        }

return 0;
    }

function fuzzyNameMatch(name1, name2) {
        if (!name1 || !name2) return 30;

const clean = (str) => {
            return str.toLowerCase()
                .replace(/[]/g, '')
                .replace(/[【】\[\]()（）]/g, '')
                .replace(/品牌|官方|正品|旗舰店|专卖店|专营店|新款|202[0-9]|男鞋|女士|男士|男女|儿童|童装|男童|女童|中大童/g, '')
                .replace(/\s+/g, ' ')
                .trim();
        };

const clean1 = clean(name1);
        const clean2 = clean(name2);

if (clean1 === clean2) return 95;
        if (clean1.includes(clean2) || clean2.includes(clean1)) return 85;

const words1 = clean1.match(/[\u4e00-\u9fa5]{2,}/g) || [];
        const words2 = clean2.match(/[\u4e00-\u9fa5]{2,}/g) || [];

if (words1.length === 0 || words2.length === 0) return 50;

const commonWords = words1.filter(word => words2.includes(word));
        const overlap = (commonWords.length / Math.max(words1.length, words2.length)) * 100;

return Math.min(80, Math.round(overlap));
    }

// ==================== 自动点击功能（兼容电脑端）====================
    function autoClickMatchedElement() {
        if (!STATE.matchState.matchedElement) {
            console.log('❌ 没有匹配的元素可点击');
            return;
        }

const element = STATE.matchState.matchedElement;
        console.log('🎯 准备点击元素:', element);

safeSetTimeout(() => {
            try {
                // 方法1：尝试找到可点击的链接
                const clickableSelectors = [
                    'a',
                    'button',
                    '[role="button"]',
                    '[onclick]',
                    '[class*="link"]',
                    '[class*="btn"]',
                    '[class*="goods-item"]',
                    '[class*="product"]',
                    'div[data-clickable="true"]'
                ];

let clickableElement = null;

// 首先检查元素本身是否可点击
                if (element.tagName === 'A' || element.tagName === 'BUTTON' || 
                    element.hasAttribute('onclick') || 
                    element.getAttribute('role') === 'button') {
                    clickableElement = element;
                }

// 如果没有，查找子元素中的可点击元素
                if (!clickableElement) {
                    for (const selector of clickableSelectors) {
                        const found = element.querySelector(selector);
                        if (found) {
                            clickableElement = found;
                            break;
                        }
                    }
                }

// 如果还没有，查找父元素中的可点击元素
                if (!clickableElement) {
                    let parent = element.parentElement;
                    let depth = 0;
                    while (parent && depth < 5) {
                        if (parent.tagName === 'A' || parent.tagName === 'BUTTON' ||
                            parent.hasAttribute('onclick') ||
                            parent.getAttribute('role') === 'button') {
                            clickableElement = parent;
                            break;
                        }
                        for (const selector of clickableSelectors) {
                            const found = parent.querySelector(selector);
                            if (found) {
                                clickableElement = found;
                                break;
                            }
                        }
                        if (clickableElement) break;
                        parent = parent.parentElement;
                        depth++;
                    }
                }

// 如果找到了可点击元素，使用它
                if (clickableElement) {
                    console.log('🎯 找到可点击元素:', clickableElement);

// 桌面端使用 MouseEvent
                    if (!IS_MOBILE) {
                        // 创建并分发点击事件
                        const clickEvent = new MouseEvent('click', {
                            view: window,
                            bubbles: true,
                            cancelable: true,
                            button: 0,
                            buttons: 1
                        });

// 先尝试使用 dispatchEvent
                        const dispatched = clickableElement.dispatchEvent(clickEvent);
                        console.log('📱 桌面端: 事件分发结果:', dispatched);

// 再尝试直接调用 click 方法
                        if (typeof clickableElement.click === 'function') {
                            clickableElement.click();
                            console.log('📱 桌面端: 直接调用 click 方法');
                        }

// 特别处理：尝试触发 mousedown + mouseup 序列
                        if (!dispatched) {
                            const mousedownEvent = new MouseEvent('mousedown', {
                                view: window,
                                bubbles: true,
                                cancelable: true
                            });
                            const mouseupEvent = new MouseEvent('mouseup', {
                                view: window,
                                bubbles: true,
                                cancelable: true
                            });
                            clickableElement.dispatchEvent(mousedownEvent);
                            clickableElement.dispatchEvent(mouseupEvent);
                            console.log('📱 桌面端: 触发 mousedown+mouseup');
                        }
                    } else {
                        // 移动端保持原来的触摸事件
                        const touchEvent = new TouchEvent('touchstart', {
                            view: window,
                            bubbles: true,
                            cancelable: true,
                            touches: [new Touch({
                                identifier: Date.now(),
                                target: clickableElement,
                                clientX: 0,
                                clientY: 0
                            })]
                        });
                        clickableElement.dispatchEvent(touchEvent);
                        clickableElement.click();
                    }

// 视觉反馈
                    element.style.boxShadow = '0 0 20px rgba(255, 0, 0, 0.8)';
                    setTimeout(() => {
                        element.style.boxShadow = '';
                    }, 2000);

updateStatus('✅ 已点击匹配的商品');
                    updateInfoList('✅ 已点击匹配的商品');

// 额外尝试：如果页面有跳转，可能需要等待
                    safeSetTimeout(() => {
                        if (window.location.href.includes('goods_detail')) {
                            console.log('📱 已跳转到商品详情页');
                        }
                    }, 2000);

} else {
                    console.log('❌ 未找到可点击元素，尝试直接点击原元素');
                    // 最后的尝试：直接点击原元素
                    if (typeof element.click === 'function') {
                        element.click();
                    }
                }

} catch (error) {
                console.error('❌ 点击失败:', error);
                // 最后的回退方案：尝试点击任何链接
                const anyLink = element.querySelector('a') || element.closest('a');
                if (anyLink && anyLink.href) {
                    console.log('📱 回退方案: 直接跳转到链接', anyLink.href);
                    window.location.href = anyLink.href;
                } else {
                    updateStatus('❌ 点击失败，请手动点击');
                }
            }
        }, 2000); // 延迟2秒后点击
    }
    
    // ==================== WebSocket通信 ====================
    async function loadSocketIO() {
        if (window.io) {
            return window.io;
        }

if (document.querySelector('script[src*="socket.io/3.1.3"]')) {
            return new Promise(resolve => {
                const checkLoaded = setInterval(() => {
                    if (window.io) {
                        clearInterval(checkLoaded);
                        resolve(window.io);
                    }
                }, 300);
            });
        }

return new Promise((resolve, reject) => {
            const script = document.createElement('script');
            script.src = "https://cdnjs.cloudflare.com/ajax/libs/socket.io/3.1.3/socket.io.min.js";
            script.crossOrigin = "anonymous";
            script.onload = () => {
                if (window.io) {
                    resolve(window.io);
                } else {
                    reject(new Error("socket.io加载后未定义"));
                }
            };
            script.onerror = (err) => {
                reject(new Error(`加载失败: ${err.message || '未知错误'}`));
            };
            document.head.appendChild(script);
        });
    }

async function initSocket() {
        if (STATE.socketState.isConnecting || STATE.socketState.isDestroyed) {
            return;
        }

STATE.socketState.isConnecting = true;
        STATE.socketState.reconnectCount = 0;

try {
            const io = await loadSocketIO();
            const socket = io(SERVER_CONFIG.SOCKET_URL, {
                path: SERVER_CONFIG.SOCKET_PATH,
                transports: ['websocket'],
                reconnection: false,
                query: { clientId: SERVER_CONFIG.CLIENT_ID },
                timeout: SERVER_CONFIG.CONNECT_TIMEOUT,
                autoConnect: false
            });

bindSocketEvents(socket);
            socket.connect();
            STATE.socketState.socket = socket;
            window.pddChatSocket = socket;
            return socket;

} catch (err) {
            handleReconnect();
        } finally {
            STATE.socketState.isConnecting = false;
        }
    }

function bindSocketEvents(socket) {
        socket.on('connect', () => {
            socket.emit('client_ready', {
                clientId: SERVER_CONFIG.CLIENT_ID,
                time: new Date().toISOString(),
                source: 'pdd_ctrl_f_matcher'
            });
            updateServerStatus(true);

console.log('✅ WebSocket连接成功');
        });

socket.on('connect_error', (err) => {
            console.error('❌ WebSocket连接错误:', err.message);
            updateServerStatus(false);
            handleReconnect();
        });

socket.on('connect_timeout', () => {
            console.error('⏰ WebSocket连接超时');
            updateServerStatus(false);
            handleReconnect();
        });

socket.on('disconnect', (reason) => {
            console.log('🔌 WebSocket断开连接:', reason);
            STATE.socketState.socket = null;
            window.pddChatSocket = null;
            updateServerStatus(false);

if (reason === 'io server disconnect') {
                handleReconnect();
            } else if (reason !== 'io client disconnect') {
                handleReconnect();
            }
        });

socket.on('message', (data) => {
            if (data.type === 'product_list' && data.products && Array.isArray(data.products)) {
                if (STATE.matchState.isProcessingWebSocket) {
                    console.log('⚠️ WebSocket处理中，跳过本次消息');
                    return;
                }

STATE.matchState.isProcessingWebSocket = true;

const oldCount = STATE.socketState.processedProducts.length;
                STATE.socketState.currentProducts = data.products;
                const processedProducts = processServerProducts(data.products);
                STATE.socketState.processedProducts = processedProducts;
                STATE.matchState.products = processedProducts;

STATE.matchState.hasReceivedProducts = true;
                updateServerProductCount(processedProducts.length);
                updateStatus(`收到 ${processedProducts.length} 个服务器商品`);
                updateUIProductList();

console.log(`📦 WebSocket收到商品: ${processedProducts.length} 个`);

// 只有在匹配状态下才处理
                if (processedProducts.length > 0 && STATE.matchState.isMatching) {
                    console.log('📊 收到商品，准备开始匹配');

// 先完全停止滚动
                    completelyStopAllScrolling();

// 等待后开始匹配
                    safeSetTimeout(() => {
                        if (STATE.matchState.isMatching) {
                            console.log('📊 开始匹配新收到的商品');
                            startFullMatch();
                        }
                        STATE.matchState.isProcessingWebSocket = false;
                    }, 2000);
                } else {
                    STATE.matchState.isProcessingWebSocket = false;
                }
            }
        });

socket.on('error', (err) => {
            console.error(`❌ Socket错误: ${err.message}`);
        });
    }

function handleReconnect() {
        if (STATE.socketState.isDestroyed) return;

STATE.socketState.reconnectCount++;
        if (STATE.socketState.reconnectCount > SERVER_CONFIG.MAX_RECONNECT_ATTEMPTS) {
            updateServerStatus(false, '连接失败，请检查网络');
            return;
        }

const delay = SERVER_CONFIG.RECONNECT_DELAY * STATE.socketState.reconnectCount;
        console.log(`🔄 尝试重新连接 (${STATE.socketState.reconnectCount}/${SERVER_CONFIG.MAX_RECONNECT_ATTEMPTS}) 在 ${delay}ms 后`);

safeSetTimeout(() => {
            if (!STATE.socketState.socket || !STATE.socketState.socket.connected) {
                initSocket();
            }
        }, delay);
    }

// ==================== UI界面 ====================
    function createUI() {
        const oldUI = document.getElementById('pdd-ctrl-f-matcher');
        if (oldUI) oldUI.remove();

const container = document.createElement('div');
        container.id = 'pdd-ctrl-f-matcher';
        container.style.cssText = `
            position: fixed;
            top: 20px;
            right: 20px;
            width: ${IS_MOBILE ? '350px' : '400px'};
            background: white;
            border-radius: 10px;
            box-shadow: 0 5px 25px rgba(0,0,0,0.15);
            z-index: 100000;
            font-family: 'Microsoft YaHei', sans-serif;
            overflow: hidden;
            touch-action: none;
        `;

const titleBar = document.createElement('div');
        titleBar.style.cssText = `
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            color: white;
            padding: 15px;
            font-weight: bold;
            font-size: ${IS_MOBILE ? '14px' : '16px'};
            display: flex;
            justify-content: space-between;
            align-items: center;
            cursor: move;
            -webkit-user-select: none;
            user-select: none;
            touch-action: none;
        `;
        titleBar.innerHTML = `
            <div style="display: flex; align-items: center; gap: 10px;">
                <span>🔍 Ctrl+F匹配${IS_MOBILE ? '(移动版)' : ''}</span>
                <span id="pdd-server-status" style="font-size: 12px; background: rgba(255,255,255,0.2); padding: 2px 8px; border-radius: 10px;">
                    连接中...
                </span>
            </div>
            <div>
                <button id="pdd-minimize" style="background:none;border:none;color:white;cursor:pointer;margin-right:10px;font-size:18px;">−</button>
                <button id="pdd-close" style="background:none;border:none;color:white;cursor:pointer;font-size:20px;">×</button>
            </div>
        `;

const content = document.createElement('div');
        content.id = 'pdd-content';
        content.style.padding = '15px';

const controls = document.createElement('div');
        controls.style.cssText = `
            display: grid;
            grid-template-columns: 1fr 1fr;
            gap: 10px;
            margin-bottom: 15px;
        `;
        controls.innerHTML = `
            <button id="pdd-start-btn" style="padding:10px;background:#10b981;color:white;border:none;border-radius:6px;cursor:pointer;font-weight:bold;">▶️ 开始匹配</button>
            <button id="pdd-stop-btn" style="padding:10px;background:#ef4444;color:white;border:none;border-radius:6px;cursor:pointer;font-weight:bold;">⏹️ 停止</button>
        `;

const status = document.createElement('div');
        status.id = 'pdd-status';
        status.style.cssText = `
            padding: 12px;
            margin-bottom: 15px;
            border-radius: 8px;
            background: #f8fafc;
            font-size: 14px;
            text-align: center;
            min-height: 20px;
            border: 2px solid #e2e8f0;
            color: #334155;
        `;
        status.textContent = '等待服务器连接...';

const progress = document.createElement('div');
        progress.id = 'pdd-progress';
        progress.style.cssText = `
            display: flex;
            align-items: center;
            gap: 10px;
            margin-bottom: 15px;
            font-size: 12px;
            color: #64748b;
            justify-content: space-between;
        `;
        progress.innerHTML = `
            <div>商品: <span id="pdd-progress-text">0/0</span></div>
            <div>匹配度: <span id="pdd-match-rate">0%</span></div>
            <div>服务器商品: <span id="pdd-server-count">0</span></div>
        `;

const infoHeader = document.createElement('div');
        infoHeader.style.cssText = `
            font-weight: bold;
            color: #1e293b;
            margin-bottom: 10px;
            padding-bottom: 8px;
            border-bottom: 2px solid #cbd5e1;
            font-size: 14px;
        `;
        infoHeader.innerHTML = '📊 匹配信息';

const infoList = document.createElement('div');
        infoList.id = 'pdd-info-list';
        infoList.style.cssText = `
            max-height: 150px;
            overflow-y: auto;
            border: 1px solid #e2e8f0;
            border-radius: 6px;
            padding: 5px;
            background: #f9fafb;
            font-size: 12px;
            line-height: 1.4;
        `;

const productsHeader = document.createElement('div');
        productsHeader.style.cssText = `
            font-weight: bold;
            color: #1e293b;
            margin-bottom: 10px;
            padding-bottom: 8px;
            border-bottom: 2px solid #cbd5e1;
            font-size: 14px;
        `;
        productsHeader.innerHTML = '📦 服务器商品 <span id="pdd-product-count">(0)</span>';

const productsList = document.createElement('div');
        productsList.id = 'pdd-products-list';
        productsList.style.cssText = `
            max-height: 200px;
            overflow-y: auto;
            border: 1px solid #e2e8f0;
            border-radius: 6px;
            padding: 5px;
            background: #f9fafb;
        `;

content.appendChild(controls);
        content.appendChild(status);
        content.appendChild(progress);
        content.appendChild(infoHeader);
        content.appendChild(infoList);
        content.appendChild(productsHeader);
        content.appendChild(productsList);

container.appendChild(titleBar);
        container.appendChild(content);

document.body.appendChild(container);

setupUIEvents(container);
        setupDragEvents(container, titleBar);
    }

function setupDragEvents(container, dragHandle) {
        let isDragging = false;
        let startX, startY, initialLeft, initialTop;

dragHandle.addEventListener('mousedown', startDrag);

dragHandle.addEventListener('touchstart', (e) => {
            e.preventDefault();
            const touch = e.touches[0];
            startDrag({
                clientX: touch.clientX,
                clientY: touch.clientY,
                target: e.target
            });
        });

function startDrag(e) {
            if (e.target.tagName === 'BUTTON') return;

isDragging = true;
            startX = e.clientX;
            startY = e.clientY;

const rect = container.getBoundingClientRect();
            initialLeft = rect.left;
            initialTop = rect.top;

container.style.opacity = '0.9';
            container.style.transition = 'none';

document.addEventListener('mousemove', onDrag);
            document.addEventListener('mouseup', stopDrag);
            document.addEventListener('touchmove', onTouchMove);
            document.addEventListener('touchend', stopDrag);
        }

function onDrag(e) {
            if (!isDragging) return;
            e.preventDefault();
            updatePosition(e.clientX, e.clientY);
        }

function onTouchMove(e) {
            if (!isDragging) return;
            e.preventDefault();
            const touch = e.touches[0];
            updatePosition(touch.clientX, touch.clientY);
        }

function updatePosition(clientX, clientY) {
            const dx = clientX - startX;
            const dy = clientY - startY;

let newLeft = initialLeft + dx;
            let newTop = initialTop + dy;

const maxLeft = window.innerWidth - container.offsetWidth;
            const maxTop = window.innerHeight - container.offsetHeight;

newLeft = Math.max(0, Math.min(newLeft, maxLeft));
            newTop = Math.max(0, Math.min(newTop, maxTop));

container.style.left = newLeft + 'px';
            container.style.top = newTop + 'px';
            container.style.right = 'auto';
        }

function stopDrag() {
            if (!isDragging) return;

isDragging = false;
            container.style.opacity = '1';
            container.style.transition = 'opacity 0.2s';

document.removeEventListener('mousemove', onDrag);
            document.removeEventListener('mouseup', stopDrag);
            document.removeEventListener('touchmove', onTouchMove);
            document.removeEventListener('touchend', stopDrag);
        }

dragHandle.style.userSelect = 'none';
        dragHandle.style.webkitUserSelect = 'none';
    }

function setupUIEvents(container) {
    // 通过 container 查找按钮，更可靠
    const startBtn = container.querySelector('#pdd-start-btn');
    const stopBtn = container.querySelector('#pdd-stop-btn');
    const minimizeBtn = container.querySelector('#pdd-minimize');
    const closeBtn = container.querySelector('#pdd-close');
    const content = container.querySelector('#pdd-content');  // 确保 content 有 id="pdd-content"

// 开始/停止（沿用原有 click，移动端 click 一般正常）
    if (startBtn) startBtn.onclick = startMatching;
    if (stopBtn) stopBtn.onclick = stopMatching;

// ---------- 最小化按钮（修复移动端）----------
    if (minimizeBtn) {
        const toggleContent = () => {
            if (content) {
                content.style.display = content.style.display === 'none' ? 'block' : 'none';
            }
        };
        // 电脑端用 click
        minimizeBtn.onclick = toggleContent;
        // 移动端用 touchstart 直接触发，并阻止默认行为（避免触发拖拽）
        minimizeBtn.ontouchstart = (e) => {
            e.preventDefault();   // 关键：防止滚动/拖拽干扰
            toggleContent();
        };
    }

// ---------- 关闭按钮（修复移动端）----------
    if (closeBtn) {
        const hidePanel = () => {
            container.style.display = 'none';
            stopMatching();       // 停止匹配并清空状态
        };
        closeBtn.onclick = hidePanel;
        closeBtn.ontouchstart = (e) => {
            e.preventDefault();
            hidePanel();
        };
    }
}

function updateStatus(message, isSuccess = false) {
        const status = document.getElementById('pdd-status');
        if (status) {
            status.textContent = message;
            status.style.background = isSuccess ? '#d1fae5' : '#f8fafc';
            status.style.color = isSuccess ? '#065f46' : '#334155';
            status.style.borderColor = isSuccess ? '#10b981' : '#e2e8f0';
        }

updateInfoList(`状态: ${message}`);
    }

function updateInfoList(message) {
        const infoList = document.getElementById('pdd-info-list');
        if (!infoList) return;

const item = document.createElement('div');
        item.style.cssText = `
            padding: 4px;
            border-bottom: 1px solid #e2e8f0;
            color: #475569;
        `;

infoList.appendChild(item);

while (infoList.children.length > 20) {
            infoList.removeChild(infoList.firstChild);
        }

infoList.scrollTop = infoList.scrollHeight;
    }

function updateUIProgress() {
        const progressText = document.getElementById('pdd-progress-text');
        const matchRate = document.getElementById('pdd-match-rate');

if (progressText) {
            const products = STATE.socketState.processedProducts;
            progressText.textContent = `${STATE.matchState.productIndex + 1}/${products.length}`;
        }

if (matchRate && STATE.matchState.matchHistory.length > 0) {
            const lastMatch = STATE.matchState.matchHistory[STATE.matchState.matchHistory.length - 1];
            matchRate.textContent = `${lastMatch.matchRate}%`;
            matchRate.style.color = lastMatch.matchRate >= 85 ? '#10b981' :
                                   lastMatch.matchRate >= 60 ? '#f59e0b' : '#ef4444';
        }
    }

function updateUIProductList() {
        const list = document.getElementById('pdd-products-list');
        const count = document.getElementById('pdd-product-count');

if (!list || !count) return;

const products = STATE.socketState.processedProducts;

list.innerHTML = '';
        count.textContent = `(${products.length})`;

products.forEach((product, index) => {
            const item = document.createElement('div');
            item.style.cssText = `
                padding: 10px;
                margin-bottom: 6px;
                background: ${index === STATE.matchState.productIndex ? '#e0e7ff' : '#f1f5f9'};
                border-radius: 6px;
                border-left: 4px solid ${index === STATE.matchState.productIndex ? '#4f46e5' : '#94a3b8'};
                font-size: 12px;
                transition: all 0.2s;
                display: flex;
                align-items: center;
                gap: 10px;
            `;

const img = document.createElement('img');
            img.src = product.image;
            img.style.cssText = `
                width: 50px;
                height: 50px;
                border-radius: 4px;
                object-fit: cover;
                border: 1px solid #e2e8f0;
            `;
            img.onerror = () => {
                img.src = 'https://picsum.photos/50/50';
            };

const info = document.createElement('div');
            info.style.flex = '1';

const displayName = product.name || '未知商品';
            const shortDisplayName = displayName.length > 25 ? displayName.substring(0, 25) + '...' : displayName;

const searchText = product.sales_tip || product.price_info || product.name || '无搜索文本';

info.innerHTML = `
                <div style="font-weight: bold; margin-bottom: 4px; color: ${index === STATE.matchState.productIndex ? '#3730a3' : '#334155'}">
                    ${index + 1}. ${shortDisplayName}
                </div>
                <div style="color: #475569; font-size: 11px;">
                    <div>💰 价格: <strong>${product.price_info || '无'}</strong></div>
                    <div>📈 销量: <strong>${product.sales_tip || '无'}</strong></div>
                    <div style="margin-top: 4px; color: #7c3aed; font-weight: bold; background: #f3f4f6; padding: 3px 6px; border-radius: 3px;">
                        🔍 搜索文本: "${searchText.substring(0, 20)}${searchText.length > 20 ? '...' : ''}"
                    </div>
                </div>
            `;

item.appendChild(img);
            item.appendChild(info);
            list.appendChild(item);
        });
    }

function updateServerStatus(connected, message = '') {
        const statusElement = document.getElementById('pdd-server-status');
        if (!statusElement) return;

if (connected) {
            statusElement.innerHTML = '✅ 已连接';
            statusElement.style.background = 'rgba(34, 197, 94, 0.2)';
        } else {
            statusElement.innerHTML = message || '❌ 未连接';
            statusElement.style.background = 'rgba(239, 68, 68, 0.2)';
        }
    }

function updateServerProductCount(count) {
        const countElement = document.getElementById('pdd-server-count');
        if (countElement) {
            countElement.textContent = count;
            countElement.style.color = count > 0 ? '#10b981' : '#ef4444';
        }
    }

// ==================== 样式 ====================
    function addStyles() {
        const style = document.createElement('style');
        style.textContent = `
            @keyframes pdd-highlight-blink {
                0% { background-color: #ffff00; }
                50% { background-color: #ffea00; }
                100% { background-color: #ffff00; }
            }

.pdd-product-highlight {
                transition: outline 0.3s ease;
                animation: pdd-product-pulse 2s infinite;
            }

@keyframes pdd-product-pulse {
                0% { outline-color: #ff6b6b; }
                50% { outline-color: #ff9e6b; }
                100% { outline-color: #ff6b6b; }
            }

#pdd-ctrl-f-matcher {
                touch-action: none !important;
            }
        `;
        document.head.appendChild(style);
    }

// ==================== 初始化 ====================
    function initialize() {
        STATE.matchState.searcher = new TextSearcher();
        installJsonHook();
        setupScrollListener();
        createUI();
        addStyles();

console.log(`🚀 PDD Ctrl+F式商品匹配系统启动（终极修复版）`);
        console.log(`📱 设备类型: ${IS_MOBILE ? '移动设备' : '桌面设备'}`);
        console.log('🔄 滚动控制: 终极修复版本');

// 启动WebSocket连接
        initSocket();
        startHealthCheck();

// 页面加载自动开始
        safeSetTimeout(() => {
            autoStartOnPageLoad();
        }, 3000);
    }

// ==================== 全局暴露 ====================
    window.PDD_CtrlF_Matcher = {
        start: startMatching,
        stop: stopMatching,
        startAutoScroll: startAutoScroll,
        stopAutoScroll: completelyStopAllScrolling,
        getProducts: () => STATE.socketState.processedProducts,
        getRawProducts: () => STATE.socketState.currentProducts,
        getFirstInteraction: () => STATE.firstInteraction,
        state: STATE
    };

// 启动
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', initialize);
    } else {
        setTimeout(initialize, 1000);
    }

})();