haha/gui_app.py

import os
import sys
import re
from pathlib import Path
from datetime import datetime, timedelta
from typing import Any, Dict, List, Optional

import pandas as pd
from PyQt5.QtWidgets import (
    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
    QLabel, QFileDialog, QTableWidgetItem, QMessageBox,
    QGridLayout, QStackedWidget, QButtonGroup,
    QStyle, QComboBox, QFrame, QShortcut, QMenu,
    QAbstractItemView, QTableView, QHeaderView,
    QTabWidget, QSplitter, QSizePolicy, QCheckBox
)
from PyQt5.QtCore import Qt, QSortFilterProxyModel, QRegularExpression, QSettings, QTimer, QEvent
from PyQt5.QtGui import QFont, QTextCursor, QKeySequence, QColor

from qfluentwidgets import (
    setTheme, Theme,
    PushButton, PrimaryPushButton, LineEdit, TextEdit,
    TableWidget, CheckBox, ProgressBar, CardWidget,
    InfoBar, InfoBarPosition
)
from loguru import logger

from gui_constants import get_default_folder_path, TABLE_HEADERS, MODEL_VIEW_HEADERS
from gui_worker import WorkerThread
from gui_models import ConfigTableModel, TableActionDelegate


# ---------------------------------------------------------------------------
# 主窗口
# ---------------------------------------------------------------------------

