Update app.py

app.py

@@ -132,40 +132,30 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             ]
             assert len(plot_configs) == 19, "Mancata corrispondenza in plot_configs e grafici attesi."
             
-            # Get unique section names in order of appearance in plot_configs
             unique_ordered_sections = list(OrderedDict.fromkeys(pc["section"] for pc in plot_configs))
             num_unique_sections = len(unique_ordered_sections)
 
             active_panel_action_state = gr.State(None)
             explored_plot_id_state = gr.State(None)
 
-            # plot_ui_objects will store plot-specific UI like panels and buttons
-            # section_titles_map will store Markdown components for section titles
             plot_ui_objects = {} 
-            section_titles_map = {} # Expected to be populated by build_analytics_tab_plot_area
+            section_titles_map = {} 
 
             with gr.Row(equal_height=False):
                 with gr.Column(scale=8) as plots_area_col:
-                    # IMPORTANT ASSUMPTION: build_analytics_tab_plot_area now returns a tuple:
-                    # (dict_of_plot_ui_elements, dict_of_section_title_markdown_components)
-                    # Ensure ui_generators.py is updated accordingly.
-                    ui_elements_tuple = build_analytics_tab_plot_area(plot_configs)
+                    ui_elements_tuple = build_analytics_tab_plot_area(plot_configs) # This function is in ui_generators.py
                     if isinstance(ui_elements_tuple, tuple) and len(ui_elements_tuple) == 2:
-                        plot_ui_objects = ui_elements_tuple[0]
-                        section_titles_map = ui_elements_tuple[1]
-                        # Verify section_titles_map contains all unique_ordered_sections
+                        plot_ui_objects, section_titles_map = ui_elements_tuple
                         if not all(sec_name in section_titles_map for sec_name in unique_ordered_sections):
-                            logging.error("section_titles_map from build_analytics_tab_plot_area is incomplete or missing keys for defined sections.")
-                            # Fallback for safety, though this indicates an issue in ui_generators
+                            logging.error("section_titles_map from build_analytics_tab_plot_area is incomplete.")
                             for sec_name in unique_ordered_sections:
                                 if sec_name not in section_titles_map:
-                                     section_titles_map[sec_name] = gr.Markdown(f"## {sec_name} (Placeholder - Error)") # Placeholder
+                                     section_titles_map[sec_name] = gr.Markdown(f"### {sec_name} (Error Placeholder)") 
                     else:
-                        logging.error("build_analytics_tab_plot_area did not return the expected tuple (plot_ui_objects, section_titles_map). Section titles will not work correctly.")
-                        plot_ui_objects = ui_elements_tuple # Old behavior, section titles won't work
-                        # Create placeholder section_titles_map to prevent crashes, but log error
-                        for sec_name in unique_ordered_sections:
-                            section_titles_map[sec_name] = gr.Markdown(f"## {sec_name} (Placeholder - Error)")
+                        logging.error("build_analytics_tab_plot_area did not return (plot_ui_objects, section_titles_map).")
+                        plot_ui_objects = ui_elements_tuple if isinstance(ui_elements_tuple, dict) else {} # Fallback
+                        for sec_name in unique_ordered_sections: # Fallback for section titles
+                            section_titles_map[sec_name] = gr.Markdown(f"### {sec_name} (Error Placeholder)")
 
 
                 with gr.Column(scale=4, visible=False) as global_actions_column_ui:
@@ -187,34 +177,32 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                     formula_display_markdown_ui = gr.Markdown(
                         "I dettagli sulla formula/metodologia appariranno qui.", visible=False
                     )
+                    # NEW: Hint for closing the formula panel
+                    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
+                    )
+
 
             async def handle_panel_action(
-                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 
+                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"Azione '{action_type}' per grafico: {plot_id_clicked}. Attualmente attivo: {current_active_action_from_state}, Esplorato: {current_explored_plot_id}")
+                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"Configurazione non trovata per plot_id {plot_id_clicked}")
+                    logging.error(f"Config not found for plot_id {plot_id_clicked}")
+                    # Ensure this error return matches the expected number of outputs
                     num_plots = len(plot_configs)
