YJJ_YBM/YBM/nextpage.py

from playwright.sync_api import sync_playwright, TimeoutError as PlaywrightTimeoutError
import os
import json
import random
from logger_config import logger
from config import *
import re
COOKIE_FILE_PATH = "ybm_cookies.json"  # Cookie保存路径
LOGIN_VALIDATE_URL = "https://www.ybm100.com/new/"
TARGET_LOGIN_URL = "https://www.ybm100.com/new/login"


# ========== 新增：滚动相关配置（可根据需要调整） ==========
SCROLL_STEP = 200  # 每次滚动的步长（像素），越小越慢越逼真
SCROLL_DELAY = 0.15  # 每步滚动的延迟（秒），越大越慢
MAX_SCROLL_ATTEMPTS = 50  # 最大滚动次数（防止无限循环）



def load_cookies(context, cookie_path=COOKIE_FILE_PATH):
    """从本地JSON文件加载Cookie到浏览器上下文"""
    if not os.path.exists(cookie_path):
        # logger.warning(f" Cookie文件不存在：{cookie_path}")
        return False
    try:
        with open(cookie_path, "r", encoding="utf-8") as f:
            cookies = json.load(f)
        context.add_cookies(cookies)
        # logger.info(f"✅ 已从{cookie_path}加载Cookie")
        return True
    except Exception as e:
        # logger.error(f" 加载Cookie失败：{e}")
        return False



def is_login(page):
    """验证是否已登录（核心：检测登录态）"""
    try:
        # 访问需要登录的页面
        page.goto(LOGIN_VALIDATE_URL, timeout=5000)
        page.wait_for_load_state("networkidle")

        # 检测是否跳转到登录页（URL包含login则未登录）
        if "login" in page.url.lower():
            # logger.warning(" Cookie失效，需要重新登录")
            return False

        # 可选：检测登录后的专属元素（比如用户名、个人中心等）
        # if page.locator("用户中心选择器").count() > 0:
        #     return True
        # logger.info(" Cookie有效，已保持登录状态")
        return True
    except Exception as e:
        # logger.error(f" 验证登录状态失败：{e}")
        return False


def popup_guard(page, tag=""):
    """
    全局弹窗/遮罩守卫：多步引导 + 关闭按钮 + 遮罩清理 + 恢复滚动
    tag 仅用于日志区分调用位置
    """
    try:
        # 给弹窗一点出现时间
        page.wait_for_timeout(300)

        # 1) 连续点“下一步/完成/我知道了/关闭”
        for _ in range(6):
            btn = page.locator(
                "xpath=//button[normalize-space()='下一步' or normalize-space()='完成' or normalize-space()='我知道了' or normalize-space()='关闭']"
            ).first
            if btn.count() > 0 and btn.is_visible():
                btn.click(timeout=1500)
                page.wait_for_timeout(250)
                continue

            # 2) 常见的 close icon
            close_btn = page.locator(
                "css=.el-dialog__headerbtn, .el-message-box__headerbtn, .close, .icon-close, .el-icon-close"
            ).first
            if close_btn.count() > 0 and close_btn.is_visible():
                close_btn.click(timeout=1200)
                page.wait_for_timeout(250)
                continue

            break

        # 3) 清遮罩 + 恢复滚动/交互
        page.evaluate(r"""
        () => {
          // 第一步：精准清理已知的遮罩/弹窗类名（Element UI框架常用）
          const selectors = [
            '.v-modal', '.el-overlay', '.el-overlay-dialog', '.el-dialog__wrapper',
            '.el-message-box__wrapper', '.el-loading-mask'
          ];
          selectors.forEach(sel => document.querySelectorAll(sel).forEach(e => e.remove()));

          // 泛化兜底：近似全屏 + 高 z-index 的层直接屏蔽
          const all = Array.from(document.querySelectorAll('body *'));
          for (const el of all) {
            const s = getComputedStyle(el); // 获取元素的实际样式（含CSS生效的样式）
            const z = parseInt(s.zIndex || '0', 10);    // 取元素的层级（z-index），默认0
            // 条件1：元素是固定/绝对定位（弹窗/遮罩常见定位方式）+ 层级≥1000（高优先级遮挡）+ 能拦截鼠标事件
            if ((s.position === 'fixed' || s.position === 'absolute') && z >= 1000 && s.pointerEvents !== 'none') {
              const r = el.getBoundingClientRect();     // 获取元素的尺寸和位置
                // 条件2：元素宽度/高度≥屏幕80%（近似全屏遮罩）
              const nearFull = r.width >= innerWidth * 0.8 && r.height >= innerHeight * 0.8;
              if (nearFull) {
                el.style.pointerEvents = 'none';    // 让元素不拦截鼠标点击
                el.style.display = 'none';          // 隐藏元素
              }
            }
          }
        // 第三步：恢复页面滚动功能（弹窗常把页面设为不可滚动）
          document.documentElement.style.overflow = 'auto';     // html标签恢复滚动
          document.body.style.overflow = 'auto';    // body标签恢复滚动
          document.body.classList.remove('el-popup-parent--hidden');  // 移除Element UI的滚动禁用类
        }
        """)

        # logger.info("杀除弹窗成功")
    except Exception:
        pass