class MainWindow(QMainWindow):
    """主窗口"""

    def __init__(self):
        super().__init__()
        self.worker_thread = None
        self.configs: List[Dict[str, Any]] = []  # 存储从Excel导入的配置
        self.prepared_files = None  # 存储通过"更新数据"找到的文件列表
        self.running_total = 0
        self.running_done = 0
        self.nav_compact = False
        self.table_match_rows = []
        self.table_match_index = -1
        self.table_sort_keys = []
        self.page_size = 20
        self.current_page = 1
        self.page_row_indices = []
        self.filtered_config_indices = None  # 文本/状态筛选后的配置索引，None 表示未筛选（显示全部）
        self.use_model_view = False
        # 批量任务队列相关
        self.batch_task_queue = []  # 任务队列
        self.current_batch_task_index = 0  # 当前任务索引
        self.batch_total_tasks = 0  # 总任务数
        self.batch_processed = 0  # 已处理任务数
        self.batch_pending_tasks = 0  # 待处理任务数
        self.batch_success_count = 0  # 成功数量
        self.batch_failed_count = 0  # 失败数量
        self._is_paused = False  # 任务是否暂停
        self._is_terminated = False  # 任务是否被终止
        self.table_model = None
        self.table_proxy = None
        self.log_match_positions = []
        self.log_match_index = -1
        self.is_updating_table = False
        self._is_closing = False  # 标记是否正在关闭窗口
        self._column_width_ratios = {}  # 存储列宽比例，用于自动调整
        self._is_manual_resize = False  # 标记是否正在手动调整列宽
        # 任务执行时用于“多多ID+序号 -> 行号”的映射（用于精确回写状态）
        self._row_map_by_user_index = {}
        # 以下属性在 init_ui() 中初始化，提前声明以满足 PyCharm 代码审查
        self._table_view_column_width_ratios = {}
        self._is_table_view_manual_resize = False
        self._resize_timer = None
        self._table_view_resize_timer = None
        self._auto_resize_timer = None
        self._auto_resize_table_view_timer = None
        self.execute_btn = None
        self.pause_btn = None
        self.resume_btn = None
        self.terminate_btn = None
        self.status_update_value = None
        self.status_pending_value = None
        self.status_running_value = None
        self.status_success_value = None
        self.status_failed_value = None
        self.nav_card = None
        self.nav_title = None
        self.nav_divider = None
        self.nav_group = None
        self.nav_main = None
        self.nav_log = None
        self.nav_buttons = []
        self.nav_footer = None
        self.nav_toggle_btn = None
        self.page_stack = None
        self.excel_path_input = None
        self.import_btn = None
        self.download_template_btn = None
        self.add_user_id_input = None
        self.add_index_input = None
        self.add_topic_input = None
        self.add_schedule_input = None
        self.add_interval_input = None
        self.add_expert_link_input = None
        self.add_executor_input = None
        self.add_config_btn = None
        self.clear_add_inputs_btn = None
        self.folder_path_input = None
        self.folder_browse_btn = None
        self.update_data_btn = None
        self.update_status_label = None
        self.batch_upload_checkbox = None
        self.batch_limit_input = None
        self.table_group = None
        self.table_edit_hint = None
        self.table_select_all_checkbox = None
        self.table_search_input = None
        self.table_column_filter = None
        self.table_highlight = None
        self.table_only_match = None
        self.table_prev_match_btn = None
        self.table_next_match_btn = None
        self.table_clear_btn = None
        self.table_export_all_btn = None
        self.table_select_count = None
        self.config_table = None
        self._filter_table_columns = []
        self._filter_model_columns = []
        self.table_view = None
        self.table_empty_label = None
        self.page_size_combo = None
        self.page_info_label = None
        self.page_first_btn = None
        self.page_prev_btn = None
        self.page_next_btn = None
        self.page_last_btn = None
        self.config_splitter = None
        self.workbench_tabs = None
        self.progress_bar = None
        self.log_search_input = None
        self.log_highlight_check = None
        self.log_whole_word = None
        self.log_prev_btn = None
        self.log_next_btn = None
        self.log_match_status = None
        self.log_export_btn = None
        self.clear_log_btn = None
        self.log_text = None
        self.shortcut_log_next = None
        self.shortcut_log_prev = None
        self._suppress_filter_clear_once = False
        self._current_status_filter = None
        self._update_data_running = False
        self.init_ui()

    def init_ui(self):
        # 初始化列宽调整相关的变量和定时器
        if not hasattr(self, '_table_view_column_width_ratios'):
            self._table_view_column_width_ratios = {}
        if not hasattr(self, '_is_table_view_manual_resize'):
            self._is_table_view_manual_resize = False
        if not hasattr(self, '_resize_timer'):
            self._resize_timer = QTimer()
            self._resize_timer.setSingleShot(True)
            self._resize_timer.timeout.connect(self._delayed_update_ratios)
        if not hasattr(self, '_table_view_resize_timer'):
            self._table_view_resize_timer = QTimer()
            self._table_view_resize_timer.setSingleShot(True)
            self._table_view_resize_timer.timeout.connect(self._delayed_update_table_view_ratios)
        if not hasattr(self, '_auto_resize_timer'):
            self._auto_resize_timer = QTimer()
            self._auto_resize_timer.setSingleShot(True)
            self._auto_resize_timer.timeout.connect(self._auto_resize_table_columns)
        if not hasattr(self, '_auto_resize_table_view_timer'):
            self._auto_resize_table_view_timer = QTimer()
            self._auto_resize_table_view_timer.setSingleShot(True)
            self._auto_resize_table_view_timer.timeout.connect(self._auto_resize_table_view_columns)
        
        self.setWindowTitle("拼多多自动化发布工具")
        self.setGeometry(100, 100, 1000, 800)

        # 创建中央部件
        central_widget = QWidget()
        self.setCentralWidget(central_widget)

        # 主布局
        main_layout = QVBoxLayout()
        main_layout.setContentsMargins(20, 20, 20, 20)
        main_layout.setSpacing(14)
        central_widget.setLayout(main_layout)

        # 顶部标题区
        header_layout = QHBoxLayout()
        title_box = QVBoxLayout()
        title_label = QLabel("拼多多自动化发布工具", None)
        title_label.setFont(QFont("Microsoft YaHei", 16, QFont.Bold))
        subtitle_label = QLabel("配置导入 • 文件查找 • 批量上传", None)
        subtitle_label.setFont(QFont("Microsoft YaHei", 10))
        title_box.addWidget(title_label)
        title_box.addWidget(subtitle_label)
        header_layout.addLayout(title_box)
        header_layout.addStretch()
        header_actions = QHBoxLayout()
        self.execute_btn = PrimaryPushButton("开始上传", None)
        self.execute_btn.clicked.connect(self.execute_task)
        header_actions.addWidget(self.execute_btn)

        self.pause_btn = PushButton("暂停", None)
        self.pause_btn.setVisible(False)
        self.pause_btn.clicked.connect(self.pause_task)
        self.pause_btn.setStyleSheet("QPushButton { background-color: #fff3e0; color: #e65100; }")
        header_actions.addWidget(self.pause_btn)

        self.resume_btn = PushButton("继续", None)
        self.resume_btn.setVisible(False)
        self.resume_btn.clicked.connect(self.resume_task)
        self.resume_btn.setStyleSheet("QPushButton { background-color: #e8f5e9; color: #2e7d32; }")
        header_actions.addWidget(self.resume_btn)

        self.terminate_btn = PushButton("终止", None)
        self.terminate_btn.setVisible(False)
        self.terminate_btn.clicked.connect(self.terminate_task)
        self.terminate_btn.setStyleSheet("QPushButton { background-color: #ffebee; color: #c62828; }")
        header_actions.addWidget(self.terminate_btn)

        header_layout.addLayout(header_actions)
        main_layout.addLayout(header_layout)

        # 状态卡片区
        status_layout = QHBoxLayout()
        self.status_update_value = QLabel("未更新", None)
        self.status_pending_value = QLabel("0", None)
        self.status_running_value = QLabel("0", None)
        self.status_success_value = QLabel("0", None)
        self.status_failed_value = QLabel("0", None)

        update_card = self._build_status_card(
            "更新状态",
            self.status_update_value,
            self.style().standardIcon(QStyle.StandardPixmap.SP_BrowserReload),
            "#e6f4ff",
            "文件路径扫描"
        )
        pending_card = self._build_status_card(
            "待执行",
            self.status_pending_value,
            self.style().standardIcon(QStyle.StandardPixmap.SP_FileDialogInfoView),
            "#fff7ed",
            "等待处理任务"
        )
        running_card = self._build_status_card(
            "执行中",
            self.status_running_value,
            self.style().standardIcon(QStyle.StandardPixmap.SP_MediaPlay),
            "#ecfdf3",
            "当前执行进度",
            with_progress=True
        )
        success_card = self._build_status_card(
            "成功",
            self.status_success_value,
            self.style().standardIcon(QStyle.StandardPixmap.SP_DialogApplyButton),
            "#dcfce7",
            "成功任务数量",
            clickable=False
        )
        failed_card = self._build_status_card(
            "失败",
            self.status_failed_value,
            self.style().standardIcon(QStyle.StandardPixmap.SP_MessageBoxCritical),
            "#fee2e2",
            "失败任务数量",
            clickable=False
        )

        status_layout.addWidget(update_card)
        status_layout.addWidget(pending_card)
        status_layout.addWidget(running_card)
        status_layout.addWidget(success_card)
        status_layout.addWidget(failed_card)
        main_layout.addLayout(status_layout)

        # 中间内容区（侧边导航 + 页面）
        content_layout = QHBoxLayout()
        content_layout.setSpacing(12)
        main_layout.addLayout(content_layout)

        nav_card = CardWidget()
        self.nav_card = nav_card
        nav_layout = QVBoxLayout(nav_card)
        nav_layout.setContentsMargins(10, 10, 10, 10)
        nav_layout.setSpacing(8)
        nav_card.setFixedWidth(150)

        nav_card.setStyleSheet("""
            QPushButton {
                text-align: left;
                padding: 8px 10px;
                border-radius: 6px;
                border-left: 3px solid transparent;
            }
            QPushButton:hover {
                background-color: rgba(0, 120, 212, 0.08);
            }
            QPushButton:checked {
                background-color: rgba(0, 120, 212, 0.15);
                font-weight: 600;
                border-left: 3px solid #0078D4;
            }
        """)

        self.nav_title = QLabel("导航", None)
        self.nav_title.setFont(QFont("Microsoft YaHei", 10, QFont.Bold))
        nav_layout.addWidget(self.nav_title)
        self.nav_divider = QFrame()
        self.nav_divider.setFrameShape(QFrame.HLine)
        self.nav_divider.setStyleSheet("color: rgba(0, 0, 0, 0.12);")
        nav_layout.addWidget(self.nav_divider)

        self.nav_group = QButtonGroup(self)
        self.nav_group.setExclusive(True)

        self.nav_main = PushButton("工作台", None)
        self.nav_log = PushButton("日志", None)

        nav_items = [
            (self.nav_main, QStyle.StandardPixmap.SP_DesktopIcon),
            (self.nav_log, QStyle.StandardPixmap.SP_FileDialogContentsView),
        ]
        self.nav_buttons = []
        for idx, (btn, icon_type) in enumerate(nav_items):
            btn.setCheckable(True)
            # 去掉左侧图标，避免在某些环境下图标位置异常遮挡中文文字
            # 如果后续需要图标，可以在这里重新启用并配合样式表单独调整 padding
            # btn.setIcon(self.style().standardIcon(icon_type))
            # btn.setIconSize(QSize(16, 16))
            self.nav_group.addButton(btn, idx)
            nav_layout.addWidget(btn)
            self.nav_buttons.append(btn)

        nav_layout.addStretch()
        nav_footer_row = QHBoxLayout()
        self.nav_footer = QLabel("v1.0", None)
        self.nav_footer.setStyleSheet("color: #999; font-size: 10px;")
        nav_footer_row.addWidget(self.nav_footer)
        nav_footer_row.addStretch()
        self.nav_toggle_btn = PushButton("收起", None)
        self.nav_toggle_btn.clicked.connect(self.toggle_nav_compact)
        nav_footer_row.addWidget(self.nav_toggle_btn)
        nav_layout.addLayout(nav_footer_row)
        content_layout.addWidget(nav_card)

        self.page_stack = QStackedWidget()
        content_layout.addWidget(self.page_stack)
        content_layout.setStretch(1, 1)

        # 配置输入区域
        config_group = CardWidget()
        config_layout = QVBoxLayout(config_group)
        config_layout.setContentsMargins(12, 12, 12, 12)
        config_title = QLabel("配置信息", None)
        config_title.setFont(QFont("Microsoft YaHei", 11, QFont.Bold))
        config_layout.addWidget(config_title)
        config_group.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
        config_group.setMaximumHeight(450)  # 增加高度以容纳单条配置输入区域

        # Excel导入（合并到配置）
        import_row = QHBoxLayout()
        import_row.addWidget(QLabel("Excel文件:", None))
        self.excel_path_input = LineEdit()
        self.excel_path_input.setReadOnly(True)
        self.excel_path_input.setPlaceholderText("点击导入按钮选择Excel配置文件")
        import_row.addWidget(self.excel_path_input)
        self.import_btn = PrimaryPushButton("导入配置", None)
        self.import_btn.setToolTip("选择Excel文件并导入配置")
        self.import_btn.clicked.connect(self.import_excel)
        import_row.addWidget(self.import_btn)
        self.download_template_btn = PushButton("下载模板", None)
        self.download_template_btn.setToolTip("下载Excel配置模板文件")
        self.download_template_btn.clicked.connect(self.download_excel_template)
        import_row.addWidget(self.download_template_btn)
        config_layout.addLayout(import_row)

        # 添加单条配置输入区域
        add_config_separator = QLabel("或 手动添加单条配置", None)
        add_config_separator.setFont(QFont("Microsoft YaHei", 9, QFont.Bold))
        add_config_separator.setStyleSheet("color: #666; margin-top: 8px;")
        config_layout.addWidget(add_config_separator)
        
        # 单条配置输入表单
        add_config_grid = QGridLayout()
        add_config_grid.setHorizontalSpacing(12)
        add_config_grid.setVerticalSpacing(8)
        
        # 第一行：多多ID、序号、话题
        add_config_grid.addWidget(QLabel("多多ID:", None), 0, 0)
        self.add_user_id_input = LineEdit()
        self.add_user_id_input.setPlaceholderText("输入多多ID")
        add_config_grid.addWidget(self.add_user_id_input, 0, 1)
        
        add_config_grid.addWidget(QLabel("序号:", None), 0, 2)
        self.add_index_input = LineEdit()
        self.add_index_input.setPlaceholderText("输入序号")
        self.add_index_input.setFixedWidth(80)
        add_config_grid.addWidget(self.add_index_input, 0, 3)
        
        add_config_grid.addWidget(QLabel("话题:", None), 0, 4)
        self.add_topic_input = LineEdit()
        self.add_topic_input.setPlaceholderText("输入话题（如 #话题）")
        add_config_grid.addWidget(self.add_topic_input, 0, 5)
        
        # 第二行：定时发布、间隔时间、达人链接
        add_config_grid.addWidget(QLabel("定时发布:", None), 1, 0)
        self.add_schedule_input = LineEdit()
        self.add_schedule_input.setPlaceholderText("yyyy-MM-dd HH:mm（可选）")
        add_config_grid.addWidget(self.add_schedule_input, 1, 1)
        
        add_config_grid.addWidget(QLabel("间隔(分):", None), 1, 2)
        self.add_interval_input = LineEdit()
        self.add_interval_input.setPlaceholderText("延迟分钟")
        self.add_interval_input.setFixedWidth(80)
        add_config_grid.addWidget(self.add_interval_input, 1, 3)
        
        add_config_grid.addWidget(QLabel("达人链接:", None), 1, 4)
        self.add_expert_link_input = LineEdit()
        self.add_expert_link_input.setPlaceholderText("输入达人链接（可选）")
        add_config_grid.addWidget(self.add_expert_link_input, 1, 5)
        
        # 第三行：执行人和添加按钮
        add_config_grid.addWidget(QLabel("执行人:", None), 2, 0)
        self.add_executor_input = LineEdit()
        self.add_executor_input.setPlaceholderText("输入执行人（可选）")
        add_config_grid.addWidget(self.add_executor_input, 2, 1)
        
        add_config_btn_layout = QHBoxLayout()
        add_config_btn_layout.addStretch()
        self.add_config_btn = PrimaryPushButton("添加到配置列表", None)
        self.add_config_btn.setToolTip("将当前输入的配置添加到配置列表中")
        self.add_config_btn.clicked.connect(self.add_single_config)
        add_config_btn_layout.addWidget(self.add_config_btn)
        self.clear_add_inputs_btn = PushButton("清空输入", None)
        self.clear_add_inputs_btn.clicked.connect(self.clear_add_config_inputs)
        add_config_btn_layout.addWidget(self.clear_add_inputs_btn)
        add_config_grid.addLayout(add_config_btn_layout, 2, 2, 1, 4)
        
        config_layout.addLayout(add_config_grid)
        
        # 分隔线
        divider = QFrame()
        divider.setFrameShape(QFrame.HLine)
        divider.setStyleSheet("color: rgba(0, 0, 0, 0.12); margin: 8px 0;")
        config_layout.addWidget(divider)

        grid = QGridLayout()
        grid.setHorizontalSpacing(12)
        grid.setVerticalSpacing(10)

        # 文件夹路径（最外层文件夹）
        grid.addWidget(QLabel("资料文件夹路径:", None), 0, 0)
        self.folder_path_input = LineEdit()
        default_path = get_default_folder_path()
        self.folder_path_input.setPlaceholderText(f"留空则使用默认路径: {default_path}")
        self.folder_path_input.setClearButtonEnabled(True)
        grid.addWidget(self.folder_path_input, 0, 1, 1, 2)
        self.folder_browse_btn = PushButton("浏览", None)
        self.folder_browse_btn.clicked.connect(self.browse_folder)
        grid.addWidget(self.folder_browse_btn, 0, 3)

        tip_label = QLabel("提示：只需填写最外层文件夹路径，程序会自动查找子文件夹中的文件", None)
        tip_label.setStyleSheet("color: #666; font-size: 10px;")
        grid.addWidget(tip_label, 1, 0, 1, 4)

        # 更新数据按钮 + 批量上传（同一行）
        update_row = QHBoxLayout()
        self.update_data_btn = PrimaryPushButton("更新数据", None)
        self.update_data_btn.clicked.connect(self.update_data)
        update_row.addWidget(self.update_data_btn)
        self.update_status_label = QLabel("未更新", None)
        self.update_status_label.setStyleSheet("color: #666; font-size: 10px;")
        update_row.addWidget(self.update_status_label)
        update_row.addStretch()
        self.batch_upload_checkbox = CheckBox("批量上传（如果文件夹中有多个视频，将使用批量上传模式）", None)
        self.batch_upload_checkbox.setChecked(False)
        update_row.addWidget(self.batch_upload_checkbox)
        # 添加间隔
        update_row.addSpacing(20)
        # 单次上限数输入框
        batch_limit_label = QLabel("单次上限数:", None)
        update_row.addWidget(batch_limit_label)
        self.batch_limit_input = LineEdit()
        self.batch_limit_input.setPlaceholderText("5")
        self.batch_limit_input.setText("5")
        self.batch_limit_input.setFixedWidth(50)
        self.batch_limit_input.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.batch_limit_input.setToolTip("每次批量上传的最大视频数量，超过则分批上传")
        update_row.addWidget(self.batch_limit_input)
        update_row_widget = QWidget()
        update_row_widget.setLayout(update_row)
        grid.addWidget(update_row_widget, 2, 0, 1, 4)



        config_layout.addLayout(grid)
        config_layout.addStretch()

        config_page = QWidget()
        config_page_layout = QVBoxLayout(config_page)
        config_page_layout.setContentsMargins(0, 0, 0, 0)
        config_page_layout.setSpacing(12)
        config_page_layout.addWidget(config_group)

        # 配置列表表格（如果从Excel导入）
        self.table_group = CardWidget()
        table_layout = QVBoxLayout(self.table_group)
        table_layout.setContentsMargins(12, 12, 12, 12)
        table_title = QLabel("配置列表（从Excel导入后显示，可直接在表格中编辑）", None)
        table_title.setFont(QFont("Microsoft YaHei", 11, QFont.Bold))
        table_layout.addWidget(table_title)
        self.table_edit_hint = QLabel("编辑模式：当前行已高亮，其它行已锁定。修改后点击“确认”保存，点击“退出”还原。", None)
        self.table_edit_hint.setVisible(False)
        self.table_edit_hint.setStyleSheet(
            "background-color: #fff7ed; color: #9a3412; "
            "border: 1px solid #fed7aa; border-radius: 6px; padding: 6px 8px;"
        )
        table_layout.addWidget(self.table_edit_hint)

        search_row = QHBoxLayout()
        self.table_select_all_checkbox = CheckBox("全选/取消", None)
        # noinspection PyUnresolvedReferences
        self.table_select_all_checkbox.stateChanged.connect(self.toggle_all_checkboxes)
        search_row.addWidget(self.table_select_all_checkbox)
        self.table_search_input = LineEdit()
        self.table_search_input.setPlaceholderText("搜索表格（支持空格多关键词）")
        self.table_search_input.setClearButtonEnabled(True)
        self.table_search_input.setFixedWidth(250)
        self.table_search_input.textChanged.connect(self.filter_table)
        search_row.addWidget(self.table_search_input)
        self.table_column_filter = QComboBox()
        self.table_column_filter.currentIndexChanged.connect(lambda: self.filter_table(self.table_search_input.text()))
        search_row.addWidget(self.table_column_filter)
        self.table_highlight = CheckBox("高亮匹配", None)
        self.table_highlight.setChecked(True)
        # noinspection PyUnresolvedReferences
        self.table_highlight.stateChanged.connect(lambda: self.filter_table(self.table_search_input.text()))
        search_row.addWidget(self.table_highlight)
        self.table_only_match = CheckBox("仅显示匹配项", None)
        self.table_only_match.setChecked(True)
        # noinspection PyUnresolvedReferences
        self.table_only_match.stateChanged.connect(lambda: self.filter_table(self.table_search_input.text()))
        search_row.addWidget(self.table_only_match)
        self.table_prev_match_btn = PushButton("上一条", None)
        self.table_prev_match_btn.clicked.connect(self.prev_table_match)
        search_row.addWidget(self.table_prev_match_btn)
        self.table_next_match_btn = PushButton("下一条", None)
        self.table_next_match_btn.clicked.connect(self.next_table_match)
        search_row.addWidget(self.table_next_match_btn)
        self.table_clear_btn = PushButton("清空筛选", None)
        self.table_clear_btn.clicked.connect(self._clear_filter_and_selection)
        search_row.addWidget(self.table_clear_btn)
        update_row.addSpacing(20)
        self.table_export_all_btn = PushButton("导出全部", None)
        self.table_export_all_btn.clicked.connect(self.export_all_rows)
        search_row.addWidget(self.table_export_all_btn)
        self.table_select_count = QLabel("已选: 0", None)
        self.table_select_count.setStyleSheet("color: #666; font-weight: bold;")
        search_row.addWidget(self.table_select_count)
        table_layout.addLayout(search_row)

        self.config_table = TableWidget()
        self.config_table.setStyleSheet("""
            QTableView::item:selected {
                background-color: rgba(0, 120, 212, 0.18);
            }
            QTableView::item:hover {
                background-color: rgba(0, 120, 212, 0.08);
            }
            QHeaderView::section {
                background-color: #1f2937;
                color: #ffffff;
                padding: 8px;
                border: none;
            }
            QHeaderView::section:hover {
                background-color: #374151;
            }
        """)
        self.config_table.setColumnCount(12)
        self.config_table.setHorizontalHeaderLabels(TABLE_HEADERS)
        self.table_column_filter.addItem("全部列")
        # 第0列为勾选框；记录下拉项对应的表格列索引及 Model 列索引
        self._filter_table_columns = []
        self._filter_model_columns = []  # Model/View 无勾选列
        for col in range(1, 10):
            header = self.config_table.horizontalHeaderItem(col)
            if header:
                self.table_column_filter.addItem(header.text())
                self._filter_table_columns.append(col)
                # Model/View 列映射：1..8→0..7, 9→8
                self._filter_model_columns.append(8 if col == 9 else col - 1)
        # 默认按多多ID筛选（多多ID为下拉第2项，index=1）
        if self._filter_table_columns and self._filter_table_columns[0] == 1:
            self.table_column_filter.setCurrentIndex(1)
        header = self.config_table.horizontalHeader()
        header.setStretchLastSection(True)
        # 设置所有列为Interactive模式，允许用户拖拽调整宽度
        header.setSectionResizeMode(QHeaderView.Interactive)
        # 设置最小列宽，确保内容可见
        header.setMinimumSectionSize(50)
        # 设置文本省略模式（超长文本显示省略号）
        self.config_table.setTextElideMode(Qt.TextElideMode.ElideRight)
        self.config_table.setAlternatingRowColors(True)
        self.config_table.setSortingEnabled(True)
        self.config_table.horizontalHeader().setSortIndicatorShown(True)
        self.config_table.verticalHeader().setVisible(False)
        self.config_table.verticalHeader().setDefaultSectionSize(42)
        # 禁用直接编辑，只能通过编辑按钮进入编辑模式
        self.config_table.setEditTriggers(TableWidget.NoEditTriggers)
        self.config_table.setSelectionBehavior(QAbstractItemView.SelectRows)
        self.config_table.setSelectionMode(QAbstractItemView.ExtendedSelection)
        self.config_table.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
        self.config_table.customContextMenuRequested.connect(self.show_table_context_menu)
        self.config_table.itemChanged.connect(self.on_table_item_changed)
        self.config_table.horizontalHeader().sectionClicked.connect(self.on_header_clicked)
        # 连接列宽调整信号，用于跟踪手动调整和自动调整
        self.config_table.horizontalHeader().sectionResized.connect(self.on_column_resized)
        # 连接表格resize事件，用于自动按比例调整列宽
        self.config_table.horizontalHeader().geometriesChanged.connect(self.on_table_geometry_changed)
        # 点击空白区域或按Esc键时退出编辑状态
        self.config_table.viewport().installEventFilter(self)
        self.config_table.installEventFilter(self)
        table_layout.addWidget(self.config_table, 1)  # stretch=1，占据剩余空间

        # 大数据模式表格（Model/View）
        self.table_view = QTableView()
        self.table_view.setAlternatingRowColors(True)
        self.table_view.setSortingEnabled(True)
        self.table_view.verticalHeader().setVisible(False)
        self.table_view.setSelectionBehavior(QAbstractItemView.SelectRows)
        self.table_view.setSelectionMode(QAbstractItemView.ExtendedSelection)
        # 设置文本省略模式（超长文本显示省略号）
        self.table_view.setTextElideMode(Qt.TextElideMode.ElideRight)
        self.table_view.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
        self.table_view.customContextMenuRequested.connect(self.show_table_context_menu)
        self.table_view.setStyleSheet("""
            QTableView::item:selected {
                background-color: rgba(0, 120, 212, 0.18);
            }
            QTableView::item:hover {
                background-color: rgba(0, 120, 212, 0.08);
            }
            QHeaderView::section {
                background-color: #1f2937;
                color: #ffffff;
                padding: 8px;
                border: none;
            }
            QHeaderView::section:hover {
                background-color: #374151;
            }
        """)
        self.table_view.setVisible(False)
        table_layout.addWidget(self.table_view, 1)  # stretch=1，占据剩余空间
        self.table_empty_label = QLabel("暂无数据，请先导入Excel配置", None)
        self.table_empty_label.setStyleSheet("color: #999; font-size: 12px;")
        self.table_empty_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.table_empty_label.setVisible(True)
        table_layout.addWidget(self.table_empty_label)

        # 分页控件行（不设置 stretch，固定在底部）
        pagination_row = QHBoxLayout()
        pagination_row.setContentsMargins(0, 8, 0, 0)
        pagination_row.addStretch()
        self.page_size_combo = QComboBox()
        self.page_size_combo.addItems(["10", "20", "50", "100"])
        self.page_size_combo.setCurrentText(str(self.page_size))
        self.page_size_combo.currentTextChanged.connect(self.change_page_size)
        pagination_row.addWidget(QLabel("每页", None))
        pagination_row.addWidget(self.page_size_combo)
        self.page_info_label = QLabel("第 1/1 页", None)
        pagination_row.addWidget(self.page_info_label)
        self.page_first_btn = PushButton("首页", None)
        self.page_prev_btn = PushButton("上一页", None)
        self.page_next_btn = PushButton("下一页", None)
        self.page_last_btn = PushButton("末页", None)
        self.page_first_btn.clicked.connect(self.go_first_page)
        self.page_prev_btn.clicked.connect(self.go_prev_page)
        self.page_next_btn.clicked.connect(self.go_next_page)
        self.page_last_btn.clicked.connect(self.go_last_page)
        pagination_row.addWidget(self.page_first_btn)
        pagination_row.addWidget(self.page_prev_btn)
        pagination_row.addWidget(self.page_next_btn)
        pagination_row.addWidget(self.page_last_btn)
        table_layout.addLayout(pagination_row, 0)  # stretch=0，固定大小
        self.table_group.setVisible(True)
        self.table_group.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)

        # 配置 + 列表 分割布局
        self.config_splitter = QSplitter(Qt.Orientation.Vertical)
        self.config_splitter.setChildrenCollapsible(True)
        self.config_splitter.addWidget(config_group)
        self.config_splitter.addWidget(self.table_group)
        self.config_splitter.setStretchFactor(0, 2)
        self.config_splitter.setStretchFactor(1, 3)
        self.config_splitter.splitterMoved.connect(self._save_splitter_sizes)
        config_page_layout.addWidget(self.config_splitter)
        self.page_stack.addWidget(config_page)

        # 工作台标签页
        self.workbench_tabs = QTabWidget()
        self.workbench_tabs.addTab(config_page, "配置")
        workbench_page = QWidget()
        workbench_layout = QVBoxLayout(workbench_page)
        workbench_layout.setContentsMargins(0, 0, 0, 0)
        workbench_layout.addWidget(self.workbench_tabs)
        self.page_stack.addWidget(workbench_page)

        # 进度条（全局）
        self.progress_bar = ProgressBar()
        self.progress_bar.setVisible(False)
        main_layout.addWidget(self.progress_bar)

        # 日志显示区域
        log_group = CardWidget()
        log_layout = QVBoxLayout(log_group)
        log_layout.setContentsMargins(12, 12, 12, 12)
        log_header = QHBoxLayout()
        log_title = QLabel("执行日志", None)
        log_title.setFont(QFont("Microsoft YaHei", 11, QFont.Bold))
        log_header.addWidget(log_title)
        log_header.addStretch()
        self.log_search_input = LineEdit()
        self.log_search_input.setPlaceholderText("搜索日志")
        self.log_search_input.setClearButtonEnabled(True)
        self.log_search_input.textChanged.connect(self.filter_log)
        log_header.addWidget(self.log_search_input)
        self.log_highlight_check = CheckBox("高亮所有", None)
        self.log_highlight_check.setChecked(True)
        # noinspection PyUnresolvedReferences
        self.log_highlight_check.stateChanged.connect(lambda: self.filter_log(self.log_search_input.text()))
        log_header.addWidget(self.log_highlight_check)
        self.log_whole_word = CheckBox("整词匹配", None)
        # noinspection PyUnresolvedReferences
        self.log_whole_word.stateChanged.connect(lambda: self.filter_log(self.log_search_input.text()))
        log_header.addWidget(self.log_whole_word)
        self.log_prev_btn = PushButton("上一个", None)
        self.log_prev_btn.clicked.connect(lambda: self.find_log(backward=True))
        log_header.addWidget(self.log_prev_btn)
        self.log_next_btn = PushButton("下一个", None)
        self.log_next_btn.clicked.connect(lambda: self.find_log(backward=False))
        log_header.addWidget(self.log_next_btn)
        self.log_match_status = QLabel("匹配: 0", None)
        self.log_match_status.setStyleSheet("color: #666; font-size: 10px;")
        log_header.addWidget(self.log_match_status)
        
        # 初始化表格列宽比例
        QTimer.singleShot(100, self._apply_table_column_widths)
        self.log_export_btn = PushButton("导出日志", None)
        self.log_export_btn.clicked.connect(self.export_log)
        log_header.addWidget(self.log_export_btn)
        self.clear_log_btn = PushButton("清空日志", None)
        self.clear_log_btn.clicked.connect(self.clear_log)
        log_header.addWidget(self.clear_log_btn)
        log_layout.addLayout(log_header)
        self.log_text = TextEdit()
        self.log_text.setReadOnly(True)
        self.log_text.setFont(QFont("Consolas", 10))
        log_layout.addWidget(self.log_text)
        log_page = QWidget()
        log_page_layout = QVBoxLayout(log_page)
        log_page_layout.setContentsMargins(0, 0, 0, 0)
        log_page_layout.addWidget(log_group)
        self.page_stack.addWidget(log_page)

        # 配置日志输出（保留控制台输出，GUI通过信号接收）
        logger.remove()
        logger.add(lambda msg: None)  # 禁用默认输出，通过信号在GUI中显示

        # 默认选中工作台
        self.nav_main.setChecked(True)
        self.page_stack.setCurrentIndex(0)
        self.nav_group.buttonClicked[int].connect(self.switch_page)
        self._restore_splitter_sizes()

        # 快捷键
        self.shortcut_log_next = QShortcut(QKeySequence("F3"), self)
        self.shortcut_log_next.activated.connect(lambda: self.find_log(backward=False))
        self.shortcut_log_prev = QShortcut(QKeySequence("Shift+F3"), self)
        self.shortcut_log_prev.activated.connect(lambda: self.find_log(backward=True))
        
        # 程序启动时重置状态（不累计历史数据）
        self.set_status_cards(update_text="未更新", pending=0, running=0, success=0, failed=0)

    def _build_status_card(self, title, value_label, icon, bg_color, subtitle, with_progress=False, clickable=False):
        """创建状态卡片"""
        card = CardWidget()
        if clickable:
            card.setCursor(Qt.CursorShape.PointingHandCursor)
            card.setToolTip(subtitle)
        layout = QVBoxLayout(card)
        layout.setContentsMargins(12, 10, 12, 10)
        card.setStyleSheet(f"background-color: {bg_color};")
        icon_label = QLabel()
        icon_label.setPixmap(icon.pixmap(16, 16))
        title_row = QHBoxLayout()
        title_label = QLabel(title)
        title_label.setFont(QFont("Microsoft YaHei", 9))
        title_row.addWidget(icon_label)
        title_row.addWidget(title_label)
        title_row.addStretch()
        subtitle_label = QLabel(subtitle)
        subtitle_label.setStyleSheet("color: #666; font-size: 10px;")
        value_label.setFont(QFont("Microsoft YaHei", 12, QFont.Bold))
        layout.addLayout(title_row)
        layout.addWidget(value_label)
        layout.addWidget(subtitle_label)
        if with_progress:
            self.status_running_progress = ProgressBar()
            self.status_running_progress.setRange(0, 100)
            self.status_running_progress.setValue(0)
            self.status_running_progress.setTextVisible(False)
            self.status_running_progress.setFixedHeight(6)
            layout.addWidget(self.status_running_progress)
        return card

    def switch_page(self, page_index):
        """切换侧边导航页面"""
        self.page_stack.setCurrentIndex(page_index)

    def eventFilter(self, obj, event):
        """事件过滤器：处理点击空白区域和按Esc键退出编辑状态"""
        # 处理表格viewport的鼠标点击事件
        if obj == self.config_table.viewport() and event.type() == QEvent.Type.MouseButtonPress:
            # 获取点击位置对应的单元格
            index = self.config_table.indexAt(event.pos())
            if not index.isValid():
                # 点击了空白区域，退出编辑状态
                self._exit_table_edit_mode()
                return False  # 继续传递事件
        # 处理表格的键盘事件（Esc键退出编辑）
        if obj == self.config_table and event.type() == QEvent.Type.KeyPress:
            if event.key() == Qt.Key.Key_Escape:
                self._exit_table_edit_mode()
                return True  # 阻止事件继续传递
        return super().eventFilter(obj, event)

    def _exit_table_edit_mode(self):
        """退出表格编辑状态"""
        self.config_table.clearSelection()
        self.config_table.clearFocus()
        # 关闭当前编辑器
        current_item = self.config_table.currentItem()
        if current_item:
            self.config_table.closePersistentEditor(current_item)
        self.config_table.setCurrentItem(None)
        # 恢复为只读模式
        self.config_table.setEditTriggers(TableWidget.NoEditTriggers)
        self._cleanup_edit_mode_state()

    def _set_row_highlight(self, row, enabled):
        """高亮/取消高亮某一行"""
        highlight_color = QColor(255, 247, 216)
        for col in range(1, 10):  # 数据列 1-9
            item = self.config_table.item(row, col)
            if not item:
                continue
            if enabled:
                item.setBackground(highlight_color)
            else:
                item.setData(Qt.ItemDataRole.BackgroundRole, None)

    def _set_other_rows_locked(self, edit_row, locked):
        """锁定/解锁编辑行以外的行"""
        for r in range(self.config_table.rowCount()):
            if r == edit_row:
                # 编辑行保持可用
                continue
            # 操作列按钮禁用/启用
            action_widget = self.config_table.cellWidget(r, 11)
            if action_widget:
                action_widget.setEnabled(not locked)
            # 数据列禁用/启用
            for col in range(1, 10):  # 数据列 1-9
                item = self.config_table.item(r, col)
                if not item:
                    continue
                if locked:
                    item.setFlags(item.flags() & ~Qt.ItemFlag.ItemIsEnabled)
                else:
                    item.setFlags((item.flags() | Qt.ItemFlag.ItemIsEnabled) & ~Qt.ItemFlag.ItemIsEditable)

    def _cleanup_edit_mode_state(self):
        """清理编辑态UI状态"""
        edit_row = getattr(self, '_editing_row', None)
        if edit_row is None:
            return
        self._set_row_highlight(edit_row, False)
        self._set_other_rows_locked(edit_row, False)
        self._editing_row = None
        if getattr(self, "table_edit_hint", None):
            self.table_edit_hint.setVisible(False)
        if hasattr(self, '_edit_selection_mode_backup'):
            self.config_table.setSelectionMode(self._edit_selection_mode_backup)

    def on_table_item_changed(self, item):
        """表格内容变更回调"""
        try:
            if not item:
                return

            # 防止递归调用：如果正在更新中，跳过
            if self.is_updating_table:
                return

            # 检查 item 是否仍然有效（避免访问已删除的对象）
            try:
                row = item.row()
                col = item.column()
                text = item.text()
            except RuntimeError:
                # QTableWidgetItem 已被删除
                return

            # 第8列：情况列，联动进度列的显示
            if col == 8:
                # 设置标志，防止递归
                self.is_updating_table = True
                try:
                    self._set_status_item(row, text)
                    self._set_progress_item(row, text)
                finally:
                    self.is_updating_table = False

            # 其它可编辑列：同步当前行到 configs
            self._sync_config_from_row(row)
        except Exception as e:
            logger.warning(f"表格项改变回调出错: {e}")
            # 确保标志被重置
            self.is_updating_table = False

    def _set_checkbox_item(self, row, config_index, row_height=None):
        """设置勾选框列（第0列）。row_height 传入时使用固定高度+居中对齐，避免第二行起勾选框往下错位。"""
        checkbox = QCheckBox()
        checkbox.blockSignals(True)
        checkbox.setChecked(self.configs[config_index].get('勾选', False))  # 默认不勾选
        checkbox.blockSignals(False)
        # noinspection PyUnresolvedReferences
        checkbox.stateChanged.connect(lambda state, idx=config_index: self._on_checkbox_changed(idx, state))
        checkbox.setStyleSheet(
            "QCheckBox { margin: 0px; padding: 0px; }"
            "QCheckBox::indicator { width: 20px; height: 20px; }"
        )

        wrapper = QWidget()
        h = row_height if (row_height is not None and row_height > 0) else 42
        wrapper.setFixedHeight(h)
        wrapper.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)

        layout = QVBoxLayout(wrapper)
        layout.setContentsMargins(0, 0, 0, 0)
        layout.setSpacing(0)
        layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
        layout.addWidget(checkbox)

        self.config_table.setCellWidget(row, 0, wrapper)

    def _sync_checked_from_table(self):
        """从表格当前页的勾选框同步勾选状态到 configs（仅非 model_view 且当前页）"""
        if self.use_model_view or not self.page_row_indices:
            return
        for table_row, config_index in enumerate(self.page_row_indices):
            if config_index >= len(self.configs):
                continue
            w = self.config_table.cellWidget(table_row, 0)
            if not w:
                continue
            checkbox = w.findChild(QCheckBox) if hasattr(w, 'findChild') else None
            if checkbox is not None:
                self.configs[config_index]['勾选'] = checkbox.isChecked()
    
    def _on_checkbox_changed(self, config_index, state):
        """勾选框状态改变回调"""
        if config_index < len(self.configs):
            self.configs[config_index]['勾选'] = (state == Qt.CheckState.Checked)
            # 更新已选数量显示
            self._update_checked_count()
            # 更新状态统计
            self._update_status_statistics()
    
    def _update_checked_count(self):
        """更新已勾选的数量显示"""
        if not hasattr(self, "table_select_count"):
            return
        checked_count = sum(1 for config in self.configs if config.get('勾选', False))
        self.table_select_count.setText(f"已选: {checked_count}")
    
    def _clear_filter_and_selection(self):
        """清空筛选并取消所有勾选"""
        for config in self.configs:
            config['勾选'] = False
        if hasattr(self, 'table_select_all_checkbox'):
            self.table_select_all_checkbox.setChecked(False)
        self._current_status_filter = None
        self.filtered_config_indices = None
        # 清空搜索框会触发 filter_table("")，从而刷新为全量显示
        self.table_search_input.setText("")
        self._update_checked_count()
        self._show_infobar("info", "已清空", "筛选条件和勾选已清空")
    
    def toggle_all_checkboxes(self):
        """全选/取消全选 - 跨页操作所有数据（考虑筛选条件）"""
        is_checked = self.table_select_all_checkbox.isChecked()
        visible_count = 0
        
        # 有筛选时只操作筛选结果（filtered_config_indices），否则操作全部
        indices = getattr(self, 'filtered_config_indices', None)
        if indices is not None:
            for config_index in indices:
                if 0 <= config_index < len(self.configs):
                    self.configs[config_index]['勾选'] = is_checked
                    visible_count += 1
        else:
            for config_index in range(len(self.configs)):
                self.configs[config_index]['勾选'] = is_checked
                visible_count += 1
        
        self.update_table()
        self._update_checked_count()
        self._update_status_statistics()
        if hasattr(self, 'table_search_input') and self.table_search_input.text().strip():
            self._suppress_filter_clear_once = True
            self.filter_table(self.table_search_input.text())
        
        if is_checked:
            self._show_infobar("success", "提示", f"已勾选 {visible_count} 行（跨页操作）")
        else:
            self._show_infobar("success", "提示", f"已取消 {visible_count} 行勾选（跨页操作）")
    
    @staticmethod
    def _create_centered_item(text):
        """创建居中对齐的表格单元格"""
        item = QTableWidgetItem(str(text))
        item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
        # 默认不可编辑，必须通过编辑按钮进入编辑模式
        item.setFlags(item.flags() & ~Qt.ItemFlag.ItemIsEditable)
        return item

    def _set_status_item(self, row, text):
        """设置状态列文本"""
        try:
            # 使用 blockSignals 临时阻止信号，防止递归
            self.config_table.blockSignals(True)
            try:
                item = QTableWidgetItem(text)
                item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)  # 居中对齐
                item.setFlags(item.flags() & ~Qt.ItemFlag.ItemIsEditable)
                # 根据状态设置文字颜色
                if "完成" in text or "成功" in text:
                    item.setForeground(QColor("#155724"))  # 绿色
                elif "失败" in text or "错误" in text:
                    item.setForeground(QColor("#721C24"))  # 红色
                elif "执行中" in text or "进行" in text:
                    item.setForeground(QColor("#0C5460"))  # 蓝色
                self._apply_current_highlight_to_item(row, 8, item, text)
                self.config_table.setItem(row, 8, item)
            finally:
                # 恢复信号
                self.config_table.blockSignals(False)
        except Exception as e:
            logger.warning(f"设置状态项失败: {e}")
            # 确保信号恢复
            self.config_table.blockSignals(False)

    def _set_progress_item(self, row, status_text):
        """设置进度列"""
        progress = ProgressBar()
        progress.setTextVisible(False)
        progress.setFixedHeight(8)
        progress.setRange(0, 100)
        value = 0
        if "完成" in status_text or "成功" in status_text:
            value = 100
        elif "执行中" in status_text or "进行" in status_text:
            value = 60
        elif "待" in status_text:
            value = 10
        progress.setValue(value)
        self.config_table.setCellWidget(row, 10, progress)

    def _set_action_buttons(self, row, config_index):
        """设置操作列按钮（编辑和删除）"""
        wrapper = QWidget()
        layout = QHBoxLayout(wrapper)
        layout.setContentsMargins(2, 0, 2, 0)
        layout.setSpacing(2)
        edit_btn = PushButton("编辑", None)
        edit_btn.setFixedWidth(52)
        edit_btn.setFixedHeight(32)
        edit_btn.setFont(QFont("Microsoft YaHei", 10))
        delete_btn = PushButton("删除", None)
        delete_btn.setFixedWidth(52)
        delete_btn.setFixedHeight(32)
        delete_btn.setFont(QFont("Microsoft YaHei", 10))
        # 使用默认参数捕获当前值，避免闭包问题
        edit_btn.clicked.connect(lambda checked, r=row, idx=config_index: self._enter_edit_mode(r, idx))
        delete_btn.clicked.connect(lambda checked, idx=config_index: self.delete_row_by_index(idx))
        layout.addWidget(edit_btn)
        layout.addWidget(delete_btn)
        self.config_table.setCellWidget(row, 11, wrapper)

    def _set_edit_mode_buttons(self, row, config_index):
        """设置编辑模式按钮（确认和退出）"""
        wrapper = QWidget()
        layout = QHBoxLayout(wrapper)
        layout.setContentsMargins(2, 0, 2, 0)
        layout.setSpacing(2)
        confirm_btn = PushButton("确认", None)
        confirm_btn.setFixedWidth(52)
        confirm_btn.setFixedHeight(32)
        confirm_btn.setFont(QFont("Microsoft YaHei", 10))
        cancel_btn = PushButton("退出", None)
        cancel_btn.setFixedWidth(52)
        cancel_btn.setFixedHeight(32)
        cancel_btn.setFont(QFont("Microsoft YaHei", 10))
        # 使用默认参数捕获当前值
        confirm_btn.clicked.connect(lambda checked, r=row, idx=config_index: self._confirm_edit(r, idx))
        cancel_btn.clicked.connect(lambda checked, r=row, idx=config_index: self._cancel_edit(r, idx))
        layout.addWidget(confirm_btn)
        layout.addWidget(cancel_btn)
        self.config_table.setCellWidget(row, 11, wrapper)

    def _enter_edit_mode(self, row, config_index):
        """进入编辑模式"""
        if row < 0 or row >= self.config_table.rowCount():
            return
        # 允许当前行进入编辑时的交互触发
        if not hasattr(self, '_edit_triggers_backup'):
            self._edit_triggers_backup = self.config_table.editTriggers()
        self.config_table.setEditTriggers(QAbstractItemView.DoubleClicked | QAbstractItemView.SelectedClicked)
        if not hasattr(self, '_edit_selection_mode_backup'):
            self._edit_selection_mode_backup = self.config_table.selectionMode()
        self.config_table.setSelectionMode(QAbstractItemView.SingleSelection)
        self._editing_row = row
        # 保存原始数据用于还原
        if not hasattr(self, '_edit_backup'):
            self._edit_backup = {}
        original_data = {}
        for col in range(1, 10):  # 1-9列是数据列
            item = self.config_table.item(row, col)
            original_data[col] = item.text() if item else ""
        self._edit_backup[row] = original_data
        
        # 启用该行的编辑
        for col in range(1, 10):
            item = self.config_table.item(row, col)
            if item:
                item.setFlags(item.flags() | Qt.ItemFlag.ItemIsEditable)
        # 高亮编辑行并锁定其他行
        self._set_row_highlight(row, True)
        self._set_other_rows_locked(row, True)
        
        # 切换到编辑模式按钮
        self._set_edit_mode_buttons(row, config_index)
        
        # 自动聚焦第一个可编辑单元格
        first_item = None
        for col in range(1, 10):
            item = self.config_table.item(row, col)
            if item and (item.flags() & Qt.ItemFlag.ItemIsEditable):
                first_item = item
                self.config_table.setCurrentCell(row, col)
                break
        if first_item:
            self.config_table.setFocus(Qt.FocusReason.TabFocusReason)
            self.config_table.scrollToItem(first_item, QAbstractItemView.PositionAtCenter)
            self.config_table.editItem(first_item)
        if self.table_edit_hint:
            self.table_edit_hint.setVisible(True)
        self._show_infobar("info", "编辑模式", f"正在编辑第 {row + 1} 行，修改后点击确认保存或退出还原")

    def _confirm_edit(self, row, config_index):
        """确认编辑并保存"""
        if row < 0 or row >= self.config_table.rowCount():
            return
        
        # 同步表格数据到configs
        self._sync_config_from_row(row)
        
        # 禁用该行的编辑
        for col in range(1, 10):
            item = self.config_table.item(row, col)
            if item:
                item.setFlags(item.flags() & ~Qt.ItemFlag.ItemIsEditable)
        
        # 清除备份
        if hasattr(self, '_edit_backup') and row in self._edit_backup:
            del self._edit_backup[row]
        
        # 恢复操作按钮
        self._set_action_buttons(row, config_index)
        self._show_infobar("success", "保存成功", f"第 {row + 1} 行数据已保存")
        # 退出编辑模式后恢复为只读
        self.config_table.setEditTriggers(TableWidget.NoEditTriggers)
        self._cleanup_edit_mode_state()

    def _cancel_edit(self, row, config_index):
        """取消编辑并还原数据"""
        if row < 0 or row >= self.config_table.rowCount():
            return
        
        # 还原原始数据
        if hasattr(self, '_edit_backup') and row in self._edit_backup:
            original_data = self._edit_backup[row]
            # 临时断开信号防止触发同步
            self.is_updating_table = True
            try:
                for col, value in original_data.items():
                    if col == 8:
                        self._set_status_item(row, value)
                        self._set_progress_item(row, value)
                    else:
                        item = self.config_table.item(row, col)
                        if item:
                            item.setText(value)
                    
                    # 确保清除编辑标志
                    item = self.config_table.item(row, col)
                    if item:
                        item.setFlags(item.flags() & ~Qt.ItemFlag.ItemIsEditable)
            finally:
                self.is_updating_table = False
            del self._edit_backup[row]
        
        # 恢复操作按钮
        self._set_action_buttons(row, config_index)
        self._show_infobar("info", "已退出", f"第 {row + 1} 行数据已还原")
        # 退出编辑模式后恢复为只读
        self.config_table.setEditTriggers(TableWidget.NoEditTriggers)
        self._cleanup_edit_mode_state()

    def delete_row_by_index(self, row):
        """删除指定行"""
        if row < 0 or row >= len(self.configs):
            return
        self.configs.pop(row)
        self.update_table()

    def _sync_config_from_row(self, row):
        """同步表格行到configs"""
        if row < 0 or row >= self.config_table.rowCount():
            return
        if not self.page_row_indices:
            return
        if row >= len(self.page_row_indices):
            return
        config_index = self.page_row_indices[row]
        if config_index >= len(self.configs):
            return

        # 第0列是勾选框，数据列从第1列开始
        def cell(col):
            item = self.config_table.item(row, col + 1)
            return item.text().strip() if item else ""

        self.configs[config_index].update({
            "多多id": cell(0),
            "序号": cell(1),
            "话题": cell(2),
            "定时发布": cell(3),
            "间隔时间": cell(4),
            "达人链接": cell(5),
            "执行人": cell(6),
            "情况": cell(7) or "待执行",
            "文件路径": cell(8),
        })

    def _sync_configs_from_table(self):
        """从表格同步当前页配置（跳过空行）"""
        if not self.page_row_indices:
            return
        for row, config_index in enumerate(self.page_row_indices):
            if config_index >= len(self.configs):
                continue

            # 第0列是勾选框，数据列从第1列开始
            def cell(col):
                item = self.config_table.item(row, col + 1)
                return item.text().strip() if item else ""

            # 判断是否为空行（避免把空白占位行写回）
            values = [cell(i) for i in range(1, 10)]
            if not any(values):
                continue

            self.configs[config_index].update({
                "多多id": cell(0),
                "序号": cell(1),
                "话题": cell(2),
                "定时发布": cell(3),
                "间隔时间": cell(4),
                "达人链接": cell(5),
                "执行人": cell(6),
                "情况": cell(7) or "待执行",
                "文件路径": cell(8),
            })

    def _save_splitter_sizes(self):
        """保存分割器尺寸"""
        if not hasattr(self, "config_splitter"):
            return
        settings = QSettings("haha", "gui_app")
        settings.setValue("config_splitter_sizes", self.config_splitter.sizes())

    def _restore_splitter_sizes(self):
        """恢复分割器尺寸"""
        if not hasattr(self, "config_splitter"):
            return
        settings = QSettings("haha", "gui_app")
        sizes = settings.value("config_splitter_sizes")
        if sizes:
            self.config_splitter.setSizes([int(s) for s in sizes])
        else:
            # 首次默认：配置区偏大
            self.config_splitter.setSizes([450, 550])

    def change_page_size(self, value):
        """修改分页大小"""
        try:
            self.page_size = int(value)
        except ValueError:
            self.page_size = 20
        self.current_page = 1
        self.update_table()

    def go_first_page(self):
        """首页"""
        self.current_page = 1
        self.update_table()

    def go_prev_page(self):
        """上一页"""
        if self.current_page > 1:
            self.current_page -= 1
            self.update_table()

    def go_next_page(self):
        """下一页"""
        total_rows = len(self.configs)
        total_pages = max(1, (total_rows + self.page_size - 1) // self.page_size)
        if self.current_page < total_pages:
            self.current_page += 1
            self.update_table()

    def go_last_page(self):
        """末页"""
        total_rows = len(self.configs)
        total_pages = max(1, (total_rows + self.page_size - 1) // self.page_size)
        self.current_page = total_pages
        self.update_table()

    def on_header_clicked(self, logical_index):
        """处理多列排序（Ctrl 多选）"""
        # 0列为勾选框，10/11列为进度/操作，禁止排序
        if logical_index == 0 or logical_index >= 10:
            return
        modifiers = QApplication.keyboardModifiers()
        is_multi = modifiers & Qt.KeyboardModifier.ControlModifier
        existing: Optional[int] = next((i for i, (col, _) in enumerate(self.table_sort_keys) if col == logical_index), None)
        if existing is not None:
            col, order = self.table_sort_keys[int(existing)]
            new_order = Qt.SortOrder.DescendingOrder if order == Qt.SortOrder.AscendingOrder else Qt.SortOrder.AscendingOrder
            self.table_sort_keys[int(existing)] = (col, new_order)
        else:
            if not is_multi:
                self.table_sort_keys = []
            self.table_sort_keys.append((logical_index, Qt.SortOrder.AscendingOrder))
        self._sort_table_by_keys()

    def _sort_table_by_keys(self):
        """按多列排序表格"""
        if not self.table_sort_keys:
            return
        self._sync_configs_from_table()
        key_map = {
            1: "多多id",
            2: "序号",
            3: "话题",
            4: "定时发布",
            5: "间隔时间",
            6: "达人链接",
            7: "执行人",
            8: "情况",
            9: "文件路径",
        }
        # 数字类型的列（需要按数字排序）
        numeric_fields = {"序号", "间隔时间"}
        
        def get_sort_key(cfg, field):
            """获取排序键值，数字列按数字排序"""
            value = cfg.get(field, "")
            if field in numeric_fields:
                try:
                    # 尝试转换为数字进行排序
                    return (0, float(str(value)) if value else 0)
                except (ValueError, TypeError):
                    # 转换失败则作为字符串排序，排在数字后面
                    return (1, str(value))
            return (0, str(value))
        
        for col, order in reversed(self.table_sort_keys):
            sort_field = key_map.get(col, "")
            self.configs.sort(
                key=lambda cfg, f=sort_field: get_sort_key(cfg, f),
                reverse=(order == Qt.SortOrder.DescendingOrder)
            )
        self.update_table()

    def show_table_context_menu(self, pos):
        """表格右键菜单"""
        menu = QMenu(self)
        copy_action = menu.addAction("复制选中行")
        export_csv_action = menu.addAction("导出选中行CSV")
        export_excel_action = menu.addAction("导出选中行Excel")
        delete_action = menu.addAction("删除选中行")
        view = self.table_view if self.use_model_view else self.config_table
        action = menu.exec_(view.viewport().mapToGlobal(pos))
        if action == copy_action:
            self.copy_selected_rows()
        elif action == delete_action:
            self.delete_selected_rows()
        elif action == export_csv_action:
            self.export_selected_rows("csv")
        elif action == export_excel_action:
            self.export_selected_rows("excel")

    def copy_selected_rows(self):
        """复制选中行到剪贴板"""
        if self.use_model_view:
            if not self.table_view.selectionModel():
                return
            rows = [idx.row() for idx in self.table_view.selectionModel().selectedRows()]
            if not rows:
                return
            lines = []
            for row in sorted(set(rows)):
                values = []
                for col in range(9):
                    idx = self.table_proxy.index(row, col)
                    values.append(str(self.table_proxy.data(idx)))
                lines.append("\t".join(values))
            QApplication.clipboard().setText("\n".join(lines))
            return
        ranges = self.config_table.selectedRanges()
        if not ranges:
            return
        rows = set()
        for r in ranges:
            rows.update(range(r.topRow(), r.bottomRow() + 1))
        lines = []
        for row in sorted(rows):
            values = []
            for col in range(self.config_table.columnCount()):
                item = self.config_table.item(row, col)
                values.append(item.text() if item else "")
            lines.append("\t".join(values))
        QApplication.clipboard().setText("\n".join(lines))

    def delete_selected_rows(self):
        """删除选中行"""
        if self.use_model_view and self.table_view.selectionModel():
            rows = sorted({idx.row() for idx in self.table_view.selectionModel().selectedRows()}, reverse=True)
            if not rows:
                return
            for row in rows:
                src_index = self.table_proxy.mapToSource(self.table_proxy.index(row, 0))
                if src_index.isValid():
                    self.table_model.removeRows(src_index.row(), 1)
            self._update_checked_count()
            return
        ranges = self.config_table.selectedRanges()
        if not ranges:
            return
        rows = set()
        for r in ranges:
            rows.update(range(r.topRow(), r.bottomRow() + 1))
        for row in sorted(rows, reverse=True):
            self.config_table.removeRow(row)
            if row < len(self.configs):
                self.configs.pop(row)
        self.update_table()

    def export_selected_rows(self, fmt):
        """导出选中行"""
        if self.use_model_view:
            if not self.table_view.selectionModel():
                self._show_infobar("warning", "提示", "未选择任何行")
                return
            rows = [idx.row() for idx in self.table_view.selectionModel().selectedRows()]
            if not rows:
                self._show_infobar("warning", "提示", "未选择任何行")
                return
            data = []
            headers = [self.table_proxy.headerData(i, Qt.Orientation.Horizontal) for i in range(9)]
            for row in sorted(set(rows)):
                row_data = []
                for col in range(9):
                    idx = self.table_proxy.index(row, col)
                    row_data.append(str(self.table_proxy.data(idx)))
                data.append(row_data)
            df = pd.DataFrame(data, columns=headers)
            if fmt == "csv":
                file_path, _ = QFileDialog.getSaveFileName(self, "导出CSV", "selected.csv", "CSV (*.csv)")
                if not file_path:
                    return
                df.to_csv(file_path, index=False, encoding="utf-8-sig")
                self._show_infobar("success", "成功", f"已导出CSV: {file_path}")
            else:
                file_path, _ = QFileDialog.getSaveFileName(self, "导出Excel", "selected.xlsx", "Excel (*.xlsx)")
                if not file_path:
                    return
                try:
                    df.to_excel(file_path, index=False)
                    self._show_infobar("success", "成功", f"已导出Excel: {file_path}")
                except Exception as e:
                    self._show_infobar("error", "错误", f"导出失败: {str(e)}")
            return
        ranges = self.config_table.selectedRanges()
        if not ranges:
            self._show_infobar("warning", "提示", "未选择任何行")
            return
        rows = set()
        for r in ranges:
            rows.update(range(r.topRow(), r.bottomRow() + 1))
        data = []
        headers = [self.config_table.horizontalHeaderItem(i).text() for i in range(1, 10)]
        for row in sorted(rows):
            if not self.page_row_indices or row >= len(self.page_row_indices):
                continue
            config_index = self.page_row_indices[row]
            row_data = []
            for col in range(1, 10):
                item = self.config_table.item(row, col)
                row_data.append(item.text() if item else "")
            data.append(row_data)
        df = pd.DataFrame(data, columns=headers)
        if fmt == "csv":
            file_path, _ = QFileDialog.getSaveFileName(self, "导出CSV", "selected.csv", "CSV (*.csv)")
            if not file_path:
                return
            df.to_csv(file_path, index=False, encoding="utf-8-sig")
            self._show_infobar("success", "成功", f"已导出CSV: {file_path}")
        else:
            file_path, _ = QFileDialog.getSaveFileName(self, "导出Excel", "selected.xlsx", "Excel (*.xlsx)")
            if not file_path:
                return
            try:
                df.to_excel(file_path, index=False)
                self._show_infobar("success", "成功", f"已导出Excel: {file_path}")
            except Exception as e:
                self._show_infobar("error", "错误", f"导出失败: {str(e)}")

    def export_all_rows(self):
        """导出全部数据"""
        if self.config_table.rowCount() == 0:
            self._show_infobar("warning", "提示", "没有可导出的数据")
            return
        if self.use_model_view and self.table_proxy:
            total_rows = self.table_proxy.rowCount()
            headers = [self.table_proxy.headerData(i, Qt.Orientation.Horizontal) for i in range(9)]
            data = []
            for row in range(total_rows):
                row_data = []
                for col in range(9):
                    idx = self.table_proxy.index(row, col)
                    row_data.append(str(self.table_proxy.data(idx)))
                data.append(row_data)
            df = pd.DataFrame(data, columns=headers)
            file_path, selected_filter = QFileDialog.getSaveFileName(
                self, "导出数据", "all.csv", "CSV (*.csv);;Excel (*.xlsx)"
            )
            if not file_path:
                return
            try:
                if file_path.lower().endswith(".xlsx") or "Excel" in selected_filter:
                    df.to_excel(file_path, index=False)
                else:
                    df.to_csv(file_path, index=False, encoding="utf-8-sig")
                self._show_infobar("success", "成功", f"已导出: {file_path}")
            except Exception as e:
                self._show_infobar("error", "错误", f"导出失败: {str(e)}")
            return
        headers = [self.config_table.horizontalHeaderItem(i).text() for i in range(1, 10)]
        data = []
        for row in range(self.config_table.rowCount()):
            row_data = []
            for col in range(1, 10):
                item = self.config_table.item(row, col)
                row_data.append(item.text() if item else "")
            data.append(row_data)
        df = pd.DataFrame(data, columns=headers)
        file_path, selected_filter = QFileDialog.getSaveFileName(
            self, "导出数据", "all.csv", "CSV (*.csv);;Excel (*.xlsx)"
        )
        if not file_path:
            return
        try:
            if file_path.lower().endswith(".xlsx") or "Excel" in selected_filter:
                df.to_excel(file_path, index=False)
            else:
                df.to_csv(file_path, index=False, encoding="utf-8-sig")
            self._show_infobar("success", "成功", f"已导出: {file_path}")
        except Exception as e:
            self._show_infobar("error", "错误", f"导出失败: {str(e)}")

    def toggle_nav_compact(self):
        """切换侧边导航收起/展开"""
        self.nav_compact = not self.nav_compact
        if self.nav_compact:
            self.nav_card.setFixedWidth(60)
            for btn in self.nav_buttons:
                btn.setToolTip(btn.text())
                btn.setText("")
            self.nav_toggle_btn.setText("展开")
            self.nav_title.setVisible(False)
            self.nav_divider.setVisible(False)
            self.nav_footer.setVisible(False)
        else:
            self.nav_card.setFixedWidth(150)
            labels = ["工作台", "日志"]
            for btn, label in zip(self.nav_buttons, labels):
                btn.setText(label)
                btn.setToolTip("")
            self.nav_toggle_btn.setText("收起")
            self.nav_title.setVisible(True)
            self.nav_divider.setVisible(True)
            self.nav_footer.setVisible(True)

    def filter_table(self, text):
        """筛选表格行并高亮关键词"""
        keyword_raw = text.strip()
        suppress_clear = getattr(self, "_suppress_filter_clear_once", False)
        if suppress_clear:
            self._suppress_filter_clear_once = False
        # 清除状态筛选，确保文本筛选基于全量数据
        if hasattr(self, '_current_status_filter') and self._current_status_filter:
            self._current_status_filter = None
            self.filtered_config_indices = None
            if not self.use_model_view and hasattr(self, 'config_table'):
                for row in range(self.config_table.rowCount()):
                    self.config_table.setRowHidden(row, False)
        # 如果先全选再进行筛选，先清空勾选，避免隐藏行仍保持勾选
        if (not suppress_clear and keyword_raw and hasattr(self, "table_select_all_checkbox")
                and self.table_select_all_checkbox.isChecked()):
            for config in self.configs:
                config['勾选'] = False
            self.table_select_all_checkbox.blockSignals(True)
            self.table_select_all_checkbox.setChecked(False)
            self.table_select_all_checkbox.blockSignals(False)
            self._update_checked_count()
            self._update_status_statistics()
            # 同步当前页勾选框显示
            if not self.use_model_view and hasattr(self, "config_table"):
                for row in range(self.config_table.rowCount()):
                    wrapper = self.config_table.cellWidget(row, 0)
                    if wrapper:
                        checkbox = wrapper.findChild(QCheckBox)
                        if checkbox:
                            checkbox.blockSignals(True)
                            checkbox.setChecked(False)
                            checkbox.blockSignals(False)
        if self.use_model_view:
            if not self.table_proxy:
                return
            if not keyword_raw:
                self.table_proxy.setFilterRegularExpression(QRegularExpression())
                return
            terms = [re.escape(t) for t in keyword_raw.split() if t]
            if not terms:
                pattern = ""
            else:
                pattern = "".join([f"(?=.*{t})" for t in terms]) + ".*"
            regex = QRegularExpression(pattern, QRegularExpression.CaseInsensitiveOption)
            column_index = self._filter_model_column_index()
            self.table_proxy.setFilterKeyColumn(column_index)
            self.table_proxy.setFilterRegularExpression(regex)
            return
        if not self.config_table:
            return
        # 表格列与 config 键的对应（列 1~9）
        _table_config_keys = ('多多id', '序号', '话题', '定时发布', '间隔时间', '达人链接', '执行人', '情况', '文件路径')
        if not keyword_raw:
            # 清空筛选：在全量数据上显示，并清除高亮
            self.filtered_config_indices = None
            self.current_page = 1
            self.update_table()
            for row in range(self.config_table.rowCount()):
                for col in range(self.config_table.columnCount()):
                    item = self.config_table.item(row, col)
                    if item:
                        item.setBackground(self._default_color())
                self.config_table.setRowHidden(row, False)
            self.table_match_rows = []
            self.table_match_index = -1
            return
        # 在全量 configs 上计算匹配的配置索引（不限于当前页）
        terms_raw = [t for t in keyword_raw.split() if t]
        terms_lower = [t.lower() for t in terms_raw]
        column_index = self._filter_column_index()
        matching_indices = []
        for i, config in enumerate(self.configs):
            if column_index >= 1 and column_index <= 9:
                key = _table_config_keys[column_index - 1]
                cell_text = str(config.get(key, ''))
            else:
                cell_text = ' '.join(str(config.get(k, '')) for k in _table_config_keys)
            cell_compare = cell_text.lower()
            if all(term in cell_compare for term in terms_lower):
                matching_indices.append(i)
        only_match = self.table_only_match.isChecked() if hasattr(self, 'table_only_match') and self.table_only_match else False
        if only_match:
            # 仅显示匹配项：只显示匹配的数据，表格行数=当前页数据行，不出现空行或其它数据
            self.filtered_config_indices = matching_indices
        else:
            # 显示全部，只做高亮
            self.filtered_config_indices = None
        self.current_page = 1
        self.update_table()
        # 高亮当前页中的匹配单元格（仅显示匹配项时当前页全是匹配行；显示全部时只高亮匹配的格）
        for row in range(self.config_table.rowCount()):
            for col in range(self.config_table.columnCount()):
                if column_index >= 0 and col != column_index:
                    try:
                        item = self.config_table.item(row, col)
                        if item:
                            item.setBackground(self._default_color())
                    except RuntimeError:
                        pass
                    continue
                try:
                    item = self.config_table.item(row, col)
                    if item:
                        cell_text = item.text()
                        cell_compare = cell_text.lower()
                        if all(term in cell_compare for term in terms_lower) and self.table_highlight.isChecked():
                            item.setBackground(self._highlight_color())
                        else:
                            item.setBackground(self._default_color())
                except RuntimeError:
                    continue
        self.table_match_rows = list(range(self.config_table.rowCount()))
        self.table_match_index = -1

    def next_table_match(self):
        """跳转到下一条匹配"""
        if not self.table_match_rows:
            return
        if self.table_match_index < 0:
            self.table_match_index = 0
        else:
            self.table_match_index = (self.table_match_index + 1) % len(self.table_match_rows)
        row = self.table_match_rows[self.table_match_index]
        self.config_table.selectRow(row)
        item = self.config_table.item(row, 0) or self.config_table.item(row, 1)
        if item:
            self.config_table.scrollToItem(item)

    def prev_table_match(self):
        """跳转到上一条匹配"""
        if not self.table_match_rows:
            return
        if self.table_match_index < 0:
            self.table_match_index = len(self.table_match_rows) - 1
        else:
            self.table_match_index = (self.table_match_index - 1) % len(self.table_match_rows)
        row = self.table_match_rows[self.table_match_index]
        self.config_table.selectRow(row)
        item = self.config_table.item(row, 0) or self.config_table.item(row, 1)
        if item:
            self.config_table.scrollToItem(item)

    def _apply_schedule_intervals(self, configs_with_indices):
        """按多多ID应用定时发布+间隔时间规则
        
        configs_with_indices: [{"config_index": config_index, "config": config}, ...]
        """
        from collections import defaultdict
        grouped = defaultdict(list)
        for item in configs_with_indices:
            config = item["config"]
            user_id = config.get("多多id", "")
            if not user_id:
                continue
            grouped[user_id].append(item)

        updated_count = 0
        for user_id, items in grouped.items():
            # 按原始配置列表中的顺序处理
            items.sort(key=lambda x: x["config_index"])
            base_time = None  # 上一条的发布时间（基准时间）
            
            for entry in items:
                config = entry["config"]
                config_index = entry["config_index"]
                schedule_text = (config.get("定时发布") or "").strip()
                interval_value = config.get("间隔时间", 0)
                
                # 解析间隔时间（分钟转秒）
                current_interval = self._parse_interval_seconds(interval_value)
                
                # 解析定时时间
                parsed_time = self._parse_schedule_time(schedule_text) if schedule_text else None
                
                # 情况1：当前条目有定时时间 -> 使用该定时时间，并记录为基准时间
                if parsed_time:
                    base_time = parsed_time
                
                # 情况2：当前条目没有定时时间，但有间隔时间
                elif not parsed_time and current_interval > 0:
                    if base_time:
                        # 有基准时间 -> 新时间 = 基准时间 + 间隔时间
                        base_time = base_time + timedelta(seconds=current_interval)
                        new_text = self._format_schedule_time(base_time)
                        
                        # 更新配置和表格单元格（如果可见）
                        self._update_table_cell(config_index, 4, new_text, highlight=True, is_config_index=True)
                        updated_count += 1
        
        return updated_count

    @staticmethod
    def _parse_schedule_time(text):
        """解析定时发布时间字符串"""
        if not text:
            return None
        try:
            dt = pd.to_datetime(text, errors="coerce")
            if pd.isna(dt):
                return None
            return dt.to_pydatetime()
        except (ValueError, TypeError, AttributeError):
            return None

    def _is_schedule_time_expired(self, time_start):
        """检查定时发布时间是否已过期（早于当前时间）
        
        Args:
            time_start: 定时发布时间字符串，如 "2026-01-15 09:30:00"
            
        Returns:
            bool: 如果时间已过期返回True，否则返回False。如果时间为空或无法解析，返回False（不跳过）
        """
        if not time_start:
            return False
        
        try:
            # 解析时间字符串
            schedule_dt = self._parse_schedule_time(time_start)
            if not schedule_dt:
                return False
            
            # 与当前时间比较
            now = datetime.now()
            if schedule_dt < now:
                return True
            return False
        except (ValueError, TypeError, AttributeError) as e:
            logger.warning(f"检查定时发布时间是否过期时出错: {e}")
            return False

    @staticmethod
    def _parse_interval_seconds(interval_value):
        """解析间隔时间（默认按分钟），支持秒/分钟/小时（如: 30, 10m, 2h, 10分钟, 2小时）
        
        注意：纯数字默认按分钟；空字符串或None返回0，表示没有间隔时间
        """
        if interval_value is None or interval_value == '':
            return 0
        value_str = str(interval_value).strip().lower()
        if not value_str:
            return 0
        # 中文单位映射
        cn_map = {
            "秒": "s",
            "分钟": "m",
            "分": "m",
            "小时": "h",
            "时": "h"
        }
        for cn, en in cn_map.items():
            if value_str.endswith(cn):
                value_str = value_str[:-len(cn)] + en
                break
        try:
            # 纯数字，默认分钟
            if value_str.isdigit():
                return int(value_str) * 60
            # 支持 10m / 2h / 30s
            unit = value_str[-1]
            num_part = value_str[:-1].strip()
            if not num_part:
                return 0
            num = float(num_part)
            if unit == "m":
                return int(num * 60)
            if unit == "h":
                return int(num * 3600)
            if unit == "s":
                return int(num)
        except (ValueError, TypeError):
            return 0
        return 0

    @staticmethod
    def _format_schedule_time(dt):
        """格式化定时发布时间字符串"""
        if not dt:
            return ""
        return dt.strftime("%Y-%m-%d %H:%M:%S")

    def _update_table_cell(self, index, col, value, highlight=False, is_config_index=False):
        """更新配置数据及其对应的表格单元格（如果当前可见）
        
        index: 行号 (is_config_index=False) 或 配置列表索引 (is_config_index=True)
        """
        try:
            # 1. 确定配置索引和表格行号
            if is_config_index:
                config_index = index
                row_idx = self.page_row_indices.index(config_index) if hasattr(self, 'page_row_indices') and config_index in self.page_row_indices else -1
            else:
                row_idx = index
                config_index = self.page_row_indices[row_idx] if hasattr(self, 'page_row_indices') and row_idx < len(self.page_row_indices) else row_idx

            # 2. 更新数据源 self.configs
            if 0 <= config_index < len(self.configs):
                col_to_field = {
                    4: "定时发布",
                    8: "情况",
                    9: "文件路径",
                }
                field = col_to_field.get(col)
                if field:
                    self.configs[config_index][field] = str(value)

            # 3. 如果行可见，更新 UI
            if 0 <= row_idx < self.config_table.rowCount():
                # 使用 blockSignals 临时阻止信号，防止递归
                self.config_table.blockSignals(True)
                try:
                    item = QTableWidgetItem(str(value))
                    item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
                    item.setFlags(item.flags() & ~Qt.ItemFlag.ItemIsEditable)
                    if highlight:
                        item.setBackground(QColor("#E6F4FF"))
                    self.config_table.setItem(row_idx, col, item)
                finally:
                    self.config_table.blockSignals(False)
        except Exception as e:
            logger.warning(f"更新单元格失败: {e}")
            self.config_table.blockSignals(False)
    
    def _update_table_status(self, index, status, is_config_index=False):
        """更新状态列及其对应的表格单元格
        
        index: 行号 (is_config_index=False) 或 配置列表索引 (is_config_index=True)
        """
        try:
            # 1. 确定配置索引和表格行号
            if is_config_index:
                config_index = index
                row_idx = self.page_row_indices.index(config_index) if hasattr(self, 'page_row_indices') and config_index in self.page_row_indices else -1
            else:
                row_idx = index
                config_index = self.page_row_indices[row_idx] if hasattr(self, 'page_row_indices') and row_idx < len(self.page_row_indices) else row_idx

            # 2. 更新数据源
            if 0 <= config_index < len(self.configs):
                self.configs[config_index]["情况"] = status

            # 3. 如果可见，更新 UI
            if 0 <= row_idx < self.config_table.rowCount():
                # 使用 blockSignals 临时阻止信号，防止递归
                self.config_table.blockSignals(True)
                try:
                    # 第8列是"情况"列，只设置文字颜色，不设置背景色和图标
                    status_item = QTableWidgetItem(status)
                    status_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
                    status_item.setFlags(status_item.flags() & ~Qt.ItemFlag.ItemIsEditable)
                    if status == "已完成":
                        status_item.setForeground(QColor("#155724"))  # 绿色
                    elif status == "失败":
                        status_item.setForeground(QColor("#721C24"))  # 红色
                    elif status == "执行中":
                        status_item.setForeground(QColor("#0C5460"))  # 蓝色
                    self._apply_current_highlight_to_item(row_idx, 8, status_item, status)
                    self.config_table.setItem(row_idx, 8, status_item)
                finally:
                    self.config_table.blockSignals(False)
        except Exception as e:
            logger.error(f"更新状态失败: {e}")
            self.config_table.blockSignals(False)


    @staticmethod
    def _highlight_color():
        """高亮颜色 - 淡蓝色背景"""
        return QColor(173, 216, 230)  # 淡蓝色 (Light Blue)

    def _default_color(self):
        """默认背景色"""
        return self.config_table.palette().color(self.config_table.palette().Base)

    def _apply_current_highlight_to_item(self, _row, col, item, text=None):
        """根据当前筛选条件对单元格应用高亮"""
        if not item or not hasattr(self, "table_search_input"):
            return
        if not self.table_highlight.isChecked():
            return
        keyword_raw = self.table_search_input.text().strip()
        if not keyword_raw:
            return
        column_index = self._filter_column_index()
        if column_index >= 0 and col != column_index:
            return
        terms = [t.lower() for t in keyword_raw.split() if t]
        if not terms:
            return
        cell_text = text if text is not None else item.text()
        cell_compare = (cell_text or "").lower()
        if all(term in cell_compare for term in terms):
            item.setBackground(self._highlight_color())
        else:
            item.setBackground(self._default_color())

    def _filter_column_index(self):
        """筛选项下拉对应的表格列索引；-1 表示全部列。排除情况列，以多多ID等为筛选项。"""
        i = self.table_column_filter.currentIndex()
        if i <= 0 or not getattr(self, "_filter_table_columns", None):
            return -1
        k = i - 1
        if k >= len(self._filter_table_columns):
            return -1
        return self._filter_table_columns[k]

    def _filter_model_column_index(self):
        """Model/View 模式下筛选项对应的列索引；-1 表示全部列。"""
        i = self.table_column_filter.currentIndex()
        if i <= 0 or not getattr(self, "_filter_model_columns", None):
            return -1
        k = i - 1
        if k >= len(self._filter_model_columns):
            return -1
        return self._filter_model_columns[k]

    def _show_all_rows(self):
        """显示全部行"""
        for row in range(self.config_table.rowCount()):
            self.config_table.setRowHidden(row, False)

    def _filter_by_status(self, status):
        """按状态筛选表格行（在全量数据上计算，分页显示筛选结果）"""
        if not getattr(self, 'configs', None) or not self.configs:
            self._show_infobar("warning", "提示", "暂无数据")
            return
        # 清除文本筛选，确保每次筛选都基于全量数据
        if hasattr(self, 'table_search_input') and self.table_search_input.text().strip():
            self.table_search_input.blockSignals(True)
            self.table_search_input.clear()
            self.table_search_input.blockSignals(False)
            self.filtered_config_indices = None
            self.table_match_rows = []
            self.table_match_index = -1
        # 切换筛选状态
        current_filter = getattr(self, '_current_status_filter', None)
        if current_filter == status:
            self._current_status_filter = None
            self.filtered_config_indices = None
            self.current_page = 1
            self.update_table()
            self._show_infobar("success", "提示", "已显示全部记录")
            return
        self._current_status_filter = status
        # 在全量 configs 上计算匹配的配置索引
        matching_indices = []
        for i, config in enumerate(self.configs):
            config_status = str(config.get('情况', ''))
            if status == "成功":
                match = "完成" in config_status or "成功" in config_status
            elif status == "失败":
                match = "失败" in config_status or "错误" in config_status
            else:
                match = status in config_status
            if match:
                matching_indices.append(i)
        self.filtered_config_indices = matching_indices
        self.current_page = 1
        self.update_table()
        if not matching_indices:
            self._show_infobar("warning", "提示", f"没有{status}的记录")
        else:
            self._show_infobar("success", "筛选", f"已筛选出 {len(matching_indices)} 条{status}记录，再次点击取消筛选")

    def _update_status_statistics(self):
        """更新状态统计（成功/失败/待执行数量）- 统计所有配置的真实状态
        
        待执行：勾选的且状态不是"已完成"的数据，表示用户选择要处理的任务数
        执行中：只有在任务运行时才有值，任务完成后为0
        成功：状态为"已完成"的数据数量
        失败：状态为"失败/跳过/过期"的数据数量
        """
        if not hasattr(self, 'configs') or not self.configs:
            self.set_status_cards(pending=0, running=0, success=0, failed=0)
            return
        
        pending_count = 0
        success_count = 0
        failed_count = 0
        
        # 统计所有配置的状态（根据数据总量来统计）
        for config in self.configs:
            status = config.get('情况', '待执行')
            is_checked = config.get('勾选', False)
            
            if "完成" in status or "成功" in status:
                success_count += 1
            elif "失败" in status or "错误" in status or "过期" in status or "跳过" in status:
                failed_count += 1
                # 只有勾选的失败项才算待执行
                if is_checked:
                    pending_count += 1
            elif "待" in status or not status:
                # 只有勾选的待执行项才算待执行
                if is_checked:
                    pending_count += 1
        
        # 执行中始终为0（只有任务运行时才会被单独更新）
        self.set_status_cards(pending=pending_count, running=0, success=success_count, failed=failed_count)

    def retry_failed_items(self):
        """重新发布所有失败的项目"""
        if not hasattr(self, 'configs') or not self.configs:
            self._show_infobar("warning", "提示", "暂无数据")
            return
        
        # 收集失败的项目索引
        failed_indices = []
        for idx, config in enumerate(self.configs):
            status = config.get('情况', '')
            if "失败" in status or "错误" in status or "过期" in status or "跳过" in status:
                failed_indices.append(idx)
        
        if not failed_indices:
            self._show_infobar("warning", "提示", "没有失败的项目需要重新发布")
            return
        
        # 确认对话框
        reply = QMessageBox.question(
            self,
            "确认重新发布",
            f"发现 {len(failed_indices)} 条失败记录，是否重新发布？\n\n"
            "重新发布将把这些记录的状态重置为【待执行】，然后执行发布任务。",
            QMessageBox.Yes | QMessageBox.No,
            QMessageBox.No
        )
        
        if reply != QMessageBox.Yes:
            return
        
        # 重置失败项的状态为"待执行"
        for idx in failed_indices:
            self.configs[idx]['情况'] = '待执行'
        
        # 更新表格显示
        self.update_table()
        self._update_status_statistics()
        
        # 筛选显示这些待重新发布的项
        self._filter_by_status("待执行")
        
        self._show_infobar("success", "已重置", f"已将 {len(failed_indices)} 条失败记录重置为待执行状态，请点击【开始上传】按钮开始发布")

    def get_failed_configs(self):
        """获取所有失败的配置项"""
        if not hasattr(self, 'configs') or not self.configs:
            return []
        
        failed_configs = []
        for config in self.configs:
            status = config.get('情况', '')
            if "失败" in status or "错误" in status or "过期" in status or "跳过" in status:
                failed_configs.append(config)
        return failed_configs

    def set_status_cards(self, update_text=None, pending=None, running=None, success=None, failed=None):
        """更新状态卡片显示"""
        if update_text is not None:
            self.status_update_value.setText(update_text)
            if "未找到" in update_text:
                self.status_update_value.setStyleSheet("color: #b42318;")
            elif "未更新" in update_text:
                self.status_update_value.setStyleSheet("color: #6b7280;")
            else:
                self.status_update_value.setStyleSheet("color: #1d4ed8;")
        if pending is not None:
            self.status_pending_value.setText(str(pending))
            try:
                pending_num = int(str(pending))
            except ValueError:
                pending_num = 0
            if pending_num > 0:
                self.status_pending_value.setStyleSheet("color: #b45309;")
            else:
                self.status_pending_value.setStyleSheet("color: #15803d;")
        if running is not None:
            self.status_running_value.setText(str(running))
            running_text = str(running)
            if running_text in ["0", "0/0"]:
                self.status_running_value.setStyleSheet("color: #6b7280;")
            else:
                self.status_running_value.setStyleSheet("color: #1d4ed8;")
        if success is not None:
            self.status_success_value.setText(str(success))
            try:
                success_num = int(str(success))
            except ValueError:
                success_num = 0
            if success_num > 0:
                self.status_success_value.setStyleSheet("color: #15803d; font-weight: bold;")
            else:
                self.status_success_value.setStyleSheet("color: #6b7280;")
        if failed is not None:
            self.status_failed_value.setText(str(failed))
            try:
                failed_num = int(str(failed))
            except ValueError:
                failed_num = 0
            if failed_num > 0:
                self.status_failed_value.setStyleSheet("color: #dc2626; font-weight: bold;")
            else:
                self.status_failed_value.setStyleSheet("color: #6b7280;")

    def set_running_progress(self, done, total):
        """更新执行中统计"""
        self.running_done = done
        self.running_total = total
        if total > 0:
            self.set_status_cards(running=f"{done}/{total}")
            if hasattr(self, "status_running_progress"):
                percent = int((done / total) * 100)
                self.status_running_progress.setValue(percent)
        else:
            self.set_status_cards(running="0")
            if hasattr(self, "status_running_progress"):
                self.status_running_progress.setValue(0)

    def clear_log(self):
        """清空日志显示"""
        self.log_text.clear()

    def filter_log(self, text):
        """过滤日志内容"""
        keyword = text.strip()
        self._clear_log_highlight()
        self._update_log_match_status(0)
        if not keyword:
            return
        self._update_log_matches(keyword)
        if self.log_highlight_check.isChecked():
            self._highlight_log_matches()
        self.find_log(backward=False, reset=True)

    def export_log(self):
        """导出日志到文件"""
        log_content = self.log_text.toPlainText()
        if not log_content.strip():
            self._show_infobar("warning", "提示", "日志为空，无法导出")
            return
        file_path, _ = QFileDialog.getSaveFileName(
            self, "保存日志", "log.txt", "文本文件 (*.txt)"
        )
        if not file_path:
            return
        try:
            with open(file_path, "w", encoding="utf-8") as f:
                f.write(log_content)
            self._show_infobar("success", "成功", f"日志已导出: {file_path}")
        except Exception as e:
            self._show_infobar("error", "错误", f"导出失败: {str(e)}")

    def find_log(self, backward=False, reset=False):
        """查找日志"""
        keyword = self.log_search_input.text().strip()
        if not keyword:
            return
        if not self.log_match_positions:
            self._update_log_matches(keyword)
        if not self.log_match_positions:
            return
        if reset:
            self.log_match_index = 0 if not backward else len(self.log_match_positions) - 1
        else:
            step = -1 if backward else 1
            self.log_match_index = (self.log_match_index + step) % len(self.log_match_positions)
        start, end = self.log_match_positions[self.log_match_index]
        cursor = self.log_text.textCursor()
        cursor.setPosition(start)
        cursor.setPosition(end, QTextCursor.KeepAnchor)
        self.log_text.setTextCursor(cursor)
        self.log_text.ensureCursorVisible()

    def _clear_log_highlight(self):
        """清除日志高亮"""
        cursor = self.log_text.textCursor()
        cursor.select(cursor.Document)
        cursor.setCharFormat(self.log_text.currentCharFormat())
        cursor.clearSelection()

    def _highlight_log_matches(self):
        """高亮日志所有匹配项"""
        if not self.log_match_positions:
            return
        fmt = self.log_text.currentCharFormat()
        fmt.setBackground(self.log_text.palette().color(self.log_text.palette().Highlight).lighter(160))
        for start, end in self.log_match_positions:
            cursor = self.log_text.textCursor()
            cursor.setPosition(start)
            cursor.setPosition(end, QTextCursor.KeepAnchor)
            cursor.mergeCharFormat(fmt)

    def _update_log_matches(self, keyword):
        """更新日志匹配位置"""
        self.log_match_positions = []
        self.log_match_index = -1
        if not keyword:
            self._update_log_match_status(0)
            return
        content = self.log_text.toPlainText()
        whole_word = self.log_whole_word.isChecked()
        pattern_text = re.escape(keyword)
        if whole_word:
            pattern_text = rf"\b{pattern_text}\b"
        pattern = re.compile(pattern_text, re.IGNORECASE)
        for match in pattern.finditer(content):
            self.log_match_positions.append((match.start(), match.end()))
        self._update_log_match_status(len(self.log_match_positions))

    def _update_log_match_status(self, count):
        """更新日志匹配统计"""
        if hasattr(self, "log_match_status"):
            self.log_match_status.setText(f"匹配: {count}")

    def _apply_table_column_widths(self):
        """应用配置表列宽（仅按窗口宽度自适应，不根据内容变化）"""
        header = self.config_table.horizontalHeader()
        header.setStretchLastSection(True)
        
        # 禁用根据内容自适应，防止导入或更新数据时列宽剧烈跳动
        # 设置最小列宽，确保内容可见
        min_widths = {
            0: 50,   # 勾选框
            1: 80,   # 多多ID
            2: 60,   # 序号
            3: 100,  # 话题
            4: 100,  # 定时发布
            5: 80,   # 间隔时间
            6: 120,  # 达人链接
            7: 80,   # 执行人
            8: 80,   # 情况
            9: 150,  # 文件路径
            10: 70,  # 进度
            11: 100  # 操作
        }
        
        # 切换到Interactive模式，允许手动拖拽调整
        header.setSectionResizeMode(0, QHeaderView.Fixed)  # 勾选框固定
        for col in range(1, self.config_table.columnCount()):
            header.setSectionResizeMode(col, QHeaderView.Interactive)
            if col in min_widths:
                # 仅在第一次或比例未建立时设置初始宽度
                if not self._column_width_ratios:
                    self.config_table.setColumnWidth(col, min_widths[col])
        
        # 如果已经有保存的比例，直接按比例缩放
        if self._column_width_ratios:
            self._auto_resize_table_columns()
        else:
            # 第一次加载，根据当前设置的初始宽度计算比例
            self._update_column_width_ratios()
            self._auto_resize_table_columns()

    def _update_column_width_ratios(self):
        """更新列宽比例"""
        if self.config_table.columnCount() == 0:
            return
        
        total_width = 0
        widths = {}
        # 计算所有列的总宽度（不包括勾选框）
        for col in range(1, self.config_table.columnCount()):
            width = self.config_table.columnWidth(col)
            widths[col] = width
            total_width += width
        
        # 计算比例
        if total_width > 0:
            self._column_width_ratios = {}
            for col, width in widths.items():
                self._column_width_ratios[col] = width / total_width

    def _auto_resize_table_columns(self):
        """根据比例自动调整表格列宽"""
        if not self._column_width_ratios or self._is_manual_resize:
            return
        
        header = self.config_table.horizontalHeader()
        if header.sectionResizeMode(1) != QHeaderView.Interactive:
            return
        
        # 获取表格可用宽度
        table_width = self.config_table.viewport().width()
        checkbox_width = self.config_table.columnWidth(0) if self.config_table.columnCount() > 0 else 0
        available_width = table_width - checkbox_width
        
        if available_width <= 0:
            return
        
        # 按比例分配宽度
        self._is_manual_resize = True  # 临时标记，避免触发信号
        columns = sorted(self._column_width_ratios.keys())
        assigned_width = 0
        
        for i, col in enumerate(columns):
            if col < self.config_table.columnCount():
                ratio = self._column_width_ratios[col]
                # 最后一列取剩余所有宽度，确保填满
                if i == len(columns) - 1:
                    new_width = max(60, available_width - assigned_width)
                else:
                    new_width = int(available_width * ratio)
                    min_width = 60
                    if new_width < min_width:
                        new_width = min_width
                
                self.config_table.setColumnWidth(col, new_width)
                assigned_width += new_width
        self._is_manual_resize = False

    def on_column_resized(self, logical_index, _old_size, _new_size):
        """列宽调整时的回调（手动或自动）"""
        if not self._is_manual_resize and logical_index > 0 and self._resize_timer is not None:
            # 用户手动调整了列宽，延迟更新比例（避免拖拽时频繁更新）
            self._resize_timer.stop()
            self._resize_timer.start(300)  # 300ms后更新比例

    def _delayed_update_ratios(self):
        """延迟更新列宽比例"""
        if not self._is_manual_resize:
            self._update_column_width_ratios()

    def on_table_geometry_changed(self):
        """表格几何形状改变时的回调（窗口大小改变）"""
        if not self._is_manual_resize and self._auto_resize_timer is not None:
            # 使用独立的定时器进行防抖，避免频繁触发导致卡顿
            self._auto_resize_timer.stop()
            self._auto_resize_timer.start(50)

    def _apply_table_view_column_widths(self):
        """应用 Model/View 列宽（仅按窗口宽度自适应，不根据内容变化）"""
        if not self.table_view.model():
            return
        
        header = self.table_view.horizontalHeader()
        header.setStretchLastSection(True)
        
        # 禁用根据内容自适应
        min_widths = {
            0: 80,   # 多多ID
            1: 60,   # 序号
            2: 100,  # 话题
            3: 100,  # 定时发布
            4: 80,   # 间隔时间
            5: 120,  # 达人链接
            6: 80,   # 执行人
            7: 80,   # 情况
            8: 150,  # 文件路径
            9: 70,   # 进度
            10: 100  # 操作
        }
        
        # 切换到Interactive模式
        for col in range(self.table_view.model().columnCount()):
            header.setSectionResizeMode(col, QHeaderView.Interactive)
            if col in min_widths and not self._table_view_column_width_ratios:
                self.table_view.setColumnWidth(col, min_widths[col])
        
        # 按比例分配或初始化比例
        if self._table_view_column_width_ratios:
            self._auto_resize_table_view_columns()
        else:
            self._update_table_view_column_width_ratios()
            self._auto_resize_table_view_columns()

    def _update_table_view_column_width_ratios(self):
        """更新Model/View模式的列宽比例"""
        if not self.table_view.model() or self.table_view.model().columnCount() == 0:
            return
        
        total_width = 0
        widths = {}
        # 计算所有列的总宽度
        for col in range(self.table_view.model().columnCount()):
            width = self.table_view.columnWidth(col)
            widths[col] = width
            total_width += width
        
        # 计算比例
        if total_width > 0:
            self._table_view_column_width_ratios = {}
            for col, width in widths.items():
                self._table_view_column_width_ratios[col] = width / total_width

    def _auto_resize_table_view_columns(self):
        """根据比例自动调整Model/View表格列宽"""
        if not self._table_view_column_width_ratios or self._is_table_view_manual_resize:
            return
        
        header = self.table_view.horizontalHeader()
        if not header or header.sectionResizeMode(0) != QHeaderView.Interactive:
            return
        
        # 获取表格可用宽度
        table_width = self.table_view.viewport().width()
        if table_width <= 0:
            return
        
        # 按比例分配宽度
        self._is_table_view_manual_resize = True  # 临时标记，避免触发信号
        columns = sorted(self._table_view_column_width_ratios.keys())
        assigned_width = 0
        
        for i, col in enumerate(columns):
            if col < self.table_view.model().columnCount():
                ratio = self._table_view_column_width_ratios[col]
                # 最后一列取剩余所有宽度，确保填满
                if i == len(columns) - 1:
                    new_width = max(60, table_width - assigned_width)
                else:
                    new_width = int(table_width * ratio)
                    min_width = 60
                    if new_width < min_width:
                        new_width = min_width
                
                self.table_view.setColumnWidth(col, new_width)
                assigned_width += new_width
        self._is_table_view_manual_resize = False

    def on_table_view_column_resized(self, _logical_index, _old_size, _new_size):
        """Model/View模式列宽调整时的回调（手动或自动）"""
        if not self._is_table_view_manual_resize and self._table_view_resize_timer is not None:
            # 用户手动调整了列宽，延迟更新比例（避免拖拽时频繁更新）
            self._table_view_resize_timer.stop()
            self._table_view_resize_timer.start(300)  # 300ms后更新比例

    def _delayed_update_table_view_ratios(self):
        """延迟更新Model/View模式的列宽比例"""
        if not self._is_table_view_manual_resize:
            self._update_table_view_column_width_ratios()

    def on_table_view_geometry_changed(self):
        """Model/View模式表格几何形状改变时的回调（窗口大小改变）"""
        if not self._is_table_view_manual_resize and self._auto_resize_table_view_timer is not None:
            # 使用独立的定时器进行防抖，避免频繁触发导致卡顿
            self._auto_resize_table_view_timer.stop()
            self._auto_resize_table_view_timer.start(50)

    # noinspection SpellCheckingInspection
    def _show_infobar(self, level, title, content):
        """显示提示条"""
        # noinspection PyArgumentList
        if level == "success":
            InfoBar.success(title=title, content=content, parent=self, position=InfoBarPosition.TOP_RIGHT)
        elif level == "warning":
            # noinspection PyArgumentList
            InfoBar.warning(title=title, content=content, parent=self, position=InfoBarPosition.TOP_RIGHT)
        elif level == "info":
            # noinspection PyArgumentList
            InfoBar.info(title=title, content=content, parent=self, position=InfoBarPosition.TOP_RIGHT)
        else:
            # noinspection PyArgumentList
            InfoBar.error(title=title, content=content, parent=self, position=InfoBarPosition.TOP_RIGHT)

    def browse_folder(self):
        """浏览文件夹"""
        folder_path = QFileDialog.getExistingDirectory(self, "选择文件夹")
        if folder_path:
            self.folder_path_input.setText(folder_path)

    def download_excel_template(self):
        """下载Excel配置模板"""
        try:
            # 选择保存路径
            file_path, _ = QFileDialog.getSaveFileName(
                self, 
                "保存配置模板", 
                "配置模板.xlsx", 
                "Excel文件 (*.xlsx)"
            )
            
            if not file_path:
                return
            
            # 创建模板数据
            template_data = {
                '多多id': ['示例ID_001', '示例ID_001', '示例ID_002'],
                '序号': ['1', '2', '1'],
                '话题': ['#话题1', '#话题2', '#话题1'],
                '定时发布': ['2024-01-01 10:00', '', ''],
                '间隔时间': [5, 5, 0],
                '达人链接': ['https://example.com/user1', '', 'https://example.com/user2'],
                '执行人': ['张三', '张三', '李四'],
                '情况': ['待执行', '待执行', '待执行']
            }
            
            df = pd.DataFrame(template_data)
            
            # 保存Excel文件
            df.to_excel(file_path, index=False, engine='openpyxl')
            
            self._show_infobar("success", "成功", f"模板已保存: {file_path}")
            self.log_text.append(f"配置模板已下载: {file_path}")
            self.log_text.append("模板说明:")
            self.log_text.append("  - 多多id: 用户ID，相同ID的数据会按序号顺序处理")
            self.log_text.append("  - 序号: 文件序号，用于匹配文件夹中的文件（如：1-视频名称.mp4）")
            self.log_text.append("  - 话题: 发布时的话题标签")
            self.log_text.append("  - 定时发布: 定时发布时间（格式：yyyy-MM-dd HH:mm）")
            self.log_text.append("  - 间隔时间: 在上一条基础上延迟的分钟数（无定时时间时生效）")
            self.log_text.append("  - 达人链接: 达人主页链接")
            self.log_text.append("  - 执行人: 负责人")
            self.log_text.append("  - 情况: 执行状态（待执行/执行中/已完成/失败）")
            
        except Exception as e:
            self._show_infobar("error", "错误", f"保存模板失败: {str(e)}")
            logger.error(f"保存模板失败: {e}")

    def import_excel(self):
        """导入Excel配置文件（直接弹出文件选择对话框）"""
        # 弹出文件选择对话框
        excel_path, _ = QFileDialog.getOpenFileName(
            self, "选择Excel配置文件", "", "Excel文件 (*.xlsx *.xls)"
        )
        
        if not excel_path:
            return  # 用户取消选择
        
        # 显示选择的文件路径
        self.excel_path_input.setText(excel_path)

        try:
            # 读取Excel文件，添加更多异常处理
            try:
                df = pd.read_excel(excel_path)
            except FileNotFoundError:
                self._show_infobar("error", "错误", f"找不到文件: {excel_path}")
                logger.error(f"文件不存在: {excel_path}")
                return
            except PermissionError:
                self._show_infobar("error", "错误", f"文件被占用，请关闭Excel文件后重试")
                logger.error(f"文件被占用: {excel_path}")
                return
            except Exception as e:
                self._show_infobar("error", "错误", f"读取Excel文件失败: {str(e)}")
                logger.error(f"读取Excel失败: {e}")
                return

            if df.empty:
                self._show_infobar("warning", "警告", "Excel文件为空")
                return

            # 检查必需的列
            required_columns = ['多多id', '序号', '话题', '定时发布', '间隔时间', '达人链接', '执行人', '情况']
            missing_columns = [col for col in required_columns if col not in df.columns]

            if missing_columns:
                self._show_infobar(
                    "warning",
                    "警告",
                    f"Excel缺少列: {', '.join(missing_columns)}"
                )
                return

            # 清空所有状态，根据新的Excel配置表格为准（完全重置，不保留任何上一次的数据）
            # 1. 清空配置列表
            self.configs = []
            # 2. 重置运行状态变量
            self.running_total = 0
            self.running_done = 0
            # 3. 清空批量任务队列
            self.batch_task_queue = []
            self.current_batch_task_index = 0
            # 4. 清空行映射（用于状态回写）
            self._row_map_by_user_index = {}
            # 5. 重置所有计数变量（确保导入新Excel时完全清空上一次的统计）
            self.batch_success_count = 0
            self.batch_failed_count = 0
            self.batch_total_tasks = 0
            self.batch_processed = 0
            self.batch_pending_tasks = 0
            # 6. 重置所有状态卡片显示（全部归零）
            self.set_status_cards(update_text="未更新", pending=0, running=0, success=0, failed=0)
            # 7. 重置进度条
            if hasattr(self, "status_running_progress"):
                self.status_running_progress.setValue(0)
            if hasattr(self, "progress_bar"):
                self.progress_bar.setValue(0)
                self.progress_bar.setVisible(False)
            # 8. 重置“更新数据”提示文本
            if hasattr(self, "update_status_label"):
                self.update_status_label.setText("未更新")
                self.update_status_label.setStyleSheet("color: #666; font-size: 10px;")
            
            # 转换为配置列表，添加异常处理
            for idx, row in df.iterrows():
                try:
                    # 处理间隔时间：保持原始状态，空值保持为空字符串
                    interval_raw = row.get('间隔时间')
                    if pd.notna(interval_raw) and str(interval_raw).strip() != '':
                        try:
                            interval_value = int(float(interval_raw))  # 先转float再转int，处理小数情况
                        except (ValueError, TypeError):
                            interval_value = ''  # 无效值保持为空
                    else:
                        interval_value = ''  # 空值保持为空
                    
                    # 辅助函数：将可能带.0的数字字符串转为整数型字符串
                    def clean_str(val):
                        if pd.isna(val): return ''
                        s = str(val).strip()
                        if s.endswith('.0'):
                            return s[:-2]
                        return s

                    # 导入新Excel时，强制将所有状态重置为"待执行"，根据新的Excel配置表格为准
                    # 忽略Excel中"情况"列的旧状态值，统一重置为"待执行"
                    status_value = '待执行'
                    
                    config = {
                        '勾选': False,  # 导入后默认不勾选，交由用户选择
                        '多多id': clean_str(row.get('多多id', '')),
                        '序号': clean_str(row.get('序号', '')),
                        '话题': str(row.get('话题', '')).strip() if pd.notna(row.get('话题')) else '',
                        '定时发布': str(row.get('定时发布', '')).strip() if pd.notna(row.get('定时发布')) else '',
                        '间隔时间': interval_value,
                        '达人链接': str(row.get('达人链接', '')).strip() if pd.notna(row.get('达人链接')) else '',
                        '执行人': str(row.get('执行人', '')).strip() if pd.notna(row.get('执行人')) else '',
                        '情况': status_value,  # 强制重置为"待执行"，根据新的Excel配置表格为准
                        '文件路径': ''  # 文件路径字段初始为空，通过更新数据按钮填充
                    }
                    self.configs.append(config)
                except Exception as e:
                    logger.warning(f"处理第 {idx + 1} 行数据时出错: {e}")
                    continue  # 跳过有问题的行

            if not self.configs:
                self._show_infobar("warning", "警告", "未能解析出任何有效配置")
                return

            # 清除排序状态，保持Excel原始顺序
            self.table_sort_keys = []
            self.config_table.horizontalHeader().setSortIndicator(-1, Qt.SortOrder.AscendingOrder)
            
            # 更新表格显示（跳过表格->configs同步，避免旧数据回写）
            try:
                self.update_table(skip_sync=True)
            except Exception as e:
                self._show_infobar("error", "错误", f"更新表格失败: {str(e)}")
                logger.error(f"更新表格失败: {e}")
                return

            # 导入后默认不勾选，确保全选状态为未选中
            if hasattr(self, "table_select_all_checkbox"):
                self.table_select_all_checkbox.blockSignals(True)
                self.table_select_all_checkbox.setChecked(False)
                self.table_select_all_checkbox.blockSignals(False)

            # 显示表格
            self.table_group.setVisible(True)
            # 更新状态统计（基于新导入的配置重新计算）
            self._update_status_statistics()
            # 确保更新状态显示为"未更新"（文件路径还未更新）
            self.set_status_cards(update_text="未更新")

            self._show_infobar("success", "成功", f"成功导入 {len(self.configs)} 条配置，所有状态已清空重置")

        except Exception as e:
            error_msg = f"导入Excel文件失败: {str(e)}"
            self._show_infobar("error", "错误", error_msg)
            logger.error(f"导入Excel失败: {e}", exc_info=True)

    def add_single_config(self):
        """添加单条配置到配置列表"""
        try:
            # 获取输入框的值
            user_id = self.add_user_id_input.text().strip()
            index = self.add_index_input.text().strip()
            topic = self.add_topic_input.text().strip()
            schedule = self.add_schedule_input.text().strip()
            interval_text = self.add_interval_input.text().strip()
            expert_link = self.add_expert_link_input.text().strip()
            executor = self.add_executor_input.text().strip()
            
            # 验证必填字段
            if not user_id:
                self._show_infobar("warning", "警告", "请输入多多ID")
                self.add_user_id_input.setFocus()
                return
            
            if not index:
                self._show_infobar("warning", "警告", "请输入序号")
                self.add_index_input.setFocus()
                return
            
            # 处理间隔时间
            interval_value = ''
            if interval_text:
                try:
                    interval_value = int(float(interval_text))
                except ValueError:
                    self._show_infobar("warning", "警告", "间隔时间必须是数字")
                    self.add_interval_input.setFocus()
                    return
            
            # 创建配置对象
            config = {
                '勾选': False,
                '多多id': user_id,
                '序号': index,
                '话题': topic,
                '定时发布': schedule,
                '间隔时间': interval_value,
                '达人链接': expert_link,
                '执行人': executor,
                '情况': '待执行',
                '文件路径': ''
            }
            
            # 添加到配置列表
            self.configs.append(config)
            
            # 更新表格显示
            self.update_table()
            
            # 显示表格
            self.table_group.setVisible(True)
            
            # 更新状态统计
            self._update_status_statistics()
            self.set_status_cards(update_text="未更新")
            
            # 清空输入框
            self.clear_add_config_inputs()
            
            self._show_infobar("success", "成功", f"已添加配置: {user_id} - {index}")
            
        except Exception as e:
            error_msg = f"添加配置失败: {str(e)}"
            self._show_infobar("error", "错误", error_msg)
            logger.error(f"添加配置失败: {e}", exc_info=True)
    
    def clear_add_config_inputs(self):
        """清空单条配置输入框"""
        self.add_user_id_input.clear()
        self.add_index_input.clear()
        self.add_topic_input.clear()
        self.add_schedule_input.clear()
        self.add_interval_input.clear()
        self.add_expert_link_input.clear()
        self.add_executor_input.clear()
        # 设置焦点到第一个输入框
        self.add_user_id_input.setFocus()

    def update_table(self, skip_sync=False):
        """更新配置表格。skip_sync=True 时跳过 表格→configs 同步（如刚由更新数据写入 configs 后刷新表格）。"""
        if getattr(self, "config_table", None) is None:
            return
        if not self.use_model_view and not skip_sync:
            self._sync_configs_from_table()
            
        self.is_updating_table = True
        # 使用筛选后的索引或全部索引进行分页（筛选在全量数据上计算，分页只切当前页）
        effective_indices = self.filtered_config_indices if getattr(self, 'filtered_config_indices', None) is not None else list(range(len(self.configs)))
        total_rows = len(effective_indices)
        # 设置最小显示行数，即使没有数据也显示空行
        min_display_rows = 15  # 最少显示15行
        
        if len(self.configs) > 1000:
            self._setup_model_view()
            self.is_updating_table = False
            return
        self.use_model_view = False
        if getattr(self, "table_view", None) is not None:
            self.table_view.setVisible(False)
        self.config_table.setVisible(True)
        for btn in [getattr(self, "page_first_btn", None), getattr(self, "page_prev_btn", None),
                    getattr(self, "page_next_btn", None), getattr(self, "page_last_btn", None),
                    getattr(self, "page_size_combo", None)]:
            if btn is not None:
                btn.setEnabled(True)
        total_pages = max(1, (total_rows + self.page_size - 1) // self.page_size)
        if self.current_page > total_pages:
            self.current_page = total_pages
        start = (self.current_page - 1) * self.page_size
        end = min(start + self.page_size, total_rows)
        self.page_row_indices = list(effective_indices[start:end])

        # 临时禁用排序，防止填充数据时自动排序打乱顺序
        self.config_table.setSortingEnabled(False)
        
        # 筛选时只显示当前页数据行，不预留空行，避免“仅显示匹配项”时仍看到多余行
        is_filtered = getattr(self, 'filtered_config_indices', None) is not None
        display_rows = len(self.page_row_indices) if is_filtered else max(len(self.page_row_indices), min_display_rows)
        self.config_table.setRowCount(display_rows)

        # 先统一设置行高，再填数据，避免后设行高导致勾选框列布局重算、出现“除第一行外往下移”
        default_row_height = self.config_table.verticalHeader().defaultSectionSize()
        for row in range(display_rows):
            self.config_table.setRowHeight(row, default_row_height)

        # 先清除第 0 列所有单元格控件，避免连续刷新时旧勾选框残留导致错位
        for row in range(display_rows):
            self.config_table.removeCellWidget(row, 0)

        # 填充期间禁止表格重绘，避免中间布局导致勾选框错位
        self.config_table.setUpdatesEnabled(False)
        try:
            # 填充数据行
            for table_row, config_index in enumerate(self.page_row_indices):
                config = self.configs[config_index]
                # 第0列：勾选框（传入行高，固定高度+居中对齐，避免第一页第二行等错位）
                self._set_checkbox_item(table_row, config_index, default_row_height)
                # 其他列的索引均+1
                self.config_table.setItem(table_row, 1, self._create_centered_item(str(config.get('多多id', ''))))
                self.config_table.setItem(table_row, 2, self._create_centered_item(str(config.get('序号', ''))))
                self.config_table.setItem(table_row, 3, self._create_centered_item(str(config.get('话题', ''))))
                self.config_table.setItem(table_row, 4, self._create_centered_item(str(config.get('定时发布', ''))))
                # 间隔时间：保持原始状态，空值显示为空
                interval_val = config.get('间隔时间', '')
                if interval_val == '' or interval_val is None:
                    interval_display = ''
                else:
                    interval_display = str(interval_val)
                self.config_table.setItem(table_row, 5, self._create_centered_item(interval_display))
                url_text = str(config.get('达人链接', ''))
                url_item = self._create_centered_item(url_text)
                url_item.setToolTip(url_text)
                self.config_table.setItem(table_row, 6, url_item)
                self.config_table.setItem(table_row, 7, self._create_centered_item(str(config.get('执行人', ''))))
                self._set_status_item(table_row, str(config.get('情况', '待执行')))
                file_path = str(config.get('文件路径', ''))
                file_path_item = self._create_centered_item(file_path)
                file_path_item.setToolTip(file_path)
                self.config_table.setItem(table_row, 9, file_path_item)
                self._set_progress_item(table_row, str(config.get('情况', '待执行')))
                self._set_action_buttons(table_row, config_index)
        finally:
            self.config_table.setUpdatesEnabled(True)
            # 强制表格立即完成布局，避免第一页第二行等勾选框错位
            self.config_table.doItemsLayout()
        
        # 重新启用排序功能（但不会自动排序已填充的数据）
        self.config_table.setSortingEnabled(True)

        # 固定列宽（不随内容自适应）
        self._apply_table_column_widths()
        # 更新状态卡片统计（只统计真实数据）
        self._update_status_statistics()
        if getattr(self, "table_empty_label", None) is not None:
            self.table_empty_label.setVisible(False)
        if getattr(self, "page_info_label", None) is not None:
            self.page_info_label.setText(f"第 {self.current_page}/{total_pages} 页")
        self.is_updating_table = False
        self._update_checked_count()

    def _setup_model_view(self):
        """切换到大数据量 Model/View 模式"""
        headers = MODEL_VIEW_HEADERS
        if self.table_model is None:
            self.table_model = ConfigTableModel(self.configs, headers, self)
            self.table_proxy = QSortFilterProxyModel(self)
            self.table_proxy.setSourceModel(self.table_model)
            self.table_proxy.setFilterKeyColumn(-1)
            self.table_view.setModel(self.table_proxy)
            self.table_delegate = TableActionDelegate(self.table_view, self._edit_row_from_view,
                                                      self._delete_row_from_view)
            self.table_view.setItemDelegate(self.table_delegate)
            header = self.table_view.horizontalHeader()
            header.setStretchLastSection(True)
            header.setSectionResizeMode(QHeaderView.Interactive)
            # 连接列宽调整信号，用于跟踪手动调整和自动调整
            header.sectionResized.connect(self.on_table_view_column_resized)
            header.geometriesChanged.connect(self.on_table_view_geometry_changed)
            self._apply_table_view_column_widths()
        else:
            self.table_model.update_data(self.configs)
        self.use_model_view = True
        self.table_view.setVisible(True)
        self.config_table.setVisible(False)
        if hasattr(self, "page_first_btn"):
            for btn in [self.page_first_btn, self.page_prev_btn, self.page_next_btn, self.page_last_btn,
                        self.page_size_combo]:
                btn.setEnabled(False)
        if hasattr(self, "table_empty_label"):
            self.table_empty_label.setVisible(len(self.configs) == 0)
        if hasattr(self, "page_info_label"):
            total_rows = len(self.configs)
            self.page_info_label.setText(f"大数据模式：{total_rows} 行")
        self._update_checked_count()
        self._show_infobar("warning", "提示", "数据量较大，已切换到Model/View模式（部分功能受限）")

    def _edit_row_from_view(self, index):
        """Model/View 编辑行"""
        if not index.isValid():
            return
        edit_index = index.sibling(index.row(), 0)
        self.table_view.setCurrentIndex(edit_index)
        self.table_view.edit(edit_index)

    def _delete_row_from_view(self, index):
        """Model/View 删除行"""
        if not index.isValid():
            return
        src_index = self.table_proxy.mapToSource(index)
        if src_index.isValid():
            self.table_model.removeRows(src_index.row(), 1)

    def get_config_from_table(self, row_index=0):
        """从表格中获取指定行的配置数据（使用表格中修改后的值）"""
        if row_index >= self.config_table.rowCount():
            return None

        def get_cell_text(row, col):
            """安全获取单元格文本"""
            item = self.config_table.item(row, col)
            return item.text().strip() if item else ''

        def get_cell_int_or_empty(row, col):
            """安全获取单元格整数或空字符串"""
            item = self.config_table.item(row, col)
            if item and item.text().strip():
                try:
                    return int(item.text().strip())
                except ValueError:
                    return ''  # 无效值返回空字符串
            return ''  # 空值返回空字符串

        config = {
            '多多id': get_cell_text(row_index, 1),  # 第1列
            '序号': get_cell_text(row_index, 2),  # 第2列
            '话题': get_cell_text(row_index, 3),  # 第3列
            '定时发布': get_cell_text(row_index, 4),  # 第4列
            '间隔时间': get_cell_int_or_empty(row_index, 5),  # 第5列，空值保持为空
            '达人链接': get_cell_text(row_index, 6),  # 第6列
            '执行人': get_cell_text(row_index, 7),  # 第7列
            '情况': get_cell_text(row_index, 8) or '待执行',  # 第8列
            '文件路径': get_cell_text(row_index, 9)  # 第9列是文件路径
        }

        return config

    @staticmethod
    def get_config():
        """获取当前配置数据（已废弃，配置从Excel导入）"""
        # 配置现在从Excel导入，此方法返回None表示需要先导入Excel
        return None

    def update_data(self):
        """更新数据：找出文件并保存到各行的文件路径列"""
        # 防止连续点击导致重入，避免勾选框错位
        if getattr(self, '_update_data_running', False):
            return
        try:
            self._update_data_running = True
            if hasattr(self, 'update_data_btn'):
                self.update_data_btn.setEnabled(False)

            if not self.configs:
                self._show_infobar("warning", "提示", "请先导入Excel配置文件")
                return

            # 获取文件夹路径
            folder_path = self.folder_path_input.text().strip()
            if not folder_path:
                folder_path = get_default_folder_path()

            if not os.path.exists(folder_path):
                self._show_infobar("warning", "警告", f"文件夹路径不存在: {folder_path}")
                return

            self.log_text.append("=" * 50)
            self.log_text.append("开始批量更新文件路径...")
            self.log_text.append(f"共有 {len(self.configs)} 行配置需要处理")
            self.log_text.append(f"搜索根目录: {folder_path} （结构: 根目录/多多ID/序号(-xxx).mp4 或 序号(-xxx)/）")

            total_found_files = 0
            rows_with_files = 0
            skip_no_id = 0
            no_match_log = []

            # 标记正在更新，防止触发信号
            self.is_updating_table = True
            
            # 遍历所有配置项进行更新
            for config_idx, config in enumerate(self.configs):
                user_id = str(config.get('多多id', '')).strip()
                index = str(config.get('序号', '')).strip()
                
                if not user_id or not index:
                    skip_no_id += 1
                    continue

                found_files = self._find_files_for_config(config, folder_path)

                if found_files:
                    file_paths_str = "; ".join([str(f['path']) for f in found_files])
                    config['文件路径'] = file_paths_str
                    rows_with_files += 1
                    total_found_files += len(found_files)
                else:
                    config['文件路径'] = ""
                    no_match_log.append(f"多多ID={user_id} 序号={index}")

            # 更新 UI 表格显示（跳过 sync：configs 已由更新数据写入，勿用表格回写覆盖）
            if self.use_model_view:
                if self.table_model:
                    self.table_model.layoutChanged.emit()
            else:
                self.update_table(skip_sync=True)

            # 结束更新
            self.is_updating_table = False

            if skip_no_id:
                self.log_text.append(f"跳过 {skip_no_id} 行（多多ID或序号为空）")
            if no_match_log:
                self.log_text.append(f"未匹配到文件 {len(no_match_log)} 行:")
                for s in no_match_log[:20]:
                    self.log_text.append(f"  · {s}")
                if len(no_match_log) > 20:
                    self.log_text.append(f"  ... 还有 {len(no_match_log) - 20} 行")
            total_rows = len(self.configs)
            self.log_text.append("=" * 50)
            self.log_text.append(f"更新完成！数据 {total_rows} 条，文件 {total_found_files} 个，匹配 {rows_with_files} 条")
            
            status_msg = f"数据 {total_rows} 条，文件 {total_found_files} 个，匹配 {rows_with_files} 条"
            self.update_status_label.setText(status_msg)
            self.update_status_label.setStyleSheet("color: #4CAF50; font-size: 10px;")
            self.set_status_cards(update_text=status_msg)
            self._update_status_statistics()
            
            # 更新映射
            self._rebuild_row_map()
            
            # 计算并应用间隔时间规则
            self.log_text.append("=" * 50)
            self.log_text.append("开始计算间隔时间并更新定时发布时间...")
            configs_with_rows = []
            for i, cfg in enumerate(self.configs):
                configs_with_rows.append({"config_index": i, "config": cfg})
            
            updated_count = self._apply_schedule_intervals(configs_with_rows)
            if updated_count > 0:
                self.log_text.append(f"✓ 已自动计算并更新 {updated_count} 行的定时发布时间")
                if not self.use_model_view:
                    self.update_table(skip_sync=True)
                elif self.table_model:
                    self.table_model.layoutChanged.emit()

            self.log_text.append("=" * 50)
            self._show_infobar("success", "成功",
                               f"数据 {total_rows} 条，文件 {total_found_files} 个，匹配 {rows_with_files} 条")
            return

        except Exception as e:
            error_msg = f"更新数据失败: {str(e)}"
            self.log_text.append(error_msg)
            self._show_infobar("error", "错误", error_msg)
            logger.error(f"更新数据失败: {e}")
            import traceback
            traceback.print_exc()
        finally:
            self._update_data_running = False
            if hasattr(self, 'update_data_btn'):
                self.update_data_btn.setEnabled(True)

    @staticmethod
    def _index_matches_name(index, name_or_stem):
        """序号与文件名/文件夹名是否匹配。支持：序号、序号.mp4、序号-xxx、01 与 1 数字等价。"""
        if not name_or_stem or not index:
            return False
        s = str(name_or_stem).strip()
        if s == index:
            return True
        if s.startswith(index + "-"):
            return True
        parts = s.split("-")
        part0 = parts[0].strip() if parts else ""
        if part0 == index:
            return True
        try:
            if int(s) == int(index):
                return True
            if part0 and int(part0) == int(index):
                return True
        except (ValueError, TypeError):
            pass
        return False

    def _find_files_for_config(self, config, folder_path):
        """根据配置查找文件（辅助方法）。目录结构：文件夹路径/多多ID/[(子目录)/] 序号(-xxx).mp4 或 序号(-xxx)/"""
        found_files = []
        
        if not config:
            logger.warning("配置为空，无法查找文件")
            return found_files
        if not folder_path or not os.path.exists(folder_path):
            logger.warning(f"文件夹路径无效或不存在: {folder_path}")
            return found_files
        index = str(config.get('序号', '')).strip()
        if not index:
            logger.warning("序号为空，无法查找文件")
            return found_files
        user_id = str(config.get('多多id', '')).strip()
        if not user_id:
            logger.warning("多多ID为空，无法查找文件")
            return found_files

        video_extensions = ['.mp4', '.avi', '.mov', '.mkv', '.flv', '.wmv', '.webm']

        try:
            if not os.access(folder_path, os.R_OK):
                logger.error(f"没有权限读取文件夹: {folder_path}")
                return found_files
            try:
                sub_dirs = [entry for entry in os.listdir(folder_path)
                           if os.path.isdir(os.path.join(folder_path, entry))]
            except (PermissionError, OSError) as e:
                logger.error(f"读取文件夹失败: {e}")
                return found_files

            target_subdir = None
            for subdir_name in sub_dirs:
                if subdir_name == user_id:
                    target_subdir = os.path.join(folder_path, subdir_name)
                    break
            if not target_subdir or not os.path.exists(target_subdir):
                return found_files

            def append_file(fpath):
                fpath_obj = Path(fpath)
                if not fpath_obj.exists():
                    return
                if fpath_obj.is_file():
                    if any(fpath_obj.suffix.lower() == ext for ext in video_extensions):
                        found_files.append({
                            "url": config.get('达人链接', ''),
                            "user_id": user_id,
                            "time_start": config.get('定时发布', '') if config.get('定时发布') else None,
                            "ht": config.get('话题', ''),
                            "index": index,
                            "path": fpath_obj
                        })
                elif fpath_obj.is_dir():
                    found_files.append({
                        "url": config.get('达人链接', ''),
                        "user_id": user_id,
                        "time_start": config.get('定时发布', '') if config.get('定时发布') else None,
                        "ht": config.get('话题', ''),
                        "index": index,
                        "path": fpath_obj
                    })

            search_dirs = [target_subdir]
            try:
                for sub in os.listdir(target_subdir):
                    p = os.path.join(target_subdir, sub)
                    if os.path.isdir(p):
                        search_dirs.append(p)
            except (PermissionError, OSError):
                pass

            for search_dir in search_dirs:
                try:
                    dir_items = os.listdir(search_dir)
                except (PermissionError, OSError):
                    continue
                for item_name in dir_items:
                    if item_name.startswith('.'):
                        continue
                    item_path = os.path.join(search_dir, item_name)
                    try:
                        path_obj = Path(item_path)
                        if path_obj.is_file():
                            base = path_obj.stem
                        else:
                            base = item_name
                        if not self._index_matches_name(index, base):
                            continue
                        append_file(item_path)
                    except (OSError, ValueError) as e:
                        logger.warning(f"处理 {item_name} 时出错: {e}")
                        continue
        except (OSError, ValueError) as e:
            logger.error(f"查找文件失败: {e}", exc_info=True)
        return found_files

    def execute_task(self):
        """执行任务"""
        try:
            # 检查是否有Excel导入的配置
            if self.configs:
                # 检查用户是否已经勾选了任何项
                has_user_selection = any(cfg.get('勾选', False) for cfg in self.configs)
                
                # 只有当用户没有勾选任何项时，才自动勾选失败项
                if not has_user_selection:
                    failed_indices = []
                    for idx, cfg in enumerate(self.configs):
                        status = cfg.get('情况', '')
                        if "失败" in status or "错误" in status or "过期" in status or "跳过" in status:
                            failed_indices.append(idx)
                    if failed_indices:
                        for idx, cfg in enumerate(self.configs):
                            cfg['勾选'] = idx in failed_indices
                        self.update_table()
                        self._show_infobar("info", "提示", f"检测到 {len(failed_indices)} 条失败记录，已自动仅选择失败项")
                # 如果有Excel配置，批量处理
                self.execute_batch_from_excel()
                return  # 批量处理完成后直接返回
            
            # 没有Excel导入的配置，提示用户先导入
            self._show_infobar("warning", "提示", "请先导入Excel配置文件")
            return
        except Exception as e:
            import traceback
            error_detail = traceback.format_exc()
            logger.error(f"执行任务失败: {e}\n{error_detail}")
            try:
                self._show_infobar("error", "错误", f"执行任务失败: {str(e)}")
                self.log_text.append(f"执行任务失败: {str(e)}")
                self.log_text.append(f"错误详情: {error_detail}")
            except:
                pass
            self._set_task_buttons_state('idle')
            self.progress_bar.setVisible(False)

    def execute_batch_from_excel(self):
        """从 Excel配置批量执行（自动判断相同多多ID的mp4文件，批量上传）"""
        # 执行前强制同步当前页数据，确保手动修改的内容被包含
        if not self.use_model_view:
            self._sync_configs_from_table()
            # 从表格当前页勾选框同步勾选状态到 configs，确保执行的是用户当前勾选的行
            self._sync_checked_from_table()

        # 开始新任务时，从当前数据中统计已有的成功/失败/待执行数量（累计历史数据）
        existing_success = 0
        existing_failed = 0
        existing_pending = 0
        for config in self.configs:
            status = config.get('情况', '待执行')
            if "完成" in status or "成功" in status:
                existing_success += 1
            elif "失败" in status or "错误" in status or "过期" in status or "跳过" in status:
                existing_failed += 1
                existing_pending += 1  # 失败的也算待执行
            elif "待" in status or not status:
                existing_pending += 1
        self.batch_success_count = existing_success
        self.batch_failed_count = existing_failed
        self.set_status_cards(pending=existing_pending, running=0, success=existing_success, failed=existing_failed)
        
        # 获取文件夹路径
        folder_path = self.folder_path_input.text().strip()
        if not folder_path:
            folder_path = get_default_folder_path()
    
        if not os.path.exists(folder_path):
            self._show_infobar("warning", "警告", f"文件夹路径不存在: {folder_path}")
            return
    
        # 筛选勾选的待处理配置（直接从 self.configs 获取最新数据）
        checked_indices = [i for i, cfg in enumerate(self.configs) if cfg.get('勾选', False)]
        if not checked_indices:
            self._show_infobar("warning", "提示", "请先勾选需要上传的数据行")
            return
        
        # 分析勾选项
        all_configs_with_files = []
        configs_to_process = [] # 用于计算间隔时间
        
        for idx in checked_indices:
            config = self.configs[idx]
            
            # 跳过状态为「已完成」的任务（仅上传勾选且未完成的项）
            status = (config.get('情况') or '').strip()
            if '已完成' in status:
                continue
                
            # 验证必填
            if not config.get('多多id') or not config.get('序号'):
                continue
                
            configs_to_process.append({"config_index": idx, "config": config})

        if not configs_to_process:
            self._show_infobar("warning", "提示", "所选项已完成或数据不完整")
            return

        # 重置所有要处理的配置状态为"待执行"（确保第二次运行时清除旧状态）
        for item in configs_to_process:
            idx = item["config_index"]
            self.configs[idx]['情况'] = '待执行'
            self._update_table_status(idx, "待执行", is_config_index=True)

        # 重置任务状态后，重新统计成功/失败/待执行数量以保持一致性
        existing_success = 0
        existing_failed = 0
        existing_pending = 0
        for config in self.configs:
            status = config.get('情况', '待执行')
            if "完成" in status or "成功" in status:
                existing_success += 1
            elif "失败" in status or "错误" in status or "过期" in status or "跳过" in status:
                existing_failed += 1
                existing_pending += 1  # 失败的也算待执行
            elif "待" in status or not status:
                existing_pending += 1
        self.batch_success_count = existing_success
        self.batch_failed_count = existing_failed
        self.set_status_cards(pending=existing_pending, success=existing_success, failed=existing_failed)

        # 注意：不再在此处调用 _apply_schedule_intervals
        # 间隔时间计算已在"更新数据"按钮中完成，用户可能在之后手动修改了时间，应保留用户修改

        self.log_text.append("=" * 50)
        self.log_text.append(f"开始分析配置，准备批量上传...")

        for item in configs_to_process:
            idx = item["config_index"]
            config = item["config"]
            
            # 从已保存的文件路径中获取文件（由"更新数据"按钮写入）
            file_path_str = config.get('文件路径', '').strip()
            found_files = []
            if file_path_str:
                file_paths = [p.strip() for p in file_path_str.split(';') if p.strip()]
                for fp in file_paths:
                    if os.path.exists(fp):
                        found_files.append({
                            "url": config.get('达人链接', ''),
                            "user_id": config.get('多多id', ''),
                            "time_start": config.get('定时发布', '') if config.get('定时发布') else None,
                            "ht": config.get('话题', ''),
                            "index": config.get('序号', ''),
                            "path": Path(fp)
                        })
                    else:
                        self.log_text.append(f"  ⚠ 文件路径不存在，已跳过: {fp}")
            
            if not found_files and not file_path_str:
                self.log_text.append(f"  索引 {idx+1} ({config.get('多多id')}): 未找到文件路径，请先点击'更新数据'按钮")

            if found_files:
                all_configs_with_files.append({
                    'config': config,
                    'files': found_files,
                    'config_index': idx
                })
                self.log_text.append(f"索引 {idx+1} ({config.get('多多id')}): 准备上传 {len(found_files)} 个项目")

        if not all_configs_with_files:
            self._show_infobar("warning", "警告", "未找到任何匹配文件，请先点击‘更新数据’按钮")
            return

        total_tasks = sum(len(item['files']) for item in all_configs_with_files)
        self.set_status_cards(pending=total_tasks)
        self.set_running_progress(0, total_tasks)

        # 按多多ID分组任务
        from collections import defaultdict
        grouped_by_user_id = defaultdict(list)
        for item in all_configs_with_files:
            user_id = item['config'].get('多多id', '')
            grouped_by_user_id[user_id].append(item)

        # 检查线程
        if self.worker_thread and self.worker_thread.isRunning():
            self._show_infobar("warning", "警告", "已有任务正在执行，请等待完成")
            return
        
        # 重置暂停/终止状态
        self._is_paused = False
        self._is_terminated = False
        self._set_task_buttons_state('running')
        self.progress_bar.setVisible(True)
        self.progress_bar.setValue(0)

        # 构建任务队列
        self.batch_task_queue = []
        self.current_batch_task_index = 0
        self.batch_total_tasks = total_tasks
        self.batch_processed = 0
        self.batch_pending_tasks = total_tasks
        
        video_extensions = ['.mp4', '.avi', '.mov', '.mkv', '.flv', '.wmv', '.webm']
        
        # 获取用户是否勾选了"批量上传"复选框
        use_batch_upload = self.batch_upload_checkbox.isChecked()
        self.log_text.append(f"批量上传模式: {'已勾选' if use_batch_upload else '未勾选'}")
        
        # 获取最大批量数（单次上限数）
        batch_limit = 5  # 默认值
        try:
            batch_limit_text = self.batch_limit_input.text().strip()
            if batch_limit_text:
                batch_limit = int(batch_limit_text)
                if batch_limit < 1:
                    batch_limit = 1
        except (ValueError, AttributeError):
            batch_limit = 5
        self.log_text.append(f"单次上限数: {batch_limit}")

        def _skip_expired_and_append(file_info, file_index, group_items, _cfg_indices, into_videos, into_non_videos, file_is_video):
            """若定时过期则更新状态并返回 True（失败(定时过期)），否则加入列表并返回 False"""
            f_time_start = file_info.get('time_start', '')
            if self._is_schedule_time_expired(f_time_start):
                self.log_text.append(f"  跳过序号 {file_index}：定时发布时间已过期 ({f_time_start})")
                expire_idx = next((it['config_index'] for it in group_items if it['config'].get('序号') == file_index), None)
                if expire_idx is not None:
                    self._update_table_status(expire_idx, "失败(定时过期)", is_config_index=True)
                    self.configs[expire_idx]['情况'] = '失败(定时过期)'
                self.batch_failed_count = getattr(self, "batch_failed_count", 0) + 1
                self.set_status_cards(failed=self.batch_failed_count)
                return True
            if file_is_video:
                into_videos.append(file_info)
            else:
                into_non_videos.append(file_info)
            return False

        # 按 config 顺序确定多多ID 的迭代顺序（先出现的多多ID 先处理）
        def _first_config_index(pair):
            return min(it['config_index'] for it in pair[1])
        sorted_groups = sorted(grouped_by_user_id.items(), key=_first_config_index)

        for user_id, items in sorted_groups:
            all_files = []
            related_config_indices = []
            for item in items:
                all_files.extend(item['files'])
                if item['config_index'] not in related_config_indices:
                    related_config_indices.append(item['config_index'])

            def get_sort_key(file_entry):
                try:
                    return int(file_entry.get('index', '0'))
                except (ValueError, TypeError):
                    return 0
            all_files_sorted = sorted(all_files, key=get_sort_key)
            first_config = items[0].get('config', {})

            if not use_batch_upload:
                # 未勾选批量上传：按序号一条一条上传，先完成当前多多ID的 1,2,3,4 再处理下一个多多ID
                i = 0
                while i < len(all_files_sorted):
                    current_file = all_files_sorted[i]
                    is_video = current_file['path'].is_file() and any(
                        current_file['path'].suffix.lower() == ext for ext in video_extensions)
                    f_index = current_file.get('index', '')
                    if _skip_expired_and_append(current_file, f_index, items, related_config_indices, [], [], is_video):
                        i += 1
                        continue
                    matching_idx = next(
                        (it['config_index'] for it in items if it['config'].get('序号') == f_index),
                        related_config_indices[0] if related_config_indices else 0)
                    matching_config = next(
                        (it['config'] for it in items if it['config'].get('序号') == f_index),
                        first_config)
                    if is_video:
                        self.batch_task_queue.append({
                            'type': 'single_video',
                            'config': matching_config,
                            'files': [current_file],
                            'user_id': user_id,
                            'count': 1,
                            'config_indices': [matching_idx]
                        })
                    else:
                        self.batch_task_queue.append({
                            'type': 'image_folder',
                            'config': matching_config,
                            'files': [current_file],
                            'user_id': user_id,
                            'count': 1,
                            'config_indices': [matching_idx]
                        })
                    i += 1
            else:
                # 勾选批量上传：严格按序号顺序处理。遇到图文立即上传；第一次遇到视频时，收集该多多ID下全部视频按上限分批上传，再继续后续序号（图文照常上传）
                ordered_list = []  # (f, is_video) 按序号顺序，已排除定时过期
                for f in all_files_sorted:
                    is_video = f['path'].is_file() and any(
                        f['path'].suffix.lower() == ext for ext in video_extensions)
                    f_index = f.get('index', '')
                    if _skip_expired_and_append(f, f_index, items, related_config_indices, [], [], is_video):
                        continue
                    ordered_list.append((f, is_video))

                videos_in_order = [entry for (entry, iv) in ordered_list if iv]
                videos_emitted = False
                for (f, is_video) in ordered_list:
                    f_index = f.get('index', '')
                    if not is_video:
                        matching_idx = next(
                            (it['config_index'] for it in items if it['config'].get('序号') == f_index),
                            related_config_indices[0])
                        matching_config = next(
                            (it['config'] for it in items if it['config'].get('序号') == f_index),
                            first_config)
                        self.batch_task_queue.append({
                            'type': 'image_folder',
                            'config': matching_config,
                            'files': [f],
                            'user_id': user_id,
                            'count': 1,
                            'config_indices': [matching_idx]
                        })
                    else:
                        if not videos_emitted:
                            for start in range(0, len(videos_in_order), batch_limit):
                                chunk = videos_in_order[start:start + batch_limit]
                                batch_config_indices = []
                                for fc in chunk:
                                    fi = fc.get('index', '')
                                    match_idx = next((it['config_index'] for it in items if it['config'].get('序号') == fi), None)
                                    if match_idx is not None and match_idx not in batch_config_indices:
                                        batch_config_indices.append(match_idx)
                                if len(chunk) > 1:
                                    self.batch_task_queue.append({
                                        'type': 'batch_video',
                                        'config': first_config,
                                        'files': chunk,
                                        'user_id': user_id,
                                        'count': len(chunk),
                                        'config_indices': batch_config_indices
                                    })
                                else:
                                    vid_index = chunk[0].get('index', '')
                                    matching_config = next(
                                        (it['config'] for it in items if it['config'].get('序号') == vid_index),
                                        first_config)
                                    self.batch_task_queue.append({
                                        'type': 'single_video',
                                        'config': matching_config,
                                        'files': chunk,
                                        'user_id': user_id,
                                        'count': 1,
                                        'config_indices': batch_config_indices
                                    })
                            videos_emitted = True
                        # 已在该序号前统一发过视频批次，此处跳过

        if self.batch_task_queue:
            self._process_next_batch_task()
        else:
            self._show_infobar("warning", "警告", "任务分析失败，未构建有效队列")
            self._set_task_buttons_state('idle')
            self.progress_bar.setVisible(False)

    def _cleanup_worker_thread(self):
        """安全清理工作线程"""
        if not self.worker_thread:
            return
        
        try:
            # 如果线程正在运行，请求停止
            if self.worker_thread.isRunning():
                # 请求停止（优雅方式）
                self.worker_thread.stop()
                self.worker_thread.requestInterruption()
                # 等待线程结束，设置合理超时
                if not self.worker_thread.wait(2000):
                    logger.warning("工作线程未能在2秒内停止")
                    # 不使用 terminate()，继续处理
            
            # 安全断开所有信号连接
            try:
                self.worker_thread.finished.disconnect()
            except (TypeError, RuntimeError):
                pass  # 信号未连接或已断开
            try:
                self.worker_thread.log_message.disconnect()
            except (TypeError, RuntimeError):
                pass
            try:
                self.worker_thread.progress.disconnect()
            except (TypeError, RuntimeError):
                pass
            try:
                self.worker_thread.item_result.disconnect()
            except (TypeError, RuntimeError):
                pass
        except Exception as e:
            logger.warning(f"清理工作线程时出错: {e}")
        finally:
            self.worker_thread = None

    def _set_task_buttons_state(self, state):
        """设置任务控制按钮的显示状态
        
        state: 'idle' | 'running' | 'paused'
        """
        if state == 'idle':
            self.execute_btn.setEnabled(True)
            self.pause_btn.setVisible(False)
            self.resume_btn.setVisible(False)
            self.terminate_btn.setVisible(False)
        elif state == 'running':
            self.execute_btn.setEnabled(False)
            self.pause_btn.setVisible(True)
            self.resume_btn.setVisible(False)
            self.terminate_btn.setVisible(True)
        elif state == 'paused':
            self.execute_btn.setEnabled(False)
            self.pause_btn.setVisible(False)
            self.resume_btn.setVisible(True)
            self.terminate_btn.setVisible(True)

    def pause_task(self):
        """暂停任务：当前正在执行的任务会完成，但不再启动下一个"""
        self._is_paused = True
        self._set_task_buttons_state('paused')
        self.log_text.append("=" * 50)
        self.log_text.append("⏸ 任务已暂停，当前正在执行的任务完成后将停止。点击「继续」恢复执行。")
        self._show_infobar("warning", "已暂停", "当前任务完成后将暂停，点击「继续」恢复")

    def resume_task(self):
        """继续执行暂停的任务"""
        self._is_paused = False
        self._set_task_buttons_state('running')
        self.log_text.append("=" * 50)
        self.log_text.append("▶ 任务已恢复，继续执行剩余任务...")
        self._show_infobar("success", "已恢复", "继续执行剩余任务")
        # 继续处理下一个任务
        self._process_next_batch_task()

    def terminate_task(self):
        """终止所有任务"""
        reply = QMessageBox.question(
            self, "确认终止", "确定要终止所有任务吗？当前正在执行的任务将被中断。",
            QMessageBox.Yes | QMessageBox.No
        )
        if reply != QMessageBox.Yes:
            return

        self._is_terminated = True
        self._is_paused = False

        self.log_text.append("=" * 50)
        self.log_text.append("⏹ 正在终止任务...")

        # 停止当前工作线程
        self._cleanup_worker_thread()

        # 将队列中所有未执行的任务标记为"已终止"
        remaining = 0
        for i in range(self.current_batch_task_index, len(self.batch_task_queue)):
            task = self.batch_task_queue[i]
            config_indices = task.get('config_indices', [])
            for cfg_idx in config_indices:
                try:
                    if self.configs[cfg_idx].get('情况', '') in ('待执行', '执行中'):
                        self.configs[cfg_idx]['情况'] = '已终止'
                        self._update_table_status(cfg_idx, "已终止", is_config_index=True)
                        remaining += 1
                except (IndexError, KeyError):
                    pass

        # 清空任务队列
        self.batch_task_queue = []
        self.current_batch_task_index = 0

        # 重置 UI 状态
        self._set_task_buttons_state('idle')
        self.progress_bar.setVisible(False)
        self._is_terminated = False

        self.log_text.append(f"⏹ 任务已终止。{remaining} 个待执行任务被取消。")
        self.log_text.append(f"   已完成: {self.batch_success_count} 成功, {self.batch_failed_count} 失败")
        self._update_status_statistics()
        self._show_infobar("warning", "已终止", f"任务已终止，{remaining} 个任务被取消")

    def _process_next_batch_task(self):
        """处理任务队列中的下一个任务（异步，不阻塞GUI）"""
        # 检查是否还有任务
        if self.current_batch_task_index >= len(self.batch_task_queue):
            # 所有任务完成
            self.progress_bar.setValue(100)
            self.log_text.append("=" * 50)
            self.log_text.append(f"所有任务执行完成！共处理 {self.batch_processed} 个文件/文件夹")
            self._set_task_buttons_state('idle')
            self.progress_bar.setVisible(False)
            self.set_running_progress(0, 0)
            # 更新状态统计（成功/失败/待执行数量）
            self._update_status_statistics()
            self._show_infobar("success", "任务完成", f"共处理 {self.batch_processed} 个文件/文件夹")
            # 重置任务队列
            self.batch_task_queue = []
            self.current_batch_task_index = 0
            return

        # 获取当前任务
        task = self.batch_task_queue[self.current_batch_task_index]
        task_type = task['type']
        config = task['config']
        files = task['files']
        _ = task['user_id']  # 仅提取以验证存在性

        # 根据任务类型处理
        try:
            # 清理旧线程（如果存在）
            self._cleanup_worker_thread()

            # 验证 files 参数
            if not files or not isinstance(files, list):
                raise ValueError(f"无效的 files 参数: {files}")

            # 确定是否为批量模式
            is_batch = (task_type == 'batch_video' and len(files) > 1)

            # 创建并启动工作线程
            self.worker_thread = WorkerThread(config, is_batch, files, self)
            # 连接信号
            self.worker_thread.finished.connect(self._on_batch_task_finished)
            self.worker_thread.log_message.connect(self.log_text.append)
            self.worker_thread.progress.connect(self.progress_bar.setValue)
            self.worker_thread.item_result.connect(self._on_worker_item_result)
            
            # 记录任务信息
            if task_type == 'batch_video':
                self.log_text.append(f"\n开始批量上传 {len(files)} 个视频文件...")
            elif task_type == 'single_video':
                self.log_text.append(f"\n开始上传单个视频文件...")
            elif task_type == 'image_folder':
                idx = task.get('index', 0)
                total = task.get('total', 0)
                folder_index = task.get('folder_index', '')
                self.log_text.append(f"\n开始上传第 {idx}/{total} 个图片文件夹（序号: {folder_index}）...")

            # 更新表格状态为"执行中"
            try:
                config_indices = task.get('config_indices', [])
                if config_indices:
                    for cfg_idx in config_indices:
                        try:
                            self._update_table_status(cfg_idx, "执行中", is_config_index=True)
                        except Exception as e:
                            logger.warning(f"更新状态失败（索引{cfg_idx}）: {e}")
            except Exception as e:
                logger.warning(f"更新执行中状态失败: {e}")

            # 启动线程（不阻塞）
            try:
                self.worker_thread.start()
            except Exception as e:
                error_msg = f"启动线程失败: {str(e)}"
                logger.error(error_msg)
                self.log_text.append(f"  ✗ {error_msg}")
                raise
            
        except Exception as e:
            error_msg = f"启动任务失败: {str(e)}"
            self.log_text.append(f"  ✗ {error_msg}")
            logger.error(error_msg, exc_info=True)
            # 即使失败也继续下一个任务，立即更新表格为失败并增加失败条数
            count = task.get('count', 1)
            config_indices = task.get('config_indices', [])
            for cfg_idx in config_indices:
                try:
                    self._update_table_status(cfg_idx, "失败", is_config_index=True)
                except Exception:
                    pass
            self.batch_failed_count += len(config_indices) if config_indices else 1
            self.batch_processed += count
            self.batch_pending_tasks = max(self.batch_pending_tasks - count, 0)
            self.set_status_cards(
                pending=self.batch_pending_tasks,
                success=getattr(self, 'batch_success_count', 0),
                failed=getattr(self, 'batch_failed_count', 0)
            )
            self.set_running_progress(self.batch_processed, self.batch_total_tasks)
            self.current_batch_task_index += 1
            if not self._is_terminated and not self._is_paused:
                QApplication.processEvents()
                self._process_next_batch_task()

    def _on_batch_task_finished(self, success, message):
        """批量任务完成回调（不阻塞GUI）"""
        try:
            # 获取当前任务（注意：此时任务已完成，但索引还未更新）
            if self.current_batch_task_index < len(self.batch_task_queue):
                task = self.batch_task_queue[self.current_batch_task_index]
                task_type = task['type']
                count = task.get('count', 1)
                config_indices = task.get('config_indices', [])

                # 更新进度日志
                if success:
                    if task_type == 'batch_video':
                        self.log_text.append(f"  ✓ 批量上传 {count} 个视频完成")
                    elif task_type == 'single_video':
                        self.log_text.append(f"  ✓ 单个视频上传完成")
                    elif task_type == 'image_folder':
                        self.log_text.append(f"    ✓ 图片文件夹上传完成")
                else:
                    reason_text = f"失败原因: {message}" if message else "失败原因: 未知"
                    self.log_text.append(f"  ✗ 任务失败: {reason_text}")

                # 对于 batch_video 类型，状态和计数已经在 _on_worker_item_result 中实时更新了
                # 所以这里不再重复更新，只需要处理 single_video 和 image_folder 类型
                if task_type != 'batch_video':
                    if success:
                        # 更新表格为"已完成"，并增加成功条数
                        for cfg_idx in config_indices:
                            self._update_table_status(cfg_idx, "已完成", is_config_index=True)
                        self.batch_success_count += len(config_indices)
                    else:
                        # 更新表格为"失败"，并增加失败条数
                        for cfg_idx in config_indices:
                            self._update_table_status(cfg_idx, "失败", is_config_index=True)
                        self.batch_failed_count += len(config_indices)
                    
                    # 更新统计（single_video 和 image_folder 需要在这里更新）
                    self.batch_processed += count
                    self.batch_pending_tasks = max(self.batch_pending_tasks - count, 0)
                    self.set_status_cards(
                        pending=self.batch_pending_tasks,
                        success=self.batch_success_count,
                        failed=self.batch_failed_count
                    )
                    self.set_running_progress(self.batch_processed, self.batch_total_tasks)

                # 移动到下一个任务
                self.current_batch_task_index += 1

                # 获取发布间隔时间（毫秒）
                interval_ms = self._get_publish_interval_ms()
                if interval_ms > 0 and self.current_batch_task_index < len(self.batch_task_queue):
                    self.log_text.append(f"  等待 {interval_ms // 1000} 秒后执行下一个任务...")
                
                # 检查是否被终止
                if self._is_terminated:
                    return

                # 检查是否被暂停
                if self._is_paused:
                    self.log_text.append("⏸ 当前任务已完成，等待用户点击「继续」...")
                    self._set_task_buttons_state('paused')
                    return

                # 处理下一个任务（使用QTimer延迟，包含发布间隔时间）
                delay_ms = max(100, interval_ms)  # 至少100ms确保GUI更新
                QTimer.singleShot(delay_ms, self._process_next_batch_task)
        except Exception as e:
            logger.error(f"批量任务完成回调失败: {e}")
            import traceback
            traceback.print_exc()
            # 即使出错也继续处理下一个任务（除非已暂停或终止）
            if not self._is_terminated and not self._is_paused and self.current_batch_task_index < len(self.batch_task_queue):
                self.current_batch_task_index += 1
                QTimer.singleShot(100, self._process_next_batch_task)

    def _get_publish_interval_ms(self):
        """获取发布间隔时间（毫秒）"""
        try:
            if not hasattr(self, 'publish_interval_input'):
                return 0
            value_str = self.publish_interval_input.text().strip().lower()
            if not value_str or value_str == '0':
                return 0
            
            # 解析时间格式：数字(秒)、30s(秒)、2m(分钟)
            if value_str.endswith('m') or value_str.endswith('分钟'):
                # 分钟
                num_str = value_str.replace('m', '').replace('分钟', '').strip()
                return int(float(num_str) * 60 * 1000)
            elif value_str.endswith('s') or value_str.endswith('秒'):
                # 秒
                num_str = value_str.replace('s', '').replace('秒', '').strip()
                return int(float(num_str) * 1000)
            else:
                # 默认为秒
                return int(float(value_str) * 1000)
        except (ValueError, TypeError):
            return 0

    def _rebuild_row_map(self):
        """重建 多多ID+序号 -> 表格行号 映射（仅针对当前页可见行）"""
        m = {}
        try:
            if not hasattr(self, "config_table") or self.use_model_view:
                self._row_map_by_user_index = {}
                return
            for r in range(self.config_table.rowCount()):
                # 多多ID在第1列，序号在第2列（第0列是勾选框）
                user_id = self.get_cell_text(r, 1)
                idx = self.get_cell_text(r, 2)
                if user_id and idx:
                    m[(user_id, idx)] = r
        except Exception:
            pass
        self._row_map_by_user_index = m

    def _on_worker_item_result(self, payload):
        """接收自动化侧逐条结果 - 仅用于 batch_video 类型任务的实时状态更新"""
        try:
            if not isinstance(payload, dict):
                return
            user_id = str(payload.get("user_id", "")).strip()
            idx = str(payload.get("index", "")).strip()
            ok = bool(payload.get("ok"))
            reason = str(payload.get("reason", "")).strip()
            name = str(payload.get("name", "")).strip()

            if not user_id:
                return

            # 检查当前任务类型，只有 batch_video 类型才在这里更新计数
            # single_video 和 image_folder 类型在 _on_batch_task_finished 中更新
            is_batch_video_task = False
            if hasattr(self, 'current_batch_task_index') and self.current_batch_task_index < len(self.batch_task_queue):
                current_task = self.batch_task_queue[self.current_batch_task_index]
                is_batch_video_task = current_task.get('type') == 'batch_video'

            # 全局搜索匹配的多多ID和序号
            found_config_idx = -1
            updated_count = 0  # 记录更新了多少条配置
            
            if idx:  # 如果有序号，优先通过多多ID和序号匹配
                for i, cfg in enumerate(self.configs):
                    if str(cfg.get("多多id")) == user_id and str(cfg.get("序号")) == idx:
                        found_config_idx = i
                        break
            
            # 如果通过序号没找到，尝试通过多多ID匹配
            if found_config_idx == -1:
                # 查找所有匹配多多ID的配置
                matching_indices = []
                for i, cfg in enumerate(self.configs):
                    if str(cfg.get("多多id")) == user_id:
                        matching_indices.append(i)
                
                # 如果只找到一个匹配的配置，直接使用它
                if len(matching_indices) == 1:
                    found_config_idx = matching_indices[0]
                # 如果有多个匹配的配置，且是批量视频任务，更新相关配置的状态
                elif len(matching_indices) > 1 and is_batch_video_task:
                    current_task = self.batch_task_queue[self.current_batch_task_index]
                    task_config_indices = current_task.get('config_indices', [])
                    # 只更新当前任务相关的配置状态
                    for cfg_idx in task_config_indices:
                        if cfg_idx in matching_indices:
                            self._update_table_status(cfg_idx, "已完成" if ok else "失败", is_config_index=True)
                            updated_count += 1
                    found_config_idx = -2  # 标记为已处理（多个配置）
            
            if found_config_idx >= 0:
                # 单个配置匹配成功，更新表格状态
                self._update_table_status(found_config_idx, "已完成" if ok else "失败", is_config_index=True)
                updated_count = 1
                label = name if name else payload.get("path", "") or ""
                reason_text = f"失败原因: {reason}" if (not ok and reason) else reason
                self.log_text.append(f"[结果] {user_id}-{idx}: {'✓' if ok else '✗'} {label} {reason_text}")
            elif found_config_idx == -2:
                # 多个配置已处理，只记录日志
                label = name if name else payload.get("path", "") or ""
                reason_text = f"失败原因: {reason}" if (not ok and reason) else reason
                self.log_text.append(f"[结果] {user_id}-{idx}: {'✓' if ok else '✗'} {label} {reason_text}")
            else:
                reason_text = f"失败原因: {reason}" if (not ok and reason) else reason
                self.log_text.append(f"[结果] {user_id}-{idx}: ok={ok} {reason_text} (未在列表中找到匹配项)")
            
            # 只有 batch_video 类型任务才在这里更新计数（实时反馈）
            # single_video 和 image_folder 在 _on_batch_task_finished 中更新，避免重复计数
            if is_batch_video_task and updated_count > 0:
                if ok:
                    self.batch_success_count += updated_count
                else:
                    self.batch_failed_count += updated_count
                
                # 更新待处理数量
                self.batch_pending_tasks = max(self.batch_pending_tasks - updated_count, 0)
                
                # 立即刷新状态卡片显示
                self.set_status_cards(
                    pending=self.batch_pending_tasks,
                    success=self.batch_success_count,
                    failed=self.batch_failed_count
                )
                
                # 更新进度
                self.batch_processed += updated_count
                self.set_running_progress(self.batch_processed, self.batch_total_tasks)
                
        except Exception as e:
            logger.warning(f"处理单条结果失败: {e}")

    @staticmethod
    def count_videos_in_folder(folder_path, index):
        """统计文件夹中匹配序号的视频文件数量（与main.py逻辑一致）"""
        count = 0
        try:
            # 遍历最外层文件夹下的所有子文件夹（与main.py逻辑一致）
            for file in os.listdir(folder_path):  # 获取文件夹下所有的文件夹
                file_path = os.path.join(folder_path, file)  # 拼接文件夹
                # 检查是否为目录，跳过文件（如.lnk快捷方式）
                if not os.path.isdir(file_path):
                    continue

                files = os.listdir(file_path)  # 获取用户id下的文件
                for file_name in files:
                    # 检查是否是视频文件（.mp4）
                    if ".mp4" in file_name:
                        # 用"-"分割文件名，检查第一部分是否等于序号
                        # 文件名格式：4-茶叶蛋大冒险-.mp4 -> ['4', '茶叶蛋大冒险', '', 'mp4']
                        file_names = file_name.split("-")
                        if len(file_names) > 0 and file_names[0] == str(index):
                            path = Path(os.path.join(file_path, file_name))
                            # 判断是否为文件
                            if path.is_file():
                                count += 1
                            else:
                                # 如果是文件夹，统计其中的文件
                                for sub_file in os.listdir(path):
                                    sub_path = Path(os.path.join(path, sub_file))
                                    if sub_path.is_file():
                                        count += 1
        except (OSError, PermissionError) as e:
            logger.error(f"统计视频文件失败: {e}")

        return count

    def on_task_finished(self, success, message):
        """任务完成回调（单个任务）"""
        self.progress_bar.setValue(100)
        self.set_running_progress(0, 0)

        if success:
            self._show_infobar("success", "成功", message)
            # 更新表格状态为"已完成"
            # 查找对应的行（通过配置信息）
            self._update_single_task_status(success)
        else:
            self._show_infobar("error", "失败", message)
            # 更新表格状态为"失败"
            self._update_single_task_status(success)

        # 更新状态统计（成功/失败/待执行数量）
        self._update_status_statistics()

        # 恢复按钮
        self._set_task_buttons_state('idle')

        self.log_text.append(f"任务完成: {message}")
        self.log_text.append("=" * 50)
    
    def _update_single_task_status_start(self, config):
        """更新单个任务的状态为"执行中"（根据配置查找对应的表格行）"""
        try:
            # 检查是否有表格
            if not hasattr(self, 'config_table') or self.config_table.rowCount() == 0:
                return
            
            user_id = config.get('多多id', '')
            index = config.get('序号', '')
            
            if not user_id or not index:
                return
            
            # 在表格中查找匹配的行
            for row_idx in range(self.config_table.rowCount()):
                try:
                    row_user_id = self.get_cell_text(row_idx, 0)
                    row_index = self.get_cell_text(row_idx, 1)
                    
                    if row_user_id == user_id and row_index == index:
                        self._update_table_status(row_idx, "执行中")
                        break
                except Exception as e:
                    logger.warning(f"更新状态时出错（行{row_idx}）: {e}")
                    continue
        except Exception as e:
            logger.error(f"更新任务状态失败: {e}")
            import traceback
            traceback.print_exc()
    
    def _update_single_task_status(self, success):
        """更新单个任务的状态（根据当前配置查找对应的表格行）"""
        try:
            # 检查是否有表格
            if not hasattr(self, 'config_table') or self.config_table.rowCount() == 0:
                return
            
            # 获取当前配置（从worker_thread中获取）
            if not self.worker_thread:
                return
            
            config = self.worker_thread.config_data
            user_id = config.get('多多id', '')
            index = config.get('序号', '')
            
            if not user_id or not index:
                return
            
            # 在表格中查找匹配的行
            for row_idx in range(self.config_table.rowCount()):
                try:
                    row_user_id = self.get_cell_text(row_idx, 0)
                    row_index = self.get_cell_text(row_idx, 1)
                    
                    if row_user_id == user_id and row_index == index:
                        status = "已完成" if success else "失败"
                        self._update_table_status(row_idx, status)
                        break
                except Exception as e:
                    logger.warning(f"更新状态时出错（行{row_idx}）: {e}")
                    continue
        except Exception as e:
            logger.error(f"更新任务状态失败: {e}")
            import traceback
            traceback.print_exc()
    
    def get_cell_text(self, row, col):
        """获取表格单元格文本"""
        try:
            if not hasattr(self, 'config_table'):
                return ""
            if row < 0 or row >= self.config_table.rowCount():
                return ""
            item = self.config_table.item(row, col)
            return item.text().strip() if item else ""
        except Exception as e:
            logger.warning(f"获取单元格文本失败（行{row}，列{col}）: {e}")
            return ""

    def closeEvent(self, event):
        """关闭事件"""
        if self._is_closing:
            event.accept()
            return

        if self.worker_thread and self.worker_thread.isRunning():
            reply = QMessageBox.question(
                self, "确认", "任务正在执行中，确定要退出吗？",
                QMessageBox.Yes | QMessageBox.No
            )
            if reply == QMessageBox.Yes:
                self._is_closing = True
                # 使用统一的线程清理方法
                self._cleanup_worker_thread()
                event.accept()
            else:
                event.ignore()
        else:
            event.accept()


def exception_handler(exc_type, exc_value, exc_traceback):
    """全局异常处理器"""
    if issubclass(exc_type, KeyboardInterrupt):
        sys.__excepthook__(exc_type, exc_value, exc_traceback)
        return
    
    # 防止递归：如果异常处理器本身出错，使用默认处理器
    if exc_type is RecursionError:
        # 对于递归错误，直接打印到控制台，避免再次触发递归
        print(f"递归错误: {exc_value}")
        print("这通常是由于无限递归调用导致的")
        return
    
    try:
        import traceback
        # 限制堆栈深度，避免递归错误
        error_msg = "".join(traceback.format_exception(exc_type, exc_value, exc_traceback, limit=50))
        logger.critical(f"未捕获的异常:\n{error_msg}")
        
        # 尝试显示错误对话框
        try:
            from PyQt5.QtWidgets import QMessageBox
            msg = QMessageBox()
            msg.setIcon(QMessageBox.Critical)
            msg.setWindowTitle("程序错误")
            msg.setText("程序发生未处理的错误")
            # 限制详细文本长度
            detailed_text = error_msg[:2000] if len(error_msg) > 2000 else error_msg
            msg.setDetailedText(detailed_text)
            msg.exec_()
        except:
            # 如果无法显示对话框，至少打印到控制台
            print(f"未捕获的异常:\n{error_msg[:1000]}")  # 限制输出长度
    except Exception:
        # 如果异常处理器本身出错，使用默认处理器
        sys.__excepthook__(exc_type, exc_value, exc_traceback)

def main():
    # 设置全局异常处理器
    sys.excepthook = exception_handler
    
    app = QApplication(sys.argv)
              
    # noinspection SpellCheckingInspection
    # 解决 macOS 上缺失 Segoe UI 字体导致的警告
    if sys.platform == "darwin":
        font = QFont(".AppleSystemUIFont", 10)
        font.setFamilies([".AppleSystemUIFont", "PingFang SC", "Helvetica Neue", "Arial"])
        app.setFont(font)
    
    setTheme(Theme.LIGHT)
    
    try:
        window = MainWindow()
        window.show()
        sys.exit(app.exec_())
    except Exception as e:
        import traceback
        error_detail = traceback.format_exc()
        logger.critical(f"程序启动失败: {e}\n{error_detail}")
        print(f"程序启动失败: {e}\n{error_detail}")
        sys.exit(1)


if __name__ == '__main__':
    main()