Rename services/analytics_handlers.py to services/analytics_tab_module.py

services/analytics_handlers.py

@@ -1,748 +0,0 @@
-# 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):
-        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
-        plot_gen_results = update_analytics_plots_figures(
-            current_token_state_val, 
-            date_filter_val, 
-            custom_start_val, 
-            custom_end_val, 
-            self.plot_configs
-        )
-        
-        # Debug: Log what we actually got back
-        logging.debug(f"plot_gen_results type: {type(plot_gen_results)}, length: {len(plot_gen_results) if hasattr(plot_gen_results, '__len__') else 'N/A'}")
-        
-        # Handle different possible return formats
-        if len(plot_gen_results) == 3:
-            # Expected format: (status_msg, figures_list, summaries_dict)
-            status_msg, gen_figs_result, new_summaries_dict = plot_gen_results
-        else:
-            # Fallback - try to parse based on old format
-            # Old format seemed to be: status_msg, *figures, summaries_dict
-            status_msg = plot_gen_results[0]
-            new_summaries_dict = plot_gen_results[-1]
-            gen_figs_result = plot_gen_results[1:-1]  # Everything between first and last
-        
-        # Ensure we have a list of figures
-        if isinstance(gen_figs_result, list):
-            gen_figs_list = gen_figs_result
-        else:
-            # If it's a single figure, we need to check if it should be replicated
-            # or if the function should return multiple figures
-            logging.warning(f"Got single figure of type {type(gen_figs_result)}, expected list of {len(self.plot_configs)} figures")
-            
-            # Option 1: If the single figure should be used for all plots (unlikely)
-            # gen_figs_list = [gen_figs_result] * len(self.plot_configs)
-            
-            # Option 2: If this indicates an error in the function (more likely)
-            gen_figs_list = [gen_figs_result]  # Keep as single item list for now
-        
-        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):
-            # Perfect match - use figures as-is
-            for fig in gen_figs_list:
-                all_updates.append(fig)
-        elif len(gen_figs_list) == 1 and len(self.plot_configs) > 1:
-            # Special case: one figure for multiple plots - check if this is intentional
-            logging.warning(f"Using single figure for {len(self.plot_configs)} plot components")
-            # Use the single figure for the first plot, placeholders for the rest
-            all_updates.append(gen_figs_list[0])
-            for i in range(1, len(self.plot_configs)):
-                all_updates.append(create_placeholder_plot("Info", f"Plot {i+1} - Data processing"))
-        else:
-            # Length mismatch - pad with placeholders
-            logging.error(f"Figure list length mismatch: got {len(gen_figs_list)}, expected {len(self.plot_configs)}")
-            for i in range(len(self.plot_configs)):
-                if i < len(gen_figs_list):
-                    all_updates.append(gen_figs_list[i])
-                else:
-                    all_updates.append(create_placeholder_plot("Error", "Figura mancante"))
-    
-        # Reset action panel UI elements (same as before)
-        all_updates.extend([
-            gr.update(visible=False),  # global_actions_column_ui
-            gr.update(value=[], visible=False),  # insights_chatbot_ui
-            gr.update(value="", visible=False),  # insights_chat_input_ui
-            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
-            new_summaries_dict  # plot_data_for_chatbot_st
-        ])
-        
-        # 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
-            ])
-            
-        all_updates.append(None)  # explored_plot_id_state
-    
-        # 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() to prevent Gradio errors
-            while len(all_updates) < expected_len:
-                all_updates.append(gr.update())
-    
-        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}")
-            num_outputs = len(self._get_action_panel_outputs_list())
-            error_updates = [gr.update()] * num_outputs
-            # Preserve existing state values if possible
-            # 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
-            yield tuple(error_updates) # Use yield instead of return <value>
-            return # Explicitly return to end the generator function
-
-        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)
-                    llm_history_for_generation = [{"role": "user", "content": prompt}]
-                    
-                    # Display "Thinking..." or similar
-                    chatbot_content_update = gr.update(value=[[prompt, "Sto pensando..."]])
-                    # Yield intermediate update
-                    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)
-                    
-                    new_gr_history_for_plot = [[prompt, resp_text]]
-                    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
-                    gr_history_to_display = self._convert_internal_to_gradio_chat_history(history)
-                    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 yielding final updates. Count: {len(final_updates_tuple)}")
-        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 # Or log an error, but it implies user_message wasn't added to internal_history_for_plot before calling
-
-
-        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.")
-

services/analytics_tab_module.py

