Update app.py

app.py

@@ -6,6 +6,7 @@ import matplotlib
 matplotlib.use('Agg') # Set backend for Matplotlib to avoid GUI conflicts with Gradio
 import matplotlib.pyplot as plt
 import time # For profiling if needed
+from datetime import datetime
 
 # --- Module Imports ---
 from gradio_utils import get_url_user_token
@@ -78,31 +79,131 @@ PLOT_ID_TO_FORMULA_KEY_MAP = {
     "mention_analysis_sentiment": "mention_sentiment"
 }
 
+# --- Helper function to generate textual data summaries for chatbot ---
+def generate_chatbot_data_summaries(
+    plot_configs_list,
+    filtered_merged_posts_df,
+    filtered_mentions_df,
+    date_filtered_follower_stats_df,
+    raw_follower_stats_df,
+    token_state_value # To get column names if needed
+    ):
+    """
+    Generates textual summaries for each plot ID to be used by the chatbot.
+    """
+    data_summaries = {}
+    date_col_posts = token_state_value.get("config_date_col_posts", "published_at")
+    # Ensure date columns are datetime objects for proper formatting and comparison
+    if date_col_posts in filtered_merged_posts_df.columns:
+        filtered_merged_posts_df[date_col_posts] = pd.to_datetime(filtered_merged_posts_df[date_col_posts], errors='coerce')
+    if 'date' in date_filtered_follower_stats_df.columns:
+         date_filtered_follower_stats_df['date'] = pd.to_datetime(date_filtered_follower_stats_df['date'], errors='coerce')
+    # Add more date conversions as needed for other dataframes
+
+    for plot_cfg in plot_configs_list:
+        plot_id = plot_cfg["id"]
+        summary_text = f"No data summary available for {plot_cfg['label']} for the selected period."
+
+        try:
+            if plot_id == "followers_count" and not date_filtered_follower_stats_df.empty:
+                df_summary = date_filtered_follower_stats_df[['date', 'follower_gains_monthly']].copy()
+                df_summary['date'] = df_summary['date'].dt.strftime('%Y-%m-%d')
+                summary_text = f"Follower Count (Monthly Gains):\n{df_summary.tail(5).to_string(index=False)}"
+            
+            elif plot_id == "followers_growth_rate" and not date_filtered_follower_stats_df.empty:
+                df_summary = date_filtered_follower_stats_df[['date', 'growth_rate_monthly']].copy() # Assuming 'growth_rate_monthly' column
+                df_summary['date'] = df_summary['date'].dt.strftime('%Y-%m-%d')
+                summary_text = f"Follower Growth Rate (Monthly):\n{df_summary.tail(5).to_string(index=False)}"
+
+            elif plot_id == "followers_by_location" and not raw_follower_stats_df.empty and 'follower_geo' in raw_follower_stats_df.columns:
+                # Assuming 'follower_geo' contains location names and another column like 'count' exists
+                # This part needs to align with how generate_followers_by_demographics_plot processes 'follower_geo' data
+                # For simplicity, let's assume raw_follower_stats_df has pre-aggregated data for geo
+                # This is a placeholder, actual column names for count and name are needed from your data prep
+                if 'geo_name' in raw_follower_stats_df.columns and 'geo_count' in raw_follower_stats_df.columns:
+                    df_summary = raw_follower_stats_df[['geo_name', 'geo_count']].nlargest(5, 'geo_count')
+                    summary_text = f"Followers by Location (Top 5):\n{df_summary.to_string(index=False)}"
+                else:
+                    summary_text = "Follower location data structure not as expected for summary."
+
+
+            elif plot_id == "engagement_rate" and not filtered_merged_posts_df.empty:
+                df_summary = filtered_merged_posts_df[[date_col_posts, 'engagement_rate']].copy()
+                df_summary[date_col_posts] = df_summary[date_col_posts].dt.strftime('%Y-%m-%d')
+                summary_text = f"Engagement Rate Over Time:\n{df_summary.tail(5).to_string(index=False)}"
+            
+            elif plot_id == "reach_over_time" and not filtered_merged_posts_df.empty:
+                df_summary = filtered_merged_posts_df[[date_col_posts, 'reach']].copy()
+                df_summary[date_col_posts] = df_summary[date_col_posts].dt.strftime('%Y-%m-%d')
+                summary_text = f"Reach Over Time:\n{df_summary.tail(5).to_string(index=False)}"
+
+            elif plot_id == "impressions_over_time" and not filtered_merged_posts_df.empty:
+                df_summary = filtered_merged_posts_df[[date_col_posts, 'impressions_sum']].copy() # Assuming 'impressions_sum' or similar
+                df_summary[date_col_posts] = df_summary[date_col_posts].dt.strftime('%Y-%m-%d')
+                summary_text = f"Impressions Over Time:\n{df_summary.tail(5).to_string(index=False)}"
+
+            elif plot_id == "comments_sentiment" and not filtered_merged_posts_df.empty and 'comment_sentiment' in filtered_merged_posts_df.columns:
+                sentiment_counts = filtered_merged_posts_df['comment_sentiment'].value_counts().reset_index()
+                sentiment_counts.columns = ['Sentiment', 'Count']
+                summary_text = f"Comments Sentiment Breakdown:\n{sentiment_counts.to_string(index=False)}"
+
+            # Add more elif blocks for other plot_ids, extracting relevant data:
+            # e.g., likes_over_time, clicks_over_time, shares_over_time, comments_over_time
+            # post_frequency_cs, content_format_breakdown_cs, content_topic_breakdown_cs
+            # mentions_activity, mention_sentiment
+
+            data_summaries[plot_id] = summary_text
+        except KeyError as e:
+            logging.warning(f"KeyError generating summary for {plot_id}: {e}. Using default summary.")
+            data_summaries[plot_id] = f"Data summary generation error for {plot_cfg['label']} (missing column: {e})."
+        except Exception as e:
+            logging.error(f"Error generating summary for {plot_id}: {e}", exc_info=True)
+            data_summaries[plot_id] = f"Error generating data summary for {plot_cfg['label']}."
+            
+    return data_summaries
+
 # --- Analytics Tab: Plot Figure Generation Function ---
