Update app.py

app.py

@@ -4,10 +4,11 @@ import os
 import logging
 import matplotlib
 matplotlib.use('Agg') # Set backend for Matplotlib to avoid GUI conflicts with Gradio
-import matplotlib.pyplot as plt 
+import matplotlib.pyplot as plt
+# from functools import partial # No longer needed if gr.State(value=plot_id) is used
 
 # --- Module Imports ---
-from gradio_utils import get_url_user_token 
+from gradio_utils import get_url_user_token
 
 # Functions from newly created/refactored modules
 from config import (
@@ -19,10 +20,11 @@ from sync_logic import sync_all_linkedin_data_orchestrator
 from ui_generators import (
     display_main_dashboard,
     run_mentions_tab_display,
-    run_follower_stats_tab_display
+    run_follower_stats_tab_display,
+    build_analytics_tab_ui_components # Import the new UI builder function
 )
 # Corrected import for analytics_data_processing
-from analytics_data_processing import prepare_filtered_analytics_data 
+from analytics_data_processing import prepare_filtered_analytics_data
 from analytics_plot_generator import (
     generate_posts_activity_plot, generate_engagement_type_plot,
     generate_mentions_activity_plot, generate_mention_sentiment_plot,
@@ -33,13 +35,11 @@ from analytics_plot_generator import (
     generate_reach_over_time_plot,
     generate_impressions_over_time_plot,
     create_placeholder_plot, # For initializing plots
-    # --- Import existing new plot functions ---
     generate_likes_over_time_plot,
-    generate_clicks_over_time_plot, # Note: can be same as reach
+    generate_clicks_over_time_plot,
     generate_shares_over_time_plot,
     generate_comments_over_time_plot,
     generate_comments_sentiment_breakdown_plot,
-    # --- Import NEW plot functions for Content Strategy ---
     generate_post_frequency_plot,
     generate_content_format_breakdown_plot,
     generate_content_topic_breakdown_plot
@@ -48,19 +48,14 @@ from analytics_plot_generator import (
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(module)s - %(message)s')
 
-# --- Analytics Tab: Plot Update Function ---
-def update_analytics_plots(token_state_value, date_filter_option, custom_start_date, custom_end_date):
+# --- Analytics Tab: Plot Update Function (Original, generates figures) ---
+def update_analytics_plots_figures(token_state_value, date_filter_option, custom_start_date, custom_end_date):
     """
-    Prepares analytics data using external processing function and then generates plots.
+    Prepares analytics data using external processing function and then generates plot figures.
+    This function is primarily responsible for returning the Matplotlib figure objects.
     """
-    logging.info(f"Updating analytics plots. Filter: {date_filter_option}, Custom Start: {custom_start_date}, Custom End: {custom_end_date}")
-
-    # --- Increased number of expected plots ---
-    # Original 13 + 5 engagement = 18
-    # New Content Strategy (3: freq, format, topics)
-    # New Mention Analysis (2: volume, sentiment - these reuse existing plot objects but are new UI slots)
-    # Total = 18 + 3 + 2 = 23
-    num_expected_plots = 23 
+    logging.info(f"Updating analytics plot figures. Filter: {date_filter_option}, Custom Start: {custom_start_date}, Custom End: {custom_end_date}")
+    num_expected_plots = 23 # This should match the number of plots defined in plot_configs
 
     if not token_state_value or not token_state_value.get("token"):
         message = "❌ Access denied. No token. Cannot generate analytics."
@@ -69,27 +64,14 @@ def update_analytics_plots(token_state_value, date_filter_option, custom_start_d
         return [message] + placeholder_figs
 
     try:
-        # prepare_filtered_analytics_data might need to be updated if new DFs are required for new plots
-        # (e.g. if 'media_type' or 'eb_labels' are not in 'bubble_posts_df' and need special handling)
-        # For now, we assume 'filtered_merged_posts_df' contains these columns.
-        (filtered_merged_posts_df, 
-         filtered_mentions_df, 
-         date_filtered_follower_stats_df, 
-         raw_follower_stats_df, 
+        (filtered_merged_posts_df,
+         filtered_mentions_df,
+         date_filtered_follower_stats_df,
+         raw_follower_stats_df,
          start_dt_for_msg, end_dt_for_msg) = \
             prepare_filtered_analytics_data(
                 token_state_value, date_filter_option, custom_start_date, custom_end_date
             )
-        
-        # Ensure 'media_type' and 'eb_labels' exist in filtered_merged_posts_df for new plots,
-        # or handle their absence gracefully in the plot functions themselves (which they do).
-        # Example: Add dummy columns if they might be missing, for robust testing:
-        # if 'media_type' not in filtered_merged_posts_df.columns:
-        # filtered_merged_posts_df['media_type'] = 'Unknown'
-        # if 'eb_labels' not in filtered_merged_posts_df.columns:
-        # filtered_merged_posts_df['eb_labels'] = None
-
-
     except Exception as e:
         error_msg = f"❌ Error preparing analytics data: {e}"
         logging.error(error_msg, exc_info=True)
@@ -98,114 +80,68 @@ def update_analytics_plots(token_state_value, date_filter_option, custom_start_d
 
     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")
-    # config_date_col_followers_source = token_state_value.get("config_date_col_followers", "date") 
+    media_type_col_name = token_state_value.get("config_media_type_col", "media_type")
+    eb_labels_col_name = token_state_value.get("config_eb_labels_col", "eb_labels")
 
     logging.info(f"Data for plotting - Filtered Merged Posts: {len(filtered_merged_posts_df)} rows, Filtered Mentions: {len(filtered_mentions_df)} rows.")
     logging.info(f"Date-Filtered Follower Stats: {len(date_filtered_follower_stats_df)} rows, Raw Follower Stats: {len(raw_follower_stats_df)} rows.")
 
     try:
-        # Existing plots (13)
-        plot_posts_activity = generate_posts_activity_plot(filtered_merged_posts_df, date_column=date_column_posts)
-        plot_engagement_type = generate_engagement_type_plot(filtered_merged_posts_df) 
+        plot_figs = []
+        plot_figs.append(generate_posts_activity_plot(filtered_merged_posts_df, date_column=date_column_posts))
+        plot_figs.append(generate_engagement_type_plot(filtered_merged_posts_df))
         
-        # These two will be used for the new "Mention Analysis" section as well
         fig_mentions_activity_shared = generate_mentions_activity_plot(filtered_mentions_df, date_column=date_column_mentions)
-        fig_mention_sentiment_shared = generate_mention_sentiment_plot(filtered_mentions_df) 
-
-        plot_followers_count = generate_followers_count_over_time_plot(
-            date_filtered_follower_stats_df, 
-            type_filter_column='follower_count_type',
-            type_value='follower_gains_monthly' 
-        )
-        plot_followers_growth_rate = generate_followers_growth_rate_plot(
-            date_filtered_follower_stats_df,
-            type_filter_column='follower_count_type',
-            type_value='follower_gains_monthly'
-        )
-
-        plot_followers_by_location = generate_followers_by_demographics_plot(raw_follower_stats_df, category_col='category_name', type_filter_column='follower_count_type', type_value='follower_geo', plot_title="Followers by Location")
-        plot_followers_by_role = generate_followers_by_demographics_plot(raw_follower_stats_df, category_col='category_name', type_filter_column='follower_count_type', type_value='follower_function', plot_title="Followers by Role")
-        plot_followers_by_industry = generate_followers_by_demographics_plot(raw_follower_stats_df, category_col='category_name', type_filter_column='follower_count_type', type_value='follower_industry', plot_title="Followers by Industry")
-        plot_followers_by_seniority = generate_followers_by_demographics_plot(raw_follower_stats_df, category_col='category_name', type_filter_column='follower_count_type', type_value='follower_seniority', plot_title="Followers by Seniority")
-
-        plot_engagement_rate = generate_engagement_rate_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts, engagement_rate_col='engagement')
-        plot_reach_over_time = generate_reach_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts, reach_col='clickCount')
-        plot_impressions_over_time = generate_impressions_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts, impressions_col='impressionCount')
-
-        # Additional Engagement plots (5)
-        plot_likes_over_time = generate_likes_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts, likes_col='likeCount')
-        plot_clicks_over_time = generate_clicks_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts, clicks_col='clickCount')
-        plot_shares_over_time = generate_shares_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts, shares_col='shareCount')
-        plot_comments_over_time = generate_comments_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts, comments_col='commentCount')
+        fig_mention_sentiment_shared = generate_mention_sentiment_plot(filtered_mentions_df)
         
