refactor(core): 统一交互模式，移除旧的同步等待机制

Author: baiheyyds

core/GEMINI.md

@@ -30,10 +30,8 @@
         3.  **充当信号代理 (Signal Proxy)**: 这是理解其工作模式的**关键**。`GameSyncWorker` 和 `ScriptWorker` 都会监听其内部 `GuiInteractionProvider` 实例发出的“内部”信号，然后**转发**一个由 Worker 自身定义的、名称相同的“外部”信号给 `MainWindow`。这确保了交互请求可以被线程安全地传递到主GUI线程进行处理。
         4.  **提供响应入口**: 为了接收 `MainWindow` 的响应，两个 Worker 都提供了公共方法。这些方法通过 `loop.call_soon_threadsafe` 来保证响应被安全地传递回后台的 `asyncio` 事件循环。
 
-    - **架构说明 (待重构)**:
-        目前项目**并存两套交互机制**，这是一个历史遗留问题和技术债：
-        - **现代机制 (`set_interaction_response`)**: 基于 `asyncio.Future`，用于绝大多数交互，是首选方式。
-        - **传统机制 (`set_choice`)**: 基于 `QMutex` 和 `QWaitCondition`，仅用于初次游戏选择和重复项确认。这部分逻辑未来应被重构，统一到 `asyncio.Future` 机制，以简化架构。
+    - **架构说明**:
+        交互完全基于 `asyncio.Future` 和 `InteractionProvider` 接口实现，确保了后台与前台之间通信模式的统一和线程安全。
 
 ## 3. 核心工作流（GUI模式）
 
@@ -47,6 +45,6 @@ GUI 模式下的工作流与CLI模式在核心逻辑上相似，但在交互处
 6.  Worker 监听到此内部信号，并立即发出一个**同名的外部信号**。
 7.  `MainWindow` 的对应槽函数被触发。
 8.  `MainWindow` 显示对话框，等待用户操作。
-9.  用户操作完毕后，`MainWindow` 调用 `worker.set_interaction_response(...)` 或 `worker.set_choice(...)` 将结果返回给 Worker。
+9.  用户操作完毕后，`MainWindow` 调用 `worker.set_interaction_response(...)` 将结果返回给 Worker。
 10. Worker 通过线程安全的方式将结果传递给 `GuiInteractionProvider`，解除 `await` 阻塞。
 11. 核心业务逻辑继续执行。

core/gui_worker.py

@@ -14,6 +14,7 @@
 
 class GameSyncWorker(QThread):
     process_completed = Signal(bool)
+    # --- Signals to MainWindow to request showing a dialog ---
     selection_required = Signal(list, str, str)
     duplicate_check_required = Signal(list)
     bangumi_mapping_required = Signal(dict)
@@ -31,9 +32,6 @@ def __init__(self, keyword, manual_mode=False, parent=None, shared_context=None)
         self.manual_mode = manual_mode
         self.shared_context = shared_context
         self.context = {}
-        self.mutex = QMutex()
-        self.wait_condition = QWaitCondition()
-        self.user_choice = None
         self.interaction_provider = None
         self.loop = None
 
@@ -55,19 +53,20 @@ async def setup_context():
             self.context = {**self.shared_context, **loop_specific_context}
 
         try:
-            # Run setup first to create the provider
             self.loop.run_until_complete(setup_context())
 
-            # Then connect signals
+            # Connect all interaction signals from the provider to the worker's proxy slots
             self.interaction_provider.handle_new_bangumi_key_requested.connect(self._on_bangumi_mapping_requested)
             self.interaction_provider.ask_for_new_property_type_requested.connect(self._on_property_type_requested)
             self.interaction_provider.select_bangumi_game_requested.connect(self._on_bangumi_selection_requested)
             self.interaction_provider.tag_translation_required.connect(self._on_tag_translation_requested)
             self.interaction_provider.concept_merge_required.connect(self._on_concept_merge_requested)
             self.interaction_provider.name_split_decision_required.connect(self._on_name_split_decision_requested)
             self.interaction_provider.confirm_brand_merge_requested.connect(self._on_brand_merge_requested)
+            # --- Newly refactored signal connections ---
+            self.interaction_provider.select_game_requested.connect(self._on_select_game_requested)
+            self.interaction_provider.duplicate_check_requested.connect(self._on_duplicate_check_requested)
 
-            # Now run the main game flow
             self.loop.run_until_complete(self.game_flow())
 
         except Exception as e:
@@ -77,18 +76,14 @@ async def setup_context():
         finally:
             if self.interaction_provider:
                 try:
-                    self.interaction_provider.handle_new_bangumi_key_requested.disconnect(self._on_bangumi_mapping_requested)
-                    self.interaction_provider.ask_for_new_property_type_requested.disconnect(self._on_property_type_requested)
-                    self.interaction_provider.select_bangumi_game_requested.disconnect(self._on_bangumi_selection_requested)
-                    self.interaction_provider.tag_translation_required.disconnect(self._on_tag_translation_requested)
-                    self.interaction_provider.concept_merge_required.disconnect(self._on_concept_merge_requested)
-                    self.interaction_provider.name_split_decision_required.disconnect(self._on_name_split_decision_requested)
-                    self.interaction_provider.confirm_brand_merge_requested.disconnect(self._on_brand_merge_requested)
-                except RuntimeError:
+                    # Disconnect all signals
+                    for signal_name in dir(self.interaction_provider):
+                        if isinstance(getattr(self.interaction_provider, signal_name), Signal):
+                            getattr(self.interaction_provider, signal_name).disconnect()
+                except (RuntimeError, TypeError):
                     pass
 
             async def cleanup_tasks():
-                # Cancel background tasks first
                 background_tasks = self.context.get("background_tasks", [])
                 if background_tasks:
                     logger.system(f"正在取消 {len(background_tasks)} 个后台任务...")
@@ -97,7 +92,6 @@ async def cleanup_tasks():
                     await asyncio.gather(*background_tasks, return_exceptions=True)
                     logger.system("所有后台任务已处理。")
 
-                # Close HTTP client
                 if self.context.get("async_client"):
                     await self.context["async_client"].aclose()
                     logger.system("线程内HTTP客户端已关闭。")
@@ -107,6 +101,7 @@ async def cleanup_tasks():
 
             self.loop.close()
 
+    # --- Proxy slots to forward signals from InteractionProvider to MainWindow ---
     def _on_bangumi_mapping_requested(self, request_data):
         self.bangumi_mapping_required.emit(request_data)
 
@@ -128,40 +123,18 @@ def _on_name_split_decision_requested(self, text, parts):
     def _on_brand_merge_requested(self, new_brand_name, suggested_brand):
         self.confirm_brand_merge_requested.emit(new_brand_name, suggested_brand)
 
+    def _on_select_game_requested(self, choices, title, source):
+        self.selection_required.emit(choices, title, source)
+
+    def _on_duplicate_check_requested(self, candidates):
+        self.duplicate_check_required.emit(candidates)
+
+    # --- Method for MainWindow to send response back ---
     def set_interaction_response(self, response):
         if self.loop and self.interaction_provider:
             self.loop.call_soon_threadsafe(self.interaction_provider.set_response, response)
 
-    def set_choice(self, choice):
-        self.mutex.lock()
-        self.user_choice = choice
-        self.mutex.unlock()
-        self.wait_condition.wakeAll()
-
-    async def wait_for_choice(self, choices: list, title: str, source: str = ""):
-        # 1. 先发射信号，此时不持有任何锁，避免死锁
-        if source:
-            self.selection_required.emit(choices, title, source)
-        else:
-            self.duplicate_check_required.emit(choices)
-
-        # 2. 现在获取锁，并等待主线程的响应
-        self.mutex.lock()
-        try:
-            # 为等待用户输入设置60秒超时
-            timed_out = not self.wait_condition.wait(self.mutex, 60000)
-            if timed_out and self.user_choice is None:
-                logger.warn("等待用户选择超时（60秒），将自动执行‘跳过’操作。")
-                choice = "skip"
-            else:
-                choice = self.user_choice
-        finally:
-            # 3. 重置选择并解锁，为下一次交互做准备
-            self.user_choice = None
-            self.mutex.unlock()
-        
-        return choice
-
+    # --- Core async logic ---
     async def _select_game_from_results(self, results, source):
         game = None
         while True:
@@ -178,7 +151,9 @@ async def _select_game_from_results(self, results, source):
                     logger.info(f"智能模式匹配度 ({best_score:.2f}) 过低，转为手动选择。")
 
             if game is None:
-                choice = await self.wait_for_choice(results, f"请从 {source.upper()} 结果中选择", source)
+                # REFACTORED: Call the provider instead of wait_for_choice
+                choice = await self.interaction_provider.select_game(results, f"请从 {source.upper()} 结果中选择", source)
+                
                 if choice == "search_fanza":
                     logger.info("切换到 Fanza 搜索...")
                     results, source = await search_all_sites(self.context["dlsite"], self.context["fanza"], self.keyword, site="fanza")
@@ -198,7 +173,9 @@ async def _check_for_duplicates(self, title):
         if not candidates:
             return None
 
-        choice = await self.wait_for_choice(candidates, "发现重复游戏")
+        # REFACTORED: Call the provider instead of wait_for_choice
+        choice = await self.interaction_provider.confirm_duplicate(candidates)
+
         if choice == "skip":
             logger.info("已选择跳过。")
             return "skip"