-                    error_output_list = [
-                        gr.update(visible=False), gr.update(visible=False), gr.update(value=[]),
-                        gr.update(visible=False), gr.update(visible=False), gr.update(), gr.update(), gr.update(),
-                        gr.update(visible=False), gr.update(value=""),
-                        current_active_action_from_state, current_chat_plot_id, current_chat_histories,
-                        current_explored_plot_id 
-                    ]
-                    error_output_list.extend([gr.update()] * num_plots)  # Panel vis
-                    error_output_list.extend([gr.update()] * (2 * num_plots))  # Bomb, Formula icons
-                    error_output_list.extend([gr.update()] * num_plots)  # Explore icons
-                    error_output_list.extend([gr.update()] * num_unique_sections) # Section title vis
-                    return error_output_list
+                    error_list = [gr.update(visible=False)] * 10 # Base action panel UI elements (incl. new hint)
+                    error_list.extend([current_active_action_from_state, current_chat_plot_id, current_chat_histories, current_explored_plot_id]) # States
+                    error_list.extend([gr.update()] * num_plots)  # Panel visibilities
+                    error_list.extend([gr.update()] * (2 * num_plots))  # Bomb, Formula icons
+                    error_list.extend([gr.update()] * num_plots)  # Explore icons
+                    error_list.extend([gr.update()] * num_unique_sections) # Section title visibilities
+                    return error_list
 
                 clicked_plot_label = clicked_plot_config["label"]
                 clicked_plot_section = clicked_plot_config["section"]
@@ -224,196 +212,179 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 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)
-                chatbot_content_update, suggestion_1_update, suggestion_2_update, suggestion_3_update, formula_content_update = gr.update(), gr.update(), gr.update(), gr.update(), gr.update()
+                formula_close_hint_visible_update = gr.update(visible=False) # NEW: Default to hidden
+                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
-                updated_chat_histories = current_chat_histories
-                new_explored_plot_id_to_set = current_explored_plot_id 
-
-                panel_visibility_updates = []
-                action_button_updates = [] 
-                explore_button_updates = []
-                section_title_visibility_updates = [gr.update()] * num_unique_sections
+                new_active_action_state_to_set, new_current_chat_plot_id = None, current_chat_plot_id
+                updated_chat_histories, new_explored_plot_id_to_set = current_chat_histories, current_explored_plot_id
 
+                panel_vis_updates, action_btn_updates, 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"Chiusura pannello {action_type} per {plot_id_clicked}.")
-
-                    if current_explored_plot_id: 
-                        explored_plot_cfg = next((p for p in plot_configs if p["id"] == current_explored_plot_id), None)
-                        explored_section_to_show = explored_plot_cfg["section"] if explored_plot_cfg else None
+                    action_col_visible_update = gr.update(visible=False) # Hide the whole right panel
+                    # formula_close_hint_visible_update is already set to hidden by default
+                    logging.info(f"Toggling OFF panel {action_type} for {plot_id_clicked}.")
+                    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_visibility_updates[i] = gr.update(visible=(sec_name == explored_section_to_show))
-                        for cfg_item_iter in plot_configs:
-                            is_explored = (cfg_item_iter["id"] == current_explored_plot_id)
-                            panel_visibility_updates.append(gr.update(visible=is_explored))
-                            explore_button_updates.append(gr.update(value=ACTIVE_ICON if is_explored else EXPLORE_ICON))
-                    else: 
-                        for i in range(num_unique_sections): section_title_visibility_updates[i] = gr.update(visible=True)
+                            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)
+                            panel_vis_updates.append(gr.update(visible=is_exp))
+                            explore_btn_updates.append(gr.update(value=ACTIVE_ICON if is_exp else EXPLORE_ICON))
+                    else: # No explore active, make all plots and sections visible
+                        for i in range(num_unique_sections): section_title_vis_updates[i] = gr.update(visible=True)
                         for _ in plot_configs:
-                            panel_visibility_updates.append(gr.update(visible=True))
-                            explore_button_updates.append(gr.update(value=EXPLORE_ICON))
-                    
+                            panel_vis_updates.append(gr.update(visible=True))
+                            explore_btn_updates.append(gr.update(value=EXPLORE_ICON))
                     for _ in plot_configs: # Reset bomb/formula icons
-                        action_button_updates.append(gr.update(value=BOMB_ICON))
-                        action_button_updates.append(gr.update(value=FORMULA_ICON))
+                        action_btn_updates.extend([gr.update(value=BOMB_ICON), gr.update(value=FORMULA_ICON)])
                     if action_type == "insights": new_current_chat_plot_id = None
 
-                else: # Opening a new panel or switching
+                else: # Opening a new panel or switching to a different one
                     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 explore
-                    
-                    logging.info(f"Apertura pannello {action_type} per {plot_id_clicked}. Solo questo grafico visibile. Esplorazione annullata.")
+                    action_col_visible_update = gr.update(visible=True) # Show the right panel
+                    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.")
 
                     for i, sec_name in enumerate(unique_ordered_sections): # Show only relevant section title