-        # Assuming 'comment_sentiment' column might exist, or 'sentiment' as fallback (handled in plot function)
-        plot_comments_sentiment_breakdown = generate_comments_sentiment_breakdown_plot(
-            filtered_merged_posts_df, 
-            sentiment_column='comment_sentiment' 
-        )
-
-        # --- Generate NEW plots for Content Strategy (3) ---
-        # Assuming 'media_type' and 'eb_labels' are in filtered_merged_posts_df
-        # The plot functions themselves have fallbacks/placeholders if columns are missing.
-        media_type_col_name = token_state_value.get("config_media_type_col", "media_type") # Example if configurable
-        eb_labels_col_name = token_state_value.get("config_eb_labels_col", "eb_labels") # Example if configurable
-
-        plot_post_frequency = generate_post_frequency_plot(filtered_merged_posts_df, date_column=date_column_posts)
-        plot_content_format_breakdown = generate_content_format_breakdown_plot(filtered_merged_posts_df, format_col=media_type_col_name)
-        plot_content_topic_breakdown = generate_content_topic_breakdown_plot(filtered_merged_posts_df, topics_col=eb_labels_col_name)
-
+        plot_figs.append(fig_mentions_activity_shared) # Original mention plot slot 1
+        plot_figs.append(fig_mention_sentiment_shared) # Original mention plot slot 2
+
+        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'))
+        plot_figs.append(generate_followers_by_demographics_plot(raw_follower_stats_df, type_value='follower_geo', plot_title="Followers by Location"))
+        plot_figs.append(generate_followers_by_demographics_plot(raw_follower_stats_df, type_value='follower_function', plot_title="Followers by Role"))
+        plot_figs.append(generate_followers_by_demographics_plot(raw_follower_stats_df, type_value='follower_industry', plot_title="Followers by Industry"))
+        plot_figs.append(generate_followers_by_demographics_plot(raw_follower_stats_df, type_value='follower_seniority', plot_title="Followers by Seniority"))
+        plot_figs.append(generate_engagement_rate_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts))
+        plot_figs.append(generate_reach_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts))
+        plot_figs.append(generate_impressions_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts))
+        plot_figs.append(generate_likes_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts))
+        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_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))
+        
+        # For the "Mention Analysis" section, we reuse the figures generated earlier
+        plot_figs.append(fig_mentions_activity_shared) # New UI slot for mention volume, reuses figure
+        plot_figs.append(fig_mention_sentiment_shared) # New UI slot for mention sentiment, reuses figure
 
         message = f"📊 Analytics updated for period: {date_filter_option}"
         if date_filter_option == "Custom Range":
             s_display = start_dt_for_msg.strftime('%Y-%m-%d') if start_dt_for_msg else "Any"
