cmshoppe/app/gui/tabs/generate.py

"""Tab 2: AI generation UI."""

from __future__ import annotations

from ..models import GenerateTaskTableModel
from ..widgets import *
from ..workers import GenerateWorker as _RealGenerateWorker


def GenerateWorker(*args, **kwargs):
    return _call_package_attr("GenerateWorker", _RealGenerateWorker, *args, **kwargs)


class _CoverThumbnailLabel(QLabel):
    def __init__(self, image_path, open_callback, parent=None):
        super().__init__(parent)
        self.image_path = image_path
        self.open_callback = open_callback
        self.setCursor(Qt.PointingHandCursor)

    def mouseDoubleClickEvent(self, event):
        if self.open_callback is not None:
            self.open_callback(self.image_path)
            event.accept()
            return
        super().mouseDoubleClickEvent(event)


class OriginalImageDialog(QDialog):
    def __init__(self, image_path, parent=None):
        super().__init__(parent)
        self.image_path = image_path
        self.setWindowTitle(os.path.basename(str(image_path or "")) or "原图")
        layout = QVBoxLayout(self)
        image = QImage(str(image_path))
        scroll = QScrollArea()
        scroll.setWidgetResizable(False)
        image_label = QLabel()
        image_label.setAlignment(Qt.AlignCenter)
        if image.isNull():
            image_label.setText("图片读取失败")
        else:
            self.setWindowTitle(
                f"{os.path.basename(str(image_path))} · {image.width()}x{image.height()}"
            )
            pixmap = QPixmap.fromImage(image)
            image_label.setPixmap(pixmap)
            image_label.resize(pixmap.size())
        scroll.setWidget(image_label)
        layout.addWidget(scroll, 1)
        button_layout = QHBoxLayout()
        button_layout.addStretch(1)
        close_button = QPushButton("关闭")
        close_button.clicked.connect(self.reject)
        button_layout.addWidget(close_button)
        layout.addLayout(button_layout)
        self._fit_to_screen(image)

    def _fit_to_screen(self, image):
        available = _available_geometry()
        if available is None:
            self.resize(720, 520)
            return
        max_width = max(360, int(available.width() * 0.9))
        max_height = max(300, int(available.height() * 0.9))
        image_width = image.width() if not image.isNull() else 640
        image_height = image.height() if not image.isNull() else 480
        self.resize(min(max_width, image_width + 48), min(max_height, image_height + 92))
        _center_dialog(self, available)