SEARCH_INPUT_SELECTOR = "input[placeholder*='药品名称/厂家名称']"

def pick_search_input(page):
    """优先选可见且可用的搜索输入框；第一个不行就尝试第二个"""
    inputs = page.locator(SEARCH_INPUT_SELECTOR)
    cnt = inputs.count()

    # 优先检查前两个（你说只有两个）
    for i in range(min(cnt, 2)):
        candidate = inputs.nth(i)
        try:
            candidate.wait_for(state="visible", timeout=1500)  # 小超时快速试探
            if candidate.is_enabled():
                return candidate
        except PlaywrightTimeoutError:
            continue

    # 兜底：直接找任意可见的（避免命中 hidden 模板）
    candidate = page.locator(f"{SEARCH_INPUT_SELECTOR}:visible").first
    candidate.wait_for(state="visible", timeout=5000)
    return candidate


def type_slow(locator, text: str, min_delay=0.06, max_delay=0.18):
    """逐字输入，模拟真人打字"""
    for ch in text:
        locator.type(ch, delay=int(random.uniform(min_delay, max_delay) * 1000))

SEARCH_BTN_SELECTOR = 'div.home-search-container-search-head-btn[data-scmd="text-搜索"]'



def force_close_popup(page):
    """增强版：优先清理遮罩，再处理引导按钮"""
    try:
        # 第一步：先强制移除所有遮罩层（前置操作，关键！）
        page.evaluate("""
        () => {
            // 1. 移除所有高优先级遮罩
            const maskSelectors = [
                '.v-modal', '.el-overlay', '.el-overlay-dialog', '.el-dialog__wrapper',
                '.el-message-box__wrapper', '.el-loading-mask', '[class*="mask"]', '[class*="overlay"]',
                '[style*="position: fixed"][style*="z-index: 9999"]', '[style*="position: absolute"][style*="z-index: 9999"]'
            ];
            maskSelectors.forEach(sel => {
                document.querySelectorAll(sel).forEach(el => {
                    el.remove(); // 直接删除遮罩元素
                });
            });
            // 2. 恢复body和列表容器的交互
            document.body.style.overflow = 'auto';
            document.body.style.pointerEvents = 'auto';
            // 3. 强制解除列表容器的样式限制
            document.querySelectorAll('.product-list-container, .list-container, .el-table__body-wrapper').forEach(el => {
                el.style.overflow = 'auto !important';
                el.style.height = 'auto !important';
                el.style.maxHeight = 'calc(100vh - 200px) !important';
                el.style.pointerEvents = 'auto !important';
            });
        }
        """)
        page.wait_for_timeout(500)

        # 第二步：处理引导按钮（下一步/完成/关闭）
        for _ in range(5):
            btn = page.locator(
                "//button[normalize-space()='下一步' or normalize-space()='完成' or normalize-space()='我知道了' or normalize-space()='关闭']"
            ).first
            if btn.count() > 0 and btn.is_visible():
                btn.click(timeout=1500)
                page.wait_for_timeout(300)
                continue

            close_icon = page.locator(
                "xpath=//*[contains(@class,'close') or contains(@class,'el-icon-close') or name()='svg' or name()='i'][1]"
            ).first
            if close_icon.count() > 0 and close_icon.is_visible():
                close_icon.click(timeout=1000)
                page.wait_for_timeout(300)
                continue
            break
    except Exception as e:
        logger.warning(f"⚠️ 强制清理弹窗时异常：{e}")