-            e_display = end_dt_for_msg.strftime('%Y-%m-%d') if end_dt_for_msg else "Any" 
+            e_display = end_dt_for_msg.strftime('%Y-%m-%d') if end_dt_for_msg else "Any"
             message += f" (From: {s_display} To: {e_display})"
         
-        all_generated_plots = [
-            plot_posts_activity, plot_engagement_type, 
-            fig_mentions_activity_shared, fig_mention_sentiment_shared, # Original mention plots
-            plot_followers_count, plot_followers_growth_rate,
-            plot_followers_by_location, plot_followers_by_role, plot_followers_by_industry, plot_followers_by_seniority,
-            plot_engagement_rate, plot_reach_over_time, plot_impressions_over_time,
-            # Add new engagement plot objects to the list
-            plot_likes_over_time, plot_clicks_over_time,
-            plot_shares_over_time, plot_comments_over_time,
-            plot_comments_sentiment_breakdown,
-            # --- Add NEW Content Strategy plot objects ---
-            plot_post_frequency, plot_content_format_breakdown, plot_content_topic_breakdown,
-            # --- Add plots for the NEW "Mention Analysis" section (reusing figures) ---
-            fig_mentions_activity_shared, # Reused figure for new UI slot
-            fig_mention_sentiment_shared  # Reused figure for new UI slot
-        ]
-        num_plots_generated = sum(1 for p in all_generated_plots if p is not None and not isinstance(p, str)) 
-        logging.info(f"Successfully generated {num_plots_generated} plot figures for {num_expected_plots} UI slots.")
-        
-        # Ensure the number of returned plots matches num_expected_plots, padding with placeholders if necessary
-        final_plots_list = []
-        for i, p in enumerate(all_generated_plots): # Iterate up to the expected number of plots
-            if i < num_expected_plots: # Ensure we don't exceed the expected number of outputs
-                if p is not None and not isinstance(p, str): # isinstance check for safety
-                    final_plots_list.append(p)
-                else: 
-                    logging.warning(f"A plot generation failed or returned unexpected type for slot {i}, using placeholder. Plot: {p}")
-                    final_plots_list.append(create_placeholder_plot(title="Plot Error", message="Failed to generate this plot."))
+        final_plot_figs = []
+        for i, p_fig in enumerate(plot_figs):
+            if p_fig is not None and not isinstance(p_fig, str):
+                final_plot_figs.append(p_fig)
             else:
-                logging.warning(f"Generated more plot figures ({len(all_generated_plots)}) than expected UI slots ({num_expected_plots}). Truncating.")
-                break
-
-
-        # If fewer plots were generated than expected (e.g. due to early exit or major error in a plot function)
-        while len(final_plots_list) < num_expected_plots:
-            logging.warning(f"Padding missing plot with placeholder. Expected {num_expected_plots}, got {len(final_plots_list)} so far.")
-            final_plots_list.append(create_placeholder_plot(title="Missing Plot", message="Plot could not be generated."))
-            if len(final_plots_list) > num_expected_plots + 5: # Safety break
-                logging.error("Too many placeholders added, breaking loop.")
-                break
-
-        return [message] + final_plots_list[:num_expected_plots] # Ensure correct number of outputs
+                logging.warning(f"Plot figure generation failed or returned unexpected type for slot {i}, using placeholder. Figure: {p_fig}")
+                final_plot_figs.append(create_placeholder_plot(title="Plot Error", message="Failed to generate this plot figure."))
+        
+        while len(final_plot_figs) < num_expected_plots:
+            logging.warning(f"Padding missing plot figure with placeholder. Expected {num_expected_plots}, got {len(final_plot_figs)}.")
+            final_plot_figs.append(create_placeholder_plot(title="Missing Plot", message="Plot figure could not be generated."))
+        
+        logging.info(f"Successfully generated {len(final_plot_figs)} plot figures for {num_expected_plots} UI slots.")
+        return [message] + final_plot_figs[:num_expected_plots]
 
     except Exception as e:
-        error_msg = f"❌ Error generating analytics plots: {e}"
+        error_msg = f"❌ Error generating analytics plot figures: {e}"
         logging.error(error_msg, exc_info=True)
         placeholder_figs = [create_placeholder_plot(title="Plot Generation Error", message=str(e)) for _ in range(num_expected_plots)]
         return [error_msg] + placeholder_figs
@@ -213,24 +149,21 @@ def update_analytics_plots(token_state_value, date_filter_option, custom_start_d
 
 # --- 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(), 
+        "bubble_posts_df": pd.DataFrame(),
+        "bubble_post_stats_df": pd.DataFrame(),
         "bubble_mentions_df": pd.DataFrame(),
         "bubble_follower_stats_df": pd.DataFrame(),
-        # Consider adding "bubble_comments_sentiment_df": pd.DataFrame() if you plan to fetch this data
-        # Add keys for new data if needed by prepare_filtered_analytics_data, e.g.
-        # "bubble_posts_with_content_details_df": pd.DataFrame(), 
-        "fetch_count_for_api": 0, 
+        "fetch_count_for_api": 0,
         "url_user_token_temp_storage": None,
-        "config_date_col_posts": "published_at", 
-        "config_date_col_mentions": "date",       
+        "config_date_col_posts": "published_at",
+        "config_date_col_mentions": "date",
         "config_date_col_followers": "date",
-        "config_media_type_col": "media_type", # For new plot
-        "config_eb_labels_col": "eb_labels"    # For new plot
+        "config_media_type_col": "media_type",
+        "config_eb_labels_col": "eb_labels"
     })
 
     gr.Markdown("# 🚀 LinkedIn Organization Dashboard")
@@ -243,7 +176,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
     def initial_load_sequence(url_token, org_urn_val, current_state):
         logging.info(f"Initial load sequence triggered. Org URN: {org_urn_val}, URL Token: {'Present' if url_token else 'Absent'}")
         status_msg, new_state, btn_update = process_and_store_bubble_token(url_token, org_urn_val, current_state)
-        dashboard_content = display_main_dashboard(new_state) 
+        dashboard_content = display_main_dashboard(new_state)
         return status_msg, new_state, btn_update, dashboard_content
 
     with gr.Tabs() as tabs:
@@ -260,38 +193,19 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 show_progress="full"
             )
             
-            sync_click_event = sync_data_btn.click(
-                fn=sync_all_linkedin_data_orchestrator,
-                inputs=[token_state],
-                outputs=[sync_status_html_output, token_state], 
-                show_progress="full"
-            ).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 
-            ).then(
-                fn=display_main_dashboard, 
-                inputs=[token_state],
-                outputs=[dashboard_display_html],
-                show_progress=False
-            )
-
-
         with gr.TabItem("2️⃣ Analytics", id="tab_analytics"):
             gr.Markdown("## 📈 LinkedIn Performance Analytics")