class CoverGalleryDialog(QDialog):
    THUMBNAIL_SIZE = 180
    OLD_THUMBNAIL_SIZE = 300

    def __init__(
        self,
        task,
        image_root,
        db_path,
        account=None,
        parent=None,
        config=None,
        prompt_values=None,
        diagnostic_log_dir=None,
        bulk_running_checker=None,
        regenerate_running_callback=None,
        gallery_updated_callback=None,
    ):
        super().__init__(parent)
        self.task = task
        self.image_root = image_root
        self.db_path = db_path
        self.account = account
        self.config = config or {}
        self.prompt_values = dict(prompt_values or {})
        self.diagnostic_log_dir = diagnostic_log_dir
        self.bulk_running_checker = bulk_running_checker
        self.regenerate_running_callback = regenerate_running_callback
        self.gallery_updated_callback = gallery_updated_callback
        self.current_path = _normalize_file_path(getattr(task, "new_cover_path", None))
        self.selected_path = None
        self.changed = False
        self.candidate_buttons = {}
        self.button_group = QButtonGroup(self)
        self.button_group.setExclusive(True)
        self.regenerate_worker = None
        self.regenerate_thread = None
        self._regenerate_last_error = ""
        self.candidates = image_paths.list_task_cover_candidates(image_root, task, account=account)

        self.setWindowTitle(f"封面画廊：{getattr(task, 'item_id', '')}")
        layout = QVBoxLayout(self)
        body_layout = QHBoxLayout()
        body_layout.addWidget(self._old_cover_panel(), 0)
        body_layout.addWidget(self._candidate_panel(), 1)
        layout.addLayout(body_layout, 1)

        button_layout = QHBoxLayout()
        self.regenerate_button = QPushButton("重新生成")
        self.regenerate_button.clicked.connect(self.regenerate_cover)
        button_layout.addWidget(self.regenerate_button)
        button_layout.addStretch(1)
        self.save_button = QPushButton("保存")
        self.cancel_button = QPushButton("取消")
        self.save_button.clicked.connect(self.save_selection)
        self.cancel_button.clicked.connect(self.reject)
        button_layout.addWidget(self.save_button)
        button_layout.addWidget(self.cancel_button)
        layout.addLayout(button_layout)

        self._sync_initial_selection()
        self._update_status()
        self._update_regenerate_button_state()
        self._fit_to_screen()

    def _old_cover_panel(self):
        panel = QWidget()
        layout = QVBoxLayout(panel)
        layout.addWidget(QLabel("旧封面"))
        old_path = getattr(self.task, "old_cover_path", None)
        layout.addWidget(
            _build_image_label(
                old_path,
                self.OLD_THUMBNAIL_SIZE,
                empty_text="暂无旧封面",
            )
        )
        layout.addStretch(1)
        return panel

    def _candidate_panel(self):
        panel = QWidget()
        layout = QVBoxLayout(panel)
        layout.addWidget(QLabel("生成封面候选"))
        self.status_label = QLabel()
        self.status_label.setObjectName("coverGalleryStatusLabel")
        self.status_label.setWordWrap(True)
        layout.addWidget(self.status_label)

        scroll = QScrollArea()
        scroll.setObjectName("coverGalleryScrollArea")
        scroll.setWidgetResizable(False)
        scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
        scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        content = QWidget()
        self.candidate_layout = QHBoxLayout(content)
        self.candidate_layout.setContentsMargins(0, 0, 0, 0)
        self.candidate_layout.setSpacing(12)
        if self.candidates:
            for index, candidate_path in enumerate(self.candidates):
                self.candidate_layout.addWidget(self._candidate_item(candidate_path, index))
            self.candidate_layout.addStretch(1)
        else:
            empty_label = QLabel("暂无生成封面图片")
            empty_label.setObjectName("coverGalleryEmptyLabel")
            empty_label.setMinimumSize(320, self.THUMBNAIL_SIZE)
            empty_label.setAlignment(Qt.AlignCenter)
            self.candidate_layout.addWidget(empty_label)
        scroll.setWidget(content)
        layout.addWidget(scroll, 1)
        return panel

    def _candidate_item(self, candidate_path, index):
        item = QWidget()
        item.setFixedWidth(self.THUMBNAIL_SIZE + 16)
        layout = QVBoxLayout(item)
        layout.setContentsMargins(0, 0, 0, 0)
        thumbnail = _CoverThumbnailLabel(candidate_path, self.open_original_image)
        thumbnail.setObjectName("coverCandidateThumbnail")
        thumbnail.setAlignment(Qt.AlignCenter)
        image = _load_image(candidate_path)
        if image.isNull():
            thumbnail.setText("图片读取失败")
            thumbnail.setMinimumSize(self.THUMBNAIL_SIZE, self.THUMBNAIL_SIZE)
        else:
            thumbnail.setPixmap(
                QPixmap.fromImage(
                    image.scaled(
                        self.THUMBNAIL_SIZE,
                        self.THUMBNAIL_SIZE,
                        Qt.KeepAspectRatio,
                        Qt.SmoothTransformation,
                    )
                )
            )
            thumbnail.setMinimumSize(self.THUMBNAIL_SIZE, self.THUMBNAIL_SIZE)
        radio = QRadioButton(_candidate_label(candidate_path, self.current_path))
        radio.setObjectName(f"coverCandidateRadio{index}")
        radio.toggled.connect(
            lambda checked, path=candidate_path: self._select_candidate(path) if checked else None
        )
        self.button_group.addButton(radio, index)
        self.candidate_buttons[candidate_path] = radio
        meta = QLabel(_candidate_meta(candidate_path, self.current_path))
        meta.setWordWrap(True)
        meta.setObjectName("coverCandidateMetaLabel")
        layout.addWidget(thumbnail)
        layout.addWidget(radio)
        layout.addWidget(meta)
        layout.addStretch(1)
        return item

    def _sync_initial_selection(self):
        for candidate_path, radio in self.candidate_buttons.items():
            if _same_file(candidate_path, self.current_path):
                radio.setChecked(True)
                self.selected_path = candidate_path
                break
        self.save_button.setEnabled(self.selected_path is not None)

    def _select_candidate(self, candidate_path):
        self.selected_path = candidate_path
        self.save_button.setEnabled(True)
        self._update_status()

    def _update_status(self):
        if not self.candidates:
            self.status_label.setText("暂无生成封面图片")
            self.save_button.setEnabled(False)
            return
        if self.current_path and not os.path.exists(self.current_path):
            self.status_label.setText("当前生效封面文件不存在，请选择一张后保存")
            return
        if self.current_path and self.selected_path is None:
            self.status_label.setText("当前生效封面不在候选列表，请选择一张后保存")
            return
        if self.selected_path is None:
            self.status_label.setText("请选择一张生成封面后保存")
            return
        if _same_file(self.selected_path, self.current_path):
            self.status_label.setText("当前生效封面已选中")
            return
        self.status_label.setText("已选择新的生成封面，保存后用于后续更新蝦皮")

    def save_selection(self, checked=False):
        if not self.selected_path:
            QMessageBox.warning(self, "封面画廊", "请先选择一张生成封面")
            return False
        if _same_file(self.selected_path, self.current_path):
            self.changed = False
            self.accept()
            return True
        if self._needs_committed_confirmation() and not self._confirm_committed_save():
            return False
        try:
            db.update_generated_cover(self.task.id, self.selected_path, path=self.db_path)
        except Exception as exc:
            QMessageBox.warning(self, "封面画廊", f"保存当前封面失败：{exc}")
            return False
        self.current_path = _normalize_file_path(self.selected_path)
        self.changed = True
        self.accept()
        return True

    def regenerate_cover(self, checked=False):
        if self.regenerate_thread is not None:
            return False
        if self._bulk_generate_running():
            self.status_label.setText("②批量生成正在运行，完成后才能重新生成单个封面")
            self._update_regenerate_button_state()
            return False
        if not str(getattr(self.task, "new_title", "") or "").strip():
            QMessageBox.warning(self, "重新生成封面", "当前任务缺少新标题，不能单独重新生成封面")
            return False
        if not self._confirm_regenerate():
            return False
        try:
            db.reset_generated(
                self.task.id,
                reset_title=False,
                reset_cover=True,
                path=self.db_path,
            )
            fresh_task = db.get_task(self.task.id, path=self.db_path)
        except Exception as exc:
            QMessageBox.warning(self, "重新生成封面", str(exc))
            self.status_label.setText(f"重新生成封面失败：{exc}")
            return False
        if fresh_task is None:
            QMessageBox.warning(self, "重新生成封面", "任务不存在或已删除")
            self.status_label.setText("重新生成封面失败：任务不存在或已删除")
            return False
        self._reload_task_and_candidates(fresh_task)
        self.status_label.setText(f"开始重新生成商品 {getattr(fresh_task, 'item_id', '')} 的封面图片")
        worker = GenerateWorker(
            [fresh_task],
            self.prompt_values,
            db_path=self.db_path,
            config=_cover_regenerate_config(self.config),
            diagnostic_log_dir=self.diagnostic_log_dir,
        )
        worker.progress.connect(self._on_regenerate_progress)
        worker.row_updated.connect(self._on_regenerate_row_updated)
        worker.log.connect(self._on_regenerate_log)
        worker.failed.connect(self._on_regenerate_failed)
        worker.finished.connect(self._on_regenerate_finished)
        worker.cancelled.connect(self._on_regenerate_cancelled)
        thread = run_worker(worker, thread_name="CoverRegenerateWorker", start=False)
        thread.finished.connect(lambda: self._forget_regenerate_thread(thread))
        self.regenerate_worker = worker
        self.regenerate_thread = thread
        self._set_regenerate_running(True)
        thread.start()
        return True

    def _confirm_regenerate(self):
        box = QMessageBox(self)
        box.setWindowTitle("重新生成封面")
        box.setText("将重新生成当前商品封面，可能消耗 cmhub 点数。")
        confirm_button = box.addButton("重新生成", QMessageBox.AcceptRole)
        cancel_button = box.addButton("取消", QMessageBox.RejectRole)
        box.setDefaultButton(cancel_button)
        box.exec()
        return box.clickedButton() is confirm_button

    def _needs_committed_confirmation(self):
        return int(getattr(self.task, "committed", 0) or 0) == 1 or getattr(self.task, "stage", None) == "applied"

    def _confirm_committed_save(self):
        box = QMessageBox(self)
        box.setWindowTitle("确认保存封面")
        box.setText(
            "该商品已经提交过线上。本地换封面不会回滚蝦皮，重复更新会再次提交线上。"
        )
        save_button = box.addButton("确认保存", QMessageBox.AcceptRole)
        cancel_button = box.addButton("取消", QMessageBox.RejectRole)
        box.setDefaultButton(cancel_button)
        box.exec()
        return box.clickedButton() is save_button

    def open_original_image(self, image_path):
        dialog = OriginalImageDialog(image_path, self)
        dialog.exec()

    def _bulk_generate_running(self):
        return bool(self.bulk_running_checker and self.bulk_running_checker())

    def _set_regenerate_running(self, running):
        self.save_button.setEnabled(not running and self.selected_path is not None)
        self.regenerate_button.setEnabled(not running and not self._bulk_generate_running())
        self.regenerate_button.setToolTip(
            "②批量生成正在运行，完成后才能重新生成单个封面"
            if self._bulk_generate_running()
            else ("正在重新生成当前商品封面" if running else "")
        )
        if self.regenerate_running_callback is not None:
            self.regenerate_running_callback(bool(running))

    def _update_regenerate_button_state(self):
        running = self.regenerate_thread is not None
        self.regenerate_button.setEnabled(not running and not self._bulk_generate_running())
        self.regenerate_button.setToolTip(
            "②批量生成正在运行，完成后才能重新生成单个封面"
            if self._bulk_generate_running()
            else ("正在重新生成当前商品封面" if running else "")
        )

    def _reload_task_and_candidates(self, task=None):
        if task is not None:
            self.task = task
        self.current_path = _normalize_file_path(getattr(self.task, "new_cover_path", None))
        self.selected_path = None
        self.candidates = image_paths.list_task_cover_candidates(self.image_root, self.task, account=self.account)
        self._rebuild_candidate_items()
        self._sync_initial_selection()
        self._update_status()

    def _rebuild_candidate_items(self):
        _clear_layout(self.candidate_layout)
        self.candidate_buttons = {}
        self.button_group = QButtonGroup(self)
        self.button_group.setExclusive(True)
        if self.candidates:
            for index, candidate_path in enumerate(self.candidates):
                self.candidate_layout.addWidget(self._candidate_item(candidate_path, index))
            self.candidate_layout.addStretch(1)
        else:
            empty_label = QLabel("暂无生成封面图片")
            empty_label.setObjectName("coverGalleryEmptyLabel")
            empty_label.setMinimumSize(320, self.THUMBNAIL_SIZE)
            empty_label.setAlignment(Qt.AlignCenter)
            self.candidate_layout.addWidget(empty_label)

    def _on_regenerate_progress(self, payload):
        if payload.get("failed"):
            self.status_label.setText("封面重新生成失败，历史候选仍可选择保存")

    def _on_regenerate_row_updated(self, task_id, fields):
        if self.gallery_updated_callback is not None:
            self.gallery_updated_callback(self.task)

    def _on_regenerate_log(self, message):
        text = str(message or "").strip()
        if not text:
            return
        if text.startswith("[失败]"):
            self._regenerate_last_error = text
            self.status_label.setText(text)
        elif "成功" in text or "完成" in text:
            self.status_label.setText(text)

    def _on_regenerate_failed(self, task_id, error):
        self._regenerate_last_error = str(error or "未知错误")
        self.status_label.setText(f"封面重新生成失败：{self._regenerate_last_error}")

    def _on_regenerate_finished(self, summary):
        self._finish_regenerate(summary, cancelled=False)

    def _on_regenerate_cancelled(self, summary):
        self._finish_regenerate(summary, cancelled=True)

    def _finish_regenerate(self, summary, cancelled=False):
        fresh_task = db.get_task(self.task.id, path=self.db_path)
        if fresh_task is not None:
            self._reload_task_and_candidates(fresh_task)
        self._set_regenerate_running(False)
        if self.gallery_updated_callback is not None:
            self.gallery_updated_callback(self.task)
        if cancelled or summary.get("cancelled"):
            self.status_label.setText("封面重新生成已停止，历史候选仍可选择保存")
            return
        if summary.get("ok") and summary.get("cover_done", 0) > 0:
            self.status_label.setText("封面重新生成完成")
            return
        detail = self._regenerate_last_error or summary.get("error") or "请稍后重试"
        self.status_label.setText(f"封面重新生成失败：{detail}")

    def _forget_regenerate_thread(self, thread):
        if self.regenerate_thread is thread:
            self.regenerate_thread = None
            self.regenerate_worker = None
            self._set_regenerate_running(False)

    def _fit_to_screen(self):
        available = _available_geometry()
        if available is None:
            self.resize(960, 580)
            return
        max_width = max(520, int(available.width() * 0.9))
        max_height = max(420, int(available.height() * 0.9))
        self.resize(min(960, max_width), min(580, max_height))
        _center_dialog(self, available)