def kill_masks(page):
    """增强版：强制解除所有样式限制"""
    page.evaluate(r"""
    () => {
        // 1. 移除所有已知遮罩类
        const knownSelectors = [
            '.v-modal', '.el-overlay', '.el-overlay-dialog', '.el-dialog__wrapper',
            '.el-message-box__wrapper', '.el-loading-mask', '.el-popup-parent--hidden'
        ];
        knownSelectors.forEach(sel => {
            document.querySelectorAll(sel).forEach(el => el.remove());
        });

        // 2. 泛化清理所有高z-index遮挡层
        const all = Array.from(document.querySelectorAll('body *'));
        for (const el of all) {
            const s = getComputedStyle(el);
            if (!s) continue;

            const z = parseInt(s.zIndex || '0', 10);
            const pos = s.position;
            const pe = s.pointerEvents;

            if ((pos === 'fixed' || pos === 'absolute') && z >= 1000) {
                el.remove(); // 直接删除高优先级遮挡元素
            }
        }

        // 3. 强制恢复页面所有元素的交互和滚动
        document.documentElement.style.overflow = 'auto !important';
        document.body.style.overflow = 'auto !important';
        document.body.style.position = 'static !important';
        document.body.style.width = 'auto !important';
        document.body.style.paddingRight = '0px !important';
        document.body.style.pointerEvents = 'auto !important';
        document.body.classList.remove('el-popup-parent--hidden');

        // 4. 强制恢复商品列表容器的样式（关键！）
        document.querySelectorAll('.product-list-container').forEach(el => {
            el.style.overflow = 'auto !important';
            el.style.height = 'auto !important';
            el.style.maxHeight = 'calc(100vh - 200px) !important';
            el.style.display = 'block !important';
            el.style.visibility = 'visible !important';
            el.style.pointerEvents = 'auto !important';
        });

        return { success: true };
    }
    """)




def slow_scroll_to_bottom(page):
    """
    模拟真人慢速滚动到页面最底部（适配全局/局部滚动容器）
    :param page: 页面对象
    :return: None
    """
    try:
        logger.info("📜 开始慢速滚动到页面底部...")
        # ========== 前置：强制刷新容器样式 ==========
        page.evaluate("""
        () => {
            // 1. 强制重绘商品列表容器
            const container = document.querySelector('.product-list-container');
            if (container) {
                container.style.overflow = 'auto !important';
                container.offsetHeight; // 触发重绘，更新高度
            }
            // 2. 强制刷新页面滚动高度
            document.documentElement.offsetHeight;
        }
        """)
        page.wait_for_timeout(500)

        # 调试日志：打印滚动容器信息（保留）
        container_debug = page.evaluate("""
        () => {
            const container = document.querySelector('.product-list-container') || document.documentElement;
            return {
                tag: container.tagName,
                className: container.className,
                scrollHeight: container.scrollHeight,
                clientHeight: container.clientHeight,
                scrollTop: container.scrollTop
            };
        }
        """)
        logger.info(f"滚动容器信息：{container_debug}")

        scroll_attempts = 0
        last_scroll_height = -1  # 初始值改为-1，避免首次误判

        while scroll_attempts < MAX_SCROLL_ATTEMPTS:
            # ========== 关键：每次循环都重新获取容器信息 ==========
            scroll_container_info = page.evaluate("""
            () => {
                // 优先找商品列表容器
                const container = document.querySelector('.product-list-container') || document.documentElement;
                return {
                    isGlobal: container === document.documentElement,
                    scrollHeight: container.scrollHeight,
                    scrollTop: container.scrollTop,
                    clientHeight: container.clientHeight
                };
            }
            """)

            current_scroll_height = scroll_container_info["scrollHeight"]
            current_scroll_top = scroll_container_info["scrollTop"]
            client_height = scroll_container_info["clientHeight"]
            is_global = scroll_container_info["isGlobal"]

            # ========== 优化到底判断逻辑 ==========
            # 条件1：滚动高度无变化（连续2次相同）；条件2：已滚到底（留50px余量）
            is_height_same = current_scroll_height == last_scroll_height
            is_scroll_bottom = (current_scroll_top + client_height) >= (current_scroll_height - 50)
            if is_height_same and scroll_attempts > 2:  # 至少滚动2次再判断高度无变化
                logger.info(f"✅ 滚动高度无变化，判定已到底部")
                break
            if is_scroll_bottom:
                logger.info(f"✅ 已滚动到容器底部")
                break

            # ========== 执行滚动 ==========
            random_delay = random.uniform(SCROLL_DELAY - 0.05, SCROLL_DELAY + 0.05)
            if is_global:
                # 全局滚动
                page.evaluate(f"window.scrollBy(0, {SCROLL_STEP})")
            else:
                # 局部容器滚动（核心！）
                page.evaluate(f"""
                () => {{
                    const container = document.querySelector('.product-list-container');
                    if (container) {{
                        container.scrollTop += {SCROLL_STEP};
                        // 滚动后触发重绘
                        container.offsetHeight;
                    }}
                }}
                """)

            page.wait_for_timeout(int(random_delay * 1000))

            # 更新状态
            last_scroll_height = current_scroll_height
            scroll_attempts += 1

        # 最后强制滚到底
        page.evaluate("""
        () => {
            const container = document.querySelector('.product-list-container') || document.documentElement;
            container.scrollTop = container.scrollHeight;
        }
        """)
        page.wait_for_timeout(500)
    except Exception as e:
        logger.warning(f"⚠️ 慢速滚动到底部时出现异常：{e}")