-            gr.Markdown("Select a date range to filter Posts and Mentions analytics. Follower demographic plots show overall latest data. Follower time-series plots respect the selected date range if applicable to their data source (e.g. monthly gains).")
+            gr.Markdown("Select a date range to filter analytics. Click 💣 for insights.")
             
             analytics_status_md = gr.Markdown("Analytics status will appear here...")
 
             with gr.Row():
                 date_filter_selector = gr.Radio(
                     ["All Time", "Last 7 Days", "Last 30 Days", "Custom Range"],
-                    label="Select Date Range (for Posts, Mentions, and some Follower time-series)",
-                    value="Last 30 Days"
+                    label="Select Date Range", value="Last 30 Days"
                 )
-                custom_start_date_picker = gr.DateTime(label="Start Date (Custom)", visible=False, include_time=False, type="datetime") # Changed to datetime
-                custom_end_date_picker = gr.DateTime(label="End Date (Custom)", visible=False, include_time=False, type="datetime") # Changed to datetime
+                custom_start_date_picker = gr.DateTime(label="Start Date", visible=False, include_time=False, type="datetime")
+                custom_end_date_picker = gr.DateTime(label="End Date", visible=False, include_time=False, type="datetime")
             
             apply_filter_btn = gr.Button("🔍 Apply Filter & Refresh Analytics", variant="primary")
 
@@ -305,107 +219,152 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 outputs=[custom_start_date_picker, custom_end_date_picker]
             )
 
-            gr.Markdown("### Posts & Engagement Overview (Filtered by Date)")
-            with gr.Row():
-                posts_activity_plot = gr.Plot(label="Posts Activity Over Time")
-                engagement_type_plot = gr.Plot(label="Post Engagement Types")
+            # --- Define plot configurations ---
+            # (Order must match the order of figures returned by update_analytics_plots_figures)
+            plot_configs = [
+                {"label": "Posts Activity Over Time", "id": "posts_activity", "section": "Posts & Engagement Overview"},
+                {"label": "Post Engagement Types", "id": "engagement_type", "section": "Posts & Engagement Overview"},
+                {"label": "Mentions Activity Over Time", "id": "mentions_activity", "section": "Mentions Overview"}, 
+                {"label": "Mention Sentiment Distribution", "id": "mention_sentiment", "section": "Mentions Overview"}, 
+                {"label": "Followers Count Over Time", "id": "followers_count", "section": "Follower Dynamics"},
+                {"label": "Followers Growth Rate", "id": "followers_growth_rate", "section": "Follower Dynamics"},
+                {"label": "Followers by Location", "id": "followers_by_location", "section": "Follower Demographics"},
+                {"label": "Followers by Role (Function)", "id": "followers_by_role", "section": "Follower Demographics"},
+                {"label": "Followers by Industry", "id": "followers_by_industry", "section": "Follower Demographics"},
+                {"label": "Followers by Seniority", "id": "followers_by_seniority", "section": "Follower Demographics"},
+                {"label": "Engagement Rate Over Time", "id": "engagement_rate", "section": "Post Performance Insights"},
+                {"label": "Reach Over Time (Clicks)", "id": "reach_over_time", "section": "Post Performance Insights"},
+                {"label": "Impressions Over Time", "id": "impressions_over_time", "section": "Post Performance Insights"},
+                {"label": "Reactions (Likes) Over Time", "id": "likes_over_time", "section": "Post Performance Insights"},
+                {"label": "Clicks Over Time", "id": "clicks_over_time", "section": "Detailed Post Engagement Over Time"},
+                {"label": "Shares Over Time", "id": "shares_over_time", "section": "Detailed Post Engagement Over Time"},
+                {"label": "Comments Over Time", "id": "comments_over_time", "section": "Detailed Post Engagement Over Time"},
+                {"label": "Breakdown of Comments by Sentiment", "id": "comments_sentiment", "section": "Detailed Post Engagement Over Time"},
+                {"label": "Post Frequency", "id": "post_frequency_cs", "section": "Content Strategy Analysis"},
+                {"label": "Breakdown of Content by Format", "id": "content_format_breakdown_cs", "section": "Content Strategy Analysis"},
+                {"label": "Breakdown of Content by Topics", "id": "content_topic_breakdown_cs", "section": "Content Strategy Analysis"},
+                {"label": "Mentions Volume Over Time (Detailed)", "id": "mention_analysis_volume", "section": "Mention Analysis (Detailed)"}, 
+                {"label": "Breakdown of Mentions by Sentiment (Detailed)", "id": "mention_analysis_sentiment", "section": "Mention Analysis (Detailed)"} 
+            ]
+            assert len(plot_configs) == 23, "Mismatch in number of plot configurations and expected plots."
             