-                        section_title_visibility_updates[i] = gr.update(visible=(sec_name == clicked_plot_section))
-
-                    for cfg_item_iter in plot_configs: # Show only relevant plot panel
-                        panel_visibility_updates.append(gr.update(visible=(cfg_item_iter["id"] == plot_id_clicked)))
-                        explore_button_updates.append(gr.update(value=EXPLORE_ICON)) # Reset all explore buttons
-
-                    for cfg_item_btn_iter in plot_configs: # Set active icons for bomb/formula
-                        is_active_insights = new_active_action_state_to_set == {"plot_id": cfg_item_btn_iter["id"], "type": "insights"}
-                        is_active_formula = new_active_action_state_to_set == {"plot_id": cfg_item_btn_iter["id"], "type": "formula"}
-                        action_button_updates.append(gr.update(value=ACTIVE_ICON if is_active_insights else BOMB_ICON))
-                        action_button_updates.append(gr.update(value=ACTIVE_ICON if is_active_formula else FORMULA_ICON))
-
+                        section_title_vis_updates[i] = gr.update(visible=(sec_name == clicked_plot_section))
+                    for cfg in plot_configs: # Show only relevant plot panel
+                        panel_vis_updates.append(gr.update(visible=(cfg["id"] == plot_id_clicked)))
+                        explore_btn_updates.append(gr.update(value=EXPLORE_ICON)) # Reset all explore buttons
+                    
+                    for cfg_btn in plot_configs: # Set active icons for bomb/formula
+                        is_act_ins = new_active_action_state_to_set == {"plot_id": cfg_btn["id"], "type": "insights"}
+                        is_act_for = new_active_action_state_to_set == {"plot_id": cfg_btn["id"], "type": "formula"}
+                        action_btn_updates.extend([gr.update(value=ACTIVE_ICON if is_act_ins else BOMB_ICON), 
+                                                   gr.update(value=ACTIVE_ICON if is_act_for else FORMULA_ICON)])
                     if action_type == "insights":
                         insights_chatbot_visible_update, insights_chat_input_visible_update, insights_suggestions_row_visible_update = gr.update(visible=True), gr.update(visible=True), gr.update(visible=True)
                         new_current_chat_plot_id = plot_id_clicked
-                        chat_history_for_this_plot = current_chat_histories.get(plot_id_clicked, [])
-                        plot_specific_data_summary = current_plot_data_for_chatbot.get(plot_id_clicked, f"Nessun sommario dati specifico disponibile per '{clicked_plot_label}'.")
-                        if not chat_history_for_this_plot:
-                            initial_llm_prompt, suggestions = get_initial_insight_prompt_and_suggestions(plot_id_clicked, clicked_plot_label, plot_specific_data_summary)
-                            history_for_llm_first_turn = [{"role": "user", "content": initial_llm_prompt}]
-                            initial_bot_response_text = await generate_llm_response(initial_llm_prompt, plot_id_clicked, clicked_plot_label, history_for_llm_first_turn, plot_specific_data_summary)
-                            chat_history_for_this_plot = [{"role": "assistant", "content": initial_bot_response_text}]
-                            updated_chat_histories = {**current_chat_histories, plot_id_clicked: chat_history_for_this_plot}
-                        else:
-                            _, suggestions = get_initial_insight_prompt_and_suggestions(plot_id_clicked, clicked_plot_label, plot_specific_data_summary)
-                        chatbot_content_update = gr.update(value=chat_history_for_this_plot)
-                        suggestion_1_update, suggestion_2_update, suggestion_3_update = gr.update(value=suggestions[0] if suggestions else "N/A"), gr.update(value=suggestions[1] if len(suggestions) > 1 else "N/A"), gr.update(value=suggestions[2] if len(suggestions) > 2 else "N/A")
+                        history = current_chat_histories.get(plot_id_clicked, [])
+                        summary = current_plot_data_for_chatbot.get(plot_id_clicked, f"No summary for '{clicked_plot_label}'.")
+                        if not history:
+                            prompt, sugg = get_initial_insight_prompt_and_suggestions(plot_id_clicked, clicked_plot_label, summary)
+                            llm_hist = [{"role": "user", "content": prompt}]
+                            resp = await generate_llm_response(prompt, plot_id_clicked, clicked_plot_label, llm_hist, summary)
+                            history = [{"role": "assistant", "content": resp}]
+                            updated_chat_histories = {**current_chat_histories, plot_id_clicked: history}
+                        else: _, sugg = get_initial_insight_prompt_and_suggestions(plot_id_clicked, clicked_plot_label, summary)
+                        chatbot_content_update = gr.update(value=history)
+                        s1_upd,s2_upd,s3_upd = gr.update(value=sugg[0] if sugg else "N/A"),gr.update(value=sugg[1] if len(sugg)>1 else "N/A"),gr.update(value=sugg[2] if len(sugg)>2 else "N/A")
                     elif action_type == "formula":
                         formula_display_visible_update = gr.update(visible=True)
