Update app.py

app.py

@@ -4,38 +4,50 @@ import json
 import os
 import logging
 import html
-import pandas as pd # Ensure pandas is imported
-from datetime import datetime # Used for pd.Timestamp
+import pandas as pd
+from datetime import datetime, timedelta # Used for pd.Timestamp and date checks
 
 # Import functions from your custom modules
-from Data_Fetching_and_Rendering import fetch_and_render_dashboard
 from analytics_fetch_and_rendering import fetch_and_render_analytics
-from mentions_dashboard import generate_mentions_dashboard
 from gradio_utils import get_url_user_token
-# Updated import to include fetch_posts_from_bubble
+
 from Bubble_API_Calls import (
     fetch_linkedin_token_from_bubble,
     bulk_upload_to_bubble,
-    fetch_linkedin_posts_data_from_bubble
+    fetch_linkedin_posts_data_from_bubble,
+    # You need to implement this function in Bubble_API_Calls.py:
+    fetch_linkedin_mentions_data_from_bubble 
 )
+
 from Linkedin_Data_API_Calls import (
     fetch_linkedin_posts_core,
     fetch_comments,
-    analyze_sentiment,
+    analyze_sentiment, # For post comments
     compile_detailed_posts,
-    prepare_data_for_bubble
+    prepare_data_for_bubble, # For posts, stats, comments
+    fetch_linkedin_mentions_core,
+    analyze_mentions_sentiment, # For individual mentions
+    compile_detailed_mentions, # Compiles to user-specified format
+    prepare_mentions_for_bubble # Prepares user-specified format for Bubble
 )
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
 # --- Global Constants ---
-# Standard number of posts for initial fetch
-DEFAULT_INITIAL_FETCH_COUNT = 10 
-# Key for post URN in data processed from LinkedIn (e.g., in detailed_posts)
+DEFAULT_INITIAL_FETCH_COUNT = 10
 LINKEDIN_POST_URN_KEY = 'id' 
-# Column name for post URN in the DataFrame fetched from Bubble (bubble_posts_df)
-BUBBLE_POST_URN_COLUMN_NAME = 'id' # Adjust if your Bubble 'LI_posts' table uses a different column name for URNs
+BUBBLE_POST_URN_COLUMN_NAME = 'id' 
+BUBBLE_POST_DATE_COLUMN_NAME = 'published_at'
+
+# Constants for Mentions - these should match the keys used in the data prepared for Bubble
+BUBBLE_MENTIONS_TABLE_NAME = "LI_mentions" # Your Bubble table name for mentions
+BUBBLE_MENTIONS_ID_COLUMN_NAME = "id" # Column in Bubble storing the mention's source post URN (share_urn)
+BUBBLE_MENTIONS_DATE_COLUMN_NAME = "date" # Column in Bubble storing the mention's publication date
+
+DEFAULT_MENTIONS_INITIAL_FETCH_COUNT = 20
+DEFAULT_MENTIONS_UPDATE_FETCH_COUNT = 10
+
 
 def check_token_status(token_state):
     """Checks the status of the LinkedIn token."""
@@ -43,7 +55,7 @@ def check_token_status(token_state):
 
 def process_and_store_bubble_token(url_user_token, org_urn, token_state):
     """
-    Processes user token, fetches LinkedIn token, fetches Bubble posts,
+    Processes user token, fetches LinkedIn token, fetches existing Bubble posts & mentions,
     and determines if an initial fetch or update is needed for LinkedIn posts.
     Updates token state and UI for the sync button.
     """
@@ -51,18 +63,24 @@ def process_and_store_bubble_token(url_user_token, org_urn, token_state):
     
     new_state = token_state.copy() if token_state else {
         "token": None, "client_id": None, "org_urn": None, 
-        "bubble_posts_df": None, "fetch_count_for_api": 0 
+        "bubble_posts_df": pd.DataFrame(), "fetch_count_for_api": 0,
+        "bubble_mentions_df": pd.DataFrame(), "fetch_count_for_mentions_api": 0,
+        "url_user_token_temp_storage": None
     }
-    new_state.update({"org_urn": org_urn, "bubble_posts_df": new_state.get("bubble_posts_df"), "fetch_count_for_api": new_state.get("fetch_count_for_api", 0)})
+    new_state.update({
+        "org_urn": org_urn, 
+        "bubble_posts_df": new_state.get("bubble_posts_df", pd.DataFrame()), 
+        "fetch_count_for_api": new_state.get("fetch_count_for_api", 0),
+        "bubble_mentions_df": new_state.get("bubble_mentions_df", pd.DataFrame()),
+        "fetch_count_for_mentions_api": new_state.get("fetch_count_for_mentions_api", 0),
+        "url_user_token_temp_storage": url_user_token # Store for potential re-use
+    })
 
-    button_update = gr.update(visible=False, interactive=False, value="🔄 Sync LinkedIn Posts")
+    button_update = gr.update(visible=False, interactive=False, value="🔄 Sync LinkedIn Data")
 
     client_id = os.environ.get("Linkedin_client_id")
-    if not client_id:
-        logging.error("CRITICAL ERROR: 'Linkedin_client_id' environment variable not set.")
-        new_state["client_id"] = "ENV VAR MISSING"
-    else:
-        new_state["client_id"] = client_id
+    new_state["client_id"] = client_id if client_id else "ENV VAR MISSING"
+    if not client_id: logging.error("CRITICAL ERROR: 'Linkedin_client_id' environment variable not set.")
 
     if url_user_token and "not found" not in url_user_token and "Could not access" not in url_user_token:
         logging.info(f"Attempting to fetch LinkedIn token from Bubble with user token: {url_user_token}")