@@ -209,7 +186,7 @@ async def _check_for_duplicates(self, title):
         elif choice == "create":
             logger.info("已选择强制创建新游戏。")
             return None
-        return None
+        return None # Default to cancel
 
     async def _fetch_ggbases_data(self, keyword, manual_mode):
         logger.info("[GGBases] 开始获取 GGBases 数据...")
@@ -222,7 +199,8 @@ async def _fetch_ggbases_data(self, keyword, manual_mode):
             selected_game = None
             if manual_mode:
                 logger.info("[GGBases] 手动模式，需要用户选择。")
-                choice = await self.wait_for_choice(candidates, "请从GGBases结果中选择", "ggbases")
+                # REFACTORED: Call the provider instead of wait_for_choice
+                choice = await self.interaction_provider.select_game(candidates, "请从GGBases结果中选择", "ggbases")
                 if isinstance(choice, int) and choice != -1:
                     selected_game = candidates[choice]
             else:

core/interaction.py

@@ -42,6 +42,23 @@ async def confirm_brand_merge(self, new_brand_name: str, suggested_brand: str) -
         """当发现一个新品牌与一个现有品牌高度相似时，询问用户如何操作。"""
         pass
 
+    @abstractmethod
+    async def select_game(self, choices: list, title: str, source: str) -> int | str | None:
+        """
+        要求用户从搜索结果列表中选择一个游戏。
+        也处理特定于源的选项，如“切换到Fanza搜索”。
+        返回选择的索引、特殊操作字符串或None。
+        """
+        pass
+
+    @abstractmethod
+    async def confirm_duplicate(self, candidates: list) -> str | None:
+        """
+        显示潜在的重复游戏，并询问用户是跳过、更新还是强制创建。
+        返回 'skip', 'update', 'create' 或 None。
+        """
+        pass
+
 
 class ConsoleInteractionProvider(InteractionProvider):
     """Console implementation for user interaction using input()."""
@@ -226,6 +243,69 @@ def _get_input():
             return {"action": "keep", "save_exception": True}
         return {"action": "keep", "save_exception": False}
 
+    async def select_game(self, choices: list, title: str, source: str) -> int | str | None:
+        """要求用户从搜索结果列表中选择一个游戏。"""
+        def _get_input():
+            logger.info(title)
+            if source == 'ggbases':
+                for i, item in enumerate(choices):
+                    size_info = item.get('容量', '未知')
+                    popularity = item.get('popularity', 0)
+                    print(f"  [{i+1}] {item.get('title', 'No Title')} (热度: {popularity}) (大小: {size_info})")
+            else:
+                for i, item in enumerate(choices):
+                    price = item.get("价格") or item.get("price", "未知")
+                    price_display = f"{price}円" if str(price).isdigit() else price
+                    item_type = item.get("类型", "未知")
+                    print(f"  [{i+1}] [{source.upper()}] {item.get('title', 'No Title')} | 💴 {price_display} | 🏷️ {item_type}")
+            
+            prompt = "\n请输入序号进行选择 (0 放弃"
+            if source == 'dlsite':
+                prompt += ", f 切换到Fanza搜索"
+            prompt += "): "
+            return input(prompt).strip().lower()
+
+        while True:
+            choice = await asyncio.to_thread(_get_input)
+            if choice == 'f' and source == 'dlsite':
+                logger.info("切换到 Fanza 搜索...")
+                return "search_fanza"
+            if choice == '0':
+                logger.info("用户取消了选择。")
+                return -1
+            try:
+                choice_idx = int(choice) - 1
+                if 0 <= choice_idx < len(choices):
+                    return choice_idx
+                else:
+                    logger.error("无效的序号，请重新输入。")
+            except ValueError:
+                logger.error("无效输入，请输入数字或指定字母。")
+
+    async def confirm_duplicate(self, candidates: list) -> str | None:
+        """显示潜在的重复游戏，并询问用户如何处理。"""
+        def _get_input():
+            logger.warn("发现可能重复的游戏，请选择操作：")
+            for i, (game, similarity) in enumerate(candidates):
+                title = game.get("title", "未知标题")
+                print(f"  - 相似条目: {title} (相似度: {similarity:.2f})")
+            
+            print("\n  [s] 跳过，不处理此游戏 (默认)")
+            print("  [u] 更新最相似的已有条目")
+            print("  [c] 强制创建为新条目")
+            return input("请输入您的选择 (s/u/c): ").strip().lower()
+
+        while True:
+            choice = await asyncio.to_thread(_get_input)
+            if choice in {'s', ''}:
+                return "skip"
+            elif choice == 'u':
+                return "update"
+            elif choice == 'c':
+                return "create"
+            else:
+                logger.error("无效输入，请重新选择。")
+
 # This will be implemented in a separate file to avoid circular dependencies with GUI components
 # class GuiInteractionProvider(InteractionProvider):
 #     ...