-                        formula_key = PLOT_ID_TO_FORMULA_KEY_MAP.get(plot_id_clicked)
-                        formula_text = f"**Formula/Metodologia per: {clicked_plot_label}**\n\nID Grafico: `{plot_id_clicked}`.\n\n"
-                        formula_text += PLOT_FORMULAS.get(formula_key, {}).get('description', "(Nessuna descrizione dettagliata)") if formula_key else "(Formula non definita)"
-                        formula_content_update = gr.update(value=formula_text)
+                        formula_close_hint_visible_update = gr.update(visible=True) # NEW: Show hint
+                        f_key = PLOT_ID_TO_FORMULA_KEY_MAP.get(plot_id_clicked)
+                        f_text = f"**Formula/Methodology for: {clicked_plot_label}** (ID: `{plot_id_clicked}`)\n\n"
+                        if f_key and f_key in PLOT_FORMULAS:
+                            f_data = PLOT_FORMULAS[f_key]
+                            f_text += f"### {f_data['title']}\n\n{f_data['description']}\n\n**Calculation:**\n" + "\n".join([f"- {s}" for s in f_data['calculation_steps']])
+                        else: f_text += "(No detailed formula information found.)"
+                        formula_content_update = gr.update(value=f_text)
                         new_current_chat_plot_id = None
 
                 final_updates = [
                     action_col_visible_update, insights_chatbot_visible_update, chatbot_content_update,
                     insights_chat_input_visible_update, insights_suggestions_row_visible_update, 
-                    suggestion_1_update, suggestion_2_update, suggestion_3_update,
-                    formula_display_visible_update, formula_content_update,
+                    s1_upd, s2_upd, s3_upd, formula_display_visible_update, formula_content_update,
+                    formula_close_hint_visible_update, # NEW
                     new_active_action_state_to_set, new_current_chat_plot_id, updated_chat_histories,
                     new_explored_plot_id_to_set 
                 ]