@@ -83,286 +101,383 @@ def process_and_store_bubble_token(url_user_token, org_urn, token_state):
 
     current_org_urn = new_state.get("org_urn")
     if current_org_urn:
+        # Fetch Posts from Bubble
         logging.info(f"Attempting to fetch posts from Bubble for org_urn: {current_org_urn}")
         try:
-            fetched_df, error_message = fetch_linkedin_posts_data_from_bubble(current_org_urn, "LI_posts")
-            if error_message:
-                logging.warning(f"Error reported by fetch_linkedin_posts_data_from_bubble: {error_message}. Treating as no data.")
-                new_state["bubble_posts_df"] = pd.DataFrame() # Ensure it's an empty DataFrame
-            else:
-                new_state["bubble_posts_df"] = fetched_df if fetched_df is not None else pd.DataFrame()
+            fetched_posts_df, error_message_posts = fetch_linkedin_posts_data_from_bubble(current_org_urn, "LI_posts")
+            new_state["bubble_posts_df"] = pd.DataFrame() if error_message_posts or fetched_posts_df is None else fetched_posts_df
+            if error_message_posts: logging.warning(f"Error from fetch_linkedin_posts_data_from_bubble: {error_message_posts}.")
+        except Exception as e:
+            logging.error(f"❌ Error fetching posts from Bubble: {e}.")
+            new_state["bubble_posts_df"] = pd.DataFrame()
+
+        # Fetch Mentions from Bubble
+        logging.info(f"Attempting to fetch mentions from Bubble for org_urn: {current_org_urn}")
+        try:
+            fetched_mentions_df, error_message_mentions = fetch_linkedin_mentions_data_from_bubble(current_org_urn, BUBBLE_MENTIONS_TABLE_NAME)
+            new_state["bubble_mentions_df"] = pd.DataFrame() if error_message_mentions or fetched_mentions_df is None else fetched_mentions_df
+            if error_message_mentions: logging.warning(f"Error from fetch_linkedin_mentions_data_from_bubble: {error_message_mentions}.")
         except Exception as e:
-            logging.error(f"❌ Error fetching posts from Bubble: {e}. Treating as no data.")
-            new_state["bubble_posts_df"] = pd.DataFrame() 
+            logging.error(f"❌ Error fetching mentions from Bubble: {e}.")
+            new_state["bubble_mentions_df"] = pd.DataFrame()
     else:
-        logging.warning("Org URN not available in state. Cannot fetch posts from Bubble.")
+        logging.warning("Org URN not available in state. Cannot fetch posts or mentions from Bubble.")
         new_state["bubble_posts_df"] = pd.DataFrame()
+        new_state["bubble_mentions_df"] = pd.DataFrame()
 
-
-    DATE_COLUMN_NAME = 'published_at' 
-
-    if new_state["bubble_posts_df"] is None or new_state["bubble_posts_df"].empty:
-        logging.info(f"ℹ️ No posts found in Bubble or DataFrame is empty. Button to fetch initial {DEFAULT_INITIAL_FETCH_COUNT} posts will be visible.")
+    # Determine fetch count for Posts API
+    if new_state["bubble_posts_df"].empty:
+        logging.info(f"ℹ️ No posts in Bubble. Setting to fetch initial {DEFAULT_INITIAL_FETCH_COUNT} posts.")
         new_state['fetch_count_for_api'] = DEFAULT_INITIAL_FETCH_COUNT
-        button_update = gr.update(value=f"🔄 Fetch Initial {DEFAULT_INITIAL_FETCH_COUNT} LinkedIn Posts", visible=True, interactive=True)
     else:
         try:
-            df_for_date_check = new_state["bubble_posts_df"].copy() 
-            if DATE_COLUMN_NAME not in df_for_date_check.columns:
-                logging.warning(f"Date column '{DATE_COLUMN_NAME}' not found in Bubble posts DataFrame. Assuming initial fetch of {DEFAULT_INITIAL_FETCH_COUNT} posts.")
-                new_state['fetch_count_for_api'] = DEFAULT_INITIAL_FETCH_COUNT
-                button_update = gr.update(value=f"🔄 Fetch Initial {DEFAULT_INITIAL_FETCH_COUNT} (Date Column Missing)", visible=True, interactive=True)
-            elif df_for_date_check[DATE_COLUMN_NAME].isnull().all():
-                logging.warning(f"Date column '{DATE_COLUMN_NAME}' contains all null values. Assuming initial fetch of {DEFAULT_INITIAL_FETCH_COUNT} posts.")
+            df_posts_check = new_state["bubble_posts_df"].copy()
+            if BUBBLE_POST_DATE_COLUMN_NAME not in df_posts_check.columns or df_posts_check[BUBBLE_POST_DATE_COLUMN_NAME].isnull().all():
+                logging.warning(f"Date column '{BUBBLE_POST_DATE_COLUMN_NAME}' for posts missing/all null. Initial fetch.")
                 new_state['fetch_count_for_api'] = DEFAULT_INITIAL_FETCH_COUNT
-                button_update = gr.update(value=f"🔄 Fetch Initial {DEFAULT_INITIAL_FETCH_COUNT} (Date Column Empty)", visible=True, interactive=True)
             else:
-                df_for_date_check[DATE_COLUMN_NAME] = pd.to_datetime(df_for_date_check[DATE_COLUMN_NAME], errors='coerce', utc=True)
-                last_post_date_utc = df_for_date_check[DATE_COLUMN_NAME].dropna().max()
-
+                df_posts_check[BUBBLE_POST_DATE_COLUMN_NAME] = pd.to_datetime(df_posts_check[BUBBLE_POST_DATE_COLUMN_NAME], errors='coerce', utc=True)
+                last_post_date_utc = df_posts_check[BUBBLE_POST_DATE_COLUMN_NAME].dropna().max()
                 if pd.isna(last_post_date_utc):
-                    logging.warning(f"No valid dates found in '{DATE_COLUMN_NAME}' after conversion. Assuming initial fetch of {DEFAULT_INITIAL_FETCH_COUNT} posts.")
                     new_state['fetch_count_for_api'] = DEFAULT_INITIAL_FETCH_COUNT
-                    button_update = gr.update(value=f"🔄 Fetch Initial {DEFAULT_INITIAL_FETCH_COUNT} (No Valid Dates)", visible=True, interactive=True)
                 else:
-                    today_utc = pd.Timestamp('now', tz='UTC').normalize() 
-                    last_post_date_utc_normalized = last_post_date_utc.normalize()
-
-                    time_difference_days = (today_utc - last_post_date_utc_normalized).days
-                    logging.info(f"Last post date (UTC, normalized): {last_post_date_utc_normalized}, Today (UTC, normalized): {today_utc}, Difference: {time_difference_days} days.")
-
-                    if time_difference_days >= 7:
-                        num_weeks = max(1, time_difference_days // 7) 
-                        fetch_count = num_weeks * 10
-                        new_state['fetch_count_for_api'] = fetch_count
-                        button_label = f"🔄 Update Last {num_weeks} Week(s) (~{fetch_count} Posts)"
-                        logging.info(f"Data is {time_difference_days} days old. Update needed for {num_weeks} weeks, ~{fetch_count} posts.")
-                        button_update = gr.update(value=button_label, visible=True, interactive=True)
+                    days_diff = (pd.Timestamp('now', tz='UTC').normalize() - last_post_date_utc.normalize()).days
+                    if days_diff >= 7:
+                        new_state['fetch_count_for_api'] = max(1, days_diff // 7) * 10
                     else:
-                        logging.info(f"Data is fresh ({time_difference_days} days old). No update needed now.")
-                        new_state['fetch_count_for_api'] = 0 
-                        button_update = gr.update(visible=False, interactive=False)
+                        new_state['fetch_count_for_api'] = 0
         except Exception as e:
-            logging.error(f"Error processing dates from Bubble posts: {e}. Defaulting to initial fetch of {DEFAULT_INITIAL_FETCH_COUNT} posts.")
+            logging.error(f"Error processing post dates: {e}. Defaulting to initial fetch.")
             new_state['fetch_count_for_api'] = DEFAULT_INITIAL_FETCH_COUNT
-            button_update = gr.update(value=f"🔄 Fetch Initial {DEFAULT_INITIAL_FETCH_COUNT} (Date Error)", visible=True, interactive=True)
+    
+    # Determine if mentions need fetching (actual count decided in sync_linkedin_mentions)
+    mentions_need_sync = False
+    if new_state["bubble_mentions_df"].empty:
+        mentions_need_sync = True
+    else:
+        if BUBBLE_MENTIONS_DATE_COLUMN_NAME not in new_state["bubble_mentions_df"].columns or new_state["bubble_mentions_df"][BUBBLE_MENTIONS_DATE_COLUMN_NAME].isnull().all():
+            mentions_need_sync = True
+        else:
+            df_mentions_check = new_state["bubble_mentions_df"].copy()
+            df_mentions_check[BUBBLE_MENTIONS_DATE_COLUMN_NAME] = pd.to_datetime(df_mentions_check[BUBBLE_MENTIONS_DATE_COLUMN_NAME], errors='coerce', utc=True)
+            last_mention_date_utc = df_mentions_check[BUBBLE_MENTIONS_DATE_COLUMN_NAME].dropna().max()
+            if pd.isna(last_mention_date_utc) or (pd.Timestamp('now', tz='UTC').normalize() - last_mention_date_utc.normalize()).days >= 7:
+                mentions_need_sync = True
+
+    if new_state['fetch_count_for_api'] > 0 or (new_state["token"] and mentions_need_sync):
+        button_label = "🔄 Sync LinkedIn Data"
+        if new_state['fetch_count_for_api'] > 0 and mentions_need_sync:
+            button_label += " (Posts & Mentions)"
+        elif new_state['fetch_count_for_api'] > 0:
+            button_label += f" ({new_state['fetch_count_for_api']} Posts)"
+        elif mentions_need_sync:
+             button_label += " (Mentions)"
+        button_update = gr.update(value=button_label, visible=True, interactive=True)
+    else:
+        button_update = gr.update(visible=False, interactive=False)
             
     token_status_message = check_token_status(new_state)
-    logging.info(f"Token processing complete. LinkedIn Token Status: {token_status_message}. Button update: {button_update}. Fetch count for API: {new_state['fetch_count_for_api']}")
+    logging.info(f"Token processing complete. Status: {token_status_message}. Button: {button_update}. Post Fetch: {new_state['fetch_count_for_api']}. Mentions sync needed: {mentions_need_sync}")
     return token_status_message, new_state, button_update
 
-def guarded_fetch_posts(token_state):
-    logging.info("Starting guarded_fetch_posts process.")
+
+def sync_linkedin_mentions(token_state):
+    """Fetches and syncs LinkedIn mentions to Bubble based on defined logic."""
+    logging.info("Starting LinkedIn mentions sync process.")
     if not token_state or not token_state.get("token"):
-        logging.error("Access denied for guarded_fetch_posts. No LinkedIn token available.")
-        return "<p style='color:red; text-align:center;'>❌ Access denied. LinkedIn token not available.</p>"
+        logging.error("Mentions sync: Access denied. No LinkedIn token.")
+        return "Mentions: No token. ", token_state
 
     client_id = token_state.get("client_id")
     token_dict = token_state.get("token")
     org_urn = token_state.get('org_urn')
-    fetch_count_value = token_state.get('fetch_count_for_api') 
-    bubble_posts_df = token_state.get("bubble_posts_df") # Get existing posts
-
-    if not org_urn:
-        logging.error("Organization URN (org_urn) not found in token_state.")
-        return "<p style='color:red; text-align:center;'>❌ Configuration error: Organization URN missing.</p>"
-    if not client_id or client_id == "ENV VAR MISSING":
-        logging.error("Client ID not found or missing in token_state.")
-        return "<p style='color:red; text-align:center;'>❌ Configuration error: LinkedIn Client ID missing.</p>"
-
-    if fetch_count_value == 0: 
-        logging.info("Data is fresh. No new posts fetched based on date check.")
-        return "<p style='color:green; text-align:center;'>✅ Data is already up-to-date. No new posts fetched.</p>"
+    bubble_mentions_df = token_state.get("bubble_mentions_df", pd.DataFrame())
+
+    if not org_urn or not client_id or client_id == "ENV VAR MISSING":
+        logging.error("Mentions sync: Configuration error (Org URN or Client ID missing).")
+        return "Mentions: Config error. ", token_state
+
+    fetch_count_for_mentions_api = 0
+    if bubble_mentions_df.empty:
+        fetch_count_for_mentions_api = DEFAULT_MENTIONS_INITIAL_FETCH_COUNT
+        logging.info(f"No mentions in Bubble. Fetching initial {fetch_count_for_mentions_api} mentions.")
+    else:
+        if BUBBLE_MENTIONS_DATE_COLUMN_NAME not in bubble_mentions_df.columns or bubble_mentions_df[BUBBLE_MENTIONS_DATE_COLUMN_NAME].isnull().all():
+            logging.warning(f"Date column '{BUBBLE_MENTIONS_DATE_COLUMN_NAME}' for mentions missing or all null. Fetching initial.")
+            fetch_count_for_mentions_api = DEFAULT_MENTIONS_INITIAL_FETCH_COUNT
+        else:
+            mentions_df_copy = bubble_mentions_df.copy()
+            mentions_df_copy[BUBBLE_MENTIONS_DATE_COLUMN_NAME] = pd.to_datetime(mentions_df_copy[BUBBLE_MENTIONS_DATE_COLUMN_NAME], errors='coerce', utc=True)
+            last_mention_date_utc = mentions_df_copy[BUBBLE_MENTIONS_DATE_COLUMN_NAME].dropna().max()
+
+            if pd.isna(last_mention_date_utc):
+                logging.warning("No valid dates in mentions data. Fetching initial.")
+                fetch_count_for_mentions_api = DEFAULT_MENTIONS_INITIAL_FETCH_COUNT
+            else:
+                days_since_last_mention = (pd.Timestamp('now', tz='UTC').normalize() - last_mention_date_utc.normalize()).days
+                logging.info(f"Days since last mention: {days_since_last_mention}")
+                if days_since_last_mention >= 7:
+                    fetch_count_for_mentions_api = DEFAULT_MENTIONS_UPDATE_FETCH_COUNT
+                    logging.info(f"Last mention older than 7 days. Fetching update of {fetch_count_for_mentions_api} mentions.")
+                else:
+                    logging.info("Mentions data is fresh. No API fetch needed.")
     
+    token_state["fetch_count_for_mentions_api"] = fetch_count_for_mentions_api 
+
+    if fetch_count_for_mentions_api == 0:
+        return "Mentions: Up-to-date. ", token_state
+
     try:
-        logging.info(f"Step 1: Fetching core posts for org_urn: {org_urn}. Fetch count: {fetch_count_value}")
-        processed_raw_posts, stats_map, _ = fetch_linkedin_posts_core(client_id, token_dict, org_urn, count=fetch_count_value)
-
-        if not processed_raw_posts:
-            logging.info("No posts retrieved from LinkedIn API.")
-            return "<p style='color:orange; text-align:center;'>ℹ️ No new LinkedIn posts found to process.</p>"
-
-        # --- Filter out posts already in Bubble ---
-        existing_post_urns = set()
-        if bubble_posts_df is not None and not bubble_posts_df.empty and BUBBLE_POST_URN_COLUMN_NAME in bubble_posts_df.columns:
-            existing_post_urns = set(bubble_posts_df[BUBBLE_POST_URN_COLUMN_NAME].dropna().astype(str))
-            logging.info(f"Found {len(existing_post_urns)} existing post URNs in Bubble data.")
-        else:
-            logging.info("No existing posts found in Bubble data or URN column missing; all fetched posts will be considered new.")
+        logging.info(f"Fetching {fetch_count_for_mentions_api} core mentions from LinkedIn for org_urn: {org_urn}")
+        processed_raw_mentions = fetch_linkedin_mentions_core(client_id, token_dict, org_urn, count=fetch_count_for_mentions_api)
 
-        # Filter processed_raw_posts before compiling detailed_posts
-        new_raw_posts = [
-            post for post in processed_raw_posts 
-            if str(post.get(LINKEDIN_POST_URN_KEY)) not in existing_post_urns
-        ]
+        if not processed_raw_mentions:
+            logging.info("No mentions retrieved from LinkedIn API.")
+            return "Mentions: None found via API. ", token_state
 
-        if not new_raw_posts:
-            logging.info("All fetched LinkedIn posts are already present in Bubble. No new posts to add.")
-            return "<p style='color:green; text-align:center;'>✅ All fetched posts already exist in Bubble. Data is up-to-date.</p>"
+        existing_mention_ids = set()
+        if not bubble_mentions_df.empty and BUBBLE_MENTIONS_ID_COLUMN_NAME in bubble_mentions_df.columns:
+            existing_mention_ids = set(bubble_mentions_df[BUBBLE_MENTIONS_ID_COLUMN_NAME].dropna().astype(str))
         
-        logging.info(f"Identified {len(new_raw_posts)} new posts to process after filtering against Bubble data.")
+        sentiments_map = analyze_mentions_sentiment(processed_raw_mentions)
+        all_compiled_mentions = compile_detailed_mentions(processed_raw_mentions, sentiments_map)
 
-        # Continue processing only with new_raw_posts
-        post_urns_to_process = [post[LINKEDIN_POST_URN_KEY] for post in new_raw_posts if post.get(LINKEDIN_POST_URN_KEY)]
-        
-        logging.info("Step 2: Fetching comments for new posts via LinkedIn API.")
-        # Adjust stats_map if it's keyed by URNs; ensure it's relevant for new_raw_posts
-        # For simplicity, assuming fetch_comments and subsequent steps can handle potentially fewer URNs
-        all_comments_data = fetch_comments(client_id, token_dict, post_urns_to_process, stats_map)
-
-        logging.info("Step 3: Analyzing sentiment for new posts.")
-        sentiments_per_post = analyze_sentiment(all_comments_data) # Assumes all_comments_data is now for new posts
-
-        logging.info("Step 4: Compiling detailed data for new posts.")
-        # Pass new_raw_posts to compile_detailed_posts
-        detailed_new_posts = compile_detailed_posts(new_raw_posts, stats_map, sentiments_per_post)
-
-        logging.info("Step 5: Preparing data for Bubble (only new posts).")
-        # Pass detailed_new_posts to prepare_data_for_bubble
-        li_posts, li_post_stats, li_post_comments = prepare_data_for_bubble(detailed_new_posts, all_comments_data)
-
-        logging.info(f"Step 6: Uploading {len(li_posts)} new posts and their related data to Bubble.")
-        if li_posts: # Ensure there's actually something to upload
-            bulk_upload_to_bubble(li_posts, "LI_posts")
-            if li_post_stats:
-                bulk_upload_to_bubble(li_post_stats, "LI_post_stats")
-            if li_post_comments:
-                bulk_upload_to_bubble(li_post_comments, "LI_post_comments")
-            
-            action_message = f"uploaded {len(li_posts)} new post(s)"
-        else:
-            action_message = "found no new posts to upload after detailed processing"
-            logging.info("No new posts to upload after final preparation for Bubble.")
+        new_compiled_mentions_to_upload = [
+            m for m in all_compiled_mentions if str(m.get("id")) not in existing_mention_ids
+        ]
 
+        if not new_compiled_mentions_to_upload:
+            logging.info("All fetched LinkedIn mentions are already present in Bubble.")
+            return "Mentions: All fetched already in Bubble. ", token_state
+        
+        logging.info(f"Identified {len(new_compiled_mentions_to_upload)} new mentions to process after filtering.")
+        bubble_ready_mentions = prepare_mentions_for_bubble(new_compiled_mentions_to_upload)
 
-        final_message_verb = "Initial data fetch" if fetch_count_value == DEFAULT_INITIAL_FETCH_COUNT and not existing_post_urns else "Data update"
-        logging.info(f"Successfully completed: {final_message_verb}. {action_message} to Bubble.")
-        return f"<p style='color:green; text-align:center;'>✅ {final_message_verb} complete. Successfully {action_message} to Bubble.</p>"
+        if bubble_ready_mentions:
+            logging.info(f"Uploading {len(bubble_ready_mentions)} new mentions to Bubble table: {BUBBLE_MENTIONS_TABLE_NAME}.")
+            bulk_upload_to_bubble(bubble_ready_mentions, BUBBLE_MENTIONS_TABLE_NAME)
+            return f"Mentions: Synced {len(bubble_ready_mentions)} new. ", token_state
+        else:
+            logging.info("No new mentions to upload to Bubble after final preparation.")
+            return "Mentions: No new ones to upload. ", token_state
 
     except ValueError as ve:
-        logging.error(f"ValueError during LinkedIn data processing: {ve}")
-        return f"<p style='color:red; text-align:center;'>❌ Error: {html.escape(str(ve))}</p>"
+        logging.error(f"ValueError during mentions sync: {ve}")
+        return f"Mentions Error: {html.escape(str(ve))}. ", token_state
     except Exception as e:
-        logging.exception("An unexpected error occurred in guarded_fetch_posts.")
-        return "<p style='color:red; text-align:center;'>❌ An unexpected error occurred. Please check logs.</p>"
+        logging.exception("Unexpected error in sync_linkedin_mentions.")
+        return "Mentions: Unexpected error. ", token_state
+
 
-def guarded_fetch_dashboard(token_state):
+def guarded_fetch_posts_and_mentions(token_state):
+    logging.info("Starting guarded_fetch_posts_and_mentions process.")
     if not token_state or not token_state.get("token"):
-        return "❌ Access denied. No token available for dashboard."
-    if token_state.get("bubble_posts_df") is not None and not token_state["bubble_posts_df"].empty:
-        return f"<p style='text-align: center;'>Dashboard would show {len(token_state['bubble_posts_df'])} posts from Bubble.</p>"
+        logging.error("Access denied. No LinkedIn token available.")
+        return "<p style='color:red; text-align:center;'>❌ Access denied. LinkedIn token not available.</p>", token_state
+
+    client_id = token_state.get("client_id")
+    token_dict = token_state.get("token")
+    org_urn = token_state.get('org_urn')
+    fetch_count_for_posts_api = token_state.get('fetch_count_for_api', 0)
+    bubble_posts_df = token_state.get("bubble_posts_df", pd.DataFrame())
+    posts_sync_message = ""
+
+    if not org_urn: return "<p style='color:red;'>❌ Config error: Org URN missing.</p>", token_state
+    if not client_id or client_id == "ENV VAR MISSING": return "<p style='color:red;'>❌ Config error: Client ID missing.</p>", token_state
+
+    if fetch_count_for_posts_api == 0:
+        posts_sync_message = "Posts: Already up-to-date. "
     else:
-        return "<p style='text-align: center; color: #555;'>No posts loaded from Bubble yet for the dashboard.</p>"
+        try:
+            logging.info(f"Fetching {fetch_count_for_posts_api} core posts for org_urn: {org_urn}.")
+            processed_raw_posts, stats_map, _ = fetch_linkedin_posts_core(client_id, token_dict, org_urn, count=fetch_count_for_posts_api)
+            if not processed_raw_posts: posts_sync_message = "Posts: None found via API. "
+            else:
+                existing_post_urns = set()
+                if not bubble_posts_df.empty and BUBBLE_POST_URN_COLUMN_NAME in bubble_posts_df.columns:
+                    existing_post_urns = set(bubble_posts_df[BUBBLE_POST_URN_COLUMN_NAME].dropna().astype(str))
+                new_raw_posts = [p for p in processed_raw_posts if str(p.get(LINKEDIN_POST_URN_KEY)) not in existing_post_urns]
+                if not new_raw_posts: posts_sync_message = "Posts: All fetched already in Bubble. "
+                else:
+                    post_urns_to_process = [p[LINKEDIN_POST_URN_KEY] for p in new_raw_posts if p.get(LINKEDIN_POST_URN_KEY)]
+                    all_comments_data = fetch_comments(client_id, token_dict, post_urns_to_process, stats_map)
+                    sentiments_per_post = analyze_sentiment(all_comments_data)
+                    detailed_new_posts = compile_detailed_posts(new_raw_posts, stats_map, sentiments_per_post)
+                    li_posts, li_post_stats, li_post_comments = prepare_data_for_bubble(detailed_new_posts, all_comments_data)
+                    if li_posts:
+                        bulk_upload_to_bubble(li_posts, "LI_posts")
+                        if li_post_stats: bulk_upload_to_bubble(li_post_stats, "LI_post_stats")
+                        if li_post_comments: bulk_upload_to_bubble(li_post_comments, "LI_post_comments")
+                        posts_sync_message = f"Posts: Synced {len(li_posts)} new. "
+                    else: posts_sync_message = "Posts: No new ones to upload. "
+        except ValueError as ve: posts_sync_message = f"Posts Error: {html.escape(str(ve))}. "
+        except Exception: logging.exception("Posts processing error."); posts_sync_message = "Posts: Unexpected error. "
+
+    mentions_sync_message, updated_token_state = sync_linkedin_mentions(token_state)
+    token_state = updated_token_state # Ensure state is updated after mentions sync
+
+    # Re-fetch data from Bubble to update DataFrames in state for immediate display refresh
+    if org_urn:
+        try:
+            fetched_posts_df, _ = fetch_linkedin_posts_data_from_bubble(org_urn, "LI_posts")
+            token_state["bubble_posts_df"] = pd.DataFrame() if fetched_posts_df is None else fetched_posts_df
+            fetched_mentions_df, _ = fetch_linkedin_mentions_data_from_bubble(org_urn, BUBBLE_MENTIONS_TABLE_NAME)
+            token_state["bubble_mentions_df"] = pd.DataFrame() if fetched_mentions_df is None else fetched_mentions_df
+            logging.info("Refreshed posts and mentions DataFrames in state from Bubble after sync.")
+        except Exception as e:
+            logging.error(f"Error re-fetching data from Bubble post-sync: {e}")
+
+    final_message = f"<p style='color:green; text-align:center;'>✅ Sync Attempted. {posts_sync_message} {mentions_sync_message}</p>"
+    return final_message, token_state
+
+
+def display_main_dashboard(token_state):
+    if not token_state or not token_state.get("token"):
+        return "❌ Access denied. No token available for dashboard."
+    
+    posts_df = token_state.get("bubble_posts_df", pd.DataFrame())
+    posts_html = f"<h4>Recent Posts ({len(posts_df)} in Bubble):</h4>"
+    if not posts_df.empty:
+        cols_to_show_posts = [col for col in [BUBBLE_POST_DATE_COLUMN_NAME, 'text', 'sentiment'] if col in posts_df.columns] # Example columns
+        posts_html += posts_df[cols_to_show_posts].head().to_html(escape=True, index=False, classes="table table-striped table-sm") if cols_to_show_posts else "<p>No post data to display or columns missing.</p>"
+    else: posts_html += "<p>No posts loaded from Bubble.</p>"
+
+    mentions_df = token_state.get("bubble_mentions_df", pd.DataFrame())
+    mentions_html = f"<h4>Recent Mentions ({len(mentions_df)} in Bubble):</h4>"
+    if not mentions_df.empty:
+        # Using the exact column names as defined for Bubble upload: date, id, mention_text, organization_urn, sentiment_label
+        cols_to_show_mentions = [col for col in ["date", "mention_text", "sentiment_label"] if col in mentions_df.columns]
+        mentions_html += mentions_df[cols_to_show_mentions].head().to_html(escape=True, index=False, classes="table table-striped table-sm") if cols_to_show_mentions else "<p>No mention data to display or columns missing.</p>"
+    else: mentions_html += "<p>No mentions loaded from Bubble.</p>"
+        
+    return f"<div style='padding:10px;'><h3>Dashboard Overview</h3>{posts_html}<hr/>{mentions_html}</div>"
 
 
 def guarded_fetch_analytics(token_state):
     if not token_state or not token_state.get("token"):
-        return ("❌ Access denied. No token available for analytics.",
-                None, None, None, None, None, None, None)
-    return fetch_and_render_analytics(token_state.get("client_id"), token_state.get("token"))
+        return ("❌ Access denied. No token.", None, None, None, None, None, None, None)
+    return fetch_and_render_analytics(token_state.get("client_id"), token_state.get("token"), token_state.get("org_urn"))
 
-def run_mentions_and_load(token_state):
+
+def run_mentions_tab_display(token_state):
+    logging.info("Updating Mentions Tab display.")
     if not token_state or not token_state.get("token"):
         return ("❌ Access denied. No token available for mentions.", None)
-    return generate_mentions_dashboard(token_state.get("client_id"), token_state.get("token"))
+
+    mentions_df = token_state.get("bubble_mentions_df", pd.DataFrame())
+    if mentions_df.empty:
+        return ("<p style='text-align:center;'>No mentions data in Bubble. Try syncing.</p>", None)
+
+    html_parts = ["<h3 style='text-align:center;'>Recent Mentions</h3>"]
+    # Columns expected from Bubble: date, id, mention_text, organization_urn, sentiment_label
+    display_columns = [col for col in ["date", "mention_text", "sentiment_label", "id"] if col in mentions_df.columns]
+    
+    if not display_columns:
+        html_parts.append("<p>Required columns for mentions display are missing from Bubble data.</p>")
+    else:
+        mentions_df_sorted = mentions_df.sort_values(by="date", ascending=False, errors='coerce') if "date" in display_columns else mentions_df
+        html_parts.append(mentions_df_sorted[display_columns].head(10).to_html(escape=True, index=False, classes="table table-sm"))
+    
+    mentions_html_output = "\n".join(html_parts)
+    fig = None 
+    if not mentions_df.empty and "sentiment_label" in mentions_df.columns:
+        try:
+            import matplotlib.pyplot as plt
+            import io, base64
+            plt.switch_backend('Agg') # Ensure non-interactive backend for server use
+            fig_plot, ax = plt.subplots(figsize=(6,4))
+            sentiment_counts = mentions_df["sentiment_label"].value_counts()
+            sentiment_counts.plot(kind='bar', ax=ax)
+            ax.set_title("Mention Sentiment Distribution")
+            ax.set_ylabel("Count")
+            plt.xticks(rotation=45, ha='right')
+            plt.tight_layout()
+            fig = fig_plot # Return the figure object for Gradio plot component
+        except Exception as e:
+            logging.error(f"Error generating mentions plot: {e}"); fig = None
+    return mentions_html_output, fig
+
 
 # --- Gradio UI Blocks ---
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
-               title="LinkedIn Post Viewer & Analytics") as app:
+               title="LinkedIn Organization Post Viewer & Analytics") as app:
 
     token_state = gr.State(value={
-        "token": None, 
-        "client_id": None, 
-        "org_urn": None, 
-        "bubble_posts_df": pd.DataFrame(), # Initialize with empty DataFrame
-        "fetch_count_for_api": 0 
+        "token": None, "client_id": None, "org_urn": None, 
+        "bubble_posts_df": pd.DataFrame(), "fetch_count_for_api": 0,
+        "bubble_mentions_df": pd.DataFrame(), "fetch_count_for_mentions_api": 0,
+        "url_user_token_temp_storage": None
     })
 
     gr.Markdown("# 🚀 LinkedIn Organization Post Viewer & Analytics")