def search_operation(page, keyword, is_first_search: bool = True):
    """搜索框填充+提交搜索（遮罩前置清理）"""
    try:
        # ========== 前置清理：先清遮罩，再操作搜索框 ==========
        force_close_popup(page)
        kill_masks(page)

        search_locator = page.locator(SEARCH_INPUT_SELECTOR)
        search_locator.wait_for(timeout=ELEMENT_TIMEOUT)

        # 清空搜索框
        search_locator.click(force=True)
        search_locator.fill("")
        page.keyboard.down("Control")
        page.keyboard.press("a")
        page.keyboard.up("Control")
        page.keyboard.press("Backspace")

        # 逐字输入
        type_slow(search_locator, keyword, min_delay=0.06, max_delay=0.18)
        logger.info(f"📝 已输入搜索关键词：{keyword}")

        # ========== 再次清理：点击搜索前再清一次 ==========
        force_close_popup(page)

        # 点击搜索按钮
        btn = page.locator(f"{SEARCH_BTN_SELECTOR}")
        btn.wait_for(state="visible", timeout=SEARCH_BTN_TIMEOUT)
        page.wait_for_timeout(3000)

        detail_page = page
        if is_first_search:
            try:
                with page.context.expect_page(timeout=60000) as new_page_info:
                    btn.click()
                detail_page = new_page_info.value
                # ========== 新页面立即清遮罩 ==========
                detail_page.wait_for_load_state("domcontentloaded", timeout=20000)
                force_close_popup(detail_page)
                kill_masks(detail_page)
                detail_page.wait_for_load_state("networkidle", timeout=20000)
            except PlaywrightTimeoutError:
                logger.warning(f"   未检测到新标签页")
                return None, False
            except Exception as e:
                logger.warning(f"   等待新标签页异常：{e}")
                return None, False
        else:
            btn.click()
            # ========== 原页面跳转后立即清遮罩 ==========
            page.wait_for_load_state("domcontentloaded", timeout=20000)
            force_close_popup(page)
            kill_masks(page)
            page.wait_for_load_state("networkidle", timeout=20000)
            detail_page = page
            logger.info("✅ 后续搜索：已在原页面完成跳转加载")

        # 处理引导按钮
        test_btn = detail_page.locator("div[data-v-c65c36bc].first-time-highlight-message-btn button")
        btn_count = test_btn.count()
        logger.info(f"✅ 匹配到的引导按钮数量：{btn_count}")
        if btn_count > 0:
            test_btn.wait_for(state="attached", timeout=5000)
            test_btn.click()

        # 最终清理：确保无残留遮罩
        force_close_popup(detail_page)
        kill_masks(detail_page)
        logger.info("✅ 已触发搜索并清理弹窗")

        # ========== 关键：等待列表渲染 + 强制刷新容器高度 ==========
        # 等待商品列表容器加载
        detail_page.wait_for_selector(".product-list-container", timeout=5000)
        # 强制刷新容器样式（解决高度计算错误）
        detail_page.evaluate("""
        () => {
            const container = document.querySelector('.product-list-container');
            if (container) {
                container.style.overflow = 'auto !important';
                // 强制重绘容器
                container.offsetHeight; // 触发重绘
            }
        }
        """)
        detail_page.wait_for_timeout(1000)

        return detail_page, True

    except PlaywrightTimeoutError as e:
        logger.error(f" 搜索失败：元素定位超时 - {str(e)}")
        return None, False
    except Exception as e:
        logger.error(f" 搜索异常：{str(e)}")
        return None, False


