Update app.py

app.py

@@ -1,4 +1,4 @@
-# app.py 
+# app.py
 # (Showing relevant parts that need modification)
 import gradio as gr
 import pandas as pd
@@ -24,11 +24,12 @@ from ui_generators import (
     display_main_dashboard,
     run_mentions_tab_display,
     run_follower_stats_tab_display,
-    build_analytics_tab_plot_area, 
-    BOMB_ICON, EXPLORE_ICON, FORMULA_ICON, ACTIVE_ICON 
+    build_analytics_tab_plot_area,
+    BOMB_ICON, EXPLORE_ICON, FORMULA_ICON, ACTIVE_ICON,
+    create_placeholder_plot # Assuming you have this or similar for error cases
 )
 from analytics_plot_generator import update_analytics_plots_figures
-from formulas import PLOT_FORMULAS 
+from formulas import PLOT_FORMULAS
 
 # --- NEW CHATBOT MODULE IMPORTS ---
 from chatbot_prompts import get_initial_insight_prompt_and_suggestions # MODIFIED IMPORT
@@ -41,7 +42,7 @@ logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(
 
 # --- Gradio UI Blocks ---
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
-                title="LinkedIn Organization Dashboard") as app:
+               title="LinkedIn Organization Dashboard") as app:
     token_state = gr.State(value={
         "token": None, "client_id": None, "org_urn": None,
         "bubble_posts_df": pd.DataFrame(), "bubble_post_stats_df": pd.DataFrame(),
@@ -51,16 +52,16 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
         "config_date_col_followers": "date", "config_media_type_col": "media_type",
         "config_eb_labels_col": "li_eb_label"
     })
-    
-    chat_histories_st = gr.State({}) 
-    current_chat_plot_id_st = gr.State(None) 
-    plot_data_for_chatbot_st = gr.State({}) # NEW: Store data summaries for chatbot
+
+    chat_histories_st = gr.State({})
+    current_chat_plot_id_st = gr.State(None)
+    plot_data_for_chatbot_st = gr.State({})
 
     gr.Markdown("# 🚀 LinkedIn Organization Dashboard")
     url_user_token_display = gr.Textbox(label="User Token (Nascosto)", interactive=False, visible=False)
     status_box = gr.Textbox(label="Stato Generale Token LinkedIn", interactive=False, value="Inizializzazione...")
     org_urn_display = gr.Textbox(label="URN Organizzazione (Nascosto)", interactive=False, visible=False)
-    
+
     app.load(fn=get_url_user_token, inputs=None, outputs=[url_user_token_display, org_urn_display], api_name="get_url_params", show_progress=False)
 
     def initial_load_sequence(url_token, org_urn_val, current_state):
@@ -74,7 +75,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             sync_data_btn = gr.Button("🔄 Sincronizza Dati LinkedIn", variant="primary", visible=False, interactive=False)
             sync_status_html_output = gr.HTML("<p style='text-align:center;'>Stato sincronizzazione...</p>")
             dashboard_display_html = gr.HTML("<p style='text-align:center;'>Caricamento dashboard...</p>")
-            
+
             org_urn_display.change(
                 fn=initial_load_sequence,
                 inputs=[url_user_token_display, org_urn_display, token_state],
@@ -86,15 +87,15 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             gr.Markdown("## 📈 Analisi Performance LinkedIn")
             gr.Markdown("Seleziona un intervallo di date. Clicca i pulsanti (💣 Insights, ƒ Formula, 🧭 Esplora) su un grafico per azioni.")
             analytics_status_md = gr.Markdown("Stato analisi...")
-            
+
             with gr.Row():
                 date_filter_selector = gr.Radio(
                     ["Sempre", "Ultimi 7 Giorni", "Ultimi 30 Giorni", "Intervallo Personalizzato"],
                     label="Seleziona Intervallo Date", value="Sempre", scale=3
                 )
-                with gr.Column(scale=2): 
-                    custom_start_date_picker = gr.DateTime(label="Data Inizio", visible=False, include_time=False, type="datetime") # Use gr.DateTime
-                    custom_end_date_picker = gr.DateTime(label="Data Fine", visible=False, include_time=False, type="datetime") # Use gr.DateTime
+                with gr.Column(scale=2):
+                    custom_start_date_picker = gr.DateTime(label="Data Inizio", visible=False, include_time=False, type="datetime")
+                    custom_end_date_picker = gr.DateTime(label="Data Fine", visible=False, include_time=False, type="datetime")
 
             apply_filter_btn = gr.Button("🔍 Applica Filtro & Aggiorna Analisi", variant="primary")
 
@@ -107,7 +108,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 inputs=[date_filter_selector],
                 outputs=[custom_start_date_picker, custom_end_date_picker]
             )
-            
+
             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"},
@@ -131,130 +132,163 @@ 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."
 
-            active_panel_action_state = gr.State(None) 
-            explored_plot_id_state = gr.State(None) 
-            
-            plot_ui_objects = {} 
+            active_panel_action_state = gr.State(None)
+            explored_plot_id_state = gr.State(None)
+
+            plot_ui_objects = {}
 
             with gr.Row(equal_height=False):
                 with gr.Column(scale=8) as plots_area_col:
                     plot_ui_objects = build_analytics_tab_plot_area(plot_configs)
