# -- coding: utf-8 --
import gradio as gr
import json
import os
import logging
import html
import pandas as pd # Ensure pandas is imported if you're dealing with DataFrames

# 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_posts_from_bubble  # Added new function
)
from Linkedin_Data_API_Calls import (
    fetch_linkedin_posts_core,
    fetch_comments,
    analyze_sentiment,
    compile_detailed_posts,
    prepare_data_for_bubble
)

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

def check_token_status(token_state):
    """Checks the status of the LinkedIn token."""
    return "✅ Token available" if token_state and token_state.get("token") else "❌ Token not available"

def process_and_store_bubble_token(url_user_token, org_urn, token_state):
    """
    Processes the user token from the URL, fetches LinkedIn token from Bubble,
    fetches initial posts from Bubble, and updates the token state and UI accordingly.
    Returns updates for status_box, token_state, and sync_posts_to_bubble_btn.
    """
    logging.info(f"Processing token with URL user token: '{url_user_token}', Org URN: '{org_urn}'")
    
    # Initialize or copy existing state, adding bubble_posts_df
    new_state = token_state.copy() if token_state else {"token": None, "client_id": None, "org_urn": None, "bubble_posts_df": None}
    # Ensure org_urn is updated from input, and bubble_posts_df is reset/initialized for this run.
    # Token will be set later if fetched.
    new_state.update({"org_urn": org_urn, "bubble_posts_df": None, "token": new_state.get("token")}) 

    # Determine button properties - default to hidden and non-interactive
    button_visible = True
    button_interactive = True

    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

    # Attempt to fetch LinkedIn token from Bubble (related to LinkedIn API access)
    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}")
        try:
            parsed_linkedin_token = fetch_linkedin_token_from_bubble(url_user_token)
            if isinstance(parsed_linkedin_token, dict) and "access_token" in parsed_linkedin_token:
                new_state["token"] = parsed_linkedin_token # Update token in new_state
                logging.info("✅ LinkedIn Token successfully fetched from Bubble.")
            else:
                new_state["token"] = None # Explicitly set to None if fetch fails
                logging.warning(f"❌ Failed to fetch a valid LinkedIn token from Bubble. Response: {parsed_linkedin_token}")
        except Exception as e:
            new_state["token"] = None # Explicitly set to None on error
            logging.error(f"❌ Exception while fetching LinkedIn token from Bubble: {e}")
    else:
        new_state["token"] = None # Ensure token is None if no valid url_user_token
        logging.info("No valid URL user token provided for LinkedIn token fetch, or an error was indicated.")

    # Fetch posts from Bubble using org_urn
    current_org_urn = new_state.get("org_urn")
    if current_org_urn:
        logging.info(f"Attempting to fetch posts from Bubble for org_urn: {current_org_urn}")
        try:
            # Assuming fetch_posts_from_bubble returns a Pandas DataFrame or None
            bubble_posts_df, error_message  = fetch_posts_from_bubble(current_org_urn)
            new_state["bubble_posts_df"] = bubble_posts_df # Store DataFrame in state
            logging.info(f"df  {len(bubble_posts_df)}")

            if bubble_posts_df is not None and not new_state["bubble_posts_df"].empty:
                logging.info(f"✅ Successfully fetched {len(bubble_posts_df)} posts from Bubble. Sync button will be disabled.")
                button_visible = False
                button_interactive = False
            else:
                logging.info("ℹ️ No posts found in Bubble for this organization or DataFrame is empty. Sync button will get visible.")
                # button_visible and button_interactive remain False
        except Exception as e:
            logging.error(f"❌ Error fetching posts from Bubble: {e}")
            # button_visible and button_interactive remain False
    else:
        logging.warning("Org URN not available in state. Cannot fetch posts from Bubble.")
        # button_visible and button_interactive remain False
        
    token_status_message = check_token_status(new_state) # Check based on potentially updated new_state["token"]
    
    # Log the determined visibility before creating the update object
    logging.info(f"Token processing complete. LinkedIn Token Status: {token_status_message}. Button visible: {button_visible}, Button interactive: {button_interactive}")
    
    # Create a gr.update object for the button
    button_component_update = gr.update(visible=button_visible, interactive=button_interactive)
    
    return token_status_message, new_state, button_component_update