-                final_updates.extend(panel_visibility_updates)
-                final_updates.extend(action_button_updates)
-                final_updates.extend(explore_button_updates)
-                final_updates.extend(section_title_visibility_updates)
+                final_updates.extend(panel_vis_updates)
+                final_updates.extend(action_btn_updates)
+                final_updates.extend(explore_btn_updates)
+                final_updates.extend(section_title_vis_updates)
                 return final_updates
 
             async def handle_chat_message_submission(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():
-                    yield chat_histories.get(current_plot_id, []), gr.update(value=""), chat_histories
-                    return
-                plot_config = next((p for p in plot_configs if p["id"] == current_plot_id), None)
-                plot_label = plot_config["label"] if plot_config else "Grafico Selezionato"
-                plot_specific_data_summary = current_plot_data_for_chatbot.get(current_plot_id, f"Nessun sommario dati specifico disponibile per '{plot_label}'.")
-                history_for_plot = chat_histories.get(current_plot_id, []).copy() + [{"role": "user", "content": user_message}]
-                yield history_for_plot, gr.update(value=""), chat_histories
-                bot_response_text = await generate_llm_response(user_message, current_plot_id, plot_label, history_for_plot, plot_specific_data_summary)
-                history_for_plot.append({"role": "assistant", "content": bot_response_text})
-                yield history_for_plot, "", {**chat_histories, current_plot_id: history_for_plot}
+                    yield chat_histories.get(current_plot_id, []), gr.update(value=""), chat_histories; return
+                cfg = next((p for p in plot_configs if p["id"] == current_plot_id), None)
+                lbl = cfg["label"] if cfg else "Selected Plot"
+                summary = current_plot_data_for_chatbot.get(current_plot_id, f"No summary for '{lbl}'.")
+                hist = chat_histories.get(current_plot_id, []).copy() + [{"role": "user", "content": user_message}]
+                yield hist, gr.update(value=""), chat_histories
+                resp = await generate_llm_response(user_message, current_plot_id, lbl, hist, summary)
+                hist.append({"role": "assistant", "content": resp})
+                yield hist, "", {**chat_histories, current_plot_id: hist}
 
             async def handle_suggested_question_click(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():
-                    yield chat_histories.get(current_plot_id, []), gr.update(value=""), chat_histories
-                    return
-                async for update in handle_chat_message_submission(suggestion_text, current_plot_id, chat_histories, current_plot_data_for_chatbot):
-                    yield update
+                    yield chat_histories.get(current_plot_id, []), gr.update(value=""), chat_histories; return
+                async for update in handle_chat_message_submission(suggestion_text, current_plot_id, chat_histories, current_plot_data_for_chatbot): yield update
 
             def handle_explore_click(plot_id_clicked, current_explored_plot_id_from_state, current_active_panel_action_state):
-                logging.info(f"Click Esplora: {plot_id_clicked}. Esplorato: {current_explored_plot_id_from_state}. Pannello Attivo: {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 plot_ui_objects: # Should use plot_ui_objects here
-                    logging.error("plot_ui_objects non popolato.")
-                    error_updates = [current_explored_plot_id_from_state, gr.update(visible=False), current_active_panel_action_state] + \
-                                    [gr.update()] * (num_plots + num_plots + 2 * num_plots + num_unique_sections)
-                    return error_updates
-
-                new_explored_id_to_set = None
-                is_toggling_off_explore = (plot_id_clicked == current_explored_plot_id_from_state)
-                action_col_update = gr.update() 
-                new_active_panel_action_state_update = current_active_panel_action_state
-                
-                panel_vis_updates, explore_btn_updates, bomb_btn_icon_upds, formula_btn_icon_upds = [], [], [], []
-                section_title_vis_updates = [gr.update()] * num_unique_sections
-                
-                clicked_plot_cfg = next((p for p in plot_configs if p["id"] == plot_id_clicked), None)
-                section_of_clicked_plot = clicked_plot_cfg["section"] if clicked_plot_cfg else None
+                if not plot_ui_objects: 
+                    logging.error("plot_ui_objects not populated for handle_explore_click.")
+                    # Match expected outputs: states (3) + panels (N) + explore_btns (N) + bomb_btns (N) + formula_btns (N) + section_titles (M) + formula_hint (1)
+                    err_list = [current_explored_plot_id_from_state, gr.update(visible=False), current_active_panel_action_state]
+                    err_list.extend([gr.update()] * (num_plots * 4 + num_unique_sections + 1) )
+                    return err_list
+
+                new_explored_id_to_set, is_toggling_off_explore = None, (plot_id_clicked == current_explored_plot_id_from_state)
+                action_col_upd, new_active_panel_state_upd = gr.update(), current_active_panel_action_state
+                panel_vis, explore_btns, bomb_btns, formula_btns = [], [], [], []
+                section_title_vis = [gr.update()] * num_unique_sections
+                formula_hint_upd = gr.update(visible=False) # Hide formula hint when exploring
+
+                clicked_cfg = next((p for p in plot_configs if p["id"] == plot_id_clicked), None)
+                sec_of_clicked = clicked_cfg["section"] if clicked_cfg else None
 
                 if is_toggling_off_explore:
                     new_explored_id_to_set = None
-                    logging.info(f"Stop esplorazione: {plot_id_clicked}. Tutti i grafici/titoli visibili.")
-                    for i in range(num_unique_sections): section_title_vis_updates[i] = gr.update(visible=True)
+                    logging.info(f"Stopping explore for {plot_id_clicked}. All plots/sections visible.")
+                    for i in range(num_unique_sections): section_title_vis[i] = gr.update(visible=True)
                     for _ in plot_configs:
-                        panel_vis_updates.append(gr.update(visible=True))
-                        explore_btn_updates.append(gr.update(value=EXPLORE_ICON))
-                        bomb_btn_icon_upds.append(gr.update()) # No change if not active
-                        formula_btn_icon_upds.append(gr.update()) # No change if not active
+                        panel_vis.append(gr.update(visible=True)); explore_btns.append(gr.update(value=EXPLORE_ICON))
+                        bomb_btns.append(gr.update()); formula_btns.append(gr.update()) # No change to these unless panel was active
                 else: 
                     new_explored_id_to_set = plot_id_clicked
-                    logging.info(f"Esplorazione: {plot_id_clicked}. Altri grafici/titoli nascosti.")
-                    for i, sec_name in enumerate(unique_ordered_sections):
-                        section_title_vis_updates[i] = gr.update(visible=(sec_name == section_of_clicked_plot))
+                    logging.info(f"Exploring {plot_id_clicked}. Hiding other plots/sections.")
+                    for i, sec_name in enumerate(unique_ordered_sections): section_title_vis[i] = gr.update(visible=(sec_name == sec_of_clicked))
                     for cfg in plot_configs:
                         is_target = (cfg["id"] == new_explored_id_to_set)
-                        panel_vis_updates.append(gr.update(visible=is_target))
-                        explore_btn_updates.append(gr.update(value=ACTIVE_ICON if is_target else EXPLORE_ICON))
+                        panel_vis.append(gr.update(visible=is_target)); explore_btns.append(gr.update(value=ACTIVE_ICON if is_target else EXPLORE_ICON))
                     if current_active_panel_action_state: # Close insight/formula if explore is activated
-                        logging.info("Chiusura pannello azioni per attivazione esplorazione.")
-                        action_col_update = gr.update(visible=False)
-                        new_active_panel_action_state_update = None
-                        for _ in plot_configs:
-                            bomb_btn_icon_upds.append(gr.update(value=BOMB_ICON))
-                            formula_btn_icon_upds.append(gr.update(value=FORMULA_ICON))
-                    else:
-                        for _ in plot_configs: bomb_btn_icon_upds.append(gr.update()); formula_btn_icon_upds.append(gr.update())
+                        logging.info("Closing active insight/formula panel due to explore click.")
+                        action_col_upd = gr.update(visible=False); new_active_panel_state_upd = None
+                        for _ in plot_configs: bomb_btns.extend([gr.update(value=BOMB_ICON), gr.update(value=FORMULA_ICON)])
+                    else: 
+                        for _ in plot_configs: bomb_btns.append(gr.update()); formula_btns.append(gr.update())
                 
-                return [new_explored_id_to_set, action_col_update, new_active_panel_action_state_update] + \
-                       panel_vis_updates + explore_btn_updates + bomb_btn_icon_upds + formula_btn_icon_upds + section_title_vis_updates
+                return [new_explored_id_to_set, action_col_upd, new_active_panel_state_upd, formula_hint_upd] + \
+                       panel_vis + explore_btns + bomb_btns + formula_btns + section_title_vis
 
             # --- Define Output Lists for Event Handlers ---
-            # Base UI elements for action panel
             _base_action_panel_ui_outputs = [
                 global_actions_column_ui, insights_chatbot_ui, insights_chatbot_ui, 
                 insights_chat_input_ui, insights_suggestions_row_ui, 
                 insights_suggestion_1_btn, insights_suggestion_2_btn, insights_suggestion_3_btn,
-                formula_display_markdown_ui, formula_display_markdown_ui
+                formula_display_markdown_ui, formula_display_markdown_ui,
+                formula_close_hint_md # NEW
             ]
             _action_panel_state_outputs = [active_panel_action_state, current_chat_plot_id_st, chat_histories_st, explored_plot_id_state]
             
             action_panel_outputs_list = _base_action_panel_ui_outputs + _action_panel_state_outputs
-            action_panel_outputs_list.extend([plot_ui_objects[pid]["panel_component"] if pid in plot_ui_objects else gr.update() for pid in [pc["id"] for pc in plot_configs]]) # Panel vis
-            action_panel_outputs_list.extend([plot_ui_objects[pid]["bomb_button"] if pid in plot_ui_objects else gr.update() for pid in [pc["id"] for pc in plot_configs]])    # Bomb icon
-            action_panel_outputs_list.extend([plot_ui_objects[pid]["formula_button"] if pid in plot_ui_objects else gr.update() for pid in [pc["id"] for pc in plot_configs]]) # Formula icon
-            action_panel_outputs_list.extend([plot_ui_objects[pid]["explore_button"] if pid in plot_ui_objects else gr.update() for pid in [pc["id"] for pc in plot_configs]]) # Explore icon
-            action_panel_outputs_list.extend([section_titles_map[s_name] if s_name in section_titles_map else gr.update() for s_name in unique_ordered_sections]) # Section Titles
+            action_panel_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("panel_component", gr.update()) for pc in plot_configs]) # Panel vis
+            action_panel_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("bomb_button", gr.update()) for pc in plot_configs])    # Bomb icon
+            action_panel_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("formula_button", gr.update()) for pc in plot_configs]) # Formula icon
+            action_panel_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("explore_button", gr.update()) for pc in plot_configs]) # Explore icon
+            action_panel_outputs_list.extend([section_titles_map.get(s_name, gr.update()) for s_name in unique_ordered_sections]) # Section Titles
 