-                
-                with gr.Column(scale=4, visible=False) as global_actions_column_ui: 
-                    gr.Markdown("### 💡 Azioni Contestuali Grafico") 
-                    
+
+                with gr.Column(scale=4, visible=False) as global_actions_column_ui:
+                    gr.Markdown("### 💡 Azioni Contestuali Grafico")
                     insights_chatbot_ui = gr.Chatbot(
-                        label="Chat Insights", type="messages", height=450, 
+                        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!"
                     )
                     insights_chat_input_ui = gr.Textbox(
-                        label="La tua domanda:", placeholder="Chiedi all'AI riguardo a questo grafico...", 
+                        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 insights_suggestions_row_ui:
                         insights_suggestion_1_btn = gr.Button(value="Suggerimento 1", size="sm", min_width=50)
                         insights_suggestion_2_btn = gr.Button(value="Suggerimento 2", size="sm", min_width=50)
                         insights_suggestion_3_btn = gr.Button(value="Suggerimento 3", size="sm", min_width=50)
-                    
+
                     formula_display_markdown_ui = gr.Markdown(
                         "I dettagli sulla formula/metodologia appariranno qui.", visible=False
                     )
 
-            async def handle_panel_action( 
-                plot_id_clicked: str, 
-                action_type: str, 
-                current_active_action_from_state: dict, 
-                current_chat_histories: dict, 
+            async def handle_panel_action(
+                plot_id_clicked: str,
+                action_type: str, # "insights" or "formula"
+                current_active_action_from_state: dict,
+                current_chat_histories: dict,
                 current_chat_plot_id: str,
-                current_plot_data_for_chatbot: dict # NEW: data summaries
+                current_plot_data_for_chatbot: dict,
+                current_explored_plot_id: str # NEW: Current explore state
             ):
-                logging.info(f"Azione '{action_type}' per grafico: {plot_id_clicked}. Attualmente attivo: {current_active_action_from_state}")
-                
+                logging.info(f"Azione '{action_type}' per grafico: {plot_id_clicked}. Attualmente attivo: {current_active_action_from_state}, Esplorato: {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}")
-                    num_button_updates = 2 * len(plot_configs) # insights, formula buttons
-                    error_updates = [gr.update(visible=False)] * 7 # action_col, chatbot, input, suggestions_row, 3x sugg_btn
-                    error_updates.append(gr.update(visible=False, value="")) # formula_md (visibility and value)
-                    error_updates.extend([current_active_action_from_state, current_chat_plot_id, current_chat_histories]) 
-                    error_updates.extend([gr.update()] * num_button_updates) 
-                    return error_updates
+                    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 # Pass back existing explore state
+                    ]
+                    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
+                    return error_output_list
 
                 clicked_plot_label = clicked_plot_config["label"]
-                
                 hypothetical_new_active_state = {"plot_id": plot_id_clicked, "type": action_type}
                 is_toggling_off = current_active_action_from_state == hypothetical_new_active_state
-                
-                new_active_action_state_to_set = None
-                action_col_visible_update = gr.update(visible=True)
-                
+
+                # Initialize updates
+                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)
+                chatbot_content_update = gr.update()
+                suggestion_1_update, suggestion_2_update, suggestion_3_update = gr.update(), gr.update(), gr.update()
+                formula_content_update = gr.update()
                 
-                chatbot_content_update = gr.update() # No change by default
-                suggestion_1_update = gr.update()
-                suggestion_2_update = gr.update()
-                suggestion_3_update = gr.update()
-                new_current_chat_plot_id = current_chat_plot_id 
-                updated_chat_histories = current_chat_histories 
+                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 # Default to not changing explore state
+
+                panel_visibility_component_updates = []
+                action_button_component_updates = [] # For bomb and formula buttons
+                explore_button_component_updates = []
 
-                formula_content_update = gr.update()
 
                 if is_toggling_off:
                     new_active_action_state_to_set = None
                     action_col_visible_update = gr.update(visible=False)
-                    new_current_chat_plot_id = None 
-                    logging.info(f"Chiusura pannello {action_type} per {plot_id_clicked}")
-                else:
+                    # new_explored_plot_id_to_set remains current_explored_plot_id
+                    
+                    logging.info(f"Chiusura pannello {action_type} per {plot_id_clicked}.")
+                    if current_explored_plot_id: # If an explore view is active, keep it
+                        for cfg_item_iter in plot_configs:
+                            p_id_iter = cfg_item_iter["id"]
+                            is_explored = (p_id_iter == current_explored_plot_id)
+                            panel_visibility_component_updates.append(gr.update(visible=is_explored))
+                            explore_button_component_updates.append(gr.update(value=ACTIVE_ICON if is_explored else EXPLORE_ICON))
+                    else: # No explore active, make all plots visible
+                        for _ in plot_configs:
+                            panel_visibility_component_updates.append(gr.update(visible=True))
+                            explore_button_component_updates.append(gr.update(value=EXPLORE_ICON))
+                    
+                    # Reset bomb/formula icons for all plots to default
+                    for _ in plot_configs:
+                        action_button_component_updates.append(gr.update(value=BOMB_ICON))
+                        action_button_component_updates.append(gr.update(value=FORMULA_ICON))
+                    
+                    if action_type == "insights": new_current_chat_plot_id = None
+
+                else: # Opening a new panel or switching
                     new_active_action_state_to_set = hypothetical_new_active_state
