Create analytics_handlers.py

services/analytics_handlers.py

@@ -0,0 +1,736 @@
+# handlers/analytics_handlers.py
+import gradio as gr
+import logging
+import time
+from ui.analytics_plot_generator import update_analytics_plots_figures, create_placeholder_plot
+from ui.ui_generators import BOMB_ICON, EXPLORE_ICON, FORMULA_ICON, ACTIVE_ICON # Make sure these are accessible
+from features.chatbot.chatbot_prompts import get_initial_insight_prompt_and_suggestions
+from features.chatbot.chatbot_handler import generate_llm_response
+from config import PLOT_ID_TO_FORMULA_KEY_MAP # Ensure this is correctly imported from your config
+from formulas import PLOT_FORMULAS # Ensure this is correctly imported
+
+class AnalyticsHandlers:
+    """Handles all analytics tab events and interactions."""
+    
+    def __init__(self, analytics_components, token_state_ref, chat_histories_st_ref, 
+                 current_chat_plot_id_st_ref, plot_data_for_chatbot_st_ref,
+                 active_panel_action_state_ref, explored_plot_id_state_ref):
+        self.components = analytics_components
+        self.plot_configs = analytics_components['plot_configs']
+        self.unique_ordered_sections = analytics_components['unique_ordered_sections']
+        self.num_unique_sections = len(self.unique_ordered_sections)
+        self.plot_ui_objects = analytics_components['plot_ui_objects'] # e.g. {'plot_id1': {'panel_component': gr.Plot, 'bomb_button': gr.Button, ...}}
+        self.section_titles_map = analytics_components['section_titles_map'] # e.g. {'Section Name': gr.Markdown}
+
+        # References to global states, these are gr.State objects themselves
+        self.token_state = token_state_ref
+        self.chat_histories_st = chat_histories_st_ref
+        self.current_chat_plot_id_st = current_chat_plot_id_st_ref
+        self.plot_data_for_chatbot_st = plot_data_for_chatbot_st_ref
+        self.active_panel_action_state = active_panel_action_state_ref
+        self.explored_plot_id_state = explored_plot_id_state_ref
+        
+        logging.info(f"AnalyticsHandlers initialized. {len(self.plot_configs)} plot configs, {self.num_unique_sections} unique sections.")
+        if not self.plot_ui_objects:
+            logging.warning("AnalyticsHandlers: plot_ui_objects is empty or not correctly passed.")
+        if not self.section_titles_map:
+            logging.warning("AnalyticsHandlers: section_titles_map is empty or not correctly passed.")
+
+
+    def _get_graph_refresh_outputs_list(self):
+        """Helper to construct the list of outputs for graph refresh actions."""
+        outputs = [self.components['analytics_status_md']]
+        
+        # Plot components themselves
+        for pc in self.plot_configs:
+            plot_component = self.plot_ui_objects.get(pc["id"], {}).get("plot_component")
+            if plot_component:
+                outputs.append(plot_component)
+            else:
+                outputs.append(gr.update()) # Placeholder if not found
+                logging.warning(f"Plot component for {pc['id']} not found in plot_ui_objects for refresh outputs.")
+
+        # UI resets for action panel
+        outputs.extend([
+            self.components['global_actions_column_ui'],
+            self.components['insights_chatbot_ui'], # For value reset
+            self.components['insights_chat_input_ui'], # For value reset
+            self.components['insights_suggestions_row_ui'],
+            self.components['insights_suggestion_1_btn'],
+            self.components['insights_suggestion_2_btn'],
+            self.components['insights_suggestion_3_btn'],
+            self.components['formula_display_markdown_ui'], # For value reset
+            self.components['formula_close_hint_md']
+        ])
+        
+        # State resets
+        outputs.extend([
+            self.active_panel_action_state,
+            self.current_chat_plot_id_st,
+            self.chat_histories_st,
+            self.plot_data_for_chatbot_st 
+        ])
+        
+        # Button and panel visibility resets for each plot
+        for pc in self.plot_configs:
+            plot_id = pc["id"]
+            ui_obj = self.plot_ui_objects.get(plot_id, {})
+            outputs.extend([
+                ui_obj.get("bomb_button", gr.update()),
+                ui_obj.get("formula_button", gr.update()),
+                ui_obj.get("explore_button", gr.update()),
+                ui_obj.get("panel_component", gr.update()) # For visibility reset
+            ])
+            
+        outputs.append(self.explored_plot_id_state) # Reset explored state
+
+        # Section title visibility resets
+        for s_name in self.unique_ordered_sections:
+            outputs.append(self.section_titles_map.get(s_name, gr.update()))
+            
+        expected_len = 1 + len(self.plot_configs) + 9 + 4 + (4 * len(self.plot_configs)) + 1 + self.num_unique_sections
+        # 1 (status) + N_plots (plots) + 9 (action panel UI) + 4 (states) + 4*N_plots (plot buttons/panels) + 1 (explored_id_state) + N_sections (titles)
+        logging.debug(f"Graph refresh outputs list length: {len(outputs)}, Expected: {expected_len}")
+        return outputs
+
+    async def refresh_analytics_graphs_ui(self, current_token_state_val, date_filter_val, 
+                                          custom_start_val, custom_end_val, 
+                                          # chat_histories_st is a state, its value will be accessed via self.chat_histories_st.value
+                                          ):
+        logging.info(f"Refreshing analytics graph UI. Filter: {date_filter_val}. Token set: {'yes' if current_token_state_val.get('token') else 'no'}")
+        start_time = time.time()
+
+        # Call the function that generates plot figures and summaries
+        # Ensure update_analytics_plots_figures is adapted to return:
+        # status_msg (str), figures_dict (dict: {plot_id: fig}), summaries_dict (dict: {plot_id: summary_text})
+        plot_gen_results = update_analytics_plots_figures(
+            current_token_state_val, 
+            date_filter_val, 
+            custom_start_val, 
+            custom_end_val, 
+            self.plot_configs # Pass plot_configs to it
+        )
+        # Expected: status_msg, list_of_figures, dict_of_plot_summaries
+        # Original: status_msg, gen_figs (list), new_summaries (dict)
+
+        status_msg = plot_gen_results[0]
+        gen_figs_list = plot_gen_results[1] # This should be a list of figures in order of plot_configs
+        new_summaries_dict = plot_gen_results[2] # This should be a dict {plot_id: summary}
+
+        all_updates = [gr.update(value=status_msg)] # For analytics_status_md
+
+        # Update plot components with new figures
+        if len(gen_figs_list) == len(self.plot_configs):
+            for fig in gen_figs_list:
+                all_updates.append(fig) # fig itself is the update for gr.Plot
+        else:
+            logging.error(f"Figure list length mismatch: got {len(gen_figs_list)}, expected {len(self.plot_configs)}")
+            for _ in self.plot_configs:
+                all_updates.append(create_placeholder_plot("Error", "Figura mancante"))
+
+        # Reset action panel UI elements
+        all_updates.extend([
+            gr.update(visible=False),  # global_actions_column_ui
+            gr.update(value=[], visible=False),  # insights_chatbot_ui (value and visibility)
+            gr.update(value="", visible=False),  # insights_chat_input_ui (value and visibility)
+            gr.update(visible=False),  # insights_suggestions_row_ui
+            gr.update(value="S1"),  # insights_suggestion_1_btn
+            gr.update(value="S2"),  # insights_suggestion_2_btn
+            gr.update(value="S3"),  # insights_suggestion_3_btn
+            gr.update(value="Formula details here.", visible=False),  # formula_display_markdown_ui
+            gr.update(visible=False)  # formula_close_hint_md
+        ])
+        
+        # Reset states
+        all_updates.extend([
+            None,  # active_panel_action_state
+            None,  # current_chat_plot_id_st
+            {},    # chat_histories_st (reset to empty dict)
+            new_summaries_dict # plot_data_for_chatbot_st (update with new summaries)
+        ])
+        
+        # Reset buttons and panel visibility for each plot
+        for _ in self.plot_configs:
+            all_updates.extend([
+                gr.update(value=BOMB_ICON),      # bomb_button
+                gr.update(value=FORMULA_ICON),   # formula_button
+                gr.update(value=EXPLORE_ICON),   # explore_button
+                gr.update(visible=True)          # panel_component (plot visibility)
+            ])
+            
+        all_updates.append(None) # explored_plot_id_state (reset)
+
+        # Reset section title visibility
+        for _ in self.unique_ordered_sections:
+            all_updates.append(gr.update(visible=True))
+            
+        end_time = time.time()
+        logging.info(f"Analytics graph refresh processing took {end_time - start_time:.2f} seconds.")
+        
+        expected_len = 1 + len(self.plot_configs) + 9 + 4 + (4 * len(self.plot_configs)) + 1 + self.num_unique_sections
+        logging.info(f"Prepared {len(all_updates)} updates for graph refresh. Expected {expected_len}.")
+        if len(all_updates) != expected_len:
+            logging.error(f"Output length mismatch in refresh_analytics_graphs_ui. Got {len(all_updates)}, expected {expected_len}")
+            # Pad with gr.update() if lengths don't match, to avoid Gradio errors, though this indicates a logic flaw.
+            all_updates.extend([gr.update()] * (expected_len - len(all_updates)))
+
+        return tuple(all_updates)
+
+    def _get_action_panel_outputs_list(self):
+        """Helper to construct the list of outputs for panel actions (insights, formula)."""
+        outputs = [
+            self.components['global_actions_column_ui'],
+            self.components['insights_chatbot_ui'], # For visibility
+            self.components['insights_chatbot_ui'], # For value
+            self.components['insights_chat_input_ui'],
+            self.components['insights_suggestions_row_ui'],
+            self.components['insights_suggestion_1_btn'],
+            self.components['insights_suggestion_2_btn'],
+            self.components['insights_suggestion_3_btn'],
+            self.components['formula_display_markdown_ui'], # For visibility
+            self.components['formula_display_markdown_ui'], # For value
+            self.components['formula_close_hint_md'],
+        ]
+        outputs.extend([
+            self.active_panel_action_state,
+            self.current_chat_plot_id_st,
+            self.chat_histories_st,
+            self.explored_plot_id_state 
+        ])
+        
+        for pc in self.plot_configs:
+            ui_obj = self.plot_ui_objects.get(pc["id"], {})
+            outputs.append(ui_obj.get("panel_component", gr.update())) # Plot panel visibility
+            outputs.append(ui_obj.get("bomb_button", gr.update()))
+            outputs.append(ui_obj.get("formula_button", gr.update()))
+            outputs.append(ui_obj.get("explore_button", gr.update()))
+
+        for s_name in self.unique_ordered_sections:
+            outputs.append(self.section_titles_map.get(s_name, gr.update())) # Section title visibility
+
+        expected_len = 11 + 4 + (4 * len(self.plot_configs)) + self.num_unique_sections
+        logging.debug(f"Action panel outputs list length: {len(outputs)}, Expected: {expected_len}")
+        return outputs
+
+    async def handle_panel_action(self, plot_id_clicked: str, action_type: str, 
+                                  current_active_action_from_state: dict, # This is a direct value from gr.State
+                                  current_chat_histories: dict,          # This is a direct value
+                                  current_chat_plot_id: str,             # This is a direct value
+                                  current_plot_data_for_chatbot: dict,   # This is a direct value
+                                  current_explored_plot_id: str          # This is a direct value
+                                 ):
+        logging.info(f"Panel Action: '{action_type}' for plot '{plot_id_clicked}'. Active: {current_active_action_from_state}, Explored: {current_explored_plot_id}")
+        
+        clicked_plot_config = next((p for p in self.plot_configs if p["id"] == plot_id_clicked), None)
+        if not clicked_plot_config:
+            logging.error(f"Config not found for plot_id {plot_id_clicked}")
+            # Construct a list of gr.update() of the correct length
+            num_outputs = len(self._get_action_panel_outputs_list())
+            error_updates = [gr.update()] * num_outputs
+            # Try to preserve existing state values if possible by updating specific indices
+            # This part is tricky without knowing the exact order and meaning of each output.
+            # For simplicity, returning all gr.update() might be safer if an error occurs early.
+            # Or, more robustly, identify which states need to be passed through.
+            # Indices for states in action_panel_outputs_list:
+            # active_panel_action_state is at index 11
+            # current_chat_plot_id_st is at index 12
+            # chat_histories_st is at index 13
+            # explored_plot_id_state is at index 14
+            error_updates[11] = current_active_action_from_state
+            error_updates[12] = current_chat_plot_id
+            error_updates[13] = current_chat_histories
+            error_updates[14] = current_explored_plot_id
+            return tuple(error_updates)
+
+        clicked_plot_label = clicked_plot_config["label"]
+        clicked_plot_section = clicked_plot_config["section"]
+        
+        hypothetical_new_active_state = {"plot_id": plot_id_clicked, "type": action_type}
+        is_toggling_off = current_active_action_from_state == hypothetical_new_active_state
+        
+        action_col_visible_update = gr.update(visible=False)
+        insights_chatbot_visible_update = gr.update(visible=False)
+        insights_chat_input_visible_update = gr.update(visible=False)
+        insights_suggestions_row_visible_update = gr.update(visible=False)
+        formula_display_visible_update = gr.update(visible=False)
+        formula_close_hint_visible_update = gr.update(visible=False)
+        
+        chatbot_content_update = gr.update()
+        s1_upd, s2_upd, s3_upd = gr.update(), gr.update(), gr.update()
+        formula_content_update = gr.update()
+        
+        new_active_action_state_to_set = None # This will be the new value for the gr.State
+        new_current_chat_plot_id = current_chat_plot_id # Default to existing
+        updated_chat_histories = current_chat_histories # Default to existing
+        new_explored_plot_id_to_set = current_explored_plot_id # Default to existing
+
+        generated_panel_vis_updates = [] # For individual plot panels
+        generated_bomb_btn_updates = []
+        generated_formula_btn_updates = []
+        generated_explore_btn_updates = []
+        section_title_vis_updates = [gr.update()] * self.num_unique_sections
+
+        if is_toggling_off:
+            new_active_action_state_to_set = None
+            action_col_visible_update = gr.update(visible=False)
+            logging.info(f"Toggling OFF panel {action_type} for {plot_id_clicked}.")
+
+            for _ in self.plot_configs:
+                generated_bomb_btn_updates.append(gr.update(value=BOMB_ICON))
+                generated_formula_btn_updates.append(gr.update(value=FORMULA_ICON))
+            
+            if current_explored_plot_id: # If an explore view is active, restore it
+                explored_cfg = next((p for p in self.plot_configs if p["id"] == current_explored_plot_id), None)
+                explored_sec = explored_cfg["section"] if explored_cfg else None
+                for i, sec_name in enumerate(self.unique_ordered_sections):
+                    section_title_vis_updates[i] = gr.update(visible=(sec_name == explored_sec))
+                for cfg in self.plot_configs:
+                    is_exp = (cfg["id"] == current_explored_plot_id)
+                    generated_panel_vis_updates.append(gr.update(visible=is_exp))
+                    generated_explore_btn_updates.append(gr.update(value=ACTIVE_ICON if is_exp else EXPLORE_ICON))
+            else: # No explore view, all plots/sections visible
+                for i in range(self.num_unique_sections):
+                    section_title_vis_updates[i] = gr.update(visible=True)
+                for _ in self.plot_configs:
+                    generated_panel_vis_updates.append(gr.update(visible=True))
+                    generated_explore_btn_updates.append(gr.update(value=EXPLORE_ICON))
+            
+            if action_type == "insights":
+                new_current_chat_plot_id = None # Clear chat context if insights panel is closed
+        
+        else: # Toggling ON a new action or switching actions
+            new_active_action_state_to_set = hypothetical_new_active_state
+            action_col_visible_update = gr.update(visible=True)
+            new_explored_plot_id_to_set = None # Cancel any explore view
+            logging.info(f"Toggling ON panel {action_type} for {plot_id_clicked}. Cancelling explore view if any.")
+
+            # Show only the section of the clicked plot
+            for i, sec_name in enumerate(self.unique_ordered_sections):
+                section_title_vis_updates[i] = gr.update(visible=(sec_name == clicked_plot_section))
+            
+            # Show only the clicked plot's panel, update explore buttons to non-active
+            for cfg in self.plot_configs:
+                generated_panel_vis_updates.append(gr.update(visible=(cfg["id"] == plot_id_clicked)))
+                generated_explore_btn_updates.append(gr.update(value=EXPLORE_ICON)) # Reset all explore to inactive
+
+            # Update bomb and formula buttons based on the new active action
+            for cfg_btn in self.plot_configs:
+                is_active_insights = (new_active_action_state_to_set["plot_id"] == cfg_btn["id"] and new_active_action_state_to_set["type"] == "insights")
+                is_active_formula = (new_active_action_state_to_set["plot_id"] == cfg_btn["id"] and new_active_action_state_to_set["type"] == "formula")
+                generated_bomb_btn_updates.append(gr.update(value=ACTIVE_ICON if is_active_insights else BOMB_ICON))
+                generated_formula_btn_updates.append(gr.update(value=ACTIVE_ICON if is_active_formula else FORMULA_ICON))
+
+            if action_type == "insights":
+                insights_chatbot_visible_update = gr.update(visible=True)
+                insights_chat_input_visible_update = gr.update(visible=True)
+                insights_suggestions_row_visible_update = gr.update(visible=True)
+                new_current_chat_plot_id = plot_id_clicked # Set chat context
+                
+                history = current_chat_histories.get(plot_id_clicked, [])
+                summary_for_plot = current_plot_data_for_chatbot.get(plot_id_clicked, f"Nessun sommario disponibile per '{clicked_plot_label}'.")
+
+                if not history: # First time opening insights for this plot (or after a refresh)
+                    prompt, sugg = get_initial_insight_prompt_and_suggestions(plot_id_clicked, clicked_plot_label, summary_for_plot)
+                    # Gradio's chatbot expects a list of lists/tuples: [[user_msg, None], [None, assistant_msg]]
+                    # Our generate_llm_response and history uses: [{"role": "user", "content": prompt}, {"role": "assistant", "content": resp}]
+                    # We need to adapt. For now, let's assume generate_llm_response takes our format and returns a string.
+                    # The history for Gradio Chatbot component needs to be [[user_msg, assistant_msg], ...]
+                    # Let's build history for LLM first
+                    llm_history_for_generation = [{"role": "user", "content": prompt}]
+                    
+                    # Display "Thinking..." or similar
+                    chatbot_content_update = gr.update(value=[[prompt, "Sto pensando..."]])
+                    yield tuple(self._assemble_panel_action_updates(action_col_visible_update, insights_chatbot_visible_update, chatbot_content_update, 
+                                                              insights_chat_input_visible_update, insights_suggestions_row_visible_update, 
+                                                              s1_upd, s2_upd, s3_upd, formula_display_visible_update, formula_content_update, 
+                                                              formula_close_hint_visible_update, new_active_action_state_to_set, 
+                                                              new_current_chat_plot_id, updated_chat_histories, new_explored_plot_id_to_set, 
+                                                              generated_panel_vis_updates, generated_bomb_btn_updates, 
+                                                              generated_formula_btn_updates, generated_explore_btn_updates, section_title_vis_updates))
+
+
+                    resp_text = await generate_llm_response(prompt, plot_id_clicked, clicked_plot_label, llm_history_for_generation, summary_for_plot)
+                    
+                    # Gradio chatbot history format
+                    new_gr_history_for_plot = [[prompt, resp_text]]
+                    # Internal history format for re-sending to LLM
+                    new_internal_history_for_plot = [
+                        {"role": "user", "content": prompt},
+                        {"role": "assistant", "content": resp_text}
+                    ]
+                    updated_chat_histories = {**current_chat_histories, plot_id_clicked: new_internal_history_for_plot}
+                    chatbot_content_update = gr.update(value=new_gr_history_for_plot)
+                else: # History exists, just display it
+                    _, sugg = get_initial_insight_prompt_and_suggestions(plot_id_clicked, clicked_plot_label, summary_for_plot) # Get fresh suggestions
+                    # Convert internal history to Gradio format for display
+                    gr_history_to_display = []
+                    # Assuming history is [{"role":"user", "content":"..."}, {"role":"assistant", "content":"..."}]
+                    # We need to pair them up. If an odd number, the last user message might not have a pair yet.
+                    temp_hist = history[:] # Make a copy
+                    while temp_hist:
+                        user_turn = temp_hist.pop(0)
+                        assistant_turn = None
+                        if temp_hist and temp_hist[0]["role"] == "assistant":
+                            assistant_turn = temp_hist.pop(0)
+                        gr_history_to_display.append([user_turn["content"], assistant_turn["content"] if assistant_turn else None])
+
+                    chatbot_content_update = gr.update(value=gr_history_to_display)
+
+                s1_upd = gr.update(value=sugg[0] if sugg and len(sugg) > 0 else "N/A")
+                s2_upd = gr.update(value=sugg[1] if sugg and len(sugg) > 1 else "N/A")
+                s3_upd = gr.update(value=sugg[2] if sugg and len(sugg) > 2 else "N/A")
+
+            elif action_type == "formula":
+                formula_display_visible_update = gr.update(visible=True)
+                formula_close_hint_visible_update = gr.update(visible=True)
+                formula_key = PLOT_ID_TO_FORMULA_KEY_MAP.get(plot_id_clicked)
+                formula_text = f"**Formula/Methodology for: {clicked_plot_label}** (ID: `{plot_id_clicked}`)\n\n"
+                if formula_key and formula_key in PLOT_FORMULAS:
+                    formula_data = PLOT_FORMULAS[formula_key]
+                    formula_text += f"### {formula_data['title']}\n\n{formula_data['description']}\n\n"
+                    if 'calculation_steps' in formula_data and formula_data['calculation_steps']:
+                         formula_text += "**Calculation:**\n" + "\n".join([f"- {s}" for s in formula_data['calculation_steps']])
+                else:
+                    formula_text += "(No detailed formula information found.)"
+                formula_content_update = gr.update(value=formula_text)
+                new_current_chat_plot_id = None # Clear chat context if formula panel is opened
+        
+        final_updates_tuple = self._assemble_panel_action_updates(
+            action_col_visible_update, insights_chatbot_visible_update, chatbot_content_update, 
+            insights_chat_input_visible_update, insights_suggestions_row_visible_update, 
+            s1_upd, s2_upd, s3_upd, formula_display_visible_update, formula_content_update, 
+            formula_close_hint_visible_update, new_active_action_state_to_set, 
+            new_current_chat_plot_id, updated_chat_histories, new_explored_plot_id_to_set, 
+            generated_panel_vis_updates, generated_bomb_btn_updates, 
+            generated_formula_btn_updates, generated_explore_btn_updates, section_title_vis_updates
+        )
+        logging.debug(f"handle_panel_action returning {len(final_updates_tuple)} updates.")
+        yield final_updates_tuple
+
+
+    def _assemble_panel_action_updates(self, action_col_visible_update, insights_chatbot_visible_update, chatbot_content_update, 
+                               insights_chat_input_visible_update, insights_suggestions_row_visible_update, 
+                               s1_upd, s2_upd, s3_upd, formula_display_visible_update, formula_content_update, 
+                               formula_close_hint_visible_update, new_active_action_state_to_set, 
+                               new_current_chat_plot_id, updated_chat_histories, new_explored_plot_id_to_set, 
+                               generated_panel_vis_updates, generated_bomb_btn_updates, 
+                               generated_formula_btn_updates, generated_explore_btn_updates, section_title_vis_updates):
+        """Helper to assemble the final tuple of updates for handle_panel_action."""
+        final_updates_list = [
+            action_col_visible_update,          # global_actions_column_ui (visibility)
+            insights_chatbot_visible_update,    # insights_chatbot_ui (visibility)
+            chatbot_content_update,             # insights_chatbot_ui (value)
+            insights_chat_input_visible_update, # insights_chat_input_ui
+            insights_suggestions_row_visible_update, # insights_suggestions_row_ui
+            s1_upd,                             # insights_suggestion_1_btn
+            s2_upd,                             # insights_suggestion_2_btn
+            s3_upd,                             # insights_suggestion_3_btn
+            formula_display_visible_update,     # formula_display_markdown_ui (visibility)
+            formula_content_update,             # formula_display_markdown_ui (value)
+            formula_close_hint_visible_update,  # formula_close_hint_md
+            
+            # States
+            new_active_action_state_to_set,     # active_panel_action_state
+            new_current_chat_plot_id,           # current_chat_plot_id_st
+            updated_chat_histories,             # chat_histories_st
+            new_explored_plot_id_to_set         # explored_plot_id_state
+        ]
+        final_updates_list.extend(generated_panel_vis_updates)
+        final_updates_list.extend(generated_bomb_btn_updates)
+        final_updates_list.extend(generated_formula_btn_updates)
+        final_updates_list.extend(generated_explore_btn_updates)
+        final_updates_list.extend(section_title_vis_updates)
+        
+        expected_len = len(self._get_action_panel_outputs_list())
+        if len(final_updates_list) != expected_len:
+            logging.error(f"Output length mismatch in _assemble_panel_action_updates. Got {len(final_updates_list)}, expected {expected_len}")
+            # Pad if necessary, though this is a bug indicator
+            final_updates_list.extend([gr.update()] * (expected_len - len(final_updates_list)))
+            
+        return tuple(final_updates_list)
+
+
+    async def handle_chat_message_submission(self, user_message: str, current_plot_id: str, 
+                                             chat_histories: dict, current_plot_data_for_chatbot: dict):
+        if not current_plot_id or not user_message.strip():
+            # Get current Gradio history for the plot_id to display
+            internal_history_for_plot = chat_histories.get(current_plot_id, [])
+            gr_history_display = self._convert_internal_to_gradio_chat_history(internal_history_for_plot)
+            yield gr_history_display, gr.update(value=""), chat_histories
+            return
+
+        clicked_plot_config = next((p for p in self.plot_configs if p["id"] == current_plot_id), None)
+        plot_label = clicked_plot_config["label"] if clicked_plot_config else "Selected Plot"
+        summary_for_plot = current_plot_data_for_chatbot.get(current_plot_id, f"No summary for '{plot_label}'.")
+        
+        internal_history_for_plot = chat_histories.get(current_plot_id, []).copy() # Get a mutable copy
+        internal_history_for_plot.append({"role": "user", "content": user_message})
+        
+        # Update Gradio chat display: User message + "Thinking..."
+        gr_history_display_pending = self._convert_internal_to_gradio_chat_history(internal_history_for_plot, thinking=True)
+        yield gr_history_display_pending, gr.update(value=""), chat_histories # Show user message immediately
+
+        # Generate LLM response
+        llm_response_text = await generate_llm_response(user_message, current_plot_id, plot_label, internal_history_for_plot, summary_for_plot)
+        
+        internal_history_for_plot.append({"role": "assistant", "content": llm_response_text})
+        
+        updated_chat_histories = {**chat_histories, current_plot_id: internal_history_for_plot}
+        
+        # Final Gradio chat display with LLM response
+        final_gr_history_display = self._convert_internal_to_gradio_chat_history(internal_history_for_plot)
+        yield final_gr_history_display, "", updated_chat_histories
+
+    def _convert_internal_to_gradio_chat_history(self, internal_history, thinking=False):
+        """Converts internal chat history format to Gradio's [[user, assistant], ...] format."""
+        gradio_history = []
+        temp_hist = internal_history[:] # Make a copy
+        while temp_hist:
+            user_msg_obj = temp_hist.pop(0)
+            user_msg = user_msg_obj['content']
+            assistant_msg = None
+            if temp_hist and temp_hist[0]['role'] == 'assistant':
+                assistant_msg_obj = temp_hist.pop(0)
+                assistant_msg = assistant_msg_obj['content']
+            gradio_history.append([user_msg, assistant_msg])
+        
+        if thinking and gradio_history and gradio_history[-1][1] is None: # If last message was user and we are in 'thinking' mode
+             gradio_history[-1][1] = "Sto pensando..." # Replace None with "Thinking..."
+        elif thinking and not gradio_history: # Should not happen if user_message was added
+            pass
+
+
+        return gradio_history
+
+    async def handle_suggested_question_click(self, suggestion_text: str, current_plot_id: str, 
+                                              chat_histories: dict, current_plot_data_for_chatbot: dict):
+        if not current_plot_id or not suggestion_text.strip() or suggestion_text == "N/A":
+            internal_history_for_plot = chat_histories.get(current_plot_id, [])
+            gr_history_display = self._convert_internal_to_gradio_chat_history(internal_history_for_plot)
+            yield gr_history_display, gr.update(value=""), chat_histories
+            return
+        
+        # Use the existing chat submission logic
+        async for update_chunk in self.handle_chat_message_submission(suggestion_text, current_plot_id, chat_histories, current_plot_data_for_chatbot):
+            yield update_chunk
+            
+    def _get_explore_outputs_list(self):
+        """Helper to construct the list of outputs for explore actions."""
+        outputs = [
+            self.explored_plot_id_state,
+            self.components['global_actions_column_ui'], # For visibility
+            self.active_panel_action_state, # To potentially clear it
+            self.components['formula_close_hint_md'] # For visibility
+        ]
+        
+        for pc in self.plot_configs: # Plot panel visibility
+            outputs.append(self.plot_ui_objects.get(pc["id"], {}).get("panel_component", gr.update()))
+        for pc in self.plot_configs: # Explore button state
+            outputs.append(self.plot_ui_objects.get(pc["id"], {}).get("explore_button", gr.update()))
+        for pc in self.plot_configs: # Bomb button state (may need reset)
+            outputs.append(self.plot_ui_objects.get(pc["id"], {}).get("bomb_button", gr.update()))
+        for pc in self.plot_configs: # Formula button state (may need reset)
+            outputs.append(self.plot_ui_objects.get(pc["id"], {}).get("formula_button", gr.update()))
+            
+        for s_name in self.unique_ordered_sections: # Section title visibility
+            outputs.append(self.section_titles_map.get(s_name, gr.update()))
+
+        expected_len = 4 + (4 * len(self.plot_configs)) + self.num_unique_sections
+        logging.debug(f"Explore outputs list length: {len(outputs)}, Expected: {expected_len}")
+        return outputs
+
+    def handle_explore_click(self, plot_id_clicked: str, current_explored_plot_id_from_state: str, 
+                             current_active_panel_action_state: dict):
+        logging.info(f"Explore Click: Plot '{plot_id_clicked}'. Current Explored: {current_explored_plot_id_from_state}. Active Panel: {current_active_panel_action_state}")
+
+        if not self.plot_ui_objects or not self.section_titles_map:
+            logging.error("plot_ui_objects or section_titles_map not populated for handle_explore_click.")
+            num_outputs = len(self._get_explore_outputs_list())
+            error_updates = [gr.update()] * num_outputs
+            error_updates[0] = current_explored_plot_id_from_state # Preserve explored_id_state
+            error_updates[2] = current_active_panel_action_state # Preserve active_panel_state
+            return tuple(error_updates)
+
+        new_explored_id_to_set = None
+        is_toggling_off_explore = (plot_id_clicked == current_explored_plot_id_from_state)
+        
+        action_col_upd = gr.update() # Default no change
+        new_active_panel_state_upd = current_active_panel_action_state # Default no change
+        formula_hint_upd = gr.update(visible=False) # Default hide
+
+        panel_vis_updates = []
+        explore_btns_updates = []
+        bomb_btns_updates = [gr.update()] * len(self.plot_configs) # Default no change
+        formula_btns_updates = [gr.update()] * len(self.plot_configs) # Default no change
+        section_title_vis_updates = [gr.update()] * self.num_unique_sections
+
+        clicked_cfg = next((p for p in self.plot_configs if p["id"] == plot_id_clicked), None)
+        section_of_clicked_plot = clicked_cfg["section"] if clicked_cfg else None
+
+        if is_toggling_off_explore:
+            new_explored_id_to_set = None # Clear explore state
+            logging.info(f"Stopping explore for {plot_id_clicked}. All plots/sections to be visible.")
+            for i in range(self.num_unique_sections):
+                section_title_vis_updates[i] = gr.update(visible=True)
+            for _ in self.plot_configs:
+                panel_vis_updates.append(gr.update(visible=True))
+                explore_btns_updates.append(gr.update(value=EXPLORE_ICON))
+            # Bomb and formula buttons remain as they were unless an action panel was closed (handled below if current_active_panel_action_state was set)
+        
+        else: # Starting explore or switching explored plot
+            new_explored_id_to_set = plot_id_clicked
+            logging.info(f"Exploring {plot_id_clicked}. Hiding other plots/sections.")
+            for i, sec_name in enumerate(self.unique_ordered_sections):
+                section_title_vis_updates[i] = gr.update(visible=(sec_name == section_of_clicked_plot))
+            for cfg in self.plot_configs:
+                is_target = (cfg["id"] == new_explored_id_to_set)
+                panel_vis_updates.append(gr.update(visible=is_target))
+                explore_btns_updates.append(gr.update(value=ACTIVE_ICON if is_target else EXPLORE_ICON))
+
+            if current_active_panel_action_state: # If an action panel (insights/formula) is open, close it
+                logging.info("Closing active insight/formula panel due to explore click.")
+                action_col_upd = gr.update(visible=False)
+                new_active_panel_state_upd = None # Clear active panel state
+                formula_hint_upd = gr.update(visible=False) # Hide formula hint specifically
+                # Reset bomb and formula buttons to their default icons
+                bomb_btns_updates = [gr.update(value=BOMB_ICON) for _ in self.plot_configs]
+                formula_btns_updates = [gr.update(value=FORMULA_ICON) for _ in self.plot_configs]
+        
+        final_explore_updates_list = [
+            new_explored_id_to_set, 
+            action_col_upd, 
+            new_active_panel_state_upd, 
+            formula_hint_upd
+        ]
+        final_explore_updates_list.extend(panel_vis_updates)
+        final_explore_updates_list.extend(explore_btns_updates)
+        final_explore_updates_list.extend(bomb_btns_updates)
+        final_explore_updates_list.extend(formula_btns_updates)
+        final_explore_updates_list.extend(section_title_vis_updates)
+        
+        expected_len = len(self._get_explore_outputs_list())
+        if len(final_explore_updates_list) != expected_len:
+            logging.error(f"Output length mismatch in handle_explore_click. Got {len(final_explore_updates_list)}, expected {expected_len}")
+            final_explore_updates_list.extend([gr.update()] * (expected_len - len(final_explore_updates_list)))
+
+        return tuple(final_explore_updates_list)
+
+    def setup_event_handlers(self):
+        """Set up all event handlers for the analytics tab components."""
+        logging.info("Setting up analytics event handlers.")
+
+        # Apply filter button
+        apply_filter_inputs = [
+            self.token_state, 
+            self.components['date_filter_selector'], 
+            self.components['custom_start_date_picker'], 
+            self.components['custom_end_date_picker'],
+            # self.chat_histories_st # Not directly an input to refresh_analytics_graphs_ui, it's accessed via self
+        ]
+        self.components['apply_filter_btn'].click(
+            fn=self.refresh_analytics_graphs_ui,
+            inputs=apply_filter_inputs,
+            outputs=self._get_graph_refresh_outputs_list(), # Method returns the list of components
+            show_progress="full",
+            api_name="refresh_analytics_graphs"
+        )
+        
+        # Plot action handlers (insights, formula, explore)
+        action_click_inputs = [ # These are the gr.State objects themselves
+            self.active_panel_action_state, 
+            self.chat_histories_st, 
+            self.current_chat_plot_id_st, 
+            self.plot_data_for_chatbot_st, 
+            self.explored_plot_id_state
+        ]
+        
+        explore_click_inputs = [ # gr.State objects
+            self.explored_plot_id_state, 
+            self.active_panel_action_state
+        ]
+        
+        action_panel_outputs_list = self._get_action_panel_outputs_list()
+        explore_outputs_list = self._get_explore_outputs_list()
+
+        for config_item in self.plot_configs:
+            plot_id = config_item["id"]
+            if plot_id in self.plot_ui_objects:
+                ui_obj = self.plot_ui_objects[plot_id]
+                
+                # Curry plot_id and action_type for the handler
+                # The handler function itself (self.handle_panel_action) will receive the values from the gr.State inputs directly.
+                
+                if ui_obj.get("bomb_button"):
+                    ui_obj["bomb_button"].click(
+                        fn=lambda current_active, current_chats, current_chat_pid, current_plot_data, current_explored, p_id=plot_id: \
+                             self.handle_panel_action(p_id, "insights", current_active, current_chats, current_chat_pid, current_plot_data, current_explored),
+                        inputs=action_click_inputs, # Pass the list of gr.State objects
+                        outputs=action_panel_outputs_list,
+                        api_name=f"action_insights_{plot_id}"
+                    )
+                if ui_obj.get("formula_button"):
+                    ui_obj["formula_button"].click(
+                        fn=lambda current_active, current_chats, current_chat_pid, current_plot_data, current_explored, p_id=plot_id: \
+                             self.handle_panel_action(p_id, "formula", current_active, current_chats, current_chat_pid, current_plot_data, current_explored),
+                        inputs=action_click_inputs,
+                        outputs=action_panel_outputs_list,
+                        api_name=f"action_formula_{plot_id}"
+                    )
+                if ui_obj.get("explore_button"):
+                    ui_obj["explore_button"].click(
+                        fn=lambda current_explored_val, current_active_panel_val, p_id=plot_id: \
+                             self.handle_explore_click(p_id, current_explored_val, current_active_panel_val),
+                        inputs=explore_click_inputs, # Pass the list of gr.State objects
+                        outputs=explore_outputs_list,
+                        api_name=f"action_explore_{plot_id}"
+                    )
+            else:
+                logging.warning(f"UI object for plot_id '{plot_id}' not found for setting up click handlers.")
+
+        # Chat submission handlers
+        chat_submission_outputs = [
+            self.components['insights_chatbot_ui'], 
+            self.components['insights_chat_input_ui'], 
+            self.chat_histories_st # This state will be updated
+        ]
+        chat_submission_inputs = [ # gr.Textbox, gr.State, gr.State, gr.State
+            self.components['insights_chat_input_ui'], 
+            self.current_chat_plot_id_st, 
+            self.chat_histories_st, 
+            self.plot_data_for_chatbot_st
+        ]
+        
+        self.components['insights_chat_input_ui'].submit(
+            fn=self.handle_chat_message_submission, 
+            inputs=chat_submission_inputs, 
+            outputs=chat_submission_outputs, 
+            api_name="submit_chat_message"
+        )
+        
+        suggestion_click_inputs_base = [ # gr.State, gr.State, gr.State
+            self.current_chat_plot_id_st, 
+            self.chat_histories_st, 
+            self.plot_data_for_chatbot_st
+        ]
+        
+        # For suggestion buttons, the first input is the button itself (to get its value)
+        self.components['insights_suggestion_1_btn'].click(
+            fn=self.handle_suggested_question_click, 
+            inputs=[self.components['insights_suggestion_1_btn']] + suggestion_click_inputs_base, 
+            outputs=chat_submission_outputs, 
+            api_name="click_suggestion_1"
+        )
+        self.components['insights_suggestion_2_btn'].click(
+            fn=self.handle_suggested_question_click, 
+            inputs=[self.components['insights_suggestion_2_btn']] + suggestion_click_inputs_base, 
+            outputs=chat_submission_outputs, 
+            api_name="click_suggestion_2"
+        )
+        self.components['insights_suggestion_3_btn'].click(
+            fn=self.handle_suggested_question_click, 
+            inputs=[self.components['insights_suggestion_3_btn']] + suggestion_click_inputs_base, 
+            outputs=chat_submission_outputs, 
+            api_name="click_suggestion_3"
+        )
+        logging.info("Analytics event handlers setup complete.")
+