@@ -0,0 +1,674 @@
+# analytics_tab_module.py
+import gradio as gr
+import pandas as pd
+import logging
+import time
+from datetime import datetime, timedelta
+import numpy as np
+from collections import OrderedDict, defaultdict
+import asyncio
+import matplotlib # Keep this if create_placeholder_plot or other plot fns need it
+matplotlib.use('Agg') # Keep if necessary for plotting functions
+import matplotlib.pyplot as plt # Keep if necessary
+
+# It's assumed that PLOT_CONFIGS is specific to this analytics tab.
+# If it's used elsewhere, it might need to be passed in or imported from a central config.
+PLOT_CONFIGS = [
+    {"label": "Numero di Follower nel Tempo", "id": "followers_count", "section": "Dinamiche dei Follower"},
+    {"label": "Tasso di Crescita Follower", "id": "followers_growth_rate", "section": "Dinamiche dei Follower"},
+    {"label": "Follower per Località", "id": "followers_by_location", "section": "Demografia Follower"},
+    {"label": "Follower per Ruolo (Funzione)", "id": "followers_by_role", "section": "Demografia Follower"},
+    {"label": "Follower per Settore", "id": "followers_by_industry", "section": "Demografia Follower"},
+    {"label": "Follower per Anzianità", "id": "followers_by_seniority", "section": "Demografia Follower"},
+    {"label": "Tasso di Engagement nel Tempo", "id": "engagement_rate", "section": "Approfondimenti Performance Post"},
+    {"label": "Copertura nel Tempo", "id": "reach_over_time", "section": "Approfondimenti Performance Post"},
+    {"label": "Visualizzazioni nel Tempo", "id": "impressions_over_time", "section": "Approfondimenti Performance Post"},
+    {"label": "Reazioni (Like) nel Tempo", "id": "likes_over_time", "section": "Approfondimenti Performance Post"},
+    {"label": "Click nel Tempo", "id": "clicks_over_time", "section": "Engagement Dettagliato Post nel Tempo"},
+    {"label": "Condivisioni nel Tempo", "id": "shares_over_time", "section": "Engagement Dettagliato Post nel Tempo"},
+    {"label": "Commenti nel Tempo", "id": "comments_over_time", "section": "Engagement Dettagliato Post nel Tempo"},
+    {"label": "Ripartizione Commenti per Sentiment", "id": "comments_sentiment", "section": "Engagement Dettagliato Post nel Tempo"},
+    {"label": "Frequenza Post", "id": "post_frequency_cs", "section": "Analisi Strategia Contenuti"},
+    {"label": "Ripartizione Contenuti per Formato", "id": "content_format_breakdown_cs", "section": "Analisi Strategia Contenuti"},
+    {"label": "Ripartizione Contenuti per Argomenti", "id": "content_topic_breakdown_cs", "section": "Analisi Strategia Contenuti"},
+    {"label": "Volume Menzioni nel Tempo (Dettaglio)", "id": "mention_analysis_volume", "section": "Analisi Menzioni (Dettaglio)"},
+    {"label": "Ripartizione Menzioni per Sentiment (Dettaglio)", "id": "mention_analysis_sentiment", "section": "Analisi Menzioni (Dettaglio)"}
+]
+# IMPORTANT: Review if 'mention_analysis_volume' and 'mention_analysis_sentiment' plots
+# can still be generated without the dedicated mentions data processing.
+# If not, they should also be removed from plot_configs.
+# For now, I am assuming they might draw from a general data pool in token_state.
+assert len(PLOT_CONFIGS) == 19, "Mancata corrispondenza in PLOT_CONFIGS e grafici attesi. (If mentions plots were removed, adjust this number)"
+
+UNIQUE_ORDERED_SECTIONS = list(OrderedDict.fromkeys(pc["section"] for pc in PLOT_CONFIGS))
+NUM_UNIQUE_SECTIONS = len(UNIQUE_ORDERED_SECTIONS)
+
+class AnalyticsTab:
+    def __init__(self, token_state, chat_histories_st, current_chat_plot_id_st, plot_data_for_chatbot_st,
+                 # External dependencies (functions, data, icons)
+                 plot_id_to_formula_map, plot_formulas_data, icons,
+                 fn_build_plot_area, fn_update_plot_figures, fn_create_placeholder_plot,
+                 fn_get_initial_insight, fn_generate_llm_response):
+
+        # Shared Gradio states passed from the main app
+        self.token_state = token_state
+        self.chat_histories_st = chat_histories_st
+        self.current_chat_plot_id_st = current_chat_plot_id_st
+        self.plot_data_for_chatbot_st = plot_data_for_chatbot_st
+
+        # Store external dependencies
+        self.PLOT_ID_TO_FORMULA_KEY_MAP = plot_id_to_formula_map
+        self.PLOT_FORMULAS = plot_formulas_data
+        self.BOMB_ICON = icons['bomb']
+        self.EXPLORE_ICON = icons['explore']
+        self.FORMULA_ICON = icons['formula']
+        self.ACTIVE_ICON = icons['active']
+        self.build_analytics_tab_plot_area = fn_build_plot_area
+        self.update_analytics_plots_figures = fn_update_plot_figures
+        self.create_placeholder_plot = fn_create_placeholder_plot
+        self.get_initial_insight_prompt_and_suggestions = fn_get_initial_insight
+        self.generate_llm_response = fn_generate_llm_response
+
+        # Internal Gradio states for this tab
+        self.active_panel_action_state = gr.State(None)
+        self.explored_plot_id_state = gr.State(None)
+
+        # To store UI objects created by build_analytics_tab_plot_area
+        self.plot_ui_objects = {}
+        self.section_titles_map = {}
+
+        # UI components that will be created in create_tab_ui
+        self.analytics_status_md = None
+        self.date_filter_selector = None
+        self.custom_start_date_picker = None
+        self.custom_end_date_picker = None
+        self.apply_filter_btn = None
+        self.plots_area_col = None
+        self.global_actions_column_ui = None
+        self.insights_chatbot_ui = None
+        self.insights_chat_input_ui = None
+        self.insights_suggestions_row_ui = None
+        self.insights_suggestion_1_btn = None
+        self.insights_suggestion_2_btn = None
+        self.insights_suggestion_3_btn = None
+        self.formula_display_markdown_ui = None
+        self.formula_close_hint_md = None
+
+        # Lists for Gradio callback outputs, will be populated after UI creation
+        self.graph_refresh_outputs_list = []
+        self.action_panel_outputs_list = []
+        self.explore_outputs_list = []
+
+    def _toggle_custom_date_pickers(self, selection):
+        is_custom = selection == "Intervallo Personalizzato"
+        return gr.update(visible=is_custom), gr.update(visible=is_custom)
+
+    async def _handle_panel_action(
+        self, plot_id_clicked: str, action_type: str, current_active_action_from_state: dict,
+        current_chat_histories: dict, current_chat_plot_id: str,
+        current_plot_data_for_chatbot: dict, current_explored_plot_id: str
+    ):
+        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 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}")
+            num_plots = len(PLOT_CONFIGS)
+            error_list_len = 15 + (4 * num_plots) + NUM_UNIQUE_SECTIONS
+            error_list = [gr.update()] * error_list_len
+            # Fill specific indices if needed, matching the expected output structure
+            error_list[11] = current_active_action_from_state # active_panel_action_state
+            error_list[12] = current_chat_plot_id          # current_chat_plot_id_st
+            error_list[13] = current_chat_histories        # chat_histories_st
+            error_list[14] = current_explored_plot_id      # explored_plot_id_state
+            return error_list
+
+        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, insights_chat_input_visible_update, insights_suggestions_row_visible_update = gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
+        formula_display_visible_update = gr.update(visible=False)
+        formula_close_hint_visible_update = gr.update(visible=False)
+        chatbot_content_update, s1_upd, s2_upd, s3_upd, formula_content_update = gr.update(), gr.update(), gr.update(), gr.update(), gr.update()
+
+        new_active_action_state_to_set = None
+        new_current_chat_plot_id = current_chat_plot_id # Preserve by default
+        updated_chat_histories = current_chat_histories # Preserve by default
+        new_explored_plot_id_to_set = current_explored_plot_id # Preserve by default
+
+        generated_panel_vis_updates = []
+        generated_bomb_btn_updates = []
+        generated_formula_btn_updates = []
+        generated_explore_btn_updates = []
+        section_title_vis_updates = [gr.update()] * 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 PLOT_CONFIGS:
+                generated_bomb_btn_updates.append(gr.update(value=self.BOMB_ICON))
+                generated_formula_btn_updates.append(gr.update(value=self.FORMULA_ICON))
+
+            if current_explored_plot_id: # If an explore view was active, restore it
+                explored_cfg = next((p for p in 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(UNIQUE_ORDERED_SECTIONS):
+                    section_title_vis_updates[i] = gr.update(visible=(sec_name == explored_sec))
+                for cfg in 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=self.ACTIVE_ICON if is_exp else self.EXPLORE_ICON))
+            else: # No explore view, all plots visible
+                for i in range(NUM_UNIQUE_SECTIONS):
+                    section_title_vis_updates[i] = gr.update(visible=True)
+                for _ in PLOT_CONFIGS:
+                    generated_panel_vis_updates.append(gr.update(visible=True))
+                    generated_explore_btn_updates.append(gr.update(value=self.EXPLORE_ICON))
+            
+            if action_type == "insights": # Specifically when closing insights chat
+                new_current_chat_plot_id = None # Clear the chat context
+
+        else: # Toggling ON a panel action
+            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 active explore view
+            logging.info(f"Toggling ON panel {action_type} for {plot_id_clicked}. Cancelling explore view if any.")
+
+            # Show only the clicked plot and its section title
+            for i, sec_name in enumerate(UNIQUE_ORDERED_SECTIONS):
+                section_title_vis_updates[i] = gr.update(visible=(sec_name == clicked_plot_section))
+            for cfg in PLOT_CONFIGS:
+                generated_panel_vis_updates.append(gr.update(visible=(cfg["id"] == plot_id_clicked)))
+                generated_explore_btn_updates.append(gr.update(value=self.EXPLORE_ICON)) # Reset all explore buttons
+
+            # Update bomb and formula button icons based on the new active action
+            for cfg_btn in PLOT_CONFIGS:
+                is_active_insights = new_active_action_state_to_set == {"plot_id": cfg_btn["id"], "type": "insights"}
+                is_active_formula = new_active_action_state_to_set == {"plot_id": cfg_btn["id"], "type": "formula"}
+                generated_bomb_btn_updates.append(gr.update(value=self.ACTIVE_ICON if is_active_insights else self.BOMB_ICON))
+                generated_formula_btn_updates.append(gr.update(value=self.ACTIVE_ICON if is_active_formula else self.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 to this plot
+
+                history = current_chat_histories.get(plot_id_clicked, [])
+                summary = current_plot_data_for_chatbot.get(plot_id_clicked, f"No summary available for '{clicked_plot_label}'.")
+
+                if not history: # First time opening chat for this plot
+                    prompt, sugg = self.get_initial_insight_prompt_and_suggestions(plot_id_clicked, clicked_plot_label, summary)
+                    llm_history_for_api = [{"role": "user", "content": prompt}] # API expects list of dicts
+                    resp = await self.generate_llm_response(prompt, plot_id_clicked, clicked_plot_label, llm_history_for_api, summary)
+                    history = [{"role": "assistant", "content": resp}] # Gradio expects list of tuples or specific dicts for Chatbot
+                    updated_chat_histories = {**current_chat_histories, plot_id_clicked: history}
+                else: # Re-opening chat, just get new suggestions if any
+                    _, sugg = self.get_initial_insight_prompt_and_suggestions(plot_id_clicked, clicked_plot_label, summary)
+
+                chatbot_content_update = gr.update(value=history)
+                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 = self.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 self.PLOT_FORMULAS:
+                    formula_data = self.PLOT_FORMULAS[formula_key]
+                    formula_text += f"### {formula_data['title']}\n\n{formula_data['description']}\n\n**Calculation:**\n"
+                    formula_text += "\n".join([f"- {step}" for step 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 is opened
+
+        # Order of updates must match self.action_panel_outputs_list
+        final_updates = [
+            action_col_visible_update,          # global_actions_column_ui
+            insights_chatbot_visible_update,    # insights_chatbot_ui (visibility)
+            chatbot_content_update,             # insights_chatbot_ui (content)
+            insights_chat_input_visible_update, # insights_chat_input_ui
+            insights_suggestions_row_visible_update, # insights_suggestions_row_ui
+            s1_upd, s2_upd, s3_upd,             # suggestion buttons
+            formula_display_visible_update,     # formula_display_markdown_ui (visibility)
+            formula_content_update,             # formula_display_markdown_ui (content)
+            formula_close_hint_visible_update,  # formula_close_hint_md
+            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.extend(generated_panel_vis_updates) # Plot panel visibilities
+        final_updates.extend(generated_bomb_btn_updates)    # Bomb button icons
+        final_updates.extend(generated_formula_btn_updates) # Formula button icons
+        final_updates.extend(generated_explore_btn_updates) # Explore button icons
+        final_updates.extend(section_title_vis_updates)   # Section title visibilities
+
+        logging.debug(f"handle_panel_action returning {len(final_updates)} updates. Expected {15 + 4*len(PLOT_CONFIGS) + NUM_UNIQUE_SECTIONS}.")
+        return final_updates
+
+    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():
+            current_history_for_plot = chat_histories.get(current_plot_id, [])
+            # Ensure history is in the format Gradio Chatbot expects (list of lists/tuples or specific dicts)
+            # Assuming it's already [{"role": "user/assistant", "content": "..."}]
+            yield current_history_for_plot, gr.update(value=""), chat_histories
+            return
+
+        clicked_plot_config = next((p for p in PLOT_CONFIGS if p["id"] == current_plot_id), None)
+        plot_label = clicked_plot_config["label"] if clicked_plot_config else "Selected Plot"
+        summary_data = current_plot_data_for_chatbot.get(current_plot_id, f"No summary available for '{plot_label}'.")
+
+        # Ensure history is a list of dicts {"role": ..., "content": ...} for the API
+        history_for_api = chat_histories.get(current_plot_id, []).copy() # Get a mutable copy
+        if not isinstance(history_for_api, list): history_for_api = [] # Should not happen if initialized correctly
+
+        history_for_api.append({"role": "user", "content": user_message})
+        
+        # Update Gradio chatbot UI immediately with user message
+        # Gradio Chatbot expects list of (user_msg, assistant_msg) tuples or specific dicts.
+        # If current_chat_histories stores [{"role": "user", "content": "..."}], convert for display if needed,
+        # or ensure generate_llm_response and initial prompt also use this dict format.
+        # For simplicity, let's assume chat_histories_st stores a list of such dicts.
+        current_display_history = history_for_api.copy() # This is what will be displayed
+
+        yield current_display_history, gr.update(value=""), chat_histories # Update UI, clear input, pass original histories
+
+        assistant_response = await self.generate_llm_response(user_message, current_plot_id, plot_label, history_for_api, summary_data)
+        history_for_api.append({"role": "assistant", "content": assistant_response})
+
+        updated_chat_histories = {**chat_histories, current_plot_id: history_for_api}
+        current_display_history.append({"role": "assistant", "content": assistant_response})
+
+
+        yield current_display_history, "", updated_chat_histories
+
+
+    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":
+            current_history_for_plot = chat_histories.get(current_plot_id, [])
+            yield current_history_for_plot, gr.update(value=""), chat_histories
+            return
+        
+        # Use async for to stream updates from _handle_chat_message_submission
+        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 _handle_explore_click(self, plot_id_clicked, current_explored_plot_id_from_state, current_active_panel_action_state):
+        logging.info(f"Explore Click: Plot '{plot_id_clicked}'. Current Explored: {current_explored_plot_id_from_state}. Active Panel: {current_active_panel_action_state}")
+        num_plots = len(PLOT_CONFIGS)
+
+        if not self.plot_ui_objects: # Check if plot UI objects are populated
+            logging.error("plot_ui_objects not populated for handle_explore_click.")
+            # Prepare a list of gr.update() of the correct length
+            error_list_len = 4 + (4 * num_plots) + NUM_UNIQUE_SECTIONS
+            error_list = [gr.update()] * error_list_len
+            error_list[0] = current_explored_plot_id_from_state # explored_plot_id_state
+            error_list[2] = current_active_panel_action_state   # active_panel_action_state
+            return error_list
+
+        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 to no change
+        new_active_panel_state_upd = current_active_panel_action_state # Default to no change
+        formula_hint_upd = gr.update(visible=False) # Hide by default, only shown by formula panel
+
+        panel_vis_updates = []
+        explore_btns_updates = []
+        bomb_btns_updates = [gr.update()] * num_plots # Default to no change for bomb/formula unless panel closes
+        formula_btns_updates = [gr.update()] * num_plots
+        section_title_vis_updates = [gr.update()] * NUM_UNIQUE_SECTIONS
+
+        clicked_cfg = next((p for p in 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(NUM_UNIQUE_SECTIONS):
+                section_title_vis_updates[i] = gr.update(visible=True)
+            for _ in PLOT_CONFIGS:
+                panel_vis_updates.append(gr.update(visible=True))
+                explore_btns_updates.append(gr.update(value=self.EXPLORE_ICON))
+            # If an action panel was open, it remains open. Its visibility is tied to active_panel_action_state.
+            # Bomb and formula buttons don't change unless an action panel is closed.
+        else: # Exploring a new plot or switching explore
+            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(UNIQUE_ORDERED_SECTIONS):
+                section_title_vis_updates[i] = gr.update(visible=(sec_name == section_of_clicked_plot))
+
+            for cfg in PLOT_CONFIGS:
+                is_target_plot = (cfg["id"] == new_explored_id_to_set)
+                panel_vis_updates.append(gr.update(visible=is_target_plot))
+                explore_btns_updates.append(gr.update(value=self.ACTIVE_ICON if is_target_plot else self.EXPLORE_ICON))
+
+            if current_active_panel_action_state: # If an insights/formula panel was 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 # This will be set to the state
+                # Reset bomb and formula buttons to their default icons
+                bomb_btns_updates = [gr.update(value=self.BOMB_ICON) for _ in PLOT_CONFIGS]
+                formula_btns_updates = [gr.update(value=self.FORMULA_ICON) for _ in PLOT_CONFIGS]
+                formula_hint_upd = gr.update(visible=False) # Ensure hint is hidden
+
+        # Order of updates must match self.explore_outputs_list
+        final_explore_updates = [
+            new_explored_id_to_set,         # explored_plot_id_state
+            action_col_upd,                 # global_actions_column_ui
+            new_active_panel_state_upd,     # active_panel_action_state
+            formula_hint_upd                # formula_close_hint_md
+        ]
+        final_explore_updates.extend(panel_vis_updates)         # Plot panel visibilities
+        final_explore_updates.extend(explore_btns_updates)      # Explore button icons
+        final_explore_updates.extend(bomb_btns_updates)         # Bomb button icons
+        final_explore_updates.extend(formula_btns_updates)      # Formula button icons
+        final_explore_updates.extend(section_title_vis_updates) # Section title visibilities
+
+        logging.debug(f"handle_explore_click returning {len(final_explore_updates)} updates. Expected {4 + 4*len(PLOT_CONFIGS) + NUM_UNIQUE_SECTIONS}.")
+        return final_explore_updates
+
+    def _create_panel_action_handler(self, p_id, action_type_str):
+        # This wrapper is needed because Gradio's .click() fn doesn't easily pass extra args fixed at definition time
+        # without using lambdas that might have late binding issues in loops, or functools.partial.
+        # An inner async def is a clean way for this specific pattern with async handlers.
+        async def _handler(curr_active_val, curr_chats_val, curr_chat_pid, curr_plot_data, curr_explored_id):
+            return await self._handle_panel_action(p_id, action_type_str, curr_active_val, curr_chats_val, curr_chat_pid, curr_plot_data, curr_explored_id)
+        return _handler
+
+    async def _refresh_analytics_graphs_ui(self, current_token_state_val, date_filter_val, custom_start_val, custom_end_val, current_chat_histories_val):
+        logging.info("Refreshing analytics graph UI elements and resetting actions/chat (within module).")
+        start_time = time.time()
+
+        plot_gen_results = self.update_analytics_plots_figures(current_token_state_val, date_filter_val, custom_start_val, custom_end_val, PLOT_CONFIGS)
+        status_msg, gen_figs, new_summaries_for_chatbot = plot_gen_results[0], plot_gen_results[1:-1], plot_gen_results[-1]
+
+        all_updates = []
+        # 1. Status Markdown
+        all_updates.append(status_msg) # For self.analytics_status_md
+
+        # 2. Plot components
+        if len(gen_figs) == len(PLOT_CONFIGS):
+            all_updates.extend(gen_figs)
+        else:
+            logging.error(f"Mismatch in generated figures ({len(gen_figs)}) and plot_configs ({len(PLOT_CONFIGS)})")
+            all_updates.extend([self.create_placeholder_plot("Error", f"Figura mancante {i}") for i in range(len(PLOT_CONFIGS))])
+
+        # 3. UI Resets for Action Panel (9 components)
+        all_updates.extend([
+            gr.update(visible=False),  # global_actions_column_ui
+            gr.update(value=[], visible=False),  # insights_chatbot_ui (content & visibility)
+            gr.update(value="", visible=False),  # insights_chat_input_ui
+            gr.update(visible=False),  # insights_suggestions_row_ui
+            gr.update(value="Suggerimento 1"), gr.update(value="Suggerimento 2"), gr.update(value="Suggerimento 3"),  # suggestion_btns
+            gr.update(value="I dettagli sulla formula/metodologia appariranno qui.", visible=False),  # formula_display_markdown_ui
+            gr.update(visible=False)  # formula_close_hint_md
+        ])
+
+        # 4. State Resets (4 states)
+        all_updates.extend([
+            None,  # active_panel_action_state (reset)
+            None,  # current_chat_plot_id_st (reset)
+            current_chat_histories_val, # chat_histories_st (pass through, or {} to reset all chats) - original code implies reset with {}
+            new_summaries_for_chatbot  # plot_data_for_chatbot_st (update with new summaries)
+        ])
+        # If chat_histories_st should be fully reset on graph refresh:
+        # all_updates[-2] = {} # This would reset all chat histories
+
+        # 5. Plot-specific UI Resets (4 components per plot)
+        for _ in PLOT_CONFIGS:
+            all_updates.extend([
+                gr.update(value=self.BOMB_ICON),    # bomb_button
+                gr.update(value=self.FORMULA_ICON), # formula_button
+                gr.update(value=self.EXPLORE_ICON), # explore_button
+                gr.update(visible=True)           # panel_component (plot visibility itself)
+            ])
+
+        # 6. Explored Plot ID State Reset (1 state)
+        all_updates.append(None)  # explored_plot_id_state (reset)
+
+        # 7. Section Title Visibilities
+        all_updates.extend([gr.update(visible=True)] * NUM_UNIQUE_SECTIONS)
+
+        end_time = time.time()
+        logging.info(f"Analytics graph refresh (module) took {end_time - start_time:.2f} seconds.")
+        expected_len = 1 + len(PLOT_CONFIGS) + 9 + 4 + (4 * len(PLOT_CONFIGS)) + 1 + 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}")
+        return tuple(all_updates)
+
+    def _define_callback_outputs(self):
+        # This method populates the output lists for various callbacks.
+        # It MUST be called after all UI components of this tab are created.
+
+        # Outputs for _refresh_analytics_graphs_ui
+        self.graph_refresh_outputs_list.append(self.analytics_status_md)
+        self.graph_refresh_outputs_list.extend([self.plot_ui_objects.get(pc["id"], {}).get("plot_component", gr.update()) for pc in PLOT_CONFIGS])
+        self.graph_refresh_outputs_list.extend([
+            self.global_actions_column_ui, self.insights_chatbot_ui, self.insights_chat_input_ui,
+            self.insights_suggestions_row_ui, self.insights_suggestion_1_btn, self.insights_suggestion_2_btn,
+            self.insights_suggestion_3_btn, self.formula_display_markdown_ui, self.formula_close_hint_md
+        ])
+        self.graph_refresh_outputs_list.extend([
+            self.active_panel_action_state, self.current_chat_plot_id_st,
+            self.chat_histories_st, self.plot_data_for_chatbot_st
+        ])
+        for pc in PLOT_CONFIGS:
+            pid = pc["id"]
+            self.graph_refresh_outputs_list.extend([
+                self.plot_ui_objects.get(pid, {}).get("bomb_button", gr.update()),
+                self.plot_ui_objects.get(pid, {}).get("formula_button", gr.update()),
+                self.plot_ui_objects.get(pid, {}).get("explore_button", gr.update()),
+                self.plot_ui_objects.get(pid, {}).get("panel_component", gr.update())
+            ])
+        self.graph_refresh_outputs_list.append(self.explored_plot_id_state)
+        self.graph_refresh_outputs_list.extend([self.section_titles_map.get(s_name, gr.update()) for s_name in UNIQUE_ORDERED_SECTIONS])
+
+        # Outputs for _handle_panel_action
+        self.action_panel_outputs_list.extend([
+            self.global_actions_column_ui, self.insights_chatbot_ui, self.insights_chatbot_ui, # Chatbot visibility and content
+            self.insights_chat_input_ui, self.insights_suggestions_row_ui,
+            self.insights_suggestion_1_btn, self.insights_suggestion_2_btn, self.insights_suggestion_3_btn,
+            self.formula_display_markdown_ui, self.formula_display_markdown_ui, # Formula visibility and content
+            self.formula_close_hint_md
+        ])
+        self.action_panel_outputs_list.extend([
+            self.active_panel_action_state, self.current_chat_plot_id_st,
+            self.chat_histories_st, self.explored_plot_id_state
+        ])
+        self.action_panel_outputs_list.extend([self.plot_ui_objects.get(pc["id"], {}).get("panel_component", gr.update()) for pc in PLOT_CONFIGS])
+        self.action_panel_outputs_list.extend([self.plot_ui_objects.get(pc["id"], {}).get("bomb_button", gr.update()) for pc in PLOT_CONFIGS])
+        self.action_panel_outputs_list.extend([self.plot_ui_objects.get(pc["id"], {}).get("formula_button", gr.update()) for pc in PLOT_CONFIGS])
+        self.action_panel_outputs_list.extend([self.plot_ui_objects.get(pc["id"], {}).get("explore_button", gr.update()) for pc in PLOT_CONFIGS])
+        self.action_panel_outputs_list.extend([self.section_titles_map.get(s_name, gr.update()) for s_name in UNIQUE_ORDERED_SECTIONS])
+
+        # Outputs for _handle_explore_click
+        self.explore_outputs_list.extend([
+            self.explored_plot_id_state, self.global_actions_column_ui,
+            self.active_panel_action_state, self.formula_close_hint_md
+        ])
+        self.explore_outputs_list.extend([self.plot_ui_objects.get(pc["id"], {}).get("panel_component", gr.update()) for pc in PLOT_CONFIGS])
+        self.explore_outputs_list.extend([self.plot_ui_objects.get(pc["id"], {}).get("explore_button", gr.update()) for pc in PLOT_CONFIGS])
+        self.explore_outputs_list.extend([self.plot_ui_objects.get(pc["id"], {}).get("bomb_button", gr.update()) for pc in PLOT_CONFIGS]) # For resetting if panel closes
+        self.explore_outputs_list.extend([self.plot_ui_objects.get(pc["id"], {}).get("formula_button", gr.update()) for pc in PLOT_CONFIGS])# For resetting if panel closes
+        self.explore_outputs_list.extend([self.section_titles_map.get(s_name, gr.update()) for s_name in UNIQUE_ORDERED_SECTIONS])
+
+
+    def _setup_callbacks(self):
+        # Apply filter button
+        graph_refresh_inputs = [
+            self.token_state, self.date_filter_selector,
+            self.custom_start_date_picker, self.custom_end_date_picker,
+            self.chat_histories_st # Pass the state object itself
+        ]
+        self.apply_filter_btn.click(
+            fn=self._refresh_analytics_graphs_ui,
+            inputs=graph_refresh_inputs,
+            outputs=self.graph_refresh_outputs_list,
+            show_progress="full",
+            api_name="refresh_analytics_graphs_module"
+        )
+
+        # Panel action buttons (bomb, formula, explore)
+        action_click_inputs = [
+            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 = [self.explored_plot_id_state, self.active_panel_action_state]
+
+        for config_item in PLOT_CONFIGS:
+            plot_id = config_item["id"]
+            if plot_id in self.plot_ui_objects:
+                ui_obj = self.plot_ui_objects[plot_id]
+                if ui_obj.get("bomb_button"):
+                    ui_obj["bomb_button"].click(
+                        fn=self._create_panel_action_handler(plot_id, "insights"),
+                        inputs=action_click_inputs,
+                        outputs=self.action_panel_outputs_list,
+                        api_name=f"action_insights_{plot_id}_module"
+                    )
+                if ui_obj.get("formula_button"):
+                    ui_obj["formula_button"].click(
+                        fn=self._create_panel_action_handler(plot_id, "formula"),
+                        inputs=action_click_inputs,
+                        outputs=self.action_panel_outputs_list,
+                        api_name=f"action_formula_{plot_id}_module"
+                    )
+                if ui_obj.get("explore_button"):
+                    # Lambda is okay here as p_id is captured correctly due to loop variable usage
+                    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,
+                        outputs=self.explore_outputs_list,
+                        api_name=f"action_explore_{plot_id}_module"
+                    )
+            else:
+                logging.warning(f"UI object for plot_id '{plot_id}' not found for click handlers in module.")
+
+        # Chat submission
+        chat_submission_outputs = [self.insights_chatbot_ui, self.insights_chat_input_ui, self.chat_histories_st]
+        chat_submission_inputs = [
+            self.insights_chat_input_ui, self.current_chat_plot_id_st,
+            self.chat_histories_st, self.plot_data_for_chatbot_st
+        ]
+        self.insights_chat_input_ui.submit(
+            fn=self._handle_chat_message_submission,
+            inputs=chat_submission_inputs,
+            outputs=chat_submission_outputs,
+            api_name="submit_chat_message_module"
+        )
+
+        # Suggested questions
+        suggestion_click_inputs_base = [
+            self.current_chat_plot_id_st, self.chat_histories_st, self.plot_data_for_chatbot_st
+        ]
+        self.insights_suggestion_1_btn.click(
+            fn=self._handle_suggested_question_click,
+            inputs=[self.insights_suggestion_1_btn] + suggestion_click_inputs_base, # Pass the button itself for its value
+            outputs=chat_submission_outputs,
+            api_name="click_suggestion_1_module"
+        )
+        self.insights_suggestion_2_btn.click(
+            fn=self._handle_suggested_question_click,
+            inputs=[self.insights_suggestion_2_btn] + suggestion_click_inputs_base,
+            outputs=chat_submission_outputs,
+            api_name="click_suggestion_2_module"
+        )
+        self.insights_suggestion_3_btn.click(
+            fn=self._handle_suggested_question_click,
+            inputs=[self.insights_suggestion_3_btn] + suggestion_click_inputs_base,
+            outputs=chat_submission_outputs,
+            api_name="click_suggestion_3_module"
+        )
+
+    def create_tab_ui(self):
+        # This method is called by the main app to build the UI for this tab
+        with gr.TabItem("2️⃣ Analisi Grafici", id="tab_analytics_module"): # Changed id to avoid conflict if old tab exists temporarily
+            gr.Markdown("## 📈 Analisi Performance LinkedIn")
+            gr.Markdown("Seleziona un intervallo di date per i grafici. Clicca i pulsanti (💣 Insights, ƒ Formula, 🧭 Esplora) su un grafico per azioni.")
+            self.analytics_status_md = gr.Markdown("Stato analisi grafici...")
+
+            with gr.Row():
+                self.date_filter_selector = gr.Radio(
+                    ["Sempre", "Ultimi 7 Giorni", "Ultimi 30 Giorni", "Intervallo Personalizzato"],
+                    label="Seleziona Intervallo Date per Grafici", value="Sempre", scale=3
+                )
+                with gr.Column(scale=2):
+                    self.custom_start_date_picker = gr.DateTime(label="Data Inizio", visible=False, include_time=False, type="datetime")
+                    self.custom_end_date_picker = gr.DateTime(label="Data Fine", visible=False, include_time=False, type="datetime")
+
+            self.apply_filter_btn = gr.Button("🔍 Applica Filtro & Aggiorna Grafici", variant="primary")
+
+            self.date_filter_selector.change(
+                fn=self._toggle_custom_date_pickers,
+                inputs=[self.date_filter_selector],
+                outputs=[self.custom_start_date_picker, self.custom_end_date_picker]
+            )
+
+            # Plot area and actions column
+            with gr.Row(equal_height=False):
+                with gr.Column(scale=8) as self.plots_area_col:
+                    # Dynamically build plot UI objects and section titles
+                    ui_elements_tuple = self.build_analytics_tab_plot_area(PLOT_CONFIGS) # Call injected function
+                    if isinstance(ui_elements_tuple, tuple) and len(ui_elements_tuple) == 2:
+                        self.plot_ui_objects, self.section_titles_map = ui_elements_tuple
+                        # Verify section_titles_map completeness (optional, good for debugging)
+                        if not all(sec_name in self.section_titles_map for sec_name in UNIQUE_ORDERED_SECTIONS):
+                            logging.error("section_titles_map from build_analytics_tab_plot_area is incomplete in module.")
+                            # Create placeholders if missing, to prevent errors with output lists
+                            for sec_name in UNIQUE_ORDERED_SECTIONS:
+                                if sec_name not in self.section_titles_map:
+                                    logging.warning(f"Creating fallback Markdown for missing section title: {sec_name}")
+                                    self.section_titles_map[sec_name] = gr.Markdown(f"### {sec_name} (Error Placeholder)")
+                    else:
+                        logging.error("build_analytics_tab_plot_area did not return a tuple of (plot_ui_objects, section_titles_map). Using fallback.")
+                        # Fallback: try to use the result if it's a dict, otherwise empty
+                        self.plot_ui_objects = ui_elements_tuple if isinstance(ui_elements_tuple, dict) else {}
+                        for sec_name in UNIQUE_ORDERED_SECTIONS: # Ensure section_titles_map has entries
+                             self.section_titles_map[sec_name] = gr.Markdown(f"### {sec_name} (Error Placeholder)")
+
+
+                with gr.Column(scale=4, visible=False) as self.global_actions_column_ui:
+                    gr.Markdown("### 💡 Azioni Contestuali Grafico")
+                    self.insights_chatbot_ui = gr.Chatbot(
+                        label="Chat Insights", type="messages", height=450,
+                        bubble_full_width=False, visible=False, show_label=False,
+                        placeholder="L'analisi AI del grafico apparirà qui. Fai domande di approfondimento!"
+                    )
+                    self.insights_chat_input_ui = gr.Textbox(
+                        label="La tua domanda:", placeholder="Chiedi all'AI riguardo a questo grafico...",
+                        lines=2, visible=False, show_label=False
+                    )
+                    with gr.Row(visible=False) as self.insights_suggestions_row_ui:
+                        self.insights_suggestion_1_btn = gr.Button(value="Suggerimento 1", size="sm", min_width=50)
+                        self.insights_suggestion_2_btn = gr.Button(value="Suggerimento 2", size="sm", min_width=50)
+                        self.insights_suggestion_3_btn = gr.Button(value="Suggerimento 3", size="sm", min_width=50)
+
+                    self.formula_display_markdown_ui = gr.Markdown(
+                        "I dettagli sulla formula/metodologia appariranno qui.", visible=False
+                    )
+                    self.formula_close_hint_md = gr.Markdown(
+                        "<p style='font-size:0.9em; text-align:center; margin-top:10px;'><em>Click the active ƒ button on the plot again to close this panel.</em></p>",
+                        visible=False
+                    )
+            
+            # After all UI components are defined, populate the output lists
+            self._define_callback_outputs()
+            # Then, set up the callbacks that use these components and output lists
+            self._setup_callbacks()
+
+        # The method doesn't need to return anything as it modifies the Gradio app context directly.
+        # The main app will access necessary components via the instance attributes if needed (e.g., for .then() inputs).