+                    action_col_visible_update = gr.update(visible=True)
+                    
+                    # IMPORTANT: Cancel any active explore view when opening insight/formula
+                    new_explored_plot_id_to_set = None 
+                    
+                    logging.info(f"Apertura pannello {action_type} per {plot_id_clicked}. Solo questo grafico visibile. Esplorazione annullata.")
+
+                    for cfg_item_iter in plot_configs:
+                        p_id_iter = cfg_item_iter["id"]
+                        is_target_plot = (p_id_iter == plot_id_clicked)
+                        panel_visibility_component_updates.append(gr.update(visible=is_target_plot))
+                        # Reset all explore buttons to default as explore is cancelled
+                        explore_button_component_updates.append(gr.update(value=EXPLORE_ICON))
+
+                    # Set active icons for the clicked plot's bomb/formula buttons
+                    for cfg_item_btn_iter in plot_configs:
+                        p_id_btn_iter = cfg_item_btn_iter["id"]
+                        is_active_insights = new_active_action_state_to_set == {"plot_id": p_id_btn_iter, "type": "insights"}
+                        is_active_formula = new_active_action_state_to_set == {"plot_id": p_id_btn_iter, "type": "formula"}
+                        action_button_component_updates.append(gr.update(value=ACTIVE_ICON if is_active_insights else BOMB_ICON))
+                        action_button_component_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
                         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: 
+                        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 
+                                plot_id_clicked, clicked_plot_label, plot_specific_data_summary
                             )
-                            # History for LLM's first turn: the system's prompt as a user message
                             history_for_llm_first_turn = [{"role": "user", "content": initial_llm_prompt}]
-                            
-                            logging.info(f"Generating initial LLM insight for {plot_id_clicked}...")
                             initial_bot_response_text = await generate_llm_response(
-                                user_message=initial_llm_prompt, # For context/logging in handler
-                                plot_id=plot_id_clicked, 
-                                plot_label=clicked_plot_label, 
-                                chat_history_for_plot=history_for_llm_first_turn, 
-                                plot_data_summary=plot_specific_data_summary 
+                                initial_llm_prompt, plot_id_clicked, clicked_plot_label,
+                                history_for_llm_first_turn, plot_specific_data_summary
                             )
-                            logging.info(f"LLM initial insight received for {plot_id_clicked}.")
-                            
-                            # History for Gradio display starts with the assistant's response
                             chat_history_for_this_plot = [{"role": "assistant", "content": initial_bot_response_text}]
                             updated_chat_histories = current_chat_histories.copy()
                             updated_chat_histories[plot_id_clicked] = chat_history_for_this_plot
-                        else: # History exists, get fresh suggestions
+                        else:
                             _, suggestions = get_initial_insight_prompt_and_suggestions(
-                                plot_id_clicked, 
-                                clicked_plot_label,
-                                plot_specific_data_summary
+                                plot_id_clicked, clicked_plot_label, plot_specific_data_summary
                             )
-
+                        
                         chatbot_content_update = gr.update(value=chat_history_for_this_plot)
-                        suggestion_1_update = gr.update(value=suggestions[0])
-                        suggestion_2_update = gr.update(value=suggestions[1])
-                        suggestion_3_update = gr.update(value=suggestions[2])
-                        logging.info(f"Apertura pannello CHAT per {plot_id_clicked} ('{clicked_plot_label}')")
+                        suggestion_1_update = gr.update(value=suggestions[0] if len(suggestions) > 0 else "N/A")
+                        suggestion_2_update = gr.update(value=suggestions[1] if len(suggestions) > 1 else "N/A")
+                        suggestion_3_update = gr.update(value=suggestions[2] if len(suggestions) > 2 else "N/A")
 
                     elif action_type == "formula":
                         formula_display_visible_update = gr.update(visible=True)
@@ -262,187 +296,211 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                         formula_text = f"**Formula/Metodologia per: {clicked_plot_label}**\n\nID Grafico: `{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_text += f"**Descrizione:**\n{formula_data['description']}\n\n"
-                            formula_text += "**Come viene calcolato:**\n"
-                            for step in formula_data['calculation_steps']:
-                                formula_text += f"- {step}\n"
+                            formula_text += f"### {formula_data['title']}\n\n{formula_data['description']}\n\n**Come viene calcolato:**\n"
+                            formula_text += "\n".join([f"- {step}" for step in formula_data['calculation_steps']])
                         else:
-                            formula_text += "(Nessuna informazione dettagliata sulla formula trovata per questo ID grafico in `formulas.py`)"
+                            formula_text += "(Nessuna informazione dettagliata sulla formula trovata)"
                         formula_content_update = gr.update(value=formula_text)
-                        new_current_chat_plot_id = None 
-                        logging.info(f"Apertura pannello FORMULA per {plot_id_clicked} (mappato a {formula_key})")
-                
-                all_button_icon_updates = []
-                for cfg_item in plot_configs:
-                    p_id_iter = cfg_item["id"]
-                    # Update insights button icon
-                    if new_active_action_state_to_set == {"plot_id": p_id_iter, "type": "insights"}:
-                        all_button_icon_updates.append(gr.update(value=ACTIVE_ICON))
-                    else:
-                        all_button_icon_updates.append(gr.update(value=BOMB_ICON))
-                    # Update formula button icon
-                    if new_active_action_state_to_set == {"plot_id": p_id_iter, "type": "formula"}:
-                        all_button_icon_updates.append(gr.update(value=ACTIVE_ICON))
-                    else:
-                        all_button_icon_updates.append(gr.update(value=FORMULA_ICON))
-                
+                        new_current_chat_plot_id = None # Ensure chat is cleared if formula is opened
+
                 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,