-            # Original Mentions Overview - these plots will also be used for the "Mention Analysis" section below
-            gr.Markdown("### Mentions Overview (Filtered by Date)")
-            with gr.Row():
-                mentions_activity_plot = gr.Plot(label="Mentions Activity Over Time") # Will be updated by fig_mentions_activity_shared
-                mention_sentiment_plot = gr.Plot(label="Mention Sentiment Distribution") # Will be updated by fig_mention_sentiment_shared
-
-            gr.Markdown("### Follower Dynamics")
-            with gr.Row():
-                followers_count_plot = gr.Plot(label="Followers Count Over Time (e.g., Monthly Gains)")
-                followers_growth_rate_plot = gr.Plot(label="Followers Growth Rate (e.g., Monthly Gains)")
+            # --- Build Analytics Tab UI using the function from ui_generators ---
+            # This function will create the gr.Markdown for sections and rows for plots.
+            # It needs to be called within this gr.Blocks() context.
+            plot_ui_objects = build_analytics_tab_ui_components(plot_configs)
             
-            gr.Markdown("### Follower Demographics (Overall Latest Data)")
-            with gr.Row():
-                followers_by_location_plot = gr.Plot(label="Followers by Location")
-                followers_by_role_plot = gr.Plot(label="Followers by Role (Function)")
-            with gr.Row():
-                followers_by_industry_plot = gr.Plot(label="Followers by Industry")
-                followers_by_seniority_plot = gr.Plot(label="Followers by Seniority")
-
-            gr.Markdown("### Post Performance Insights (Filtered by Date)")
-            with gr.Row(): 
-                engagement_rate_plot = gr.Plot(label="Engagement Rate Over Time")
-                reach_over_time_plot = gr.Plot(label="Reach Over Time (Clicks)")
-            with gr.Row(): 
-                impressions_over_time_plot = gr.Plot(label="Impressions Over Time")
-                likes_over_time_plot = gr.Plot(label="Reactions (Likes) Over Time")
-
-            gr.Markdown("### Detailed Post Engagement Over Time (Filtered by Date)")
-            with gr.Row():
-                clicks_over_time_plot = gr.Plot(label="Clicks Over Time") # Can be same as reach
-                shares_over_time_plot = gr.Plot(label="Shares Over Time")
-            with gr.Row():
-                comments_over_time_plot = gr.Plot(label="Comments Over Time")
-                comments_sentiment_plot = gr.Plot(label="Breakdown of Comments by Sentiment")
-
-            # --- NEW: Content Strategy Analysis ---
-            gr.Markdown("### 📊 Content Strategy Analysis (Filtered by Date)")
-            with gr.Row():
-                post_frequency_cs_plot = gr.Plot(label="Post Frequency") # New plot component
-                content_format_breakdown_cs_plot = gr.Plot(label="Breakdown of Content by Format") # New
-            with gr.Row():
-                content_topic_breakdown_cs_plot = gr.Plot(label="Breakdown of Content by Topics") # New (might need more width)
-                # You can add another plot here or make the topic plot wider if needed, e.g. by itself in a row.
-                # For now, placing it here. If it's too cramped:
-                # content_topic_breakdown_cs_plot = gr.Plot(label="Breakdown of Content by Topics", elem_id="topic_plot_wide") # and use CSS for width if needed
-
-            # --- NEW: Mention Analysis (reusing plots from above) ---
-            gr.Markdown("### 💬 Mention Analysis (Filtered by Date)")
-            with gr.Row():
-                mention_analysis_volume_plot = gr.Plot(label="Mentions Volume Over Time") # New UI slot, uses fig_mentions_activity_shared
-                mention_analysis_sentiment_plot = gr.Plot(label="Breakdown of Mentions by Sentiment") # New UI slot, uses fig_mention_sentiment_shared
+            active_insight_plot_id_state = gr.State(None) # Stores the plot_id of the currently open insight panel
+
+            # --- Bomb Button Click Handler ---
+            def handle_bomb_click(plot_id_clicked, current_active_plot_id, current_token_state):
+                logging.info(f"Bomb clicked for: {plot_id_clicked}. Currently active: {current_active_plot_id}")
+                updates = [] 
+                new_active_id = None
+
+                if plot_id_clicked == current_active_plot_id:
+                    new_active_id = None # Toggle off
+                    logging.info(f"Closing insights for {plot_id_clicked}")
+                else:
+                    new_active_id = plot_id_clicked # Activate new one
+                    logging.info(f"Opening insights for {plot_id_clicked}, closing others.")
+
+                for p_id_iter, ui_obj_dict in plot_ui_objects.items():
+                    is_target_one = (p_id_iter == new_active_id)
+                    updates.append(gr.update(visible=is_target_one)) # For insights_col visibility
+
+                    if is_target_one:
+                        # TODO: Implement actual insight generation logic here
+                        insight_text = f"**Insights for {ui_obj_dict['label']}**\n\n"
+                        insight_text += f"Plot ID: `{p_id_iter}`.\n"
+                        insight_text += "Detailed analysis would involve examining trends, anomalies, and correlations related to this specific chart.\n"
+                        insight_text += "For example, for 'Posts Activity', we might look for days with unusually high or low activity and correlate with external events or content types."
+                        updates.append(gr.update(value=insight_text))
+                    else:
+                        updates.append(gr.update(value=f"Click 💣 for insights on {ui_obj_dict['label']}...")) # Reset placeholder
+                
+                updates.append(new_active_id) # New value for active_insight_plot_id_state
+                logging.info(f"Returning {len(updates)-1} UI updates. New active ID: {new_active_id}")
+                return updates
+
+            # --- Connect Bomb Buttons ---
+            bomb_click_dynamic_outputs = []
+            # The order of items in bomb_click_dynamic_outputs must match the order of iteration
+            # in handle_bomb_click when it creates its `updates` list.
+            # plot_ui_objects is a dictionary, so .keys() gives an arbitrary order if not Python 3.7+
+            # To be safe, iterate based on plot_configs order for constructing outputs.
+            for config in plot_configs:
+                p_id_key = config["id"]
+                bomb_click_dynamic_outputs.append(plot_ui_objects[p_id_key]["insights_col"])
+                bomb_click_dynamic_outputs.append(plot_ui_objects[p_id_key]["insights_md"])
+            bomb_click_dynamic_outputs.append(active_insight_plot_id_state)
+
+            for config in plot_configs:
+                plot_id = config["id"]
+                components_dict = plot_ui_objects[plot_id]
+                components_dict["bomb"].click(
+                    fn=handle_bomb_click,
+                    inputs=[gr.State(value=plot_id), active_insight_plot_id_state, token_state],
+                    outputs=bomb_click_dynamic_outputs,
+                    api_name=f"show_insights_{plot_id}" # Gradio handles None api_name if plot_id is None (though it shouldn't be)
+                )
             