-    gr.Markdown("Token is supplied via URL parameter for Bubble.io lookup. Then explore dashboard and analytics.")
-
     url_user_token_display = gr.Textbox(label="User Token (from URL - Hidden)", interactive=False, visible=False)
     status_box = gr.Textbox(label="Overall LinkedIn Token Status", interactive=False, value="Initializing...")    
     org_urn_display = gr.Textbox(label="Organization URN (from URL - Hidden)", interactive=False, visible=False)
 
     app.load(fn=get_url_user_token, inputs=None, outputs=[url_user_token_display, org_urn_display])
+    
+    # Chain initial processing and dashboard display
+    def initial_load_sequence(url_token, org_urn_val, current_state):
+        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)
+        return status_msg, new_state, btn_update, dashboard_content
 
     with gr.Tabs():
         with gr.TabItem("1️⃣ Dashboard & Sync"):
-            gr.Markdown("System checks for existing data in Bubble. The button below will activate if new posts need to be fetched or updated from LinkedIn.")
-            
-            sync_posts_to_bubble_btn = gr.Button(
-                value="🔄 Sync LinkedIn Posts", 
-                variant="primary",
-                visible=False,    
-                interactive=False
-            )
-            
-            dashboard_html_output = gr.HTML(
-                "<p style='text-align: center; color: #555;'>System initializing... "
-                "Checking for existing data in Bubble and LinkedIn token.</p>"
-            )
+            gr.Markdown("System checks for existing data. Button activates if new posts/mentions need fetching.")
+            sync_data_btn = gr.Button("🔄 Sync LinkedIn Data", variant="primary", visible=False, interactive=False)
+            dashboard_html_output = gr.HTML("<p style='text-align:center;'>Initializing...</p>")
             