-                    new_active_action_state_to_set, 
-                    new_current_chat_plot_id,  
-                    updated_chat_histories   
-                ] + all_button_icon_updates
+                    new_active_action_state_to_set,
+                    new_current_chat_plot_id,
+                    updated_chat_histories,
+                    new_explored_plot_id_to_set # NEW: update explored_plot_id_state
+                ]
+                final_updates.extend(panel_visibility_component_updates)
+                final_updates.extend(action_button_component_updates)
+                final_updates.extend(explore_button_component_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 # NEW: data summaries
+                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():
                     history_for_plot = chat_histories.get(current_plot_id, [])
-                    # Yield current state if no action needed
-                    yield history_for_plot, gr.update(value=""), chat_histories # Clear input, return current history
+                    yield history_for_plot, 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"
-                
-                # Retrieve the specific data summary for the current plot
                 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()
                 history_for_plot.append({"role": "user", "content": user_message})
-                
-                # Update UI immediately with user message
-                yield history_for_plot, gr.update(value=""), chat_histories # Clear input
+                yield history_for_plot, gr.update(value=""), chat_histories
 
-                # Pass the data summary to the LLM along with the history
                 bot_response_text = await generate_llm_response(
-                    user_message, 
-                    current_plot_id, 
-                    plot_label, 
-                    history_for_plot, # This history now includes the user message
-                    plot_specific_data_summary # Explicitly pass for this turn if needed by LLM handler logic
+                    user_message, current_plot_id, plot_label, history_for_plot, plot_specific_data_summary
                 )
-                
                 history_for_plot.append({"role": "assistant", "content": bot_response_text})
-                
                 updated_chat_histories = chat_histories.copy()
                 updated_chat_histories[current_plot_id] = history_for_plot
-                
                 yield history_for_plot, "", updated_chat_histories
 
-
             async def handle_suggested_question_click(
                 suggestion_text: str,
-                current_plot_id: str, 
-                chat_histories: dict, 
-                current_plot_data_for_chatbot: dict # NEW: data summaries
+                current_plot_id: str,
+                chat_histories: dict,
+                current_plot_data_for_chatbot: dict
             ):
                 if not current_plot_id or not suggestion_text.strip():
                     history_for_plot = chat_histories.get(current_plot_id, [])
-                    yield history_for_plot, gr.update(value=""), chat_histories 
+                    yield history_for_plot, gr.update(value=""), chat_histories
                     return
-
-                # This is essentially the same as submitting a message, so reuse logic
-                # The suggestion_text becomes the user_message
                 async for update in handle_chat_message_submission(
-                    suggestion_text, 
-                    current_plot_id, 
-                    chat_histories, 
-                    current_plot_data_for_chatbot
+                    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):
-                logging.info(f"Click su Esplora per: {plot_id_clicked}. Attualmente esplorato da stato: {current_explored_plot_id_from_state}")
+            def handle_explore_click(
+                plot_id_clicked, 
+                current_explored_plot_id_from_state,
+                current_active_panel_action_state # NEW: current insight/formula state
+            ):
+                logging.info(f"Click su Esplora per: {plot_id_clicked}. Attualmente esplorato: {current_explored_plot_id_from_state}. Pannello Azioni Attivo: {current_active_panel_action_state}")
                 if not plot_ui_objects:
                     logging.error("plot_ui_objects non popolato durante handle_explore_click.")
-                    updates_for_missing_ui = [current_explored_plot_id_from_state] 
-                    for _ in plot_configs: # panel_component, explore_button
-                        updates_for_missing_ui.extend([gr.update(), gr.update()]) 
-                    return updates_for_missing_ui
-                
+                    num_plots = len(plot_configs)
+                    error_updates = [current_explored_plot_id_from_state, gr.update(visible=False), current_active_panel_action_state]
+                    error_updates.extend([gr.update()] * num_plots) # Panel vis
+                    error_updates.extend([gr.update()] * num_plots) # Explore icons
+                    error_updates.extend([gr.update()] * (2 * num_plots)) # Bomb, Formula icons
+                    return error_updates
+
                 new_explored_id_to_set = None
-                is_toggling_off = (plot_id_clicked == current_explored_plot_id_from_state)
+                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
                 
-                if is_toggling_off:
+                panel_vis_updates = []
+                explore_btn_updates = []
+                bomb_btn_icon_upds = []
+                formula_btn_icon_upds = []
+
+                if is_toggling_off_explore:
                     new_explored_id_to_set = None
-                    logging.info(f"Interruzione esplorazione grafico: {plot_id_clicked}")
-                else:
+                    logging.info(f"Interruzione esplorazione grafico: {plot_id_clicked}. Tutti i grafici diventano visibili.")
+                    # All plots become visible
+                    for _ in plot_configs:
+                        panel_vis_updates.append(gr.update(visible=True))
+                        explore_btn_updates.append(gr.update(value=EXPLORE_ICON))
+                    # Insight/formula buttons remain as they were (no change)
+                    for _ in plot_configs:
+                        bomb_btn_icon_upds.append(gr.update())
+                        formula_btn_icon_upds.append(gr.update())
+                else: # Activating explore for plot_id_clicked or switching explore
                     new_explored_id_to_set = plot_id_clicked
-                    logging.info(f"Esplorazione grafico: {plot_id_clicked}")
-                                        
-                panel_and_button_updates = []
-                for cfg in plot_configs:
-                    p_id = cfg["id"]
-                    if p_id in plot_ui_objects:
-                        panel_visible = not new_explored_id_to_set or (p_id == new_explored_id_to_set)
-                        panel_and_button_updates.append(gr.update(visible=panel_visible)) 
-                                                
-                        if p_id == new_explored_id_to_set: 
-                            panel_and_button_updates.append(gr.update(value=ACTIVE_ICON))
-                        else:
-                            panel_and_button_updates.append(gr.update(value=EXPLORE_ICON))
-                    else: 
-                        panel_and_button_updates.extend([gr.update(), gr.update()])
-                                        
-                final_updates = [new_explored_id_to_set] + panel_and_button_updates 
+                    logging.info(f"Esplorazione grafico: {plot_id_clicked}. Altri grafici nascosti.")
+                    # Make only explored plot visible
+                    for cfg in plot_configs:
+                        p_id = cfg["id"]
+                        is_target_plot = (p_id == new_explored_id_to_set)
+                        panel_vis_updates.append(gr.update(visible=is_target_plot))
+                        explore_btn_updates.append(gr.update(value=ACTIVE_ICON if is_target_plot else EXPLORE_ICON))
+                    
+                    # If activating explore, close any active insight/formula panel
+                    if current_active_panel_action_state:
+                        logging.info("Chiusura pannello azioni (insight/formula) a causa dell'attivazione dell'esplorazione.")
+                        action_col_update = gr.update(visible=False)
+                        new_active_panel_action_state_update = None
+                        # Reset all insight/formula button icons
+                        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: # No insight/formula panel active, no change to their buttons
+                         for _ in plot_configs:
+                            bomb_btn_icon_upds.append(gr.update())
+                            formula_btn_icon_upds.append(gr.update())
+                
+                final_updates = [
+                    new_explored_id_to_set,
+                    action_col_update,
+                    new_active_panel_action_state_update
+                ]
+                final_updates.extend(panel_vis_updates)
+                final_updates.extend(explore_btn_updates)
+                final_updates.extend(bomb_btn_icon_upds)
+                final_updates.extend(formula_btn_icon_upds)
                 return final_updates
-            
-            # Outputs for panel actions
+
+            # --- Define Output Lists for Event Handlers ---
             action_panel_outputs_list = [
-                global_actions_column_ui, 
-                insights_chatbot_ui, insights_chatbot_ui, # Target chatbot UI for visibility and value
-                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, # Target markdown for visibility and value
-                active_panel_action_state, 
+                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,
+                active_panel_action_state,
                 current_chat_plot_id_st,
-                chat_histories_st
+                chat_histories_st,
+                explored_plot_id_state # NEW: output for explore state
+            ]
+            for cfg_item_action_out in plot_configs:
+                pid_action_out = cfg_item_action_out["id"]
+                ui_obj_ref = plot_ui_objects.get(pid_action_out)
+                action_panel_outputs_list.append(ui_obj_ref["panel_component"] if ui_obj_ref else gr.update()) # Panel visibility
+            for cfg_item_action_out in plot_configs:
+                pid_action_out = cfg_item_action_out["id"]
+                ui_obj_ref = plot_ui_objects.get(pid_action_out)
+                action_panel_outputs_list.append(ui_obj_ref["bomb_button"] if ui_obj_ref else gr.update())    # Bomb icon
+                action_panel_outputs_list.append(ui_obj_ref["formula_button"] if ui_obj_ref else gr.update()) # Formula icon
+            for cfg_item_action_out in plot_configs:
+                pid_action_out = cfg_item_action_out["id"]
+                ui_obj_ref = plot_ui_objects.get(pid_action_out)
+                action_panel_outputs_list.append(ui_obj_ref["explore_button"] if ui_obj_ref else gr.update()) # Explore icon
+
+            explore_outputs_list = [
+                explored_plot_id_state,
+                global_actions_column_ui, # NEW: output for action column
+                active_panel_action_state # NEW: output for active panel state
             ]
-            for cfg_item_action in plot_configs: 
-                pid_action = cfg_item_action["id"]
-                if pid_action in plot_ui_objects:
-                    action_panel_outputs_list.append(plot_ui_objects[pid_action]["bomb_button"])
-                    action_panel_outputs_list.append(plot_ui_objects[pid_action]["formula_button"])
-                else: 
-                    action_panel_outputs_list.extend([gr.update(), gr.update()]) # Use gr.update() as placeholder
-
-            # Outputs for explore actions
-            explore_buttons_outputs_list = [explored_plot_id_state]
-            for cfg_item_explore in plot_configs:
-                pid_explore = cfg_item_explore["id"]
-                if pid_explore in plot_ui_objects:
-                    explore_buttons_outputs_list.append(plot_ui_objects[pid_explore]["panel_component"])
-                    explore_buttons_outputs_list.append(plot_ui_objects[pid_explore]["explore_button"])
-                else: 
-                    explore_buttons_outputs_list.extend([gr.update(), gr.update()])
-
-            # Inputs for panel actions
+            for cfg_item_explore_out in plot_configs: # Panel visibility
+                pid_explore_out = cfg_item_explore_out["id"]
+                ui_obj_ref = plot_ui_objects.get(pid_explore_out)
+                explore_outputs_list.append(ui_obj_ref["panel_component"] if ui_obj_ref else gr.update())
+            for cfg_item_explore_out in plot_configs: # Explore button icons
+                pid_explore_out = cfg_item_explore_out["id"]
+                ui_obj_ref = plot_ui_objects.get(pid_explore_out)
+                explore_outputs_list.append(ui_obj_ref["explore_button"] if ui_obj_ref else gr.update())
+            for cfg_item_explore_out in plot_configs: # Bomb button icons
+                pid_explore_out = cfg_item_explore_out["id"]
+                ui_obj_ref = plot_ui_objects.get(pid_explore_out)
+                explore_outputs_list.append(ui_obj_ref["bomb_button"] if ui_obj_ref else gr.update())
+            for cfg_item_explore_out in plot_configs: # Formula button icons
+                pid_explore_out = cfg_item_explore_out["id"]
+                ui_obj_ref = plot_ui_objects.get(pid_explore_out)
+                explore_outputs_list.append(ui_obj_ref["formula_button"] if ui_obj_ref else gr.update())
+
+
+            # --- Define Input Lists for Event Handlers ---
             action_click_inputs = [
-                active_panel_action_state, 
+                active_panel_action_state,
                 chat_histories_st,
                 current_chat_plot_id_st,
-                plot_data_for_chatbot_st # NEW: pass data summaries state
+                plot_data_for_chatbot_st,
+                explored_plot_id_state # NEW: input explore state
+            ]
+            explore_click_inputs = [
+                explored_plot_id_state,
+                active_panel_action_state # NEW: input active panel state
             ]
-            # Inputs for explore actions
-            explore_click_inputs = [explored_plot_id_state]
 
+            # --- Register Event Handlers ---
             def create_panel_action_handler(p_id, action_type_str):
-                async def _handler(current_active_val, current_chats_val, current_chat_pid, current_plot_data_summaries): # Add summaries
+                async def _handler(current_active_val, current_chats_val, current_chat_pid, current_plot_data_summaries, current_explored_id_val): # Added current_explored_id_val
                     logging.debug(f"Entering _handler for plot_id: {p_id}, action: {action_type_str}")
-                    result = await handle_panel_action(p_id, action_type_str, current_active_val, current_chats_val, current_chat_pid, current_plot_data_summaries) # Pass summaries
-                    logging.debug(f"_handler for plot_id: {p_id}, action: {action_type_str} completed.")
+                    result = await handle_panel_action(p_id, action_type_str, current_active_val, current_chats_val, current_chat_pid, current_plot_data_summaries, current_explored_id_val) # Pass current_explored_id_val
+                    logging.debug(f"_handler for plot_id: {p_id}, action: {action_type_str} completed with {len(result)} updates.")
                     return result
                 return _handler
 
@@ -450,143 +508,117 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 plot_id = config_item["id"]
                 if plot_id in plot_ui_objects:
                     ui_obj = plot_ui_objects[plot_id]
-                    
                     ui_obj["bomb_button"].click(
-                        fn=create_panel_action_handler(plot_id, "insights"), 
-                        inputs=action_click_inputs, 
+                        fn=create_panel_action_handler(plot_id, "insights"),
+                        inputs=action_click_inputs,
                         outputs=action_panel_outputs_list,
                         api_name=f"action_insights_{plot_id}"
                     )
                     ui_obj["formula_button"].click(
-                        fn=create_panel_action_handler(plot_id, "formula"), 
+                        fn=create_panel_action_handler(plot_id, "formula"),
                         inputs=action_click_inputs,
                         outputs=action_panel_outputs_list,
                         api_name=f"action_formula_{plot_id}"
                     )
                     ui_obj["explore_button"].click(
-                        fn=lambda current_explored_val, p_id=plot_id: handle_explore_click(p_id, current_explored_val),
-                        inputs=explore_click_inputs,
-                        outputs=explore_buttons_outputs_list,
+                        fn=lambda current_explored_val, current_active_panel_val, p_id=plot_id: handle_explore_click(p_id, current_explored_val, current_active_panel_val),
+                        inputs=explore_click_inputs, # Uses updated explore_click_inputs
+                        outputs=explore_outputs_list, # Uses updated explore_outputs_list
                         api_name=f"action_explore_{plot_id}"
                     )
                 else:
                     logging.warning(f"Oggetto UI per plot_id '{plot_id}' non trovato durante il tentativo di associare i gestori di click.")
-            
+
             chat_submission_outputs = [insights_chatbot_ui, insights_chat_input_ui, chat_histories_st]
-            chat_submission_inputs = [insights_chat_input_ui, current_chat_plot_id_st, chat_histories_st, plot_data_for_chatbot_st] # Add data summaries state
+            chat_submission_inputs = [insights_chat_input_ui, current_chat_plot_id_st, chat_histories_st, plot_data_for_chatbot_st]
 
             insights_chat_input_ui.submit(
                 fn=handle_chat_message_submission,
-                inputs=chat_submission_inputs, 
+                inputs=chat_submission_inputs,
                 outputs=chat_submission_outputs,
                 api_name="submit_chat_message"
             )
 
-            suggestion_click_inputs = [current_chat_plot_id_st, chat_histories_st, plot_data_for_chatbot_st] # Add data summaries state
+            suggestion_click_inputs = [current_chat_plot_id_st, chat_histories_st, plot_data_for_chatbot_st]
             insights_suggestion_1_btn.click(
                 fn=handle_suggested_question_click,
-                inputs=[insights_suggestion_1_btn] + suggestion_click_inputs, # Pass button value as first arg
-                outputs=chat_submission_outputs, 
-                api_name="click_suggestion_1"
+                inputs=[insights_suggestion_1_btn] + suggestion_click_inputs,
+                outputs=chat_submission_outputs, api_name="click_suggestion_1"
             )
             insights_suggestion_2_btn.click(
                 fn=handle_suggested_question_click,
-                inputs=[insights_suggestion_2_btn] + suggestion_click_inputs, 
-                outputs=chat_submission_outputs,
-                api_name="click_suggestion_2"
+                inputs=[insights_suggestion_2_btn] + suggestion_click_inputs,
+                outputs=chat_submission_outputs, api_name="click_suggestion_2"
             )
             insights_suggestion_3_btn.click(
                 fn=handle_suggested_question_click,
-                inputs=[insights_suggestion_3_btn] + suggestion_click_inputs, 
-                outputs=chat_submission_outputs,
-                api_name="click_suggestion_3"
+                inputs=[insights_suggestion_3_btn] + suggestion_click_inputs,
+                outputs=chat_submission_outputs, api_name="click_suggestion_3"
             )
 
             def refresh_all_analytics_ui_elements(current_token_state, date_filter_val, custom_start_val, custom_end_val, current_chat_histories):
                 logging.info("Aggiornamento di tutti gli elementi UI delle analisi e reset delle azioni/chat.")
-                
-                # Pass plot_configs to the update function so it can be used by generate_chatbot_data_summaries
                 plot_generation_results = update_analytics_plots_figures(
                     current_token_state, date_filter_val, custom_start_val, custom_end_val, plot_configs
                 )
                 status_message_update = plot_generation_results[0]
-                generated_plot_figures = plot_generation_results[1:-1] # All items except first (status) and last (summaries)
-                new_plot_data_summaries = plot_generation_results[-1] # Last item is the summaries dict
-                
-                all_updates = [status_message_update] 
-                
-                for i in range(len(plot_configs)): 
+                generated_plot_figures = plot_generation_results[1:-1]
+                new_plot_data_summaries = plot_generation_results[-1]
+
+                all_updates = [status_message_update]
+                for i in range(len(plot_configs)):
                     if i < len(generated_plot_figures):
-                        all_updates.append(generated_plot_figures[i]) 
-                    else: 
+                        all_updates.append(generated_plot_figures[i])
+                    else:
+                        # Ensure create_placeholder_plot is defined or handle appropriately
                         all_updates.append(create_placeholder_plot("Errore Figura", f"Figura mancante per grafico {plot_configs[i]['id']}"))
                 
                 all_updates.extend([
                     gr.update(visible=False), # global_actions_column_ui
-                    gr.update(value=[], visible=False), # insights_chatbot_ui (value & visibility)
-                    gr.update(value="", visible=False), # insights_chat_input_ui (value & visibility)
+                    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="Suggerimento 1"), # insights_suggestion_1_btn (reset value, visibility handled by row)
-                    gr.update(value="Suggerimento 2"), # insights_suggestion_2_btn
-                    gr.update(value="Suggerimento 3"), # insights_suggestion_3_btn
+                    gr.update(value="Suggerimento 1"), gr.update(value="Suggerimento 2"), gr.update(value="Suggerimento 3"),
                     gr.update(value="I dettagli sulla formula/metodologia appariranno qui.", visible=False), # formula_display_markdown_ui
                     None, # active_panel_action_state
                     None, # current_chat_plot_id_st
-                    {}, # chat_histories_st (reset chat histories on filter change)
-                    new_plot_data_summaries # NEW: plot_data_for_chatbot_st
+                    {},   # chat_histories_st (reset)
+                    new_plot_data_summaries # plot_data_for_chatbot_st
                 ])