-def update_analytics_plots_figures(token_state_value, date_filter_option, custom_start_date, custom_end_date):
+def update_analytics_plots_figures(token_state_value, date_filter_option, custom_start_date, custom_end_date, current_plot_configs):
     logging.info(f"Updating analytics plot figures. Filter: {date_filter_option}, Custom Start: {custom_start_date}, Custom End: {custom_end_date}")
     num_expected_plots = 19 # Ensure this matches the number of plots generated
     
+    plot_data_summaries_for_chatbot = {} # Initialize dict for chatbot summaries
+
     if not token_state_value or not token_state_value.get("token"):
         message = "❌ Accesso negato. Nessun token. Impossibile generare le analisi."
         logging.warning(message)
         placeholder_figs = [create_placeholder_plot(title="Accesso Negato", message="Nessun token.") for _ in range(num_expected_plots)]
-        return [message] + placeholder_figs
+        # For each plot_config, add a default "no data" summary
+        for p_cfg in current_plot_configs:
+            plot_data_summaries_for_chatbot[p_cfg["id"]] = "Accesso negato, nessun dato per il chatbot."
+        return [message] + placeholder_figs + [plot_data_summaries_for_chatbot]
     try:
-        # This call is crucial. The structure of these DataFrames determines if plots work.
         (filtered_merged_posts_df, 
          filtered_mentions_df, 
          date_filtered_follower_stats_df, # For time-based follower plots
-         raw_follower_stats_df,         # For demographic follower plots
+         raw_follower_stats_df,       # For demographic follower plots
          start_dt_for_msg, end_dt_for_msg) = \
             prepare_filtered_analytics_data(
                 token_state_value, date_filter_option, custom_start_date, custom_end_date
             )