def _load_image(image_path):
    return QImage(str(image_path or ""))


def _clear_layout(layout):
    while layout.count():
        item = layout.takeAt(0)
        widget = item.widget()
        if widget is not None:
            widget.setParent(None)
            widget.deleteLater()


def _cover_regenerate_config(config):
    runtime_config = dict(config or {})
    ai_settings = appconfig.ai_config(runtime_config)
    ai_settings["generate_cover"] = True
    runtime_config["ai"] = ai_settings
    return runtime_config


def _build_image_label(image_path, size, empty_text):
    label = QLabel()
    label.setAlignment(Qt.AlignCenter)
    label.setMinimumSize(size, size)
    image = _load_image(image_path) if image_path else QImage()
    if image.isNull():
        label.setText(empty_text)
        return label
    label.setPixmap(
        QPixmap.fromImage(
            image.scaled(
                size,
                size,
                Qt.KeepAspectRatio,
                Qt.SmoothTransformation,
            )
        )
    )
    return label


def _candidate_label(candidate_path, current_path):
    return "当前生效" if _same_file(candidate_path, current_path) else os.path.basename(candidate_path)


def _candidate_meta(candidate_path, current_path):
    if _same_file(candidate_path, current_path):
        return "当前生效封面"
    stem, _ext = os.path.splitext(os.path.basename(candidate_path))
    parts = stem.rsplit("_", 2)
    if len(parts) >= 2 and len(parts[-1]) == 14 and parts[-1].isdigit():
        return _format_archive_timestamp(parts[-1])
    if len(parts) >= 3 and len(parts[-2]) == 14 and parts[-2].isdigit() and parts[-1].isdigit():
        return f"{_format_archive_timestamp(parts[-2])} · 同秒第 {parts[-1]} 张"
    if stem.endswith("_new"):
        return "当前输出槽"
    return "历史候选"


def _format_archive_timestamp(value):
    return f"{value[0:4]}-{value[4:6]}-{value[6:8]} {value[8:10]}:{value[10:12]}:{value[12:14]}"


def _normalize_file_path(path):
    value = str(path or "").strip()
    return os.path.abspath(value) if value else None


def _same_file(left, right):
    if not left or not right:
        return False
    return os.path.normcase(os.path.abspath(str(left))) == os.path.normcase(os.path.abspath(str(right)))


def _available_geometry():
    app = QApplication.instance()
    screen = app.primaryScreen() if app is not None else None
    return screen.availableGeometry() if screen is not None else None


def _center_dialog(dialog, available):
    frame = dialog.frameGeometry()
    frame.moveCenter(available.center())
    dialog.move(frame.topLeft())