-            _explore_state_outputs = [explored_plot_id_state, global_actions_column_ui, active_panel_action_state]
+            _explore_state_outputs = [explored_plot_id_state, global_actions_column_ui, active_panel_action_state, formula_close_hint_md] # NEW: add hint to explore outputs
             explore_outputs_list = _explore_state_outputs
-            explore_outputs_list.extend([plot_ui_objects[pid]["panel_component"] if pid in plot_ui_objects else gr.update() for pid in [pc["id"] for pc in plot_configs]]) # Panel vis
-            explore_outputs_list.extend([plot_ui_objects[pid]["explore_button"] if pid in plot_ui_objects else gr.update() for pid in [pc["id"] for pc in plot_configs]]) # Explore icon
-            explore_outputs_list.extend([plot_ui_objects[pid]["bomb_button"] if pid in plot_ui_objects else gr.update() for pid in [pc["id"] for pc in plot_configs]])    # Bomb icon
-            explore_outputs_list.extend([plot_ui_objects[pid]["formula_button"] if pid in plot_ui_objects else gr.update() for pid in [pc["id"] for pc in plot_configs]]) # Formula icon
-            explore_outputs_list.extend([section_titles_map[s_name] if s_name in section_titles_map else gr.update() for s_name in unique_ordered_sections]) # Section Titles
+            explore_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("panel_component", gr.update()) for pc in plot_configs]) 
+            explore_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("explore_button", gr.update()) for pc in plot_configs]) 
+            explore_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("bomb_button", gr.update()) for pc in plot_configs])    
+            explore_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("formula_button", gr.update()) for pc in plot_configs]) 
+            explore_outputs_list.extend([section_titles_map.get(s_name, gr.update()) for s_name in unique_ordered_sections])
 
             action_click_inputs = [active_panel_action_state, chat_histories_st, current_chat_plot_id_st, plot_data_for_chatbot_st, explored_plot_id_state]
             explore_click_inputs = [explored_plot_id_state, active_panel_action_state]