+        
+        # Generate data summaries for chatbot AFTER data preparation
+        plot_data_summaries_for_chatbot = generate_chatbot_data_summaries(
+            current_plot_configs, # Pass the plot_configs list
+            filtered_merged_posts_df,
+            filtered_mentions_df,
+            date_filtered_follower_stats_df,
+            raw_follower_stats_df,
+            token_state_value
+        )
+
     except Exception as e:
         error_msg = f"❌ Errore durante la preparazione dei dati per le analisi: {e}"
         logging.error(error_msg, exc_info=True)
         placeholder_figs = [create_placeholder_plot(title="Errore Preparazione Dati", message=str(e)) for _ in range(num_expected_plots)]
-        return [error_msg] + placeholder_figs
+        for p_cfg in current_plot_configs:
+            plot_data_summaries_for_chatbot[p_cfg["id"]] = f"Errore preparazione dati: {e}"
+        return [error_msg] + placeholder_figs + [plot_data_summaries_for_chatbot]
     
     date_column_posts = token_state_value.get("config_date_col_posts", "published_at")
     date_column_mentions = token_state_value.get("config_date_col_mentions", "date")
@@ -111,14 +212,9 @@ def update_analytics_plots_figures(token_state_value, date_filter_option, custom
     
     plot_figs = [] # Initialize list to hold plot figures
     
-    # Titles for error reporting, matching the order in plot_configs
-    plot_titles_for_errors = [p_cfg["label"] for p_cfg in plot_configs] 
+    plot_titles_for_errors = [p_cfg["label"] for p_cfg in current_plot_configs] 
 
     try:
-        # Attempt to generate plots. If DataFrames are not as expected by generator functions,
-        # KeyErrors for missing columns or other ValueErrors might occur.
-        # The order of appends MUST match the order in plot_configs for UI updates.
-
         # Dinamiche dei Follower (2 plots)
         plot_figs.append(generate_followers_count_over_time_plot(date_filtered_follower_stats_df, type_value='follower_gains_monthly'))
         plot_figs.append(generate_followers_growth_rate_plot(date_filtered_follower_stats_df, type_value='follower_gains_monthly'))
@@ -139,21 +235,19 @@ def update_analytics_plots_figures(token_state_value, date_filter_option, custom
         plot_figs.append(generate_clicks_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts))
         plot_figs.append(generate_shares_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts))
         plot_figs.append(generate_comments_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts))
-        plot_figs.append(generate_comments_sentiment_breakdown_plot(filtered_merged_posts_df, sentiment_column='comment_sentiment'))
+        plot_figs.append(generate_comments_sentiment_breakdown_plot(filtered_merged_posts_df, sentiment_column='comment_sentiment')) # Make sure 'comment_sentiment' exists
         
         # Analisi Strategia Contenuti (3 plots)
         plot_figs.append(generate_post_frequency_plot(filtered_merged_posts_df, date_column=date_column_posts))
         plot_figs.append(generate_content_format_breakdown_plot(filtered_merged_posts_df, format_col=media_type_col_name))
         plot_figs.append(generate_content_topic_breakdown_plot(filtered_merged_posts_df, topics_col=eb_labels_col_name))
         
-        # Analisi Menzioni (Dettaglio) (2 plots) - These might use pre-generated figs if logic was complex
-        # For simplicity here, assuming direct calls. If they were shared, that logic would be here.
+        # Analisi Menzioni (Dettaglio) (2 plots)
         plot_figs.append(generate_mentions_activity_plot(filtered_mentions_df, date_column=date_column_mentions))