-
-            analytics_plot_outputs = [
-                analytics_status_md, 
-                posts_activity_plot, engagement_type_plot, 
-                mentions_activity_plot, mention_sentiment_plot, # Original mention plots
-                followers_count_plot, followers_growth_rate_plot,
-                followers_by_location_plot, followers_by_role_plot, 
-                followers_by_industry_plot, followers_by_seniority_plot,
-                engagement_rate_plot, reach_over_time_plot, impressions_over_time_plot,
-                # Add new engagement plot components to the output list
-                likes_over_time_plot, clicks_over_time_plot,
-                shares_over_time_plot, comments_over_time_plot,
-                comments_sentiment_plot,
-                # --- Add NEW Content Strategy plot components ---
-                post_frequency_cs_plot, content_format_breakdown_cs_plot, content_topic_breakdown_cs_plot,
-                # --- Add NEW Mention Analysis plot components (these will receive the reused figures) ---
-                mention_analysis_volume_plot, mention_analysis_sentiment_plot
-            ]
-            # Expected length: 1 (status) + 13 (original plots) + 5 (new engagement) + 3 (content strategy) + 2 (mention analysis) = 24
-            # The update_analytics_plots function returns message + 23 plots. So len(analytics_plot_outputs) should be 24.
-            # Current count: 1 + 2 + 2 + 2 + 4 + 3 + 5 + 3 + 2 = 24. Correct.
-
+            # --- Function to Refresh All Analytics UI (Plots + Reset Insights) ---
+            def refresh_all_analytics_ui_elements(current_token_state, date_filter_val, custom_start_val, custom_end_val):
+                logging.info("Refreshing all analytics UI elements.")
+                plot_generation_results = update_analytics_plots_figures(
+                    current_token_state, date_filter_val, custom_start_val, custom_end_val
+                )
+                
+                status_message_update = plot_generation_results[0]
+                generated_plot_figures = plot_generation_results[1:]
+
+                all_updates = [status_message_update]
+
+                # Plot figure updates - iterate based on plot_configs to ensure order
+                for i, config in enumerate(plot_configs):
+                    p_id_key = config["id"]
+                    if i < len(generated_plot_figures):
+                        all_updates.append(generated_plot_figures[i])
+                    else:
+                        logging.error(f"Mismatch: Expected figure for {p_id_key} but not enough figures generated.")
+                        all_updates.append(create_placeholder_plot("Figure Error", f"No figure for {p_id_key}"))
+                
+                # Insight column visibility and markdown content reset - iterate based on plot_configs
+                for config in plot_configs:
+                    p_id_key = config["id"]
+                    ui_obj_dict_val = plot_ui_objects[p_id_key]
+                    all_updates.append(gr.update(visible=False)) # Hide insights_col
+                    all_updates.append(gr.update(value=f"Click 💣 for insights on {ui_obj_dict_val['label']}...")) # Reset insights_md
+
+                all_updates.append(None) # Reset active_insight_plot_id_state
+                return all_updates
+
+            # --- Define outputs for the apply_filter_btn and sync.then() ---
+            apply_filter_and_sync_outputs = [analytics_status_md]
+            # Iterate based on plot_configs to ensure order
+            for config in plot_configs: # Plot components
+                apply_filter_and_sync_outputs.append(plot_ui_objects[config["id"]]["plot"])
+            for config in plot_configs: # Insight column components
+                apply_filter_and_sync_outputs.append(plot_ui_objects[config["id"]]["insights_col"])
+            for config in plot_configs: # Insight markdown components
+                apply_filter_and_sync_outputs.append(plot_ui_objects[config["id"]]["insights_md"])
+            apply_filter_and_sync_outputs.append(active_insight_plot_id_state) # State component
+
+            # --- Connect Apply Filter Button ---
             apply_filter_btn.click(
-                fn=update_analytics_plots,
-                inputs=[token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker],
-                outputs=analytics_plot_outputs,
-                show_progress="full"
-            )
-            
-            # Also update analytics after sync
-            sync_click_event.then( 
-                fn=update_analytics_plots,
+                fn=refresh_all_analytics_ui_elements,
                 inputs=[token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker],
-                outputs=analytics_plot_outputs,
+                outputs=apply_filter_and_sync_outputs,
                 show_progress="full"
             )
 
         with gr.TabItem("3️⃣ Mentions", id="tab_mentions"):
             refresh_mentions_display_btn = gr.Button("🔄 Refresh Mentions Display (from local data)", variant="secondary")
             mentions_html = gr.HTML("Mentions data loads from Bubble after sync. Click refresh to view current local data.")