-                
-                for cfg in plot_configs: 
+
+                for cfg in plot_configs:
                     pid = cfg["id"]
-                    if pid in plot_ui_objects:
-                        all_updates.append(gr.update(value=BOMB_ICON))   
-                        all_updates.append(gr.update(value=FORMULA_ICON)) 
-                        all_updates.append(gr.update(value=EXPLORE_ICON)) 
-                        all_updates.append(gr.update(visible=True))     # panel_component visibility
-                    else: 
-                        all_updates.extend([gr.update(), gr.update(), gr.update(), gr.update()])
-                
-                all_updates.append(None) # explored_plot_id_state
+                    # Reset button icons
+                    all_updates.append(gr.update(value=BOMB_ICON))
+                    all_updates.append(gr.update(value=FORMULA_ICON))
+                    all_updates.append(gr.update(value=EXPLORE_ICON))
+                    # Make all plot panels visible
+                    all_updates.append(gr.update(visible=True)) # panel_component visibility
                 
+                all_updates.append(None) # explored_plot_id_state (reset)
                 logging.info(f"Preparati {len(all_updates)} aggiornamenti per il refresh delle analisi.")
                 return all_updates
 
-            apply_filter_and_sync_outputs_list = [analytics_status_md] 
-            for config_item_filter_sync in plot_configs:
-                pid_filter_sync = config_item_filter_sync["id"]
-                if pid_filter_sync in plot_ui_objects and "plot_component" in plot_ui_objects[pid_filter_sync]:
-                    apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid_filter_sync]["plot_component"])
-                else:
-                    apply_filter_and_sync_outputs_list.append(gr.update()) 
+            apply_filter_and_sync_outputs_list = [analytics_status_md]
+            for config_item_filter_sync in plot_configs: # Plot components
+                pid = config_item_filter_sync["id"]
+                apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid]["plot_component"] if pid in plot_ui_objects and "plot_component" in plot_ui_objects[pid] else gr.update())
             