-        plot_figs.append(generate_mention_sentiment_plot(filtered_mentions_df))
+        plot_figs.append(generate_mention_sentiment_plot(filtered_mentions_df)) # Make sure this function handles empty/malformed df
 
         if len(plot_figs) != num_expected_plots:
             logging.warning(f"Mismatch in generated plots. Expected {num_expected_plots}, got {len(plot_figs)}. This will cause UI update issues.")
-            # Fill with placeholders if not enough plots were generated due to an early exit or logic error
             while len(plot_figs) < num_expected_plots:
                 plot_figs.append(create_placeholder_plot(title="Grafico Non Generato", message="Logica di generazione incompleta."))
         
@@ -163,7 +257,6 @@ def update_analytics_plots_figures(token_state_value, date_filter_option, custom
             e_display = end_dt_for_msg.strftime('%Y-%m-%d') if end_dt_for_msg else "Qualsiasi"
             message += f" (Da: {s_display} A: {e_display})"
         
-        # Ensure all plot_figs are actual plot objects, not None or error strings
         final_plot_figs = []
         for i, p_fig_candidate in enumerate(plot_figs):
             if p_fig_candidate is not None and not isinstance(p_fig_candidate, str): # Basic check for a plot object
@@ -173,30 +266,30 @@ def update_analytics_plots_figures(token_state_value, date_filter_option, custom
                 logging.warning(f"Plot {err_title} (index {i}) non è una figura valida: {p_fig_candidate}. Uso placeholder.")
                 final_plot_figs.append(create_placeholder_plot(title=f"Errore: {err_title}", message="Impossibile generare figura."))
         
-        return [message] + final_plot_figs[:num_expected_plots] # Slice to ensure correct number
+        return [message] + final_plot_figs[:num_expected_plots] + [plot_data_summaries_for_chatbot]
 
     except (KeyError, ValueError) as e_plot_data:
-        # This catches errors if a specific plot function fails due to missing columns or bad data
         logging.error(f"Errore dati durante la generazione di un grafico specifico: {e_plot_data}", exc_info=True)
-        # We don't know which plot failed, so fill all with placeholders after this point
-        # Or, more robustly, identify which plot failed and insert placeholder there.
-        # For now, this will likely result in fewer than num_expected_plots if it happens mid-way.
-        # The loop below will fill remaining with placeholders.
         error_msg_display = f"Errore dati in un grafico: {str(e_plot_data)[:100]}"
         
-        # Fill remaining plot_figs with placeholders
         num_already_generated = len(plot_figs)
         for i in range(num_already_generated, num_expected_plots):
             err_title_fill = plot_titles_for_errors[i] if i < len(plot_titles_for_errors) else f"Grafico {i+1}"
             plot_figs.append(create_placeholder_plot(title=f"Errore Dati: {err_title_fill}", message=f"Precedente errore: {str(e_plot_data)[:50]}"))
         
-        return [error_msg_display] + plot_figs[:num_expected_plots]
+        for p_cfg in current_plot_configs: # Ensure summaries dict is populated on error
+            if p_cfg["id"] not in plot_data_summaries_for_chatbot:
+                 plot_data_summaries_for_chatbot[p_cfg["id"]] = f"Errore dati grafico: {e_plot_data}"
+        return [error_msg_display] + plot_figs[:num_expected_plots] + [plot_data_summaries_for_chatbot]
 
     except Exception as e_general:
         error_msg = f"❌ Errore generale durante la generazione dei grafici: {e_general}"
         logging.error(error_msg, exc_info=True)
         placeholder_figs_general = [create_placeholder_plot(title=plot_titles_for_errors[i] if i < len(plot_titles_for_errors) else f"Grafico {i+1}", message=str(e_general)) for i in range(num_expected_plots)]
-        return [error_msg] + placeholder_figs_general
+        for p_cfg in current_plot_configs: # Ensure summaries dict is populated on error
+             if p_cfg["id"] not in plot_data_summaries_for_chatbot:
+                plot_data_summaries_for_chatbot[p_cfg["id"]] = f"Errore generale grafici: {e_general}"
+        return [error_msg] + placeholder_figs_general + [plot_data_summaries_for_chatbot]
 
 
 # --- Gradio UI Blocks ---
@@ -214,6 +307,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
     
     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
 
     gr.Markdown("# 🚀 LinkedIn Organization Dashboard")
     url_user_token_display = gr.Textbox(label="User Token (Nascosto)", interactive=False, visible=False)
@@ -252,8 +346,8 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                     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")
-                    custom_end_date_picker = gr.DateTime(label="Data Fine", visible=False, include_time=False, type="datetime")
+                    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
 
             apply_filter_btn = gr.Button("🔍 Applica Filtro & Aggiorna Analisi", variant="primary")
 
@@ -267,6 +361,8 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 outputs=[custom_start_date_picker, custom_end_date_picker]
             )
             
+            # Moved plot_configs to be globally accessible within the Blocks scope if needed by update_analytics_plots_figures
+            # or pass it explicitly. For now, it's defined here.
             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"},
@@ -325,15 +421,16 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 action_type: str, 
                 current_active_action_from_state: dict, 
                 current_chat_histories: dict, 
-                current_chat_plot_id: str 
+                current_chat_plot_id: str,
+                current_plot_data_for_chatbot: dict # NEW: data summaries
             ):
                 logging.info(f"Azione '{action_type}' per grafico: {plot_id_clicked}. Attualmente attivo: {current_active_action_from_state}")
                 
                 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)