-            mentions_sentiment_dist_plot = gr.Plot(label="Mention Sentiment Distribution") 
+            mentions_sentiment_dist_plot = gr.Plot(label="Mention Sentiment Distribution")
             refresh_mentions_display_btn.click(
                 fn=run_mentions_tab_display, inputs=[token_state],
-                outputs=[mentions_html, mentions_sentiment_dist_plot], 
+                outputs=[mentions_html, mentions_sentiment_dist_plot],
                 show_progress="full"
             )
 
@@ -413,17 +372,43 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             refresh_follower_stats_btn = gr.Button("🔄 Refresh Follower Stats Display (from local data)", variant="secondary")
             follower_stats_html = gr.HTML("Follower statistics load from Bubble after sync. Click refresh to view current local data.")
             with gr.Row():
-                fs_plot_monthly_gains = gr.Plot(label="Monthly Follower Gains") 
+                fs_plot_monthly_gains = gr.Plot(label="Monthly Follower Gains")
             with gr.Row():
                 fs_plot_seniority = gr.Plot(label="Followers by Seniority (Top 10 Organic)")
                 fs_plot_industry = gr.Plot(label="Followers by Industry (Top 10 Organic)")
 
             refresh_follower_stats_btn.click(
                 fn=run_follower_stats_tab_display, inputs=[token_state],
-                outputs=[follower_stats_html, fs_plot_monthly_gains, fs_plot_seniority, fs_plot_industry], 
+                outputs=[follower_stats_html, fs_plot_monthly_gains, fs_plot_seniority, fs_plot_industry],
                 show_progress="full"
             )
     
+    # --- Define the full sync_click_event chain HERE, now that analytics outputs are known ---
+    sync_event_part1 = sync_data_btn.click(
+        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,
+        inputs=[url_user_token_display, org_urn_display, token_state], 
+        outputs=[status_box, token_state, sync_data_btn], 
+        show_progress=False
+    )
+    sync_event_part3 = sync_event_part2.then(
+        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,
+        inputs=[token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker], 
+        outputs=apply_filter_and_sync_outputs, 
+        show_progress="full"
+    )
+
 
 if __name__ == "__main__":
     if not os.environ.get(LINKEDIN_CLIENT_ID_ENV_VAR):
@@ -439,3 +424,4 @@ if __name__ == "__main__":
         logging.error("Matplotlib is not installed. Plots will not be generated.")
 
     app.launch(server_name="0.0.0.0", server_port=7860, debug=True)
+