-            apply_filter_and_sync_outputs_list.extend([
-                global_actions_column_ui,       # Reset visibility
-                insights_chatbot_ui,            # Reset content & visibility
-                insights_chat_input_ui,         # Reset content & visibility
-                insights_suggestions_row_ui,    # Reset visibility
-                insights_suggestion_1_btn,      # Reset text & visibility
-                insights_suggestion_2_btn,
-                insights_suggestion_3_btn,
-                formula_display_markdown_ui,    # Reset content & visibility
-                active_panel_action_state,      # Reset state
-                current_chat_plot_id_st,        # Reset state
-                chat_histories_st,              # Preserve or reset state (resetting via refresh_all_analytics_ui_elements)
-                plot_data_for_chatbot_st        # NEW: Update this state
+            apply_filter_and_sync_outputs_list.extend([ # UI elements to reset
+                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 cfg_filter_sync_btns in plot_configs:
-                pid_filter_sync_btns = cfg_filter_sync_btns["id"]
-                if pid_filter_sync_btns in plot_ui_objects:
-                    apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid_filter_sync_btns]["bomb_button"])
-                    apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid_filter_sync_btns]["formula_button"])
-                    apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid_filter_sync_btns]["explore_button"])
-                    apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid_filter_sync_btns]["panel_component"]) 
-                else:
-                    apply_filter_and_sync_outputs_list.extend([gr.update(), gr.update(), gr.update(), gr.update()]) 
+            for cfg_filter_sync_btns in plot_configs: # Button icons and panel visibility
+                pid = cfg_filter_sync_btns["id"]
+                apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid]["bomb_button"] if pid in plot_ui_objects else gr.update())
+                apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid]["formula_button"] if pid in plot_ui_objects else gr.update())
+                apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid]["explore_button"] if pid in plot_ui_objects else gr.update())
+                apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid]["panel_component"] if pid in plot_ui_objects else gr.update())
             