def guarded_fetch_posts(token_state):
    """
    Fetches LinkedIn posts, analyzes them, and uploads to Bubble.
    This function is guarded by token availability.
    """
    logging.info("Starting guarded_fetch_posts process.")
    if not token_state or not token_state.get("token"): # Checks for LinkedIn 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. Please ensure token is fetched via URL parameter.</p>"

    client_id = token_state.get("client_id")
    token_dict = token_state.get("token") # This is the LinkedIn token dict
    org_urn = token_state.get('org_urn')

    if not org_urn:
        logging.error("Organization URN (org_urn) not found in token_state for guarded_fetch_posts.")
        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 for guarded_fetch_posts.")
        return "<p style='color:red; text-align:center;'>❌ Configuration error: LinkedIn Client ID missing (check .env file or environment variables).</p>"

    # Additional check: Ensure the button was meant to be clickable (i.e., Bubble posts were found)
    # This is an indirect check, as the button's clickability should prevent this if UI works as intended.
    # However, adding a check on bubble_posts_df might be redundant if the button is correctly managed.
    # For now, relying on the LinkedIn token check as the primary guard for this function.

    try:
        logging.info(f"Step 1: Fetching core posts for org_urn: {org_urn} using LinkedIn API.")
        processed_raw_posts, stats_map, _ = fetch_linkedin_posts_core(client_id, token_dict, org_urn)

        if not processed_raw_posts:
            logging.info("No posts found to process via LinkedIn API after step 1.")
            return "<p style='color:orange; text-align:center;'>ℹ️ No new LinkedIn posts found to process at this time.</p>"

        post_urns = [post["id"] for post in processed_raw_posts if post.get("id")]
        logging.info(f"Extracted {len(post_urns)} post URNs for further processing.")

        logging.info("Step 2: Fetching comments via LinkedIn API.")
        all_comments_data = fetch_comments(client_id, token_dict, post_urns, stats_map)

        logging.info("Step 3: Analyzing sentiment.")
        sentiments_per_post = analyze_sentiment(all_comments_data)

        logging.info("Step 4: Compiling detailed posts.")
        detailed_posts = compile_detailed_posts(processed_raw_posts, stats_map, sentiments_per_post)

        logging.info("Step 5: Preparing data for Bubble.")
        li_posts, li_post_stats, li_post_comments = prepare_data_for_bubble(detailed_posts, all_comments_data)

        logging.info("Step 6: Uploading data to Bubble.")
        bulk_upload_to_bubble(li_posts, "LI_posts")
        bulk_upload_to_bubble(li_post_stats, "LI_post_stats")
        bulk_upload_to_bubble(li_post_comments, "LI_post_comments")

        logging.info("Successfully fetched from LinkedIn and uploaded posts and comments to Bubble.")
        return "<p style='color:green; text-align:center;'>✅ Posts and comments from LinkedIn uploaded to Bubble.</p>"

    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>"
    except Exception as e:
        logging.exception("An unexpected error occurred in guarded_fetch_posts.") # Logs full traceback
        return "<p style='color:red; text-align:center;'>❌ An unexpected error occurred while processing LinkedIn data. Please check logs.</p>"

def guarded_fetch_dashboard(token_state):
    """Fetches and renders the dashboard if token is available."""
    if not token_state or not token_state.get("token"):
        return "❌ Access denied. No token available for dashboard."
    return "<p style='text-align: center; color: #555;'>Dashboard content would load here if implemented.</p>"


def guarded_fetch_analytics(token_state):
    """Fetches and renders analytics if token is available."""
    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"))

def run_mentions_and_load(token_state):
    """Generates mentions dashboard if token is available."""
    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"))

# --- Gradio UI Blocks ---
with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
               title="LinkedIn Post Viewer & Analytics") as app:

    # Initialize state with the new field for Bubble DataFrame
    token_state = gr.State(value={"token": None, "client_id": None, "org_urn": None, "bubble_posts_df": 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])

    with gr.Tabs():
        with gr.TabItem("1️⃣ Dashboard & Sync"):
            gr.Markdown("Fetch initial data from Bubble. If posts are found, you can choose to sync newer posts from LinkedIn.")
            
            sync_posts_to_bubble_btn = gr.Button(
                "🔄 Fetch from LinkedIn, Analyze & Store to Bubble", # Updated label for clarity
                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. The 'Fetch from LinkedIn...' button will activate if initial data is found.</p>"
            )
            
            # Combined trigger: process tokens and Bubble data once both URL params are potentially loaded.
            # Using .then() to chain after initial load.
            # The `process_and_store_bubble_token` will run when `org_urn_display` (which is an output of app.load)
            # receives its value.
            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] 
            )
            # Fallback if url_user_token_display changes after org_urn_display (less likely but for robustness)
            url_user_token_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]
            )

            sync_posts_to_bubble_btn.click(
                fn=guarded_fetch_posts, 
                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()

            fetch_analytics_btn.click(
                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],
                outputs=[mentions_html, mentions_plot]
            )
            
    # This app.load updates the status_box based on the initial token_state.
    # The process_and_store_bubble_token function will provide a more definitive update soon after.
    app.load(fn=lambda ts: check_token_status(ts), inputs=[token_state], outputs=status_box)
    # Timer to periodically update the LinkedIn token status display
    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)