-                    error_updates = [gr.update(visible=False)] * 10 
+                    num_button_updates = 2 * len(plot_configs) # insights, formula buttons
+                    error_updates = [gr.update(visible=False)] * 10 # action_col, chatbot, input, suggestions_row, 3x sugg_btn, formula_md
                     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
@@ -375,13 +472,26 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                         new_current_chat_plot_id = plot_id_clicked
                         chat_history_for_this_plot = current_chat_histories.get(plot_id_clicked, [])
                         
+                        # Get data summary for this plot
+                        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_insight_msg, suggestions = get_initial_insight_and_suggestions(plot_id_clicked, clicked_plot_label)
-                            chat_history_for_this_plot = [initial_insight_msg]
+                            initial_insight_msg, suggestions = get_initial_insight_and_suggestions(
+                                plot_id_clicked, 
+                                clicked_plot_label,
+                                plot_specific_data_summary # Pass the summary
+                            )
+                            chat_history_for_this_plot = [initial_insight_msg] # Gradio expects list of dicts
                             updated_chat_histories = current_chat_histories.copy()
                             updated_chat_histories[plot_id_clicked] = chat_history_for_this_plot
                         else: 
-                            _, suggestions = get_initial_insight_and_suggestions(plot_id_clicked, clicked_plot_label)
+                            # If history exists, still get fresh suggestions, but don't overwrite history's first message
+                            _, suggestions = get_initial_insight_and_suggestions(
+                                plot_id_clicked, 
+                                clicked_plot_label,
+                                plot_specific_data_summary # Pass summary for context if needed by suggestions
+                            )
+
 
                         chatbot_content_update = gr.update(value=chat_history_for_this_plot)
                         suggestion_1_update = gr.update(value=suggestions[0])
@@ -409,10 +519,12 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 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:
@@ -425,8 +537,8 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                     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         
+                    new_current_chat_plot_id,    
+                    updated_chat_histories     
                 ] + all_button_icon_updates
                 
                 return final_updates
@@ -435,21 +547,35 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 user_message: str, 
                 current_plot_id: str, 
                 chat_histories: dict, 
+                current_plot_data_for_chatbot: dict # NEW: data summaries
             ):
                 if not current_plot_id or not user_message.strip():
                     history_for_plot = chat_histories.get(current_plot_id, [])