@@ -442,43 +413,58 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
 
             def refresh_all_analytics_ui_elements(current_token_state, date_filter_val, custom_start_val, custom_end_val, current_chat_histories):
                 logging.info("Refreshing all analytics UI elements and resetting actions/chat.")
-                plot_generation_results = update_analytics_plots_figures(current_token_state, date_filter_val, custom_start_val, custom_end_val, plot_configs)
-                status_msg, generated_figs, new_plot_data_summaries = plot_generation_results[0], plot_generation_results[1:-1], plot_generation_results[-1]
+                plot_gen_results = update_analytics_plots_figures(current_token_state, date_filter_val, custom_start_val, custom_end_val, plot_configs)
+                status_msg, gen_figs, new_summaries = plot_gen_results[0], plot_gen_results[1:-1], plot_gen_results[-1]
                 
                 all_updates = [status_msg]
-                all_updates.extend(generated_figs if len(generated_figs) == len(plot_configs) else [create_placeholder_plot("Error", f"Fig missing {i}") for i in range(len(plot_configs))])
+                all_updates.extend(gen_figs if len(gen_figs) == len(plot_configs) else [create_placeholder_plot("Error", f"Fig missing {i}") for i in range(len(plot_configs))])
                 
-                all_updates.extend([ # Reset action panel UI
+                all_updates.extend([ # Reset action panel UI (11 elements including new hint)
                     gr.update(visible=False), gr.update(value=[], visible=False), gr.update(value="", visible=False),
                     gr.update(visible=False), gr.update(value="S1"), gr.update(value="S2"), gr.update(value="S3"),
-                    gr.update(value="Formula details here.", visible=False),
-                    None, None, {}, new_plot_data_summaries # Reset states
-                ])
-                for _ in plot_configs: # Reset button icons & panel visibility
+                    gr.update(value="Formula details here.", visible=False), gr.update(visible=False), # Formula MD and Hint MD
+                    None, None, {}, new_summaries # Reset states (4 elements)
+                ]) # Total 11 + 4 = 15 here
+                for _ in plot_configs: # Reset button icons & panel visibility (4 per plot)
                     all_updates.extend([gr.update(value=BOMB_ICON), gr.update(value=FORMULA_ICON), gr.update(value=EXPLORE_ICON), gr.update(visible=True)])
-                all_updates.append(None) # Reset explored_plot_id_state
-                all_updates.extend([gr.update(visible=True)] * num_unique_sections) # Make all section titles visible
+                all_updates.append(None) # Reset explored_plot_id_state (1 element)
+                all_updates.extend([gr.update(visible=True)] * num_unique_sections) # Make all section titles visible (M elements)
                 logging.info(f"Prepared {len(all_updates)} updates for analytics refresh.")
                 return all_updates
 
