ksaa 2025.11b1__py3-none-any.whl → 2025.11.post1__py3-none-any.whl

kaa/application/ui/facade.py

@@ -0,0 +1,189 @@
+import logging
+import os
+import zipfile
+from datetime import datetime
+from typing import Any, Dict, List, Tuple
+
+from kaa.main.kaa import Kaa
+from kaa.application.services.config_service import ConfigService, ConfigValidationError
+from kaa.application.services.produce_solution_service import ProduceSolutionService
+from kaa.application.services.task_service import TaskService
+from kaa.application.services.update_service import UpdateService
+from kaa.application.services.feedback_service import FeedbackService
+from kaa.application.core.idle_mode import IdleModeManager
+from kaa.config.produce import ProduceSolution
+from kotonebot.errors import ContextNotInitializedError
+
+logger = logging.getLogger(__name__)
+
+class KaaFacade:
+    """
+    The Facade provides a simplified interface to the application's core services,
+    acting as a single bridge between the UI (View) and the business logic (Services).
+    It orchestrates service interactions and manages application state flow.
+    """
+
+    def __init__(self, kaa_instance: Kaa):
+        # Core services
+        self.config_service = ConfigService()
+        self.produce_solution_service = ProduceSolutionService()
+        self.task_service = TaskService(kaa_instance)
+
+        # Other existing services
+        self.update_service = UpdateService()
+        self.feedback_service = FeedbackService()
+        self.idle_mgr = self._setup_idle_manager()
+
+        self._kaa = kaa_instance
+
+    def _setup_idle_manager(self) -> IdleModeManager:
+        """Initializes and configures the IdleModeManager."""
+
+        def is_task_running():
+            try:
+                return self.task_service.is_running() and not self.task_service.is_stopping
+            except ContextNotInitializedError:
+                return False
+
+        def is_task_paused():
+            try:
+                status = self.task_service.get_pause_status()
+                return status is True
+            except ContextNotInitializedError:
+                return False
+
+        return IdleModeManager(
+            get_is_running=is_task_running,
+            get_is_paused=is_task_paused,
+            get_config=lambda: self.config_service.get_options().idle,
+        )
+
+    # --- Task Control ---
+
+    def start_all_tasks(self):
+        """Starts all tasks and notifies the idle manager."""
+        self.task_service.start_all_tasks()
+        self.idle_mgr.notify_on_start()
+
+    def stop_all_tasks(self):
+        """Stops all running tasks and notifies the idle manager."""
+        self.task_service.stop_tasks()
+        self.idle_mgr.notify_on_stop()
+
+    def get_run_status(self) -> Dict[str, Any]:
+        """
+        Gets the comprehensive status for the main run button.
+        :return: A dictionary with 'text' and 'interactive' keys for the button.
+        """
+        tcs = self.task_service
+        if not tcs.is_running_all:
+            return {"text": "启动", "interactive": True}
+        if tcs.is_stopping:
+            return {"text": "停止中...", "interactive": False}
+        return {"text": "停止", "interactive": True}
+
+    def get_task_statuses(self) -> List[Tuple[str, str]]:
+        """Gets a list of all tasks and their current statuses."""
+        return self.task_service.get_task_statuses()
+
+    def toggle_pause(self) -> bool | None:
+        """Toggles the pause/resume state of tasks."""
+        return self.task_service.toggle_pause()
+
+    def get_pause_button_status(self) -> Dict[str, Any]:
+        """
+
+        Gets the status for the pause button.
+        :return: A dictionary with 'text' and 'interactive' keys for the button.
+        """
+        pause_status = self.task_service.get_pause_status()
+        is_paused = pause_status is True
+        is_stoppable = not self.task_service.is_stopping
+        can_pause = self.task_service.is_running() and is_stoppable
+
+        return {
+            "text": "恢复" if is_paused else "暂停",
+            "interactive": can_pause,
+        }
+
+    def get_task_runtime(self) -> str:
+        """
+        Gets the current task runtime as a formatted string.
+        :return: A string representing the runtime (e.g., "00:05:23"), or "未运行" if no task is running.
+        """
+        runtime = self.task_service.get_task_runtime()
+        if runtime is None:
+            return "未运行"
+        
+        total_seconds = int(runtime.total_seconds())
+        hours = total_seconds // 3600
+        minutes = (total_seconds % 3600) // 60
+        seconds = total_seconds % 60
+        return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+
+    # --- Configuration ---
+
+    def get_all_configs(self) -> Tuple[Any, Any]:
+        """
+        Gets all configuration objects.
+        :return: A tuple of (root_config, current_user_config).
+        """
+        return self.config_service.get_root_config(), self.config_service.get_current_user_config()
+
+    def save_configs(self):
+        """
+        Saves the current configuration and re-initializes Kaa.
+        The UI is responsible for updating the config object in ConfigService before calling this.
+        """
+        try:
+            self.config_service.save()
+            logger.info("Configuration saved and Kaa re-initialized.")
+            return "设置已保存并应用！"
+        except ConfigValidationError as e:
+            logger.warning(f"Configuration validation failed: {e}")
+            raise  # Re-raise for the view to handle
+        except Exception as e:
+            logger.error(f"Failed to save or reload config: {e}", exc_info=True)
+            raise RuntimeError("设置已保存，但重新加载失败，请重启程序。") from e
+
+    # --- Produce Solutions ---
+
+    def list_produce_solutions(self) -> List[ProduceSolution]:
+        """Lists all produce solutions."""
+        return self.produce_solution_service.list_solutions()
+
+    def get_produce_solution(self, solution_id: str) -> ProduceSolution:
+        """Gets a single produce solution by ID."""
+        return self.produce_solution_service.get_solution(solution_id)
+
+    def create_produce_solution(self, name: str) -> ProduceSolution:
+        """Creates a new produce solution."""
+        return self.produce_solution_service.create_solution(name)
+
+    def delete_produce_solution(self, solution_id: str):
+        """Deletes a produce solution."""
+        # Prevent deleting the currently selected solution
+        selected_id = self.config_service.get_options().produce.selected_solution_id
+        if solution_id == selected_id:
+            raise ValueError("不可删除当前正在使用的培育方案。")
+        self.produce_solution_service.delete_solution(solution_id)
+
+    def save_produce_solution(self, solution: ProduceSolution):
+        """Saves a produce solution."""
+        self.produce_solution_service.save_solution(solution)
+
+    # --- Misc ---
+    def export_logs_as_zip(self) -> str:
+        # This logic was in gr.py, moving it here.
+        # It doesn't neatly fit a service, but facade is ok for now.
+        if not os.path.exists('logs'):
+            return "logs 文件夹不存在"
+        timestamp = datetime.now().strftime('%y-%m-%d-%H-%M-%S')
+        zip_filename = f'logs-{timestamp}.zip'
+        with zipfile.ZipFile(zip_filename, 'w', zipfile.ZIP_DEFLATED, compresslevel=9) as zipf:
+            for root, _, files in os.walk('logs'):
+                for file in files:
+                    file_path = os.path.join(root, file)
+                    arcname = os.path.relpath(file_path, 'logs')
+                    zipf.write(file_path, arcname)
+        return f"已导出到 {zip_filename}"