#翻下一页
def goto_next_page(page) -> bool:
    """
    核心修改：基于 button.btn-next 的 aria-disabled 属性判断是否有下一页
    :param page: 搜索结果页面对象（detail_page）
    :return: True=翻页成功，False=无下一页/翻页失败
    """
    try:
        # 1. 定位下一页按钮（精准匹配你指定的元素）
        next_btn = page.locator("button.btn-next").first

        # 2. 先等待按钮加载（确保元素存在）
        next_btn.wait_for(state="attached", timeout=3000)

        # 3. 获取 aria-disabled 属性值（核心判断依据）
        aria_disabled = next_btn.get_attribute("aria-disabled")
        logger.info(f"下一页按钮 aria-disabled 属性值：{aria_disabled}")

        # 4. 判断是否有下一页：aria-disabled="true" 表示无下一页
        if aria_disabled == "true":
            logger.warning("⚠️ 下一页按钮 aria-disabled=true，已无更多页面")
            return False

        # 5. 按钮可用（aria-disabled="false"），先滚动到顶部（避免按钮被遮挡）
        page.evaluate("window.scrollTo(0, 0);")
        page.wait_for_timeout(500)

        # 6. 确保按钮可见且可点击（强制点击兜底）
        if next_btn.is_visible() and next_btn.is_enabled():
            next_btn.click(timeout=5000)
        else:
            # 兜底：强制点击（避免元素不可见但实际可点击的情况）
            next_btn.click(force=True, timeout=5000)

        # 7. 等待页面加载完成（确保翻页后内容刷新）
        page.wait_for_load_state("networkidle", timeout=15000)

        # 8. 翻页后清理遮罩（避免新页面遮罩影响）
        force_close_popup(page)
        kill_masks(page)

        logger.info("✅ 翻页成功，下一页按钮 aria-disabled=false")
        return True

    except PlaywrightTimeoutError:
        logger.warning("⚠️ 下一页按钮加载超时，判定无更多页面")
        return False
    except Exception as e:
        logger.warning(f"⚠️ 翻页操作异常：{e}，判定无更多页面")
        return False



import time
import random
# from playwright.sync_api import MouseWheelDirection

# ========== 滚动配置（保持你的原有配置） ==========
SCROLL_STEP = 50  # 每步滚动50px
SCROLL_INTERVAL = 0.05  # 每步间隔0.05秒
SCROLL_OFFSET_RANGE = 50  # 滚动距离随机偏移±50px
MIN_CLICK_DELAY = 0.5
MAX_CLICK_DELAY = 1.0

def random_delay(min_delay, max_delay):
    """随机延迟（模拟真人操作）"""
    time.sleep(random.uniform(min_delay, max_delay))