-            apply_filter_and_sync_outputs_list = [analytics_status_md] # Status
-            apply_filter_and_sync_outputs_list.extend([plot_ui_objects[pc["id"]]["plot_component"] if pc["id"] in plot_ui_objects and "plot_component" in plot_ui_objects[pc["id"]] else gr.update() for pc in plot_configs]) # Plot figures
-            apply_filter_and_sync_outputs_list.extend([ # Action panel UI reset
+            apply_filter_and_sync_outputs_list = [analytics_status_md] # Status (1)
+            apply_filter_and_sync_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("plot_component", gr.update()) for pc in plot_configs]) # Plot figures (N)
+            apply_filter_and_sync_outputs_list.extend([ # Action panel UI reset (11 elements)
                 global_actions_column_ui, insights_chatbot_ui, insights_chat_input_ui,
                 insights_suggestions_row_ui, insights_suggestion_1_btn, insights_suggestion_2_btn, insights_suggestion_3_btn,
-                formula_display_markdown_ui,
-                active_panel_action_state, current_chat_plot_id_st, chat_histories_st, plot_data_for_chatbot_st
-            ])
-            for pc in plot_configs: # Button icons and panel visibility
+                formula_display_markdown_ui, formula_close_hint_md, # Added hint
+                active_panel_action_state, current_chat_plot_id_st, chat_histories_st, plot_data_for_chatbot_st # States (4) -> total 11+4 = 15 for this block
+            ]) # This was 12, now 13 with hint. State resets are separate. Let's be precise.
+            # Action Panel UI (9) + Formula MD (1) + Hint MD (1) = 11
+            # States (4) = active_panel_action_state, current_chat_plot_id_st, chat_histories_st, plot_data_for_chatbot_st
+            # So, 11 UI + 4 states = 15 elements.
+            
+            # Corrected block for apply_filter_outputs:
+            _ui_resets_for_filter = [
+                global_actions_column_ui, insights_chatbot_ui, insights_chat_input_ui,
+                insights_suggestions_row_ui, insights_suggestion_1_btn, insights_suggestion_2_btn, insights_suggestion_3_btn,
+                formula_display_markdown_ui, formula_close_hint_md # 9 elements
+            ]
+            _state_resets_for_filter = [active_panel_action_state, current_chat_plot_id_st, chat_histories_st, plot_data_for_chatbot_st] # 4 elements
+            
+            apply_filter_and_sync_outputs_list.extend(_ui_resets_for_filter)
+            apply_filter_and_sync_outputs_list.extend(_state_resets_for_filter)
+
+            for pc in plot_configs: # Button icons (3) and panel visibility (1) = 4 per plot
                 pid = pc["id"]
                 apply_filter_and_sync_outputs_list.extend([
-                    plot_ui_objects[pid]["bomb_button"] if pid in plot_ui_objects else gr.update(),
-                    plot_ui_objects[pid]["formula_button"] if pid in plot_ui_objects else gr.update(),
-                    plot_ui_objects[pid]["explore_button"] if pid in plot_ui_objects else gr.update(),
-                    plot_ui_objects[pid]["panel_component"] if pid in plot_ui_objects else gr.update()
+                    plot_ui_objects.get(pid, {}).get("bomb_button", gr.update()),
+                    plot_ui_objects.get(pid, {}).get("formula_button", gr.update()),
+                    plot_ui_objects.get(pid, {}).get("explore_button", gr.update()),
+                    plot_ui_objects.get(pid, {}).get("panel_component", gr.update())
                 ])
-            apply_filter_and_sync_outputs_list.append(explored_plot_id_state) # Reset explored state
-            apply_filter_and_sync_outputs_list.extend([section_titles_map[s_name] if s_name in section_titles_map else gr.update() for s_name in unique_ordered_sections]) # Section Titles
+            apply_filter_and_sync_outputs_list.append(explored_plot_id_state) # Reset explored state (1)
+            apply_filter_and_sync_outputs_list.extend([section_titles_map.get(s_name, gr.update()) for s_name in unique_ordered_sections]) # Section Titles (M)
             
             apply_filter_btn.click(
                 fn=refresh_all_analytics_ui_elements,
@@ -487,7 +473,6 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             )
 
         with gr.TabItem("3️⃣ Menzioni", id="tab_mentions"):
-            # ... (rest of the tab unchanged) ...
             refresh_mentions_display_btn = gr.Button("🔄 Aggiorna Visualizzazione Menzioni", variant="secondary")
             mentions_html = gr.HTML("Dati menzioni...")
             mentions_sentiment_dist_plot = gr.Plot(label="Distribuzione Sentiment Menzioni")
@@ -498,7 +483,6 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             )
 
         with gr.TabItem("4️⃣ Statistiche Follower", id="tab_follower_stats"):
-            # ... (rest of the tab unchanged) ...
             refresh_follower_stats_btn = gr.Button("🔄 Aggiorna Visualizzazione Statistiche Follower", variant="secondary")
             follower_stats_html = gr.HTML("Statistiche follower...")
             with gr.Row():