kaa/application/ui/gradio_view.py

@@ -0,0 +1,135 @@
+import logging
+import gradio as gr
+
+from kaa.application.ui.facade import KaaFacade
+from kaa.application.ui.common import GradioComponents, ConfigBuilderReturnValue
+from kaa.application.ui.views.status_view import StatusView
+from kaa.application.ui.views.task_view import TaskView
+from kaa.application.ui.views.produce_view import ProduceView
+from kaa.application.ui.views.settings_view import SettingsView
+from kaa.application.ui.views.feedback_view import FeedbackView
+from kaa.application.ui.views.update_view import UpdateView
+
+logger = logging.getLogger(__name__)
+
+class KaaGradioView:
+    """
+    The View layer for the kaa application, responsible for rendering the UI
+    and delegating all user actions to the Facade.
+    """
+
+    def __init__(self, facade: KaaFacade):
+        self.facade = facade
+        # A dataclass to hold all UI components that need to be accessed later
+        self.components = GradioComponents()
+        # A list to hold all the config builder return values for the save function
+        self.config_builders: list[ConfigBuilderReturnValue] = []
+
+        # Initialize sub-views
+        self.status_view = StatusView(facade, self.components)
+        self.task_view = TaskView(facade, self.components)
+        self.produce_view = ProduceView(facade, self.components)
+        self.settings_view = SettingsView(facade, self.components, self.config_builders)
+        self.feedback_view = FeedbackView(facade, self.components)
+        self.update_view = UpdateView(facade, self.components)
+
+    def create_ui(self) -> gr.Blocks:
+        """
+        Builds the entire Gradio UI and returns the final Blocks object.
+        """
+        with gr.Blocks(title=f"琴音小助手 v{self.facade._kaa.version}") as blocks:
+            self._create_header()
+            with gr.Tabs() as tabs:
+                self.components.tabs = tabs
+                with gr.Tab("状态", id="status"):
+                    self.status_view.create_ui()
+                with gr.Tab("任务", id="tasks"):
+                    self.task_view.create_ui()
+                with gr.Tab("设置", id="settings"):
+                    self.settings_view.create_ui()
+                with gr.Tab("方案", id="produce"):
+                    self.produce_view.create_ui()
+                with gr.Tab("反馈", id="feedback"):
+                    self.feedback_view.create_ui()
+                # Update tab is created inside the view itself because it's a single tab
+                self.update_view.create_ui()
+
+            self._setup_timers()
+        return blocks
+
+    
+    def _create_header(self):
+        gr.Markdown(f"# 琴音小助手 v{self.facade._kaa.version}")
+
+    def _setup_timers(self):
+        """Sets up all the UI polling timers."""
+
+        # Timer for run/pause buttons
+        def update_run_buttons():
+            run_status = self.facade.get_run_status()
+            pause_status = self.facade.get_pause_button_status()
+            return {
+                self.components.run_btn: gr.Button(value=run_status['text'], interactive=run_status['interactive']),
+                self.components.pause_btn: gr.Button(value=pause_status['text'], interactive=pause_status['interactive']),
+            }
+        gr.Timer(1.0).tick(
+            fn=update_run_buttons,
+            outputs=[self.components.run_btn, self.components.pause_btn]
+        )
+
+        # Timer for task status dataframe
+        def update_task_status_df():
+            statuses = self.facade.get_task_statuses()
+            # Convert status keys to display text
+            status_map = {
+                'pending': '等待中', 'running': '运行中', 'finished': '已完成',
+                'error': '出错', 'cancelled': '已取消'
+            }
+            display_statuses = [[name, status_map.get(status, '未知')] for name, status in statuses]
+            return gr.Dataframe(value=display_statuses)
+
+        gr.Timer(1.0).tick(
+            fn=update_task_status_df,
+            outputs=[self.components.task_status_df]
+        )
+
+        # Timer for task runtime
+        def update_task_runtime():
+            runtime_str = self.facade.get_task_runtime()
+            return gr.Textbox(value=runtime_str)
+
+        gr.Timer(1.0).tick(
+            fn=update_task_runtime,
+            outputs=[self.components.task_runtime_text]
+        )
+        
+        # Timer for quick-setting checkboxes
+        def update_quick_checkboxes():
+            opts = self.facade.config_service.get_options()
+            
+            end_game_opts = opts.end_game
+            if end_game_opts.shutdown:
+                end_action_val = "完成后关机"
+            elif end_game_opts.hibernate:
+                end_action_val = "完成后休眠"
+            else:
+                end_action_val = "完成后什么都不做"
+
+            return {
+                self.components.quick_checkboxes[0]: gr.Checkbox(value=opts.purchase.enabled),
+                self.components.quick_checkboxes[1]: gr.Checkbox(value=opts.assignment.enabled),
+                self.components.quick_checkboxes[2]: gr.Checkbox(value=opts.contest.enabled),
+                self.components.quick_checkboxes[3]: gr.Checkbox(value=opts.produce.enabled),
+                self.components.quick_checkboxes[4]: gr.Checkbox(value=opts.mission_reward.enabled),
+                self.components.quick_checkboxes[5]: gr.Checkbox(value=opts.club_reward.enabled),
+                self.components.quick_checkboxes[6]: gr.Checkbox(value=opts.activity_funds.enabled),
+                self.components.quick_checkboxes[7]: gr.Checkbox(value=opts.presents.enabled),
+                self.components.quick_checkboxes[8]: gr.Checkbox(value=opts.capsule_toys.enabled),
+                self.components.quick_checkboxes[9]: gr.Checkbox(value=opts.upgrade_support_card.enabled),
+                self.components.end_action_dropdown: gr.Dropdown(value=end_action_val),
+            }
+
+        gr.Timer(2.0).tick(
+            fn=update_quick_checkboxes,
+            outputs=self.components.quick_checkboxes + [self.components.end_action_dropdown]
+        )