-                    yield history_for_plot, "", chat_histories 
+                    # Yield current state if no action needed
+                    yield history_for_plot, gr.update(value=""), chat_histories # Clear input, return current history
                     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})
                 
-                yield history_for_plot, "", chat_histories 
-
-                bot_response_text = await generate_llm_response(user_message, current_plot_id, plot_label, history_for_plot)
+                # Update UI immediately with user message
+                yield history_for_plot, gr.update(value=""), chat_histories # Clear input
+
+                # 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 initial insight with summary + user message
+                    plot_specific_data_summary # Explicitly pass for this turn if needed by LLM handler logic
+                )
                 
                 history_for_plot.append({"role": "assistant", "content": bot_response_text})
                 
@@ -458,38 +584,35 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 
                 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
             ):
                 if not current_plot_id or not suggestion_text.strip():
                     history_for_plot = chat_histories.get(current_plot_id, [])
-                    yield history_for_plot, "", chat_histories 
+                    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"
-
-                history_for_plot = chat_histories.get(current_plot_id, []).copy()
-                history_for_plot.append({"role": "user", "content": suggestion_text})
-                
-                yield history_for_plot, "", chat_histories
+                # 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
+                ):
+                    yield update
 
-                bot_response_text = await generate_llm_response(suggestion_text, current_plot_id, plot_label, history_for_plot)
-                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
 
             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}")
                 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:
+                    for _ in plot_configs: # panel_component, explore_button
                         updates_for_missing_ui.extend([gr.update(), gr.update()]) 
                     return updates_for_missing_ui
                 
@@ -502,7 +625,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 else:
                     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"]
@@ -516,16 +639,17 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                             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 
                 return final_updates
             
+            # Outputs for panel actions
             action_panel_outputs_list = [
                 global_actions_column_ui, 
-                insights_chatbot_ui, insights_chatbot_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, 
+                formula_display_markdown_ui, formula_display_markdown_ui, # Target markdown for visibility and value
                 active_panel_action_state, 
                 current_chat_plot_id_st,
                 chat_histories_st
@@ -538,6 +662,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 else: 
                     action_panel_outputs_list.extend([None, None]) 
 
+            # 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"]
@@ -547,30 +672,29 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 else: 
                     explore_buttons_outputs_list.extend([None, None])
 
+            # Inputs for panel actions
             action_click_inputs = [
                 active_panel_action_state, 
                 chat_histories_st,
-                current_chat_plot_id_st
+                current_chat_plot_id_st,
+                plot_data_for_chatbot_st # NEW: pass data summaries state
             ]
+            # Inputs for explore actions
             explore_click_inputs = [explored_plot_id_state]
 
-            # --- Define "creator" functions for async click handlers ---
             def create_panel_action_handler(p_id, action_type_str):
-                # This inner function is what Gradio will call. It's async.
-                async def _handler(current_active_val, current_chats_val, current_chat_pid):
+                async def _handler(current_active_val, current_chats_val, current_chat_pid, current_plot_data_summaries): # Add summaries
                     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)
+                    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.")
                     return result
-                return _handler # Return the async handler function itself
-            # --- End "creator" functions ---
+                return _handler
 
             for config_item in plot_configs:
                 plot_id = config_item["id"]
                 if plot_id in plot_ui_objects:
                     ui_obj = plot_ui_objects[plot_id]
                     