class GenerateTab(QWidget):
    """Tab 2: prompt area plus generation task filters/list."""

    STATUS_FILTERS = [
        ("全部状态", "all"),
        ("待生成", "to_generate"),
        ("已生成", "generated"),
        ("失败", "failed"),
        ("略过", "skipped"),
        ("已更新", "applied"),
    ]
    RESET_MODE_LABELS = {
        "title": "标题",
        "cover": "封面",
        "all": "标题和封面",
    }
    TABLE_COLUMN_WEIGHTS = (1.0, 0.5, 1.8375, 1.8375, 0.4125, 0.4125)

    def __init__(
        self,
        parent=None,
        db_path=None,
        config=None,
        config_path=None,
        status_callback=None,
        title_prompt_path=None,
        cover_prompts_dir=None,
        open_accounts_callback=None,
    ):
        super().__init__(parent)
        self.config = appconfig.load_config(config_path or appconfig.CONFIG_PATH) if config is None else config
        self.config_path = (
            config_path
            or self.config.get("config_path")
            or appconfig.CONFIG_PATH
        )
        self.db_path = _database_path(db_path, self.config)
        self.status_callback = status_callback
        self.open_accounts_callback = open_accounts_callback
        self.title_prompt_path = title_prompt_path or appconfig.title_prompt_path(self.config)
        self.cover_prompts_dir = cover_prompts_dir or appconfig.cover_prompts_dir(self.config)
        self.current_cover_template = None
        self.generate_worker = None
        self.generate_thread = None
        self.generate_running = False
        self.cover_gallery_regenerate_running = False
        self._title_elapsed_start = None
        self._cover_elapsed_start = None
        self._title_elapsed_seconds = 0
        self._cover_elapsed_seconds = 0

        self.title_prompt_edit = QPlainTextEdit()
        self.title_prompt_edit.setObjectName("titlePromptEdit")
        self.title_prompt_edit.setPlaceholderText("标题提示词")
        self.title_prompt_edit.setPlainText(
            prompts.load_title_prompt(self.title_prompt_path)
        )
        self.save_title_button = QPushButton("保存标题提示词")
        self.insert_old_title_button = QPushButton("插入旧标题")
        self.insert_old_title_button.setObjectName("insertOldTitleButton")
        self.cover_prompt_edit = QPlainTextEdit()
        self.cover_prompt_edit.setObjectName("coverPromptEdit")
        self.cover_prompt_edit.setPlaceholderText("封面提示词")
        self.cover_template_combo = QComboBox()
        self.cover_template_combo.setObjectName("coverTemplateCombo")
        self.new_cover_template_button = QPushButton("新建")
        self.save_cover_template_button = QPushButton("保存")
        self.cover_template_actions_button = QPushButton("模板操作")
        self.cover_template_actions_button.setObjectName("coverTemplateActionsButton")
        self.cover_template_actions_menu = QMenu(self)
        self.save_cover_template_as_action = self.cover_template_actions_menu.addAction("另存为")
        self.save_cover_template_as_action.setObjectName("saveCoverTemplateAsAction")
        self.rename_cover_template_action = self.cover_template_actions_menu.addAction("重命名")
        self.rename_cover_template_action.setObjectName("renameCoverTemplateAction")
        self.delete_cover_template_action = self.cover_template_actions_menu.addAction("删除")
        self.delete_cover_template_action.setObjectName("deleteCoverTemplateAction")
        self.cover_template_actions_button.setMenu(self.cover_template_actions_menu)
        self.insert_title_button = QPushButton("插入标题")
        self.preview_prompt_button = QPushButton("预览")
        self.generate_button = QPushButton("开始生成")
        self.stop_generate_button = QPushButton("停止")
        self.reset_generate_button = QPushButton("重置生成结果")
        self.reset_generate_button.setObjectName("resetGenerateButton")
        self.stop_generate_button.setEnabled(False)
        ai_settings = appconfig.ai_config(self.config)
        self.generate_cover_checkbox = QCheckBox("生成封面图片（成本较高）")
        self.generate_cover_checkbox.setObjectName("generateCoverCheckbox")
        self.generate_cover_checkbox.setToolTip("关闭后只生成标题并保存为可更新，不调用图片模型")
        self.generate_cover_checkbox.setChecked(bool(ai_settings.get("generate_cover", False)))
        self.progress_label = QLabel("进度：标题0/0 · 图片0/0 · 失败0")
        self.title_progress_label = QLabel("标题 0/0")
        self.title_progress_label.setObjectName("generateTitleProgressLabel")
        self.title_progress_bar = QProgressBar()
        self.title_progress_bar.setObjectName("generateTitleProgressBar")
        self.title_progress_bar.setTextVisible(False)
        self.title_progress_bar.setRange(0, 1)
        self.title_progress_bar.setValue(0)
        self.cover_progress_label = QLabel("图片 0/0")
        self.cover_progress_label.setObjectName("generateCoverProgressLabel")
        self.cover_progress_bar = QProgressBar()
        self.cover_progress_bar.setObjectName("generateCoverProgressBar")
        self.cover_progress_bar.setTextVisible(False)
        self.cover_progress_bar.setRange(0, 1)
        self.cover_progress_bar.setValue(0)
        self.failed_progress_label = QLabel("失败 0")
        self.failed_progress_label.setObjectName("generateFailedProgressLabel")
        self.failed_progress_label.setVisible(False)
        self.cmhub_balance_label = QLabel("cmhub余额：未获取")
        self.cmhub_balance_label.setObjectName("generateCmhubBalanceLabel")
        self.cmhub_balance_label.setVisible(False)
        self.title_elapsed_label = QLabel("生标题用时 0 秒")
        self.title_elapsed_label.setObjectName("generateTitleElapsedLabel")
        self.cover_elapsed_label = QLabel("生图用时 0 秒")
        self.cover_elapsed_label.setObjectName("generateCoverElapsedLabel")
        elapsed_width = max(
            self.title_elapsed_label.fontMetrics().horizontalAdvance("生标题用时 9999 秒"),
            self.cover_elapsed_label.fontMetrics().horizontalAdvance("生图用时 9999 秒"),
        ) + 12
        self.title_elapsed_label.setFixedWidth(elapsed_width)
        self.cover_elapsed_label.setFixedWidth(elapsed_width)
        self._generate_elapsed_timer = QTimer(self)
        self._generate_elapsed_timer.setInterval(1000)
        self._generate_elapsed_timer.timeout.connect(self._refresh_elapsed_labels)

        left_panel = QWidget()
        left_layout = QVBoxLayout(left_panel)
        left_layout.setContentsMargins(0, 0, 12, 0)
        left_layout.addWidget(QLabel("标题提示词"))
        left_layout.addWidget(self.title_prompt_edit, 1)
        title_action_layout = QHBoxLayout()
        title_action_layout.addWidget(self.save_title_button)
        title_action_layout.addWidget(self.insert_old_title_button)
        title_action_layout.addStretch(1)
        left_layout.addLayout(title_action_layout)
        left_layout.addWidget(QLabel("封面提示词"))
        left_layout.addWidget(self.cover_template_combo)
        cover_template_layout = QHBoxLayout()
        cover_template_layout.addWidget(self.new_cover_template_button)
        cover_template_layout.addWidget(self.save_cover_template_button)
        cover_template_layout.addWidget(self.cover_template_actions_button)
        cover_template_layout.addStretch(1)
        left_layout.addLayout(cover_template_layout)
        left_layout.addWidget(self.cover_prompt_edit, 2)
        cover_action_layout = QHBoxLayout()
        cover_action_layout.addWidget(self.insert_title_button)
        cover_action_layout.addWidget(self.preview_prompt_button)
        left_layout.addLayout(cover_action_layout)

        self.batch_filter = QComboBox()
        self.batch_filter.setObjectName("batchFilter")
        self.shop_filter = QComboBox()
        self.shop_filter.setObjectName("shopFilter")
        self.item_filter = QLineEdit()
        self.item_filter.setObjectName("generateItemFilter")
        self.item_filter.setPlaceholderText("商品ID")
        self.status_filter = QComboBox()
        self.status_filter.setObjectName("statusFilter")
        for label, value in self.STATUS_FILTERS:
            self.status_filter.addItem(label, value)
        self.refresh_button = QPushButton("刷新")

        filter_layout = QHBoxLayout()
        filter_layout.addWidget(QLabel("批次"))
        filter_layout.addWidget(self.batch_filter, 2)
        filter_layout.addWidget(QLabel("店铺"))
        filter_layout.addWidget(self.shop_filter, 1)
        filter_layout.addWidget(QLabel("商品ID"))
        filter_layout.addWidget(self.item_filter, 1)
        filter_layout.addWidget(QLabel("状态"))
        filter_layout.addWidget(self.status_filter, 1)
        filter_layout.addWidget(self.refresh_button)

        self.summary_label = QLabel("任务 0 条")
        self.batch_progress_label = _build_batch_progress_overview("generateBatchProgressOverview")
        (
            self.empty_state_card,
            self.empty_state_label,
            self.empty_state_button,
        ) = _build_empty_state_card("generateEmptyStateCard")
        if self.open_accounts_callback is not None:
            self.empty_state_button.clicked.connect(self.open_accounts_callback)
        self.task_table = QTableView()
        self.model = GenerateTaskTableModel(self.task_table, db_path=self.db_path, status_callback=self._set_status)
        self.model.set_generate_cover_enabled(self.generate_cover_checkbox.isChecked())
        self.task_table.setModel(self.model)
        self.task_table.setSelectionBehavior(QAbstractItemView.SelectRows)
        self.task_table.setSelectionMode(QAbstractItemView.ExtendedSelection)
        self.task_table.setEditTriggers(QAbstractItemView.DoubleClicked | QAbstractItemView.EditKeyPressed)
        self.task_table.horizontalHeader().setSectionResizeMode(QHeaderView.Interactive)
        self.task_table.horizontalHeader().setStretchLastSection(False)
        self.task_table.verticalHeader().setVisible(False)

        self.run_log_view = QPlainTextEdit()
        self.run_log_view.setObjectName("generateRunLogView")
        self.run_log_view.setReadOnly(True)
        self.run_log_view.setMaximumHeight(128)
        self.run_log_view.setPlaceholderText("AI生成运行日志")

        right_panel = QWidget()
        right_layout = QVBoxLayout(right_panel)
        right_layout.setContentsMargins(12, 0, 0, 0)
        right_layout.addLayout(filter_layout)
        right_layout.addWidget(self.summary_label)
        right_layout.addWidget(self.batch_progress_label)
        right_layout.addWidget(self.empty_state_card)
        right_layout.addWidget(self.task_table, 1)
        right_layout.addWidget(QLabel("AI生成运行日志"))
        right_layout.addWidget(self.run_log_view)

        self.splitter = QSplitter(Qt.Horizontal)
        self.splitter.addWidget(left_panel)
        self.splitter.addWidget(right_panel)
        self.splitter.setStretchFactor(0, 1)
        self.splitter.setStretchFactor(1, 3)
        self.splitter.setSizes([280, 860])
        self.splitter.splitterMoved.connect(lambda *_: self._apply_task_table_column_widths())

        title_progress_layout = QHBoxLayout()
        title_progress_layout.addWidget(self.title_progress_label)
        title_progress_layout.addWidget(self.title_progress_bar, 1)
        title_progress_layout.addWidget(self.title_elapsed_label)
        cover_progress_layout = QHBoxLayout()
        cover_progress_layout.addWidget(self.cover_progress_label)
        cover_progress_layout.addWidget(self.cover_progress_bar, 1)
        cover_progress_layout.addWidget(self.cover_elapsed_label)
        progress_layout = QVBoxLayout()
        progress_layout.addLayout(title_progress_layout)
        progress_layout.addLayout(cover_progress_layout)

        button_layout = QHBoxLayout()
        button_layout.addStretch(1)
        button_layout.addWidget(self.generate_button)
        button_layout.addWidget(self.stop_generate_button)
        button_layout.addWidget(self.reset_generate_button)

        bottom_layout = QHBoxLayout()
        bottom_layout.addWidget(self.generate_cover_checkbox)
        bottom_layout.addLayout(progress_layout, 1)
        bottom_layout.addLayout(button_layout)

        layout = QVBoxLayout(self)
        layout.setContentsMargins(18, 18, 18, 18)
        layout.addWidget(self.splitter, 1)
        layout.addLayout(bottom_layout)

        self.batch_filter.currentIndexChanged.connect(self.refresh_tasks)
        self.shop_filter.currentIndexChanged.connect(self.refresh_tasks)
        self.item_filter.textChanged.connect(self.refresh_tasks)
        self.status_filter.currentIndexChanged.connect(self.refresh_tasks)
        self.refresh_button.clicked.connect(self.refresh_tasks)
        self.save_title_button.clicked.connect(self.save_title_prompt)
        self.insert_old_title_button.clicked.connect(self.insert_old_title_placeholder)
        self.cover_template_combo.currentIndexChanged.connect(self.load_selected_cover_template)
        self.new_cover_template_button.clicked.connect(self.new_cover_template)
        self.save_cover_template_button.clicked.connect(self.save_cover_template)
        self.save_cover_template_as_action.triggered.connect(self.save_cover_template_as)
        self.rename_cover_template_action.triggered.connect(self.rename_cover_template)
        self.delete_cover_template_action.triggered.connect(self.delete_cover_template)
        self.insert_title_button.clicked.connect(self.insert_title_placeholder)
        self.preview_prompt_button.clicked.connect(self.preview_cover_prompt)
        self.generate_cover_checkbox.toggled.connect(self._on_generate_cover_toggled)
        self.generate_button.clicked.connect(self.start_generate)
        self.stop_generate_button.clicked.connect(self.stop_generate)
        self.reset_generate_button.clicked.connect(self.reset_generated_result)
        self.task_table.doubleClicked.connect(self.show_task_images)

        self.refresh_cover_templates()
        self.refresh_tasks()
        self._show_current_run_log_empty()
        self._reset_generation_elapsed()
        self._update_cmhub_balance_label({})

    def resizeEvent(self, event):
        super().resizeEvent(event)
        self._apply_task_table_column_widths()

    def _set_status(self, message, level=None):
        _emit_status(self.status_callback, message, level=level)

    def _on_generate_log(self, message):
        self._append_generate_log(message)
        self._set_status(message)

    def _append_generate_log(self, message):
        self.run_log_view.appendPlainText(str(message))
        scroll_bar = self.run_log_view.verticalScrollBar()
        scroll_bar.setValue(scroll_bar.maximum())

    def _show_current_run_log_empty(self):
        self.run_log_view.setPlainText("本轮日志会在开始运行后显示")

    def _reset_generate_run_log(self, tasks, generate_cover):
        self.run_log_view.clear()
        cover_text = "是" if generate_cover else "否"
        self._append_generate_log(
            f"本轮AI生成开始：任务 {len(tasks)} 条，生成封面：{cover_text}"
        )

    def _reset_generation_elapsed(self):
        self._generate_elapsed_timer.stop()
        self._title_elapsed_start = None
        self._cover_elapsed_start = None
        self._title_elapsed_seconds = 0
        self._cover_elapsed_seconds = 0
        self._refresh_elapsed_labels()

    def _start_generation_elapsed(self, title_total, cover_total):
        self._reset_generation_elapsed()
        now = time.monotonic()
        if int(title_total or 0) > 0:
            self._title_elapsed_start = now
        elif int(cover_total or 0) > 0:
            self._cover_elapsed_start = now
        self._refresh_elapsed_labels()
        self._update_elapsed_timer_state()

    def _elapsed_seconds(self, start, frozen_seconds):
        if start is None:
            return max(0, int(frozen_seconds or 0))
        return max(0, int(time.monotonic() - start))

    def _refresh_elapsed_labels(self):
        title_seconds = self._elapsed_seconds(
            self._title_elapsed_start,
            self._title_elapsed_seconds,
        )
        cover_seconds = self._elapsed_seconds(
            self._cover_elapsed_start,
            self._cover_elapsed_seconds,
        )
        self.title_elapsed_label.setText(f"生标题用时 {title_seconds} 秒")
        self.cover_elapsed_label.setText(f"生图用时 {cover_seconds} 秒")

    def _update_elapsed_timer_state(self):
        if self._title_elapsed_start is not None or self._cover_elapsed_start is not None:
            if not self._generate_elapsed_timer.isActive():
                self._generate_elapsed_timer.start()
            return
        self._generate_elapsed_timer.stop()

    def _freeze_title_elapsed(self):
        if self._title_elapsed_start is None:
            return
        self._title_elapsed_seconds = self._elapsed_seconds(
            self._title_elapsed_start,
            self._title_elapsed_seconds,
        )
        self._title_elapsed_start = None

    def _freeze_cover_elapsed(self):
        if self._cover_elapsed_start is None:
            return
        self._cover_elapsed_seconds = self._elapsed_seconds(
            self._cover_elapsed_start,
            self._cover_elapsed_seconds,
        )
        self._cover_elapsed_start = None

    def _sync_generation_elapsed(self, payload):
        title_total = max(0, int(payload.get("title_total", 0) or 0))
        title_done = max(0, int(payload.get("title_done", 0) or 0))
        cover_total = self._cover_total_for_progress(payload, int(payload.get("total", 0) or 0))
        cover_done = max(0, int(payload.get("cover_done", 0) or 0))
        if title_total > 0 and title_done >= title_total:
            self._freeze_title_elapsed()
        if (
            cover_total > 0
            and cover_done < cover_total
            and self._cover_elapsed_start is None
            and self._cover_elapsed_seconds == 0
            and (title_total == 0 or title_done >= title_total)
        ):
            self._cover_elapsed_start = time.monotonic()
        if cover_total > 0 and cover_done >= cover_total:
            self._freeze_cover_elapsed()
        self._refresh_elapsed_labels()
        self._update_elapsed_timer_state()

    def _finish_generation_elapsed(self, payload=None):
        self._freeze_title_elapsed()
        self._freeze_cover_elapsed()
        self._refresh_elapsed_labels()
        self._update_elapsed_timer_state()

    def _on_generate_cover_toggled(self, checked):
        previous = bool(appconfig.ai_config(self.config).get("generate_cover", False))
        if self._save_generate_cover_setting(show_status=True):
            self.model.set_generate_cover_enabled(bool(checked))
            self.refresh_tasks()
            return
        self.generate_cover_checkbox.blockSignals(True)
        self.generate_cover_checkbox.setChecked(previous)
        self.generate_cover_checkbox.blockSignals(False)
        self.model.set_generate_cover_enabled(previous)

    def _apply_task_table_column_widths(self):
        if self.model.columnCount() != len(self.TABLE_COLUMN_WEIGHTS):
            return
        width = max(0, int(self.task_table.viewport().width()))
        if width <= 0:
            return
        total_weight = sum(self.TABLE_COLUMN_WEIGHTS)
        used = 0
        last_column = len(self.TABLE_COLUMN_WEIGHTS) - 1
        header = self.task_table.horizontalHeader()
        for column, weight in enumerate(self.TABLE_COLUMN_WEIGHTS):
            if column == last_column:
                section_width = max(1, width - used)
            else:
                section_width = max(1, int(width * weight / total_weight))
                used += section_width
            header.resizeSection(column, section_width)

    def _save_generate_cover_setting(self, show_status=True):
        generate_cover = bool(self.generate_cover_checkbox.isChecked())
        ai_settings = appconfig.ai_config(self.config)
        ai_settings["generate_cover"] = generate_cover
        payload = {
            key: value
            for key, value in self.config.items()
            if key not in {"config_path", "ai_models_path", "cmhub_config_path", "data_dir"}
        }
        payload["ai"] = ai_settings
        try:
            saved = appconfig.save_config(payload, path=self.config_path)
        except Exception as exc:
            self._set_status(f"生成封面开关保存失败：{exc}")
            return False
        internal = {
            key: value
            for key, value in self.config.items()
            if key in {"config_path", "ai_models_path", "cmhub_config_path", "data_dir"}
        }
        self.config.clear()
        self.config.update(saved)
        self.config.update(internal)
        if self.config_path != appconfig.CONFIG_PATH:
            self.config["config_path"] = self.config_path
        if show_status:
            mode = "会同时生成封面图片" if generate_cover else "只生成标题，不生成图片"
            self._set_status(f"AI生成设置已保存：{mode}")
        return True

    def _load_latest_generate_run_log(self):
        try:
            logs = db.list_run_logs(limit=1, run_type="generate", path=self.db_path)
            if not logs:
                return
            events = db.list_run_log_events(logs[0].id, limit=40, path=self.db_path)
        except Exception:
            return
        lines = [
            f"{event.created_at} [{event.level}] {event.message}"
            for event in reversed(events)
        ]
        self.run_log_view.setPlainText("\n".join(lines))
        scroll_bar = self.run_log_view.verticalScrollBar()
        scroll_bar.setValue(scroll_bar.maximum())

    def save_title_prompt(self, checked=False):
        try:
            prompts.save_title_prompt(
                self.title_prompt_edit.toPlainText(),
                self.title_prompt_path,
            )
        except Exception as exc:
            self._show_prompt_error(exc)
            return
        self._set_status("标题提示词已保存")

    def refresh_cover_templates(self, selected=None):
        try:
            template_names = prompts.list_cover_templates(self.cover_prompts_dir)
        except Exception as exc:
            template_names = []
            self._show_prompt_error(exc)
        current = selected if selected is not None else self.current_cover_template
        self.cover_template_combo.blockSignals(True)
        self.cover_template_combo.clear()
        if template_names:
            for name in template_names:
                self.cover_template_combo.addItem(name, name)
            index = self.cover_template_combo.findData(current)
            self.cover_template_combo.setCurrentIndex(index if index >= 0 else 0)
        else:
            self.cover_template_combo.addItem("默认", None)
            self.cover_template_combo.setCurrentIndex(0)
        self.cover_template_combo.blockSignals(False)
        self.load_selected_cover_template()

    def load_selected_cover_template(self, index=None):
        name = self.cover_template_combo.currentData()
        self.current_cover_template = name
        if name is None:
            self.cover_prompt_edit.setPlainText("")
            return
        try:
            self.cover_prompt_edit.setPlainText(
                prompts.load_cover_template(name, self.cover_prompts_dir)
            )
        except Exception as exc:
            self.cover_prompt_edit.setPlainText("")
            self._show_prompt_error(exc)

    def new_cover_template(self, checked=False):
        name = self._ask_template_name("新建封面提示词模板")
        if not name:
            return
        try:
            prompts.save_cover_template(name, "", self.cover_prompts_dir)
        except Exception as exc:
            self._show_prompt_error(exc)
            return
        self.refresh_cover_templates(selected=name)
        self._set_status(f"封面提示词模板已新建：{name}")

    def save_cover_template(self, checked=False):
        name = self.current_cover_template
        if name is None:
            self.save_cover_template_as()
            return
        try:
            prompts.save_cover_template(
                name,
                self.cover_prompt_edit.toPlainText(),
                self.cover_prompts_dir,
            )
        except Exception as exc:
            self._show_prompt_error(exc)
            return
        self._set_status(f"封面提示词模板已保存：{name}")

    def save_cover_template_as(self, checked=False):
        name = self._ask_template_name("另存封面提示词模板")
        if not name:
            return
        try:
            prompts.save_cover_template(
                name,
                self.cover_prompt_edit.toPlainText(),
                self.cover_prompts_dir,
            )
        except Exception as exc:
            self._show_prompt_error(exc)
            return
        self.refresh_cover_templates(selected=name)
        self._set_status(f"封面提示词模板已另存为：{name}")

    def rename_cover_template(self, checked=False):
        old_name = self.current_cover_template
        if old_name is None:
            self._set_status("没有可重命名的封面提示词模板")
            return
        new_name = self._ask_template_name("重命名封面提示词模板", text=old_name)
        if not new_name or new_name == old_name:
            return
        try:
            prompts.rename_cover_template(old_name, new_name, self.cover_prompts_dir)
        except Exception as exc:
            self._show_prompt_error(exc)
            return
        self.refresh_cover_templates(selected=new_name)
        self._set_status(f"封面提示词模板已重命名：{new_name}")

    def delete_cover_template(self, checked=False):
        name = self.current_cover_template
        if name is None:
            self._set_status("没有可删除的封面提示词模板")
            return
        choice = QMessageBox.question(
            self,
            "删除封面提示词模板",
            f"确定删除「{name}」吗？",
        )
        if choice != QMessageBox.Yes:
            return
        try:
            prompts.delete_cover_template(name, self.cover_prompts_dir)
        except Exception as exc:
            self._show_prompt_error(exc)
            return
        self.refresh_cover_templates()
        self._set_status(f"封面提示词模板已删除：{name}")

    def insert_title_placeholder(self, checked=False):
        self.cover_prompt_edit.insertPlainText("{新标题}")

    def insert_old_title_placeholder(self, checked=False):
        self.title_prompt_edit.insertPlainText("{旧标题}")

    def preview_cover_prompt(self, checked=False):
        task = self._selected_task()
        if task is None:
            self._set_status("没有可预览的任务")
            return
        rendered = prompts.render_prompt(
            self.cover_prompt_edit.toPlainText(),
            self._prompt_context(task),
        )
        QMessageBox.information(self, "封面提示词预览", rendered)
        self._set_status("封面提示词预览已生成")

    def start_generate(self, checked=False):
        if self.cover_gallery_regenerate_running:
            self._set_status("封面画廊正在重新生成，完成后再开始批量生成")
            return
        if self.generate_thread is not None:
            self._set_status("AI 生成正在进行...")
            return
        if not self._save_generate_cover_setting(show_status=False):
            return
        generate_cover = bool(self.generate_cover_checkbox.isChecked())
        tasks = [
            task for task in self.model.tasks
            if ai.is_generatable_task(task, generate_cover=generate_cover)
        ]
        if not tasks:
            self._set_status(
                "当前筛选结果没有可生成的缺失内容；请先在①导入采集完成采集，或勾选“生成封面图片（成本较高）”补封面"
            )
            return
        component_totals = ai.generation_component_totals(
            tasks,
            generate_cover=generate_cover,
        )
        prompt_values = {
            "title": self.title_prompt_edit.toPlainText(),
            "cover": self.cover_prompt_edit.toPlainText(),
        }
        worker = GenerateWorker(
            tasks,
            prompt_values,
            db_path=self.db_path,
            config=self.config,
            diagnostic_log_dir=diagnostics.DEFAULT_LOG_DIR,
        )
        worker.progress.connect(self._on_generate_progress)
        worker.row_updated.connect(self._on_generate_row_updated)
        worker.log.connect(self._on_generate_log)
        worker.failed.connect(self._on_generate_failed)
        worker.finished.connect(self._on_generate_finished)
        worker.cancelled.connect(self._on_generate_cancelled)
        self._reset_generate_run_log(tasks, generate_cover)
        self._reset_cmhub_balance_label()
        self._start_generation_elapsed(
            component_totals["title_total"],
            component_totals["cover_total"] if generate_cover else 0,
        )
        thread = run_worker(worker, thread_name="GenerateWorker", start=False)
        thread.finished.connect(lambda: self._forget_generate_thread(thread))
        self.generate_worker = worker
        self.generate_thread = thread
        self._set_generate_running(True)
        self._update_generate_progress(
            {
                "total": len(tasks),
                "title_total": component_totals["title_total"],
                "title_done": 0,
                "cover_done": 0,
                "cover_total": component_totals["cover_total"] if generate_cover else 0,
                "generated_done": 0,
                "failed": 0,
                "generate_cover": generate_cover,
            }
        )
        self._set_status(f"开始 AI 生成：{len(tasks)} 条")
        thread.start()

    def stop_generate(self, checked=False):
        if self.generate_worker is not None:
            self.generate_worker.cancel()
            self._append_generate_log("[停止] 已收到停止请求，当前正在运行的任务结束后停止")
            self._set_status("正在停止 AI 生成...")

    def reset_generated_result(self, checked=False):
        if self.generate_thread is not None:
            self._set_status("AI 生成正在进行，不能重置")
            return
        scope, tasks = self._reset_scope_tasks()
        if not tasks:
            self._set_status("当前没有可重置生成结果的任务")
            return
        if not self._resettable_tasks(tasks, reset_title=True, reset_cover=True):
            self._set_status("当前范围没有可重置的生成结果")
            return
        mode = self._ask_reset_generated_mode(tasks, scope)
        if mode is None:
            self._set_status("已取消重置生成结果")
            return
        reset_title, reset_cover = self._reset_mode_flags(mode)
        target_tasks = self._resettable_tasks(
            tasks,
            reset_title=reset_title,
            reset_cover=reset_cover,
        )
        if not target_tasks:
            self._set_status(f"当前范围没有可重置的{self.RESET_MODE_LABELS[mode]}")
            return
        label = self.RESET_MODE_LABELS[mode]
        try:
            for task in target_tasks:
                db.reset_generated(
                    task.id,
                    reset_title=reset_title,
                    reset_cover=reset_cover,
                    path=self.db_path,
                )
            run_id = self._write_generated_reset_run_log(
                target_tasks,
                scope,
                mode,
                reset_title=reset_title,
                reset_cover=reset_cover,
            )
        except Exception as exc:
            QMessageBox.warning(self, "重置生成结果", str(exc))
            self._set_status(f"重置生成结果失败：{exc}")
            return
        message = (
            "action=reset_generated step=db_write result=success "
            f"detail=重置{label} scope={scope} total={len(target_tasks)}"
        )
        self.refresh_tasks()
        self._append_generate_log(message)
        self._set_status(
            f"已重置生成结果：{len(target_tasks)} 条，内容：{label}，run_id={run_id}"
        )

    def _reset_scope_tasks(self):
        selection = self.task_table.selectionModel()
        selected_rows = []
        if selection is not None:
            selected_rows = sorted({index.row() for index in selection.selectedRows()})
        if selected_rows:
            tasks = [self.model.task_at(row) for row in selected_rows]
            return "selected", [task for task in tasks if task is not None]
        return "filtered", list(self.model.tasks)

    def _ask_reset_generated_mode(self, tasks, scope):
        scope_text = "选中任务" if scope == "selected" else "当前筛选结果"
        title_count = sum(1 for task in tasks if getattr(task, "new_title", None))
        cover_count = sum(1 for task in tasks if getattr(task, "new_cover_path", None))
        committed_count = sum(1 for task in tasks if int(getattr(task, "committed", 0) or 0))
        running_count = sum(1 for task in tasks if getattr(task, "status", None) == "running")
        sample_ids = [str(getattr(task, "item_id", "") or "") for task in tasks[:5]]
        sample_ids = [item_id for item_id in sample_ids if item_id]
        sample_text = "、".join(sample_ids)
        if len(tasks) > 5:
            sample_text += f" 等 {len(tasks)} 条"
        lines = [
            "请选择要重置的本地生成内容。",
            "",
            f"作用范围：{scope_text} {len(tasks)} 条",
            f"包含新标题：{title_count} 条",
            f"包含新封面：{cover_count} 条",
        ]
        if sample_text:
            lines.append(f"商品ID：{sample_text}")
        if running_count:
            lines.append(f"运行中任务会跳过：{running_count} 条")
        lines.extend([
            "",
            "重置标题：只清空新标题，保留新封面。",
            "重置封面：只清空新封面，保留新标题和手动微调标题。",
            "重置全部：清空新标题和新封面。",
            "",
            "不会触碰蝦皮，也不会自动回写 Excel；后续重新生成会消耗 cmhub 点数。",
            "默认不删除本地新封面文件。",
        ])
        if committed_count:
            lines.extend([
                "",
                f"注意：其中 {committed_count} 条已经提交过线上。本地重置不会回滚蝦皮，重生成后再更新会再次提交线上。",
            ])
        box = QMessageBox(self)
        box.setWindowTitle("重置生成结果")
        box.setText("\n".join(lines))
        title_button = box.addButton("重置标题", QMessageBox.AcceptRole)
        cover_button = box.addButton("重置封面", QMessageBox.AcceptRole)
        all_button = box.addButton("重置全部", QMessageBox.DestructiveRole)
        cancel_button = box.addButton("取消", QMessageBox.RejectRole)
        box.setDefaultButton(cancel_button)
        box.exec()
        clicked = box.clickedButton()
        if clicked is title_button:
            return "title"
        if clicked is cover_button:
            return "cover"
        if clicked is all_button:
            return "all"
        return None

    def _reset_mode_flags(self, mode):
        if mode == "title":
            return True, False
        if mode == "cover":
            return False, True
        return True, True

    def _resettable_tasks(self, tasks, reset_title=True, reset_cover=True):
        resettable = []
        for task in tasks:
            if getattr(task, "status", None) == "running":
                continue
            has_title = bool(getattr(task, "new_title", None))
            has_cover = bool(getattr(task, "new_cover_path", None))
            if reset_title and has_title:
                resettable.append(task)
                continue
            if reset_cover and has_cover:
                resettable.append(task)
        return resettable

    def _write_generated_reset_run_log(
        self,
        tasks,
        scope,
        mode,
        reset_title=True,
        reset_cover=True,
    ):
        task_ids = [getattr(task, "id", None) for task in tasks]
        committed_count = sum(1 for task in tasks if int(getattr(task, "committed", 0) or 0))
        options = {
            "action": "reset_generated",
            "scope": scope,
            "mode": mode,
            "reset_title": bool(reset_title),
            "reset_cover": bool(reset_cover),
            "task_ids": task_ids,
            "committed_count": committed_count,
        }
        run_id = db.create_run_log(
            "reset",
            total=len(tasks),
            options=options,
            path=self.db_path,
        )
        label = self.RESET_MODE_LABELS[mode]
        for task in tasks:
            message = (
                "action=reset_generated step=db_write result=success "
                f"detail=重置{label} task_id={getattr(task, 'id', None)}"
            )
            db.add_run_log_event(
                run_id,
                message,
                task_id=getattr(task, "id", None),
                alias=getattr(task, "alias", None),
                item_id=getattr(task, "item_id", None),
                path=self.db_path,
            )
        db.finish_run_log(
            run_id,
            status="done",
            done=len(tasks),
            success_count=len(tasks),
            failed_count=0,
            summary_json=options,
            path=self.db_path,
        )
        return run_id

    def show_task_images(self, index):
        if index.isValid() and index.column() == 3:
            return
        task = self.model.task_at(index.row()) if index.isValid() else self._selected_task()
        if task is None:
            self._set_status("没有可预览的任务")
            return
        account = self.model.account_by_alias.get(str(getattr(task, "alias", "") or "").strip())
        dialog = CoverGalleryDialog(
            task,
            image_root=appconfig.image_dir(self.config),
            db_path=self.db_path,
            account=account,
            parent=self,
            config=self.config,
            prompt_values={
                "title": self.title_prompt_edit.toPlainText(),
                "cover": self.cover_prompt_edit.toPlainText(),
            },
            diagnostic_log_dir=diagnostics.DEFAULT_LOG_DIR,
            bulk_running_checker=lambda: self.generate_thread is not None,
            regenerate_running_callback=self._set_cover_gallery_regenerate_running,
            gallery_updated_callback=self._on_cover_gallery_updated,
        )
        if dialog.exec() == QDialog.Accepted:
            self.refresh_tasks()
            if dialog.changed:
                self._set_status(f"已保存当前新封面：{task.item_id}")
            else:
                self._set_status(f"当前新封面未变更：{task.item_id}")

    def _set_generate_running(self, running):
        self.generate_running = bool(running)
        self.generate_button.setEnabled(not running and not self.cover_gallery_regenerate_running)
        self.stop_generate_button.setEnabled(running)
        self.reset_generate_button.setEnabled(not running and not self.cover_gallery_regenerate_running)
        self.refresh_button.setEnabled(not running)
        self.batch_filter.setEnabled(not running)
        self.shop_filter.setEnabled(not running)
        self.item_filter.setEnabled(not running)
        self.status_filter.setEnabled(not running)
        self.save_title_button.setEnabled(not running)
        self.new_cover_template_button.setEnabled(not running)
        self.save_cover_template_button.setEnabled(not running)
        self.cover_template_actions_button.setEnabled(not running)
        self.save_cover_template_as_action.setEnabled(not running)
        self.rename_cover_template_action.setEnabled(not running)
        self.delete_cover_template_action.setEnabled(not running)
        self.generate_cover_checkbox.setEnabled(not running)
        self._sync_cover_gallery_regenerate_guard()

    def _set_cover_gallery_regenerate_running(self, running):
        self.cover_gallery_regenerate_running = bool(running)
        self._sync_cover_gallery_regenerate_guard()

    def _sync_cover_gallery_regenerate_guard(self):
        if self.generate_thread is not None or self.generate_running:
            return
        blocked = bool(self.cover_gallery_regenerate_running)
        self.generate_button.setEnabled(not blocked)
        self.reset_generate_button.setEnabled(not blocked)
        tooltip = "封面画廊正在重新生成，完成后再开始批量生成" if blocked else ""
        self.generate_button.setToolTip(tooltip)
        self.reset_generate_button.setToolTip(tooltip)

    def _on_cover_gallery_updated(self, task):
        self.refresh_tasks()

    def _forget_generate_thread(self, thread):
        if self.generate_thread is thread:
            self.generate_thread = None
            self.generate_worker = None

    def _on_generate_progress(self, payload):
        self._update_generate_progress(payload)
        self._sync_generation_elapsed(payload)
        self._update_cmhub_balance_label(payload)
        self._set_status("生成进度：" + self._generate_progress_text(payload))

    def _on_generate_row_updated(self, task_id, fields):
        self.refresh_tasks()

    def _on_generate_failed(self, task_id, error):
        self._set_status(f"AI 生成失败：{error}")

    def _on_generate_finished(self, payload):
        self._set_generate_running(False)
        self.refresh_tasks()
        self._update_generate_progress(payload)
        self._finish_generation_elapsed(payload)
        self._update_cmhub_balance_label(payload)
        billing_error = payload.get("billing_error")
        if billing_error:
            self._show_billing_error(billing_error)
            return
        if payload.get("error"):
            self._set_status(f"AI 生成失败：{payload.get('error')}")
            return
        self._set_status("AI 生成完成：" + self._generate_progress_text(payload))

    def _on_generate_cancelled(self, payload):
        self._set_generate_running(False)
        self.refresh_tasks()
        self._update_generate_progress(payload)
        self._finish_generation_elapsed(payload)
        self._update_cmhub_balance_label(payload)
        billing_error = payload.get("billing_error")
        if billing_error:
            self._show_billing_error(billing_error)
            return
        self._set_status("AI 生成已停止：" + self._generate_progress_text(payload))

    def _update_generate_progress(self, payload):
        total = max(0, int(payload.get("total", 0) or 0))
        title_total = max(0, int(payload.get("title_total", total) or 0))
        title_done = max(0, int(payload.get("title_done", 0) or 0))
        cover_done = max(0, int(payload.get("cover_done", 0) or 0))
        cover_total = self._cover_total_for_progress(payload, total)
        failed = max(0, int(payload.get("failed", 0) or 0))
        self.progress_label.setText("进度：" + self._generate_progress_text(payload))
        self.title_progress_label.setText(f"标题 {title_done}/{title_total}")
        self.cover_progress_label.setText(f"图片 {cover_done}/{cover_total}")
        self.failed_progress_label.setText(f"失败 {failed}")
        self._set_progress_bar(self.title_progress_bar, title_done, title_total)
        self._set_progress_bar(self.cover_progress_bar, cover_done, cover_total)

    def _reset_cmhub_balance_label(self):
        self.cmhub_balance_label.setVisible(False)
        if self._is_cmhub_backend():
            self.cmhub_balance_label.setText("cmhub余额：生成后刷新")
        else:
            self.cmhub_balance_label.setText("")

    def _update_cmhub_balance_label(self, payload):
        self.cmhub_balance_label.setVisible(False)
        if not self._is_cmhub_backend():
            return
        balance = payload.get("points_balance") if isinstance(payload, dict) else None
        if balance is None:
            if not self.cmhub_balance_label.text():
                self.cmhub_balance_label.setText("cmhub余额：未获取")
            return
        self.cmhub_balance_label.setText(f"cmhub余额：{balance}")

    def _is_cmhub_backend(self):
        try:
            return appconfig.ai_config(self.config).get("backend") == "cmhub"
        except Exception:
            return False

    def _show_billing_error(self, billing_error):
        message = billing_error.get("message") or "点数不足，请先充值。"
        QMessageBox.warning(self, "AI生成", message)
        self._set_status("AI 生成已中止：" + message)

    def _set_progress_bar(self, bar, done, total):
        maximum = max(1, int(total or 0))
        value = min(max(0, int(done or 0)), maximum)
        bar.setRange(0, maximum)
        bar.setValue(value)

    def _cover_total_for_progress(self, payload, total):
        cover_total = payload.get("cover_total")
        if cover_total is None:
            cover_total = total if payload.get("generate_cover", True) else 0
        return max(0, int(cover_total or 0))

    def _generate_progress_text(self, payload):
        total = max(0, int(payload.get("total", 0) or 0))
        title_total = max(0, int(payload.get("title_total", total) or 0))
        cover_total = self._cover_total_for_progress(payload, total)
        return "标题{title}/{title_total} · 图片{cover}/{cover_total} · 失败{failed}".format(
            title=payload.get("title_done", 0),
            cover=payload.get("cover_done", 0),
            cover_total=cover_total,
            title_total=title_total,
            failed=payload.get("failed", 0),
        )

    def _selected_task(self):
        index = self.task_table.currentIndex()
        if index.isValid():
            return self.model.task_at(index.row())
        if self.model.rowCount() > 0:
            return self.model.task_at(0)
        return None

    def _prompt_context(self, task):
        return {
            "old_title": task.old_title,
            "new_title": task.new_title,
            "item_id": task.item_id,
            "account_name": self.model.account_name_for(task),
            "alias": task.alias,
        }

    def _ask_template_name(self, title, text=""):
        value, ok = QInputDialog.getText(
            self,
            title,
            "模板名",
            QLineEdit.Normal,
            text,
        )
        if not ok:
            return None
        return str(value).strip()

    def _show_prompt_error(self, error):
        message = str(error)
        QMessageBox.warning(self, "提示词管理", message)
        self._set_status(message)

    def refresh_tasks(self, checked=False):
        try:
            db.init_db(self.db_path)
            batches = db.list_batches(path=self.db_path)
            accounts_rows = accounts.list_accounts(path=self.db_path, config=self.config)
            selected_batch = self.batch_filter.currentData()
            selected_shop = self.shop_filter.currentData()
            selected_status = self.status_filter.currentData() or "all"
            item_query = self.item_filter.text().strip()
            self._populate_batch_filter(batches, selected_batch)
            selected_batch = self.batch_filter.currentData()
            batch_tasks = db.list_tasks(batch_id=selected_batch, path=self.db_path)
            self._populate_shop_filter(batch_tasks, accounts_rows, selected_shop)
            selected_shop = self.shop_filter.currentData()
            filtered_tasks = [
                task for task in batch_tasks
                if self._matches_shop(task, selected_shop)
                and self._matches_item(task, item_query)
                and self._matches_status(task, selected_status)
            ]
        except Exception as exc:
            self.model.set_tasks([], [])
            self.summary_label.setText("任务读取失败")
            _set_batch_progress_overview(self.batch_progress_label, [])
            _set_empty_state(self.empty_state_card, self.empty_state_label, self.empty_state_button)
            self._set_status(f"AI 生成任务读取失败：{exc}")
            return
        self.model.set_generate_cover_enabled(self.generate_cover_checkbox.isChecked())
        self.model.set_tasks(filtered_tasks, accounts_rows)
        self._apply_task_table_column_widths()
        self.summary_label.setText(
            f"任务 {len(filtered_tasks)}/{len(batch_tasks)} 条"
        )
        _set_batch_progress_overview(self.batch_progress_label, batch_tasks)
        self._update_empty_state(batch_tasks, filtered_tasks, accounts_rows)

    def _update_empty_state(self, batch_tasks, filtered_tasks, account_rows):
        if not account_rows:
            _set_empty_state(
                self.empty_state_card,
                self.empty_state_label,
                self.empty_state_button,
                "第一步：前往『④账号管理』配置并登录账号，再回到②生成标题和封面。",
                self.open_accounts_callback is not None,
            )
            return
        if not batch_tasks:
            _set_empty_state(
                self.empty_state_card,
                self.empty_state_label,
                self.empty_state_button,
                "还没有可生成任务。请先在①导入采集完成旧标题和旧封面采集。",
            )
            return
        if not filtered_tasks:
            _set_empty_state(
                self.empty_state_card,
                self.empty_state_label,
                self.empty_state_button,
                "当前筛选没有匹配的生成任务，请调整批次、店铺、商品ID或状态筛选。",
            )
            return
        _set_empty_state(self.empty_state_card, self.empty_state_label, self.empty_state_button)

    def _populate_batch_filter(self, batches, selected_batch):
        had_previous_items = self.batch_filter.count() > 0
        self.batch_filter.blockSignals(True)
        self.batch_filter.clear()
        self.batch_filter.addItem("全部批次", None)
        for batch in batches:
            self.batch_filter.addItem(self._batch_label(batch), batch.id)
        self.batch_filter.setCurrentIndex(
            _batch_filter_current_index(
                self.batch_filter,
                batches,
                selected_batch,
                had_previous_items,
            )
        )
        self.batch_filter.blockSignals(False)

    def _populate_shop_filter(self, tasks, account_rows, selected_shop):
        account_by_alias = {
            str(account.alias).strip(): account
            for account in account_rows
            if str(account.alias).strip()
        }
        aliases = []
        for task in tasks:
            alias = str(task.alias).strip()
            if alias and alias not in aliases:
                aliases.append(alias)
        previous = selected_shop if selected_shop in aliases else None
        self.shop_filter.blockSignals(True)
        self.shop_filter.clear()
        self.shop_filter.addItem("全部店铺", None)
        for alias in sorted(aliases, key=lambda value: self._shop_label(value, account_by_alias)):
            self.shop_filter.addItem(self._shop_label(alias, account_by_alias), alias)
        index = self.shop_filter.findData(previous)
        self.shop_filter.setCurrentIndex(index if index >= 0 else 0)
        self.shop_filter.blockSignals(False)

    def _batch_label(self, batch):
        source_files = batch.source_files
        first_file = os.path.basename(source_files[0]) if source_files else batch.id
        return f"{batch.created_at} · {first_file}"

    def _shop_label(self, alias, account_by_alias):
        account = account_by_alias.get(alias)
        if account is not None:
            return f"{account.account_name} ({alias})"
        return alias

    def _matches_shop(self, task, selected_shop):
        return selected_shop is None or str(task.alias).strip() == selected_shop

    def _matches_item(self, task, item_query):
        if not item_query:
            return True
        return item_query in str(getattr(task, "item_id", ""))

    def _matches_status(self, task, selected_status):
        if selected_status in (None, "all"):
            return True
        if selected_status == "to_generate":
            generate_cover = bool(self.generate_cover_checkbox.isChecked())
            return ai.is_generatable_task(task, generate_cover=generate_cover) and task.status != "failed"
        if selected_status == "generated":
            return task.stage == "generated"
        if selected_status == "applied":
            return task.stage == "applied"
        if selected_status == "failed":
            return task.status == "failed"
        if selected_status == "skipped":
            return task.status == "skipped"
        return True