kaa/application/ui/views/feedback_view.py

@@ -0,0 +1,65 @@
+import gradio as gr
+from typing import Dict, Any
+from functools import partial
+from kaa.application.ui.facade import KaaFacade
+from kaa.application.ui.common import GradioComponents
+from kaa.errors import FeedbackServiceError
+
+class FeedbackView:
+    def __init__(self, facade: KaaFacade, components: GradioComponents):
+        self.facade = facade
+        self.components = components
+
+    def create_ui(self) -> None:
+        gr.Markdown("## 反馈")
+        gr.Markdown('脚本报错或者卡住？在这里填写信息可以快速反馈！')
+        with gr.Column():
+            report_title = gr.Textbox(label="标题", placeholder="用一句话概括问题")
+            report_type = gr.Dropdown(label="反馈类型", choices=["bug"], value="bug", interactive=False)
+            report_description = gr.Textbox(label="描述", lines=5, placeholder="详细描述问题。例如：什么时候出错、是否每次都出错、出错时的步骤是什么")
+            with gr.Row():
+                upload_report_btn = gr.Button("上传")
+                save_local_report_btn = gr.Button("保存至本地")
+
+            result_text = gr.Markdown("等待操作\n\n\n")
+
+        def create_report(title: str, description: str, upload: bool, progress=gr.Progress()):
+            
+            def on_progress(data: Dict[str, Any]):
+                progress_val = data['step'] / data['total_steps']
+                if data['type'] == 'packing':
+                    desc = f"({data['step']}/{data['total_steps']}) 正在打包 {data['item']}"
+                elif data['type'] == 'uploading':
+                    desc = f"({data['step']}/{data['total_steps']}) 正在上传 {data['item']}"
+                elif data['type'] == 'done':
+                    if 'url' in data:
+                        desc = "上传完成"
+                    else:
+                        desc = "已保存至本地"
+                else:
+                    desc = "正在处理..."
+                progress(progress_val, desc=desc)
+
+            try:
+                result = self.facade.feedback_service.report(
+                    title=title,
+                    description=description,
+                    version=self.facade._kaa.version,
+                    upload=upload,
+                    on_progress=on_progress
+                )
+                return result.message
+            except FeedbackServiceError as e:
+                gr.Error(str(e))
+                return f"### 操作失败\n\n{e}"
+
+        upload_report_btn.click(
+            fn=partial(create_report, upload=True),
+            inputs=[report_title, report_description],
+            outputs=[result_text]
+        )
+        save_local_report_btn.click(
+            fn=partial(create_report, upload=False),
+            inputs=[report_title, report_description],
+            outputs=[result_text]
+        )