-            apply_filter_and_sync_outputs_list.append(explored_plot_id_state) # Reset state
-            
-            logging.info(f"Output totali definiti per apply_filter/sync: {len(apply_filter_and_sync_outputs_list)}")
+            apply_filter_and_sync_outputs_list.append(explored_plot_id_state) # Reset explored state
             
             apply_filter_btn.click(
                 fn=refresh_all_analytics_ui_elements,
@@ -608,7 +640,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
         with gr.TabItem("4️⃣ Statistiche Follower", id="tab_follower_stats"):
             refresh_follower_stats_btn = gr.Button("🔄 Aggiorna Visualizzazione Statistiche Follower", variant="secondary")
             follower_stats_html = gr.HTML("Statistiche follower...")
-            with gr.Row(): 
+            with gr.Row():
                 fs_plot_monthly_gains = gr.Plot(label="Guadagni Mensili Follower")
             with gr.Row():
                 fs_plot_seniority = gr.Plot(label="Follower per Anzianità (Top 10 Organici)")
@@ -624,19 +656,19 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
         fn=sync_all_linkedin_data_orchestrator,
         inputs=[token_state], outputs=[sync_status_html_output, token_state], show_progress="full"
     )
-    sync_event_part2 = sync_event_part1.then( 
-        fn=process_and_store_bubble_token, 
+    sync_event_part2 = sync_event_part1.then(
+        fn=process_and_store_bubble_token,
         inputs=[url_user_token_display, org_urn_display, token_state],
-        outputs=[status_box, token_state, sync_data_btn], show_progress=False 
+        outputs=[status_box, token_state, sync_data_btn], show_progress=False
     )
     sync_event_part3 = sync_event_part2.then(
-        fn=display_main_dashboard, 
+        fn=display_main_dashboard,
         inputs=[token_state], outputs=[dashboard_display_html], show_progress=False
     )
     sync_event_final = sync_event_part3.then(
-        fn=refresh_all_analytics_ui_elements, # This will now also update chatbot data summaries
+        fn=refresh_all_analytics_ui_elements, 
         inputs=[token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker, chat_histories_st],
-        outputs=apply_filter_and_sync_outputs_list, 
+        outputs=apply_filter_and_sync_outputs_list,
         show_progress="full"
     )
 
@@ -650,7 +682,7 @@ if __name__ == "__main__":
     
     try:
         logging.info(f"Versione Matplotlib: {matplotlib.__version__}, Backend: {matplotlib.get_backend()}")
-    except ImportError: 
+    except ImportError:
         logging.warning("Matplotlib non trovato direttamente, ma potrebbe essere usato dai generatori di grafici.")
         
-    app.launch(server_name="0.0.0.0", server_port=7860, debug=True)
+    app.launch(server_name="0.0.0.0", server_port=7860, debug=True)