+            # Trigger initial load when org_urn (from URL) is available
             org_urn_display.change(
-                fn=process_and_store_bubble_token,
-                inputs=[url_user_token_display, org_urn_display, token_state],
-                outputs=[status_box, token_state, sync_posts_to_bubble_btn]    
-            )
-            url_user_token_display.change(
-                fn=process_and_store_bubble_token,
+                fn=initial_load_sequence,
                 inputs=[url_user_token_display, org_urn_display, token_state],
-                outputs=[status_box, token_state, sync_posts_to_bubble_btn]
+                outputs=[status_box, token_state, sync_data_btn, dashboard_html_output]
             )
+            # Also allow re-processing if user token changes (e.g. manual input if that was a feature)
+            # url_user_token_display.change(...) 
 
-            sync_posts_to_bubble_btn.click(
-                fn=guarded_fetch_posts,    
+            sync_data_btn.click(
+                fn=guarded_fetch_posts_and_mentions, 
                 inputs=[token_state],    
-                outputs=[dashboard_html_output]
+                outputs=[dashboard_html_output, token_state] 
             ).then( 
-                fn=process_and_store_bubble_token,
+                fn=process_and_store_bubble_token, 
                 inputs=[url_user_token_display, org_urn_display, token_state],
-                outputs=[status_box, token_state, sync_posts_to_bubble_btn]
+                outputs=[status_box, token_state, sync_data_btn]
+            ).then(
+                fn=display_main_dashboard, 
+                inputs=[token_state],
+                outputs=[dashboard_html_output]
             )
             
         with gr.TabItem("2️⃣ Analytics"):
-            gr.Markdown("View follower count and monthly gains for your organization (requires LinkedIn token).")
             fetch_analytics_btn = gr.Button("📈 Fetch Follower Analytics", variant="primary")
-            follower_count = gr.Markdown("<p style='text-align: center; color: #555;'>Waiting for LinkedIn token...</p>")
-
-            with gr.Row():
-                follower_plot, growth_plot = gr.Plot(), gr.Plot()
-            with gr.Row():
-                eng_rate_plot = gr.Plot()
-            with gr.Row():
-                interaction_plot = gr.Plot()
-            with gr.Row():
-                eb_plot = gr.Plot()
-            with gr.Row():
-                mentions_vol_plot, mentions_sentiment_plot = gr.Plot(), gr.Plot()
-
+            follower_count = gr.Markdown("Waiting for token...")
+            with gr.Row(): follower_plot, growth_plot = gr.Plot(), gr.Plot()
+            with gr.Row(): eng_rate_plot = gr.Plot()
+            with gr.Row(): interaction_plot = gr.Plot()
+            with gr.Row(): eb_plot = gr.Plot()
+            with gr.Row(): mentions_vol_plot, mentions_sentiment_plot = gr.Plot(), gr.Plot() 
             fetch_analytics_btn.click(
-                fn=guarded_fetch_analytics,
-                inputs=[token_state],
+                fn=guarded_fetch_analytics, inputs=[token_state],
                 outputs=[follower_count, follower_plot, growth_plot, eng_rate_plot,
                          interaction_plot, eb_plot, mentions_vol_plot, mentions_sentiment_plot]
             )
 
         with gr.TabItem("3️⃣ Mentions"):
-            gr.Markdown("Analyze sentiment of recent posts that mention your organization (requires LinkedIn token).")
-            fetch_mentions_btn = gr.Button("🧠 Fetch Mentions & Sentiment", variant="primary")
-            mentions_html = gr.HTML("<p style='text-align: center; color: #555;'>Waiting for LinkedIn token...</p>")
-            mentions_plot = gr.Plot()
-            fetch_mentions_btn.click(
-                fn=run_mentions_and_load,
-                inputs=[token_state],
+            refresh_mentions_display_btn = gr.Button("🔄 Refresh Mentions Display", variant="secondary")
+            mentions_html = gr.HTML("Mentions data loads from Bubble after sync.")
+            mentions_plot = gr.Plot() 
+            refresh_mentions_display_btn.click(
+                fn=run_mentions_tab_display, inputs=[token_state],
                 outputs=[mentions_html, mentions_plot]
             )
             
     app.load(fn=lambda ts: check_token_status(ts), inputs=[token_state], outputs=status_box)
     gr.Timer(15.0).tick(fn=lambda ts: check_token_status(ts), inputs=[token_state], outputs=status_box)
 
-
 if __name__ == "__main__":
     if not os.environ.get("Linkedin_client_id"):
-        logging.warning("WARNING: The 'Linkedin_client_id' environment variable is not set. The application may not function correctly for LinkedIn API calls.")
-    app.launch(server_name="0.0.0.0", server_port=7860, share=True)
+        logging.warning("WARNING: 'Linkedin_client_id' env var not set.")
+    app.launch(server_name="0.0.0.0", server_port=7860)