kaa/application/ui/views/produce_view.py

@@ -0,0 +1,251 @@
+import gradio as gr
+from kaa.application.ui.components.alert import Alert
+from kaa.application.ui.facade import KaaFacade
+from kaa.application.ui.common import GradioComponents
+from kaa.config.produce import ProduceData, ProduceSolution
+from kaa.config.const import ProduceAction, RecommendCardDetectionMode
+from kaa.db.idol_card import IdolCard
+
+class ProduceView:
+    def __init__(self, facade: KaaFacade, components: GradioComponents):
+        self.facade = facade
+        self.components = components
+
+    def create_ui(self):
+        """Creates the content for the 'Produce' tab for managing solutions."""
+        gr.Markdown("## 培育方案管理")
+
+        solutions = self.facade.list_produce_solutions()
+        solution_choices = [(f"{sol.name}{f' - {sol.description}' if sol.description else ''}", sol.id) for sol in solutions]
+
+        solution_dropdown = gr.Dropdown(
+            choices=solution_choices,
+            value=None,
+            label="选择培育方案",
+            interactive=True
+        )
+        self.components.produce_tab_solution_dropdown = solution_dropdown
+
+        with gr.Row():
+            new_solution_btn = gr.Button("新建培育", scale=1)
+            delete_solution_btn = gr.Button("删除当前培育", scale=1)
+
+        # Solution details group
+        with gr.Group(visible=False) as solution_settings_group:
+            self.components.produce_solution_settings_group = solution_settings_group
+            
+            solution_name = gr.Textbox(label="方案名称", interactive=True)
+            self.components.produce_solution_name = solution_name
+            
+            solution_description = gr.Textbox(label="方案描述", interactive=True)
+            self.components.produce_solution_description = solution_description
+            
+            produce_mode = gr.Dropdown(choices=["regular", "pro", "master"], label="培育模式", interactive=True)
+            self.components.produce_mode = produce_mode
+            
+            idol_choices = [(f'{idol.name}{f" 「{idol.another_name}」" if idol.is_another and idol.another_name else ""}', idol.skin_id) for idol in IdolCard.all()]
+            produce_idols = gr.Dropdown(choices=idol_choices, label="选择要培育的偶像", multiselect=False, interactive=True)
+            self.components.produce_idols = produce_idols
+
+            auto_set_memory = gr.Checkbox(label="自动编成回忆", interactive=True)
+            self.components.produce_auto_set_memory = auto_set_memory
+            
+            with gr.Group() as memory_sets_group:
+                self.components.produce_memory_sets_group = memory_sets_group
+                memory_sets = gr.Dropdown(choices=[str(i) for i in range(1, 21)], label="回忆编成编号", multiselect=False, interactive=True)
+                self.components.produce_memory_sets = memory_sets
+            
+            auto_set_support = gr.Checkbox(label="自动编成支援卡", interactive=True)
+            self.components.produce_auto_set_support = auto_set_support
+
+            Alert('目前只能自动编成支援卡，无论是否勾选“自动编成支援卡”', variant="info")
+            
+            with gr.Group() as support_card_sets_group:
+                self.components.produce_support_card_sets_group = support_card_sets_group
+                support_card_sets = gr.Dropdown(choices=[str(i) for i in range(1, 21)], label="支援卡编成编号", multiselect=False, interactive=True)
+                self.components.produce_support_card_sets = support_card_sets
+
+            use_pt_boost = gr.Checkbox(label="使用支援强化 Pt 提升", interactive=True)
+            self.components.produce_use_pt_boost = use_pt_boost
+            
+            use_note_boost = gr.Checkbox(label="使用笔记数提升", interactive=True)
+            self.components.produce_use_note_boost = use_note_boost
+            
+            follow_producer = gr.Checkbox(label="关注租借了支援卡的制作人", interactive=True)
+            self.components.produce_follow_producer = follow_producer
+            
+            self_study_lesson = gr.Dropdown(choices=['dance', 'visual', 'vocal'], label='文化课自习时选项', interactive=True)
+            self.components.produce_self_study_lesson = self_study_lesson
+            
+            prefer_lesson_ap = gr.Checkbox(label="SP 课程优先", interactive=True)
+            self.components.produce_prefer_lesson_ap = prefer_lesson_ap
+            
+            actions_order = gr.Dropdown(
+                choices=[(action.display_name, action.value) for action in ProduceAction],
+                label="行动优先级", multiselect=True, interactive=True
+            )
+            self.components.produce_actions_order = actions_order
+            
+            recommend_card_detection_mode = gr.Dropdown(
+                choices=[(mode.display_name, mode.value) for mode in RecommendCardDetectionMode],
+                label="推荐卡检测模式", interactive=True
+            )
+            self.components.produce_recommend_card_detection_mode = recommend_card_detection_mode
+            
+            use_ap_drink = gr.Checkbox(label="AP 不足时自动使用 AP 饮料", interactive=True)
+            self.components.produce_use_ap_drink = use_ap_drink
+            
+            skip_commu = gr.Checkbox(label="检测并跳过交流", interactive=True)
+            self.components.produce_skip_commu = skip_commu
+            @gr.render([skip_commu])
+            def _tip(skip):
+                if not skip: return
+                Alert(
+                    variant="warning",
+                    value="建议关闭此处设置，转而开启游戏内快进所有交流，效果更佳。",
+                )
+
+            save_solution_btn = gr.Button("保存培育方案", variant="primary")
+
+        # --- Event Handlers ---
+        
+        all_detail_components = [
+            solution_settings_group, solution_name, solution_description, produce_mode, produce_idols,
+            auto_set_memory, memory_sets_group, memory_sets, auto_set_support, support_card_sets_group,
+            support_card_sets, use_pt_boost, use_note_boost, follow_producer, self_study_lesson,
+            prefer_lesson_ap, actions_order, recommend_card_detection_mode, use_ap_drink, skip_commu
+        ]
+        self.components.produce_all_detail_components = all_detail_components
+
+        def on_new_solution():
+            """Creates a new solution and refreshes the dropdowns."""
+            new_solution = self.facade.create_produce_solution("新培育方案")
+            solutions = self.facade.list_produce_solutions()
+            choices = [(f"{s.name}{f' - {s.description}' if s.description else ''}", s.id) for s in solutions]
+            gr.Success("新培育方案创建成功")
+            # TODO: 创建一个 state 用于记录当前选中的培育 id
+            # Return an update for the solution dropdown (use gr.update for better typing)
+            return gr.update(choices=choices, value=new_solution.id)
+
+        def on_delete_solution(solution_id):
+            """Deletes the selected solution and refreshes dropdowns."""
+            if not solution_id:
+                gr.Warning("请先选择要删除的培育方案")
+                # No change to dropdown
+                return gr.update()
+            try:
+                self.facade.delete_produce_solution(solution_id)
+                solutions = self.facade.list_produce_solutions()
+                choices = [(f"{s.name}{f' - {s.description}' if s.description else ''}", s.id) for s in solutions]
+                gr.Success("培育方案删除成功")
+                return gr.update(choices=choices, value=None)
+            except ValueError as e:
+                gr.Warning(str(e))
+                return gr.update()
+            except Exception as e:
+                gr.Error(f"删除失败: {e}")
+                return gr.update()
+        
+        def on_save_solution(solution_id, name, desc, mode, idol, auto_mem, mem_set, auto_sup, sup_set, pt_boost, note_boost, follow, study, pref_ap, actions, detect_mode, ap_drink, skip):
+            if not solution_id:
+                gr.Warning("没有选择要保存的方案")
+                return gr.update()
+            try:
+                produce_data = ProduceData(
+                    mode=mode, idol=idol,
+                    auto_set_memory=auto_mem, memory_set=int(mem_set) if mem_set else None,
+                    auto_set_support_card=auto_sup, support_card_set=int(sup_set) if sup_set else None,
+                    use_pt_boost=pt_boost, use_note_boost=note_boost, follow_producer=follow,
+                    self_study_lesson=study, prefer_lesson_ap=pref_ap,
+                    actions_order=[ProduceAction(a) for a in actions],
+                    recommend_card_detection_mode=RecommendCardDetectionMode(detect_mode),
+                    use_ap_drink=ap_drink, skip_commu=skip
+                )
+                solution = ProduceSolution(id=solution_id, name=name, description=desc, data=produce_data)
+                self.facade.save_produce_solution(solution)
+                gr.Success("培育方案保存成功")
+                # Refresh dropdowns to reflect name/desc changes
+                solutions = self.facade.list_produce_solutions()
+                choices = [(f"{s.name} - {s.description or '无描述'}", s.id) for s in solutions]
+                return gr.update(choices=choices, value=solution_id)
+            except Exception as e:
+                gr.Error(f"保存失败: {e}")
+                return gr.update()
+
+
+        # --- UI Callbacks ---
+        
+        solution_dropdown.change(
+            fn=self.update_produce_solution_details,
+            inputs=[solution_dropdown],
+            outputs=all_detail_components
+        )
+
+        auto_set_memory.change(fn=lambda x: gr.update(visible=not x), inputs=[auto_set_memory], outputs=[memory_sets_group])
+        auto_set_support.change(fn=lambda x: gr.update(visible=not x), inputs=[auto_set_support], outputs=[support_card_sets_group])
+
+        new_solution_btn.click(fn=on_new_solution, outputs=[solution_dropdown])
+        delete_solution_btn.click(fn=on_delete_solution, inputs=[solution_dropdown], outputs=[solution_dropdown])
+
+        save_inputs = [
+            solution_dropdown, solution_name, solution_description, produce_mode, produce_idols,
+            auto_set_memory, memory_sets, auto_set_support, support_card_sets,
+            use_pt_boost, use_note_boost, follow_producer, self_study_lesson,
+            prefer_lesson_ap, actions_order, recommend_card_detection_mode,
+            use_ap_drink, skip_commu
+        ]
+        save_solution_btn.click(fn=on_save_solution, inputs=save_inputs, outputs=[solution_dropdown])
+
+    def update_produce_solution_details(self, solution_id: str):
+        """Updates the produce solution detail view when the selected solution changes."""
+        if not solution_id:
+            # Return a default/empty state for all components in the form
+            return {
+                self.components.produce_solution_settings_group: gr.Group(visible=False),
+                self.components.produce_solution_name: gr.Textbox(value=""),
+                self.components.produce_solution_description: gr.Textbox(value=""),
+                self.components.produce_mode: gr.Dropdown(value=None),
+                self.components.produce_idols: gr.Dropdown(value=None),
+                self.components.produce_auto_set_memory: gr.Checkbox(value=False),
+                self.components.produce_memory_sets_group: gr.Group(visible=True),
+                self.components.produce_memory_sets: gr.Dropdown(value=None),
+                self.components.produce_auto_set_support: gr.Checkbox(value=False),
+                self.components.produce_support_card_sets_group: gr.Group(visible=True),
+                self.components.produce_support_card_sets: gr.Dropdown(value=None),
+                self.components.produce_use_pt_boost: gr.Checkbox(value=False),
+                self.components.produce_use_note_boost: gr.Checkbox(value=False),
+                self.components.produce_follow_producer: gr.Checkbox(value=False),
+                self.components.produce_self_study_lesson: gr.Dropdown(value=None),
+                self.components.produce_prefer_lesson_ap: gr.Checkbox(value=False),
+                self.components.produce_actions_order: gr.Dropdown(value=[]),
+                self.components.produce_recommend_card_detection_mode: gr.Dropdown(value=None),
+                self.components.produce_use_ap_drink: gr.Checkbox(value=False),
+                self.components.produce_skip_commu: gr.Checkbox(value=False),
+            }
+        try:
+            solution = self.facade.get_produce_solution(solution_id)
+            return {
+                self.components.produce_solution_settings_group: gr.Group(visible=True),
+                self.components.produce_solution_name: gr.Textbox(value=solution.name),
+                self.components.produce_solution_description: gr.Textbox(value=solution.description),
+                self.components.produce_mode: gr.Dropdown(value=solution.data.mode),
+                self.components.produce_idols: gr.Dropdown(value=solution.data.idol),
+                self.components.produce_auto_set_memory: gr.Checkbox(value=solution.data.auto_set_memory),
+                self.components.produce_memory_sets_group: gr.Group(visible=not solution.data.auto_set_memory),
+                self.components.produce_memory_sets: gr.Dropdown(value=str(solution.data.memory_set) if solution.data.memory_set else None),
+                self.components.produce_auto_set_support: gr.Checkbox(value=solution.data.auto_set_support_card),
+                self.components.produce_support_card_sets_group: gr.Group(visible=not solution.data.auto_set_support_card),
+                self.components.produce_support_card_sets: gr.Dropdown(value=str(solution.data.support_card_set) if solution.data.support_card_set else None),
+                self.components.produce_use_pt_boost: gr.Checkbox(value=solution.data.use_pt_boost),
+                self.components.produce_use_note_boost: gr.Checkbox(value=solution.data.use_note_boost),
+                self.components.produce_follow_producer: gr.Checkbox(value=solution.data.follow_producer),
+                self.components.produce_self_study_lesson: gr.Dropdown(value=solution.data.self_study_lesson),
+                self.components.produce_prefer_lesson_ap: gr.Checkbox(value=solution.data.prefer_lesson_ap),
+                self.components.produce_actions_order: gr.Dropdown(value=[action.value for action in solution.data.actions_order]),
+                self.components.produce_recommend_card_detection_mode: gr.Dropdown(value=solution.data.recommend_card_detection_mode.value),
+                self.components.produce_use_ap_drink: gr.Checkbox(value=solution.data.use_ap_drink),
+                self.components.produce_skip_commu: gr.Checkbox(value=solution.data.skip_commu),
+            }
+        except Exception as e:
+            gr.Error(f"加载培育方案失败: {e}")
+            return {self.components.produce_solution_settings_group: gr.Group(visible=False)}