-                    # The 'fn' passed to .click() is the async function returned by the creator
                     ui_obj["bomb_button"].click(
                         fn=create_panel_action_handler(plot_id, "insights"), 
                         inputs=action_click_inputs, 
@@ -593,39 +717,45 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                     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
+
             insights_chat_input_ui.submit(
                 fn=handle_chat_message_submission,
-                inputs=[insights_chat_input_ui, current_chat_plot_id_st, chat_histories_st], 
+                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
             insights_suggestion_1_btn.click(
                 fn=handle_suggested_question_click,
-                inputs=[insights_suggestion_1_btn, current_chat_plot_id_st, chat_histories_st], 
+                inputs=[insights_suggestion_1_btn] + suggestion_click_inputs, # Pass button value as first arg
                 outputs=chat_submission_outputs, 
                 api_name="click_suggestion_1"
             )
             insights_suggestion_2_btn.click(
                 fn=handle_suggested_question_click,
-                inputs=[insights_suggestion_2_btn, current_chat_plot_id_st, chat_histories_st], 
+                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, current_chat_plot_id_st, chat_histories_st], 
+                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
+                    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:]
+                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] 
                 
@@ -636,30 +766,31 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                         all_updates.append(create_placeholder_plot("Errore Figura", f"Figura mancante per grafico {plot_configs[i]['id']}"))
                 
                 all_updates.extend([
-                    gr.update(visible=False), 
-                    gr.update(value=[], visible=False), 
-                    gr.update(value="", visible=False), 
-                    gr.update(visible=False), 
-                    gr.update(value="Suggerimento 1", visible=True), 
-                    gr.update(value="Suggerimento 2", visible=True), 
-                    gr.update(value="Suggerimento 3", visible=True), 
-                    gr.update(value="I dettagli sulla formula/metodologia appariranno qui.", visible=False), 
-                    None, 
-                    None, 
-                    current_chat_histories, 
+                    gr.update(visible=False), # global_actions_column_ui
+                    gr.update(value=[], visible=False), # insights_chatbot_ui (value)
+                    gr.update(value="", visible=False), # insights_chat_input_ui (value)
+                    gr.update(visible=False), # insights_suggestions_row_ui
+                    gr.update(value="Suggerimento 1", visible=True), # insights_suggestion_1_btn
+                    gr.update(value="Suggerimento 2", visible=True), # insights_suggestion_2_btn
+                    gr.update(value="Suggerimento 3", visible=True), # insights_suggestion_3_btn
+                    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
+                    current_chat_histories, # chat_histories_st (preserve or reset as needed, here preserving)
+                    new_plot_data_summaries # NEW: plot_data_for_chatbot_st
                 ])
                 
                 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=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))       
+                        all_updates.append(gr.update(visible=True))      # panel_component visibility
                     else: 
                         all_updates.extend([None, None, None, None])
                 
-                all_updates.append(None) 
+                all_updates.append(None) # explored_plot_id_state
                 
                 logging.info(f"Preparati {len(all_updates)} aggiornamenti per il refresh delle analisi.")
                 return all_updates
@@ -673,17 +804,18 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                     apply_filter_and_sync_outputs_list.append(None) 
             
             apply_filter_and_sync_outputs_list.extend([
-                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               
+                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
+                plot_data_for_chatbot_st          # NEW: Update this state
             ])
 
             for cfg_filter_sync_btns in plot_configs:
@@ -696,7 +828,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 else:
                     apply_filter_and_sync_outputs_list.extend([None, None, None, None]) 
             
-            apply_filter_and_sync_outputs_list.append(explored_plot_id_state) 
+            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)}")
             
@@ -746,7 +878,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
         inputs=[token_state], outputs=[dashboard_display_html], show_progress=False
     )
     sync_event_final = sync_event_part3.then(
-        fn=refresh_all_analytics_ui_elements,
+        fn=refresh_all_analytics_ui_elements, # This will now also update chatbot data summaries
         inputs=[token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker, chat_histories_st],
         outputs=apply_filter_and_sync_outputs_list, 
         show_progress="full"
@@ -763,6 +895,6 @@ if __name__ == "__main__":
     try:
         logging.info(f"Versione Matplotlib: {matplotlib.__version__}, Backend: {matplotlib.get_backend()}")
     except ImportError: 
-        logging.warning("Matplotlib non trovato direttamente, ma potrebbe essere usato dai generatori di grafici.") # Changed from error to warning
+        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)