def slow_scroll_400px(page, scroll_distance1=400):
    """
    慢速滚动400px±50px（模拟真人鼠标滚轮+强制解除滚动限制）
    适配：全局滚动条动，但JS scrollBy无效的场景
    :param page: 页面对象
    :return: 滚动是否成功
    """
    try:
        # 1. 前置：强制解除页面所有滚动限制（核心！）
        page.evaluate("""
            () => {
                // 强制恢复html/body的滚动能力
                document.documentElement.style.overflow = 'auto !important';
                document.body.style.overflow = 'auto !important';
                document.documentElement.style.pointerEvents = 'auto !important';
                document.body.style.pointerEvents = 'auto !important';
                document.documentElement.style.position = 'static !important';
                document.body.style.position = 'static !important';

                // 移除所有可能禁用滚动的类/属性
                document.body.classList.remove('el-popup-parent--hidden', 'no-scroll');
                document.documentElement.classList.remove('el-popup-parent--hidden', 'no-scroll');

                // 强制刷新滚动高度（避免计算错误）
                document.documentElement.offsetHeight;
            }
        """)
        page.wait_for_timeout(300)

        # 2. 生成随机滚动距离（400±50px）
        scroll_distance = random.randint(
            scroll_distance1 - SCROLL_OFFSET_RANGE,
            scroll_distance1 + SCROLL_OFFSET_RANGE
        )
        # 转换为鼠标滚轮的“步长”（1个滚轮步长≈100px，需适配）
        wheel_steps = int(scroll_distance / 100)
        remaining_pixels = scroll_distance % 100

        logger.info(
            f"📜 开始模拟鼠标滚轮滚动（目标距离：{scroll_distance}px，滚轮步数：{wheel_steps}步 + {remaining_pixels}px）"
        )

        # 3. 第一步：用鼠标滚轮模拟真人滚动（反爬友好）
        # 先把鼠标移到页面中间（商品列表区域），避免滚动空白处
        page.mouse.move(random.randint(300, 800), random.randint(400, 600))
        for _ in range(wheel_steps):
            # 模拟鼠标滚轮向下滚动（1步≈100px）
            page.mouse.wheel(delta_x=0, delta_y=100)
            time.sleep(random.uniform(SCROLL_INTERVAL*2, SCROLL_INTERVAL*5))  # 随机间隔，更像真人

        # 4. 第二步：处理剩余不足1步的像素（用scrollTo兜底）
        if remaining_pixels > 0:
            current_scroll_top = page.evaluate("window.scrollY || document.documentElement.scrollTop")
            target_scroll_top = current_scroll_top + remaining_pixels
            # 用scrollTo强制滚动（比scrollBy更稳定）
            page.evaluate(f"window.scrollTo(0, {target_scroll_top});")
            time.sleep(SCROLL_INTERVAL)

        # 5. 验证滚动是否生效
        final_scroll_top = page.evaluate("window.scrollY || document.documentElement.scrollTop")
        logger.info(f" 滚动完成，当前全局滚动位置：{final_scroll_top}px")

        # 6. 滚动后等待懒加载+模拟真人停顿
        page.wait_for_load_state("networkidle", timeout=8000)
        random_delay(2.0, 3.0)
        return True

    except Exception as e:
        logger.warning(f" 慢速滚动失败：{e}")
        return False



def main():
    with sync_playwright() as p:
        browser = p.chromium.launch(
            headless=False,  # 不要用无头模式（反爬：无头模式易被识别）
            channel="chrome",  # 使用真实Chrome内核
            slow_mo=random.randint(100, 300),  # 全局操作延迟（模拟真人慢速操作）
            args=[
                "--disable-blink-features=AutomationControlled",  # 禁用webdriver特征（核心！）
                "--enable-automation=false",  # 新增：禁用自动化标识
                "--disable-infobars",  # 新增：禁用信息栏
                "--remote-debugging-port=0",  # 新增：随机调试端口
                "--start-maximized",  # 最大化窗口（模拟真人使用）
                "--disable-extensions",  # 禁用扩展（避免特征）
                "--disable-plugins-discovery",  # 禁用插件发现
                "--no-sandbox",  # 避免沙箱模式特征
                "--disable-dev-shm-usage",  # 避免内存限制导致的异常
                f"--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{random.randint(110, 120)}.0.0.0 Safari/537.36"  # 随机Chrome版本的UA
            ]
        )
        # 创建页面时伪装指纹
        context = browser.new_context(
            locale="zh-CN",  # 中文环境
            timezone_id="Asia/Shanghai",  # 上海时区
            geolocation={"latitude": 31.230416, "longitude": 121.473701},  # 模拟上海地理位置（可选）
            permissions=["geolocation"],  # 授予定位权限（模拟真人）
            user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
            no_viewport=True,
            # 关键：隐藏自动化特征
            java_script_enabled=True,
            bypass_csp=True,
            # user_data_dir="./temp_user_data"  # 模拟真实用户数据目录
        )
        # input("...")
        page = context.new_page()


        # 关键：移除navigator.webdriver标识（反爬核心）
        page.add_init_script("""
            Object.defineProperty(navigator, 'webdriver', { get: () => undefined });
            Object.defineProperty(navigator, 'plugins', { get: () => [1, 2, 3] });  // 新增：模拟插件
            Object.defineProperty(navigator, 'mimeTypes', { get: () => [1, 2, 3] });  // 新增：模拟MIME类型
            window.chrome = { runtime: {}, loadTimes: () => ({}) };  // 增强Chrome模拟
            delete window.navigator.languages;
            window.navigator.languages = ['zh-CN', 'zh'];
            // 新增：模拟真实鼠标移动特征
            (() => {
                const originalAddEventListener = EventTarget.prototype.addEventListener;
                EventTarget.prototype.addEventListener = function(type, listener) {
                    if (type === 'mousemove') {
                        return originalAddEventListener.call(this, type, (e) => {
                            e._automation = undefined;
                            listener(e);
                        });
                    }
                    return originalAddEventListener.call(this, type, listener);
                };
            })();
""")


        try:
            # ========== 核心：Cookie复用逻辑 ==========
            # 1. 加载本地Cookie
            load_cookies(context)

            # 2. 验证登录状态
            if not is_login(page):
                # 3. Cookie失效/不存在，执行登录
                page.goto(TARGET_LOGIN_URL)
                page.wait_for_load_state("networkidle")
                # logger.info("🔑 开始执行登录流程")

                # 执行登录操作
                # login_success = login_operation(page, USERNAME, PASSWORD)
                # if not login_success:
                #     logger.error(" 登录失败，程序终止")
                #     return

                # # 4. 登录成功后保存Cookie
                # save_cookies(context)
                # logger.info(" 登录并保存Cookie成功！")

            KEYWORDS = ['999皮炎平 糠酸莫米松凝胶']
            # get_search_keywords_from_db()
            # 执行搜索
            total_num = 0
            # current_page = page
            detail_page = None
            nums = 0
            page_no = 1
            for kw in KEYWORDS:
                popup_guard(page, "before_search")
                if nums == 0:
                    popup_guard(detail_page if detail_page else page, "before_search")  # page是你的初始页面对象，需提前定义
                    detail_page, search_success = search_operation(page, kw, is_first_search=True)
                    nums += 1
                else:
                    if detail_page is None:
                        logger.error(f" ❌ 无可用的搜索页面，跳过「{kw}」")
                        continue
                    popup_guard(detail_page, "before_search")
                    detail_page, search_success = search_operation(detail_page, kw, is_first_search=False)

                if not search_success:
                    print(f"❌ 搜索失败：{kw}")
                    continue

                if detail_page is None:
                    break

                popup_guard(detail_page, "after_search")



                #找不到数据跳过判断和出现杂数据跳过
                not_found_keywords = detail_page.locator("div.filter-panel-container-empty-text")
                if not_found_keywords.count() > 0:
                    logger.warning(f"⚠️ 关键词「{kw}」无匹配商品，直接跳过整个关键词采集")
                    continue



                # detail_page.wait_for_selector("div[class*='product-list'], .el-table", timeout=5000)

                # slow_scroll_to_bottom(detail_page)

                while True:
                    # ✅ 先获取当前页商品个数
                    detail_page.wait_for_load_state("domcontentloaded")  # 先等DOM加载
                    detail_page.wait_for_load_state("networkidle")
                    detail_page.wait_for_timeout(500)                   # 额外等待渲染稳定
                    goods_item = detail_page.locator("div.product-list-item").count()
                    print(f"这页商品有{goods_item}个")


                    slow_scroll_400px(detail_page)
                    if goto_next_page(detail_page):
                        logger.info(f"「{kw}」还有下一页")
                        page_no += 1
                        continue
                    else:
                        logger.info(f" 「{kw}」已无下一页，关键词采集结束")
                        break

        except Exception as e:
            print(f" 程序异常：{str(e)}")
        finally:
            browser.close()
            print(" 浏览器已关闭，程序结束")

# ==================== 程序入口 ====================
if __name__ == '__main__':
    main()