app.py

import gradio as gr
import faiss
import numpy as np
import os
import json
import datetime
import uuid
import asyncio
import time
from typing import Dict, List, Optional, Tuple, Any
from urllib.parse import urlparse
from urllib.robotparser import RobotFileParser

import pandas as pd
import ollama
from duckduckgo_search import DDGS
import requests

# crawl4ai setup
try:
    from crawl4ai import AsyncWebCrawler, BrowserConfig, CacheMode, CrawlerRunConfig
    from crawl4ai.content_filter_strategy import BM25ContentFilter
    from crawl4ai.markdown_generation_strategy import DefaultMarkdownGenerator
    CRAWL4AI_AVAILABLE = True
except ImportError:
    print("WARNING: crawl4ai library not found or failed to import. Resource finding will be disabled.")
    print("Install it: pip install 'crawl4ai[playwright]' and run 'playwright install --with-deps'")
    CRAWL4AI_AVAILABLE = False


# --- Configuration ---
OLLAMA_MODEL = "llama3:8b" # Or your preferred model
FAISS_INDEX_FILE = "faiss_index.index"
FAISS_METADATA_FILE = "faiss_metadata.json"
USER_DATA_DIR = "user_data"
COMMUNITY_FILE = "community_posts.json"
os.makedirs(USER_DATA_DIR, exist_ok=True)

# FAISS Vector Dimension (Must match Ollama embedding model)
# nomic-embed-text: 768
VECTOR_DIMENSION = 768


# --- System Prompts (Same as before) ---
EMOTION_ANALYSIS_PROMPT = """...""" # Keep as is
GROWTH_PLAN_PROMPT = """...""" # Keep as is
RESOURCE_SYNTHESIS_PROMPT = """...""" # Keep as is (adjust if needed for FAISS context)
COMMUNITY_SUGGESTION_PROMPT = """...""" # Keep as is

# --- Data Persistence Functions ---

def load_user_data(username: str) -> Dict:
    """Loads data for a specific user from a JSON file."""
    if not username: return {"entries": [], "plans": {}, "resources": {}, "profile": {}}
    filepath = os.path.join(USER_DATA_DIR, f"{username}.json")
    if os.path.exists(filepath):
        try:
            with open(filepath, 'r') as f:
                return json.load(f)
        except json.JSONDecodeError:
            print(f"Warning: Corrupted data file for user {username}. Starting fresh.")
            return {"entries": [], "plans": {}, "resources": {}, "profile": {}} # Return default on error
    else:
        # Create initial structure for new user
        return {"entries": [], "plans": {}, "resources": {}, "profile": {"username": username, "joined": datetime.datetime.now().isoformat(), "points": 0, "goals":{}}}

def save_user_data(username: str, data: Dict):
    """Saves data for a specific user to a JSON file."""
    if not username: return
    filepath = os.path.join(USER_DATA_DIR, f"{username}.json")
    with open(filepath, 'w') as f:
        json.dump(data, f, indent=4)

def load_community_posts() -> List[Dict]:
    """Loads community posts from a JSON file."""
    if os.path.exists(COMMUNITY_FILE):
        try:
            with open(COMMUNITY_FILE, 'r') as f:
                return json.load(f)
        except json.JSONDecodeError:
             print("Warning: Community posts file corrupted. Starting fresh.")
             return []
    else:
        return []

def save_community_posts(posts: List[Dict]):
    """Saves community posts to a JSON file."""
    with open(COMMUNITY_FILE, 'w') as f:
        json.dump(posts, f, indent=4)

# --- FAISS and Embedding Functions ---

def get_ollama_embeddings(texts: List[str], model_name: str = "nomic-embed-text:latest") -> Tuple[List[List[float]], bool]:
    """Gets embeddings from Ollama. Returns embeddings and a success flag."""
    ollama_api_url = os.getenv("OLLAMA_BASE_URL", "http://localhost:11434") + "/api/embeddings"
    embeddings = []
    all_successful = True
    max_retries = 2
    retry_delay = 1

    for text in texts:
        if not text or not isinstance(text, str):
            print(f"Warning: Skipping embedding for invalid input: {text}")
            embeddings.append([])
            all_successful = False
            continue

        current_embedding = []
        for attempt in range(max_retries):
            try:
                response = requests.post(ollama_api_url, json={"model": model_name, "prompt": text}, headers={"Content-Type": "application/json"})
                response.raise_for_status()
                result = response.json()
                if "embedding" in result and len(result["embedding"]) == VECTOR_DIMENSION:
                    current_embedding = result["embedding"]
                    break # Success for this text
                else:
                    print(f"Warning: Ollama response issue (attempt {attempt+1}) for text: {text[:50]}... Response: {result}")
                    if attempt == max_retries - 1: all_successful = False
            except Exception as e:
                print(f"Error getting Ollama embedding (Attempt {attempt+1}/{max_retries}): {e}")
                if attempt < max_retries - 1: time.sleep(retry_delay)
                else: all_successful = False

        embeddings.append(current_embedding) # Append embedding or empty list if failed

    # Replace empty lists with zero vectors
    final_embeddings = []
    for emb in embeddings:
         if emb:
             final_embeddings.append(emb)
         else:
             print("Warning: Replacing failed embedding with zero vector.")
             final_embeddings.append([0.0] * VECTOR_DIMENSION)
             all_successful = False # Mark overall success as False if any failed

    return final_embeddings, all_successful

def create_or_load_faiss_index() -> Tuple[Optional[faiss.Index], Dict[int, Dict]]:
    """Loads FAISS index and metadata, or creates empty ones."""
    index = None
    metadata = {}
    if os.path.exists(FAISS_INDEX_FILE) and os.path.exists(FAISS_METADATA_FILE):
        try:
            print(f"Loading FAISS index from {FAISS_INDEX_FILE}")
            index = faiss.read_index(FAISS_INDEX_FILE)
            print(f"Loading FAISS metadata from {FAISS_METADATA_FILE}")
            with open(FAISS_METADATA_FILE, 'r') as f:
                # Load metadata, converting string keys back to int
                metadata_str_keys = json.load(f)
                metadata = {int(k): v for k, v in metadata_str_keys.items()}
            print(f"Loaded index with {index.ntotal} vectors and {len(metadata)} metadata entries.")
            # Consistency check (optional but recommended)
            if index.ntotal != len(metadata):
                print(f"WARNING: FAISS index size ({index.ntotal}) != metadata size ({len(metadata)}). Rebuilding might be needed.")
                # Decide recovery strategy: clear both, try to align, etc.
                # Simplest: clear both and start over if inconsistent
                # index = None
                # metadata = {}
        except Exception as e:
            print(f"Error loading FAISS data: {e}. Starting fresh.")
            index = None
            metadata = {}

    if index is None:
        print("Creating new FAISS index.")
        # Using IndexFlatL2, simple L2 distance. IndexIVFFlat is faster for large datasets but needs training.
        index = faiss.IndexFlatL2(VECTOR_DIMENSION)
        metadata = {}

    return index, metadata

def save_faiss_index(index: faiss.Index, metadata: Dict[int, Dict]):
    """Saves FAISS index and metadata."""
    try:
        print(f"Saving FAISS index to {FAISS_INDEX_FILE} ({index.ntotal} vectors)")
        faiss.write_index(index, FAISS_INDEX_FILE)
        print(f"Saving FAISS metadata to {FAISS_METADATA_FILE} ({len(metadata)} entries)")
        with open(FAISS_METADATA_FILE, 'w') as f:
            # Store metadata with string keys for JSON compatibility
            json.dump({str(k): v for k, v in metadata.items()}, f, indent=4)
        print("FAISS data saved successfully.")
    except Exception as e:
        print(f"Error saving FAISS data: {e}")
        gr.Warning(f"Failed to save resource index: {e}")


def add_to_faiss(index: faiss.Index, metadata: Dict[int, Dict], content_list: List[Dict]) -> Tuple[faiss.Index, Dict[int, Dict], int]:
    """Adds crawled content to FAISS index and metadata."""
    texts_to_embed = [item.get('markdown', '') for item in content_list if item.get('markdown')]
    urls = [item.get('url', 'Unknown URL') for item in content_list] # Track URLs

    if not texts_to_embed:
        print("No text content provided to add_to_faiss.")
        return index, metadata, 0

    print(f"Generating embeddings for {len(texts_to_embed)} chunks...")
    embeddings, success = get_ollama_embeddings(texts_to_embed)
    if not success:
        gr.Warning("Some embeddings failed to generate. Results might be incomplete.")

    valid_embeddings = np.array([emb for emb in embeddings if emb], dtype='float32')

    if valid_embeddings.shape[0] == 0:
        print("No valid embeddings generated.")
        return index, metadata, 0

    # Add vectors to FAISS index
    start_index = index.ntotal
    index.add(valid_embeddings)
    print(f"Added {valid_embeddings.shape[0]} vectors to FAISS index. New total: {index.ntotal}")

    # Add corresponding metadata
    added_count = 0
    original_indices_added = [i for i, emb in enumerate(embeddings) if emb] # Indices from original list that had valid embeddings

    for i, original_idx in enumerate(original_indices_added):
        faiss_id = start_index + i
        metadata[faiss_id] = {
            "text": texts_to_embed[original_idx],
            "url": urls[original_idx],
            # Add other relevant info like title if available from crawler
        }
        added_count += 1

    print(f"Added metadata for {added_count} entries.")
    return index, metadata, added_count

def search_faiss(index: faiss.Index, metadata: Dict[int, Dict], query_text: str, k: int = 5) -> List[Dict]:
    """Searches FAISS index and returns relevant metadata entries."""
    if not query_text or index.ntotal == 0:
        return []

    print(f"Generating embedding for query: {query_text[:50]}...")
    query_embedding, success = get_ollama_embeddings([query_text])

    if not success or not query_embedding[0]:
        gr.Error("Failed to generate embedding for search query.")
        return []

    query_vector = np.array(query_embedding, dtype='float32')

    print(f"Searching FAISS index (k={k})...")
    try:
         # D: distances, I: indices (IDs)
        distances, indices = index.search(query_vector, k)
        results = []
        if indices.size > 0:
            for i, faiss_id in enumerate(indices[0]): # indices is 2D array [[id1, id2, ...]]
                 if faiss_id != -1: # -1 indicates no neighbor found
                    entry = metadata.get(faiss_id)
                    if entry:
                         entry_with_score = entry.copy()
                         # L2 distance, lower is better. Can convert to similarity score if needed.
                         entry_with_score['score'] = float(distances[0][i])
                         results.append(entry_with_score)
                    else:
                        print(f"Warning: FAISS ID {faiss_id} not found in metadata.")
        print(f"Found {len(results)} results from FAISS.")
        return results
    except Exception as e:
         print(f"Error during FAISS search: {e}")
         gr.Error(f"FAISS search failed: {e}")
         return []

# --- LLM Interaction Functions ---
def call_ollama_chat(system_prompt: str, user_prompt: str) -> Dict:
    messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt}]
    try:
        response = ollama.chat(model=OLLAMA_MODEL, messages=messages)
        response_content = response['message']['content']
        try:
            # Clean potential markdown code block fences
            if response_content.startswith("```json"): response_content = response_content[7:]
            if response_content.endswith("```"): response_content = response_content[:-3]
            parsed_json = json.loads(response_content.strip())
            return parsed_json
        except json.JSONDecodeError:
            print(f"LLM response for '{system_prompt[:30]}...' was not valid JSON.")
            return {"raw_response": response_content}
    except Exception as e:
        print(f"Error calling Ollama: {e}")
        return {"error": str(e)}

# Specific LLM tasks
def analyze_emotion(journal_entry: str) -> Dict:
    return call_ollama_chat(EMOTION_ANALYSIS_PROMPT, journal_entry)

def generate_growth_plan(emotion_analysis: Dict, user_goals: Dict) -> Dict:
    input_data = {"emotion_analysis": emotion_analysis, "user_goals": user_goals}
    return call_ollama_chat(GROWTH_PLAN_PROMPT, json.dumps(input_data, indent=2))

def synthesize_resources_llm(emotion_analysis: Dict, growth_plan: Optional[Dict], search_results: List[Dict]) -> Dict:
    """Synthesizes resources using LLM based on FAISS search results."""
    if not search_results: return {"error": "No search results provided for synthesis."}
    # Extract text and URLs from search results
    snippets = [f"--- Content from {res.get('url', 'Unknown')} ---\n{res.get('text', '')}" for res in search_results]
    source_urls = list(set([res.get('url', 'Unknown') for res in search_results]))
    combined_content = "\n\n".join(snippets)

    input_data = {
        "emotion_analysis": emotion_analysis,
        "growth_plan": growth_plan if growth_plan else "No specific growth plan available.",
        "web_content_snippets": combined_content,
        "source_urls_provided": source_urls
    }
    synthesis_result = call_ollama_chat(RESOURCE_SYNTHESIS_PROMPT, json.dumps(input_data, indent=2))
    # Add source URLs if LLM didn't
    if isinstance(synthesis_result, dict) and 'source_urls' not in synthesis_result:
         synthesis_result['source_urls'] = source_urls
    return synthesis_result

def get_community_suggestions(emotion_analysis: Dict, growth_plan: Optional[Dict]) -> Dict:
    input_data = {"emotion_analysis": emotion_analysis, "growth_plan": growth_plan}
    return call_ollama_chat(COMMUNITY_SUGGESTION_PROMPT, json.dumps(input_data, indent=2))


# --- Web Search and Crawl Functions ---
def get_web_urls(search_term: str, num_results: int = 3) -> List[str]:
    # ... (Keep implementation from previous simplified version) ...
    allowed_urls = []
    try:
        enhanced_search = f"{search_term} emotional regulation coping strategies therapy techniques"
        print(f"Searching DDG for: {enhanced_search}")
        results = DDGS().text(enhanced_search, max_results=num_results * 2) # Fetch slightly more
        urls = [result["href"] for result in results if result.get("href")]
        # Basic filtering
        filtered_urls = []
        seen_domains = set()
        discard_domains = {"youtube.com", "amazon.com", "pinterest.com", "facebook.com", "instagram.com", "twitter.com", "tiktok.com"}
        for url in urls:
            if url.lower().endswith(".pdf"): continue
            try:
                domain = urlparse(url).netloc.replace("www.", "")
                if domain and domain not in seen_domains and domain not in discard_domains:
                    filtered_urls.append(url)
                    seen_domains.add(domain)
            except Exception: continue
        allowed_urls = check_robots_txt(filtered_urls[:num_results]) # Limit to desired number
        print(f"Allowed URLs: {allowed_urls}")
    except Exception as e: print(f"❌ Failed search: {str(e)}")
    return allowed_urls

def check_robots_txt(urls: List[str]) -> List[str]: # Simplified
    return urls

async def crawl_webpages_simple(urls: List[str]) -> List[Dict]:
    """Crawls pages, returns [{'url': url, 'markdown': markdown}]."""
    if not CRAWL4AI_AVAILABLE or not urls: return []
    md_generator = DefaultMarkdownGenerator()
    crawler_config = CrawlerRunConfig(markdown_generator=md_generator, excluded_tags=["script", "style", "nav", "footer", "aside"], only_text=False, cache_mode=CacheMode.NORMAL, user_agent="Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)", page_timeout=20000, wait_for_network_idle=True, network_idle_timeout=3000)
    browser_config = BrowserConfig(headless=True, text_mode=False, light_mode=True)
    results_list = []
    print(f"Crawling {len(urls)} URLs...")
    try:
        async with AsyncWebCrawler(config=browser_config) as crawler:
            crawl_results = await crawler.arun_many(urls, config=crawler_config)
            for res in crawl_results:
                 markdown_content = res.markdown_v2.raw_markdown if (res and res.markdown_v2 and res.markdown_v2.raw_markdown) else ""
                 if markdown_content.strip(): results_list.append({'url': res.url, 'markdown': markdown_content.strip()})
    except Exception as e: print(f"Crawling error: {e}")
    print(f"Crawled {len(results_list)} pages successfully.")
    return results_list


# --- Gradio App Logic ---

# Load initial FAISS data
faiss_index, faiss_metadata = create_or_load_faiss_index()
community_posts_global = load_community_posts() # Load community posts once

# Helper to format analysis for display
def format_analysis(analysis):
    if not analysis or "error" in analysis or "raw_response" in analysis:
         return f"Analysis Error or Incomplete:\n```json\n{json.dumps(analysis, indent=2)}\n```"
    md = f"""
**Primary Emotion:** {analysis.get('primary_emotion', 'N/A')} (Intensity: {analysis.get('intensity', 'N/A')}/10)
**Triggers:** {', '.join(analysis.get('triggers', [])) or 'None'}
**Patterns:** {', '.join(analysis.get('patterns', [])) or 'None'}

**Growth Opportunities:**
"""
    for opp in analysis.get('growth_opportunities', []): md += f"- {opp}\n"
    md += "\n**Action Steps:**\n"
    for step in analysis.get('action_steps', []): md += f"- {step}\n"
    return md

# Helper to format plan for display
def format_plan(plan):
     if not plan or "error" in plan or "raw_response" in plan:
          return f"Plan Error or Incomplete:\n```json\n{json.dumps(plan, indent=2)}\n```"
     md = "**Short-term Actions:**\n"
     for item in plan.get('short_term_actions', []): md += f"- {item}\n"
     md += "\n**Medium-term Practices:**\n"
     for item in plan.get('medium_term_practices', []): md += f"- {item}\n"
     md += "\n**Long-term Changes:**\n"
     for item in plan.get('long_term_changes', []): md += f"- {item}\n"
     md += "\n**Reflection Prompts:**\n"
     for item in plan.get('reflection_prompts', []): md += f"- {item}\n"
     md += "\n**Success Metrics:**\n"
     for item in plan.get('success_metrics', []): md += f"- {item}\n"
     return md

# Helper to format synthesis for display
def format_synthesis(synthesis):
    if not synthesis or "error" in synthesis or "raw_response" in synthesis:
        return f"Synthesis Error or Incomplete:\n```json\n{json.dumps(synthesis, indent=2)}\n```"
    md = "**Key Insights:**\n"
    for item in synthesis.get('key_insights', []): md += f"- {item}\n"
    md += "\n**Practical Exercises:**\n"
    for item in synthesis.get('practical_exercises', []): md += f"- {item}\n"
    md += "\n**Recommended Readings:**\n"
    for item in synthesis.get('recommended_readings', []): md += f"- {item}\n"
    md += f"\n**Expert Advice Summary:**\n{synthesis.get('expert_advice', 'N/A')}\n"
    md += "\n**Action Plan:**\n"
    for item in synthesis.get('action_plan', []): md += f"- {item}\n"
    md += "\n**Sources:**\n"
    for item in synthesis.get('source_urls', []): md += f"- {item}\n"
    return md

# Helper to format community posts
def format_community_posts(posts):
    if not posts: return "No community posts yet."
    md = ""
    for post in sorted(posts, key=lambda x: x['timestamp'], reverse=True):
         comments_md = ""
         for c in sorted(post.get('comments', []), key=lambda x: x['timestamp']):
             comments_md += f"  - **{c['user_id']}** ({c['timestamp'][:16]}): {c['comment']}\n"
         md += f"""
### {post['title']}
**By:** {post['user_id']} ({post['timestamp'][:16]}) | **Likes:** {post['likes']}
{post['content']}
**Comments ({len(post.get('comments',[]))}):**
{comments_md or '  (No comments)'}
---
"""
    return md


# --- Gradio Interface ---
with gr.Blocks(theme=gr.themes.Soft(), title="EmotionToAction") as demo:
    # --- State Management ---
    # User-specific data loaded from file
    user_data_state = gr.State({})
    # FAISS index and metadata loaded once
    faiss_index_state = gr.State(faiss_index)
    faiss_metadata_state = gr.State(faiss_metadata)
    # Session state for current analysis/plan context
    current_analysis_state = gr.State(None)
    current_plan_state = gr.State(None)
    current_emotion_id_state = gr.State(None) # ID of the entry being viewed/processed
    community_posts_state = gr.State(community_posts_global) # Use global list loaded once

    gr.Markdown("# 🌱 EmotionToAction (Gradio Version)")

    with gr.Row():
         username_input = gr.Textbox(label="Enter Username", placeholder="Type username and press Enter")
         # Output for status messages
         status_output = gr.Markdown("")

    # --- Main Tabs ---
    with gr.Tabs() as tabs:
        # --- Journal Tab ---
        with gr.TabItem("📝 Journal", id=0):
            with gr.Row():
                with gr.Column(scale=2):
                     journal_entry_input = gr.Textbox(label="What are you feeling right now?", lines=10, placeholder="Describe your emotional experience...")
                     analyze_button = gr.Button("Analyze Emotions", variant="primary")
                with gr.Column(scale=1):
                     gr.Markdown("### Past Entries")
                     past_entries_display = gr.DataFrame(headers=["Date", "Emotion", "Entry Snippet", "Entry ID"], interactive=False, height=300)
                     # Load past entries when user changes or button clicked?

        # --- Analysis Tab ---
        with gr.TabItem("🧠 Analysis", id=1):
            gr.Markdown("### AI Emotion Analysis")
            analysis_display = gr.Markdown("Analysis will appear here after submitting a journal entry.")
            with gr.Row():
                 plan_button = gr.Button("💡 Create Growth Plan")
                 find_resources_button = gr.Button("🔎 Find & Add Resources") # Changed label

        # --- Plan Tab ---
        with gr.TabItem("🚀 Growth Plan", id=2):
            gr.Markdown("### Your Personalized Growth Plan")
            plan_display = gr.Markdown("Plan will appear here after generation.")

        # --- Resources Tab ---
        with gr.TabItem("📚 Resources", id=3):
             with gr.Accordion("Find New Resources (Adds to Index)", open=False):
                  find_resources_status = gr.Markdown("Trigger resource finding from the 'Analysis' tab.")
             with gr.Accordion("Synthesize Found Resources", open=True):
                  synthesis_query_input = gr.Textbox(label="Describe the topic you want synthesized resources for (e.g., 'managing anxiety triggered by work')", placeholder="Uses info stored in resource index...")
                  synthesize_button = gr.Button("Synthesize Resources", variant="secondary")
                  synthesis_display = gr.Markdown("Synthesized insights will appear here.")
             with gr.Accordion("Search Indexed Resources", open=True):
                  search_query_input = gr.Textbox(label="Search indexed content", placeholder="Enter keywords...")
                  search_button = gr.Button("Search Index", variant="secondary")
                  search_results_display = gr.DataFrame(headers=["Text Snippet", "Source URL", "Score"], interactive=False, height=300)


        # --- Community Tab ---
        with gr.TabItem("👥 Community", id=4):
            gr.Markdown("### Community Hub")
            with gr.Row():
                with gr.Column(scale=2):
                    gr.Markdown("#### Recent Posts")
                    community_feed_display = gr.Markdown("Loading posts...") # Use Markdown for better formatting
                with gr.Column(scale=1):
                     gr.Markdown("#### New Post")
                     post_title_input = gr.Textbox(label="Title")
                     post_content_input = gr.Textbox(label="Content", lines=5)
                     post_button = gr.Button("Submit Post", variant="primary")
                     # Add like/comment inputs here if desired (more complex)

        # --- Profile Tab ---
        with gr.TabItem("👤 Profile", id=5):
             gr.Markdown("### Your Profile")
             profile_points_display = gr.Number(label="Growth Points", interactive=False)
             profile_joined_display = gr.Textbox(label="Member Since", interactive=False)
             gr.Markdown("#### Growth Goals")
             profile_goal1_input = gr.Textbox(label="Goal 1")
             profile_goal2_input = gr.Textbox(label="Goal 2")
             save_goals_button = gr.Button("Save Goals")

    # --- Event Handlers ---

    # Load user data when username is entered
    def handle_username_change(username, user_data_s):
        if not username:
            return {"entries": [], "plans": {}, "resources": {}, "profile": {}}, "Please enter a username.", None, None, None, None, None, None, None
        print(f"Loading data for user: {username}")
        user_data = load_user_data(username)
        # Ensure profile exists
        if "profile" not in user_data:
             user_data["profile"] = {"username": username, "joined": datetime.datetime.now().isoformat(), "points": 0, "goals":{}}
        # Format past entries for DataFrame display
        entry_list = user_data.get("entries", [])
        df_data = [
             [e['timestamp'][:10], e['analysis'].get('primary_emotion', 'N/A'), e['journal_entry'][:50]+'...', e['id']]
             for e in sorted(entry_list, key=lambda x:x['timestamp'], reverse=True)
         ]
        past_entries_df = pd.DataFrame(df_data, columns=["Date", "Emotion", "Entry Snippet", "Entry ID"])

        return user_data, f"Loaded data for {username}.", past_entries_df, \
               user_data.get("profile", {}).get("points", 0), \
               user_data.get("profile", {}).get("joined", ""), \
               user_data.get("profile", {}).get("goals", {}).get("goal1", ""), \
               user_data.get("profile", {}).get("goals", {}).get("goal2", "")

    username_input.submit(
        handle_username_change,
        inputs=[username_input, user_data_state],
        outputs=[user_data_state, status_output, past_entries_display,
                 profile_points_display, profile_joined_display,
                 profile_goal1_input, profile_goal2_input]
    )

    # Analyze Button Click
    def handle_analyze(username, user_data_s, journal_entry):
        if not username: return "Please enter username first.", None, None, None, None, None
        if not journal_entry: return "Journal entry cannot be empty.", None, None, None, None, None

        status = "Analyzing emotions..."
        yield status, None, None, None, None, None # Update status immediately

        analysis = analyze_emotion(journal_entry)

        if "error" in analysis:
            status = f"Analysis failed: {analysis['error']}"
            formatted_analysis = f"Error:\n```json\n{json.dumps(analysis, indent=2)}\n```"
            yield status, formatted_analysis, None, None, None, None
        elif "raw_response" in analysis:
             status = "Analysis complete (raw response)."
             formatted_analysis = f"Raw Response:\n```\n{analysis['raw_response']}\n```"
             # Cannot proceed with raw response usually
             yield status, formatted_analysis, None, None, None, None
        else:
            # Save entry and update user data
            entry_id = str(uuid.uuid4())
            new_entry = {
                'id': entry_id,
                'timestamp': datetime.datetime.now().isoformat(),
                'journal_entry': journal_entry,
                'analysis': analysis
            }
            user_data_s["entries"] = user_data_s.get("entries", []) + [new_entry]
            user_data_s["profile"]["points"] = user_data_s.get("profile", {}).get("points", 0) + 10
            save_user_data(username, user_data_s)

            # Update UI
            status = "Analysis complete!"
            formatted_analysis = format_analysis(analysis)
            # Update past entries display immediately
            entry_list = user_data_s.get("entries", [])
            df_data = [[e['timestamp'][:10], e['analysis'].get('primary_emotion', 'N/A'), e['journal_entry'][:50]+'...', e['id']] for e in sorted(entry_list, key=lambda x:x['timestamp'], reverse=True)]
            past_entries_df = pd.DataFrame(df_data, columns=["Date", "Emotion", "Entry Snippet", "Entry ID"])

            # Return updates for status, analysis display, current analysis state, current emotion ID, user data state, and past entries df
            yield status, formatted_analysis, analysis, entry_id, user_data_s, past_entries_df

    analyze_button.click(
        handle_analyze,
        inputs=[username_input, user_data_state, journal_entry_input],
        outputs=[status_output, analysis_display, current_analysis_state, current_emotion_id_state, user_data_state, past_entries_display]
    )

    # Create Plan Button Click
    def handle_create_plan(username, user_data_s, current_analysis, current_emotion_id):
        if not username: return "Please enter username.", None, None
        if not current_analysis: return "Please analyze an entry first.", None, None
        if not current_emotion_id: return "Internal error: Missing emotion ID.", None, None

        status = "Generating growth plan..."
        yield status, None, None # Update status immediately

        user_goals = user_data_s.get("profile", {}).get("goals", {})
        plan = generate_growth_plan(current_analysis, user_goals)

        if "error" in plan or "raw_response" in plan:
            status = "Failed to generate plan."
            formatted_plan = f"Error/Raw:\n```json\n{json.dumps(plan, indent=2)}\n```"
            yield status, formatted_plan, None
        else:
            # Save plan and update points
            user_data_s["plans"] = user_data_s.get("plans", {})
            user_data_s["plans"][current_emotion_id] = plan
            user_data_s["profile"]["points"] = user_data_s.get("profile", {}).get("points", 0) + 20
            save_user_data(username, user_data_s)
            status = "Growth plan generated!"
            formatted_plan = format_plan(plan)
            yield status, formatted_plan, plan # Update status, display, and plan state

    plan_button.click(
         handle_create_plan,
         inputs=[username_input, user_data_state, current_analysis_state, current_emotion_id_state],
         outputs=[status_output, plan_display, current_plan_state]
    )

    # Find & Add Resources Button Click (Async)
    async def handle_find_resources(username, current_analysis, faiss_index_s, faiss_metadata_s, progress=gr.Progress(track_tqdm=True)):
        if not username: return "Please enter username.", faiss_index_s, faiss_metadata_s, "Idle"
        if not current_analysis: return "Please analyze an entry first.", faiss_index_s, faiss_metadata_s, "Idle"
        if not CRAWL4AI_AVAILABLE: return "crawl4ai library not installed.", faiss_index_s, faiss_metadata_s, "Error"

        status_msg = "Starting resource finding..."
        yield status_msg, faiss_index_s, faiss_metadata_s, status_msg # Initial update

        emotion = current_analysis.get('primary_emotion', 'challenge')
        triggers = current_analysis.get('triggers', [])
        search_term = f"{emotion} coping strategies {' '.join(triggers)}"

        progress(0.1, desc="Searching web...")
        status_msg = "Searching web..."
        yield status_msg, faiss_index_s, faiss_metadata_s, status_msg
        urls = get_web_urls(search_term, num_results=3) # Limit URLs
        if not urls: yield "No relevant URLs found.", faiss_index_s, faiss_metadata_s, "No URLs found."; return

        progress(0.3, desc=f"Crawling {len(urls)} pages...")
        status_msg = f"Crawling {len(urls)} pages..."
        yield status_msg, faiss_index_s, faiss_metadata_s, status_msg
        crawled_content = await crawl_webpages_simple(urls) # Async call
        if not crawled_content: yield "Crawling failed or yielded no content.", faiss_index_s, faiss_metadata_s, "Crawling failed."; return

        progress(0.7, desc="Adding content to FAISS index...")
        status_msg = "Adding content to index..."
        yield status_msg, faiss_index_s, faiss_metadata_s, status_msg
        # Note: add_to_faiss modifies the index/metadata objects in place
        index_obj = faiss_index_s # Get current index from state
        meta_obj = faiss_metadata_s # Get current metadata from state
        _, _, added_count = add_to_faiss(index_obj, meta_obj, crawled_content)

        if added_count > 0:
             # IMPORTANT: Save the modified index and metadata back to disk
             save_faiss_index(index_obj, meta_obj)
             status_msg = f"Successfully added {added_count} content chunks to the index."
             yield status_msg, index_obj, meta_obj, status_msg # Return updated state objects
        else:
             status_msg = "Crawled content, but failed to add anything to the index."
             yield status_msg, index_obj, meta_obj, status_msg

    # Use the wrapper for async function
    find_resources_button.click(
        handle_find_resources,
        inputs=[username_input, current_analysis_state, faiss_index_state, faiss_metadata_state],
        outputs=[status_output, faiss_index_state, faiss_metadata_state, find_resources_status] # Update index/meta state
    )

    # Synthesize Button Click
    def handle_synthesize(username, user_data_s, current_emotion_id, faiss_index_s, faiss_metadata_s, query_override=""):
        if not username: return "Please enter username.", None
        # Prioritize using an emotion context if available, else use the override query
        search_text = ""
        context_analysis = None
        context_plan = None
        if not query_override and current_emotion_id:
            entry = next((e for e in user_data_s.get("entries", []) if e['id'] == current_emotion_id), None)
            if entry and 'analysis' in entry:
                 context_analysis = entry['analysis']
                 context_plan = user_data_s.get("plans", {}).get(current_emotion_id)
                 emotion = context_analysis.get('primary_emotion', 'issue')
                 triggers = context_analysis.get('triggers', [])
                 search_text = f"{emotion} coping techniques {' '.join(triggers)}"
            else: query_override = "general emotional coping strategies" # Fallback if context missing
        elif not query_override:
             query_override = "general emotional coping strategies" # Default if no context

        if query_override: search_text = query_override
        if not search_text: return "Cannot determine search topic.", None

        status = f"Searching index for '{search_text[:30]}...' and synthesizing..."
        yield status, "Synthesizing..." # Update status

        search_results = search_faiss(faiss_index_s, faiss_metadata_s, search_text, k=5)
        if not search_results:
            yield f"No relevant info found in index for '{search_text[:30]}...'", "No results found."
            return

        synthesis = synthesize_resources_llm(context_analysis or {}, context_plan, search_results)

        if "error" in synthesis or "raw_response" in synthesis:
             formatted_synthesis = f"Synthesis Error/Raw:\n```json\n{json.dumps(synthesis, indent=2)}\n```"
             yield "Synthesis failed.", formatted_synthesis
        else:
             # Save synthesis result associated with the emotion ID if context was used
             if context_analysis and current_emotion_id:
                 user_data_s["resources"] = user_data_s.get("resources", {})
                 user_data_s["resources"][current_emotion_id] = synthesis
                 save_user_data(username, user_data_s)
                 status = "Synthesis complete and saved!"
             else:
                 status = "Synthesis complete (not saved to specific entry)."
             formatted_synthesis = format_synthesis(synthesis)
             yield status, formatted_synthesis

    synthesize_button.click(
        handle_synthesize,
        inputs=[username_input, user_data_state, current_emotion_id_state, faiss_index_state, faiss_metadata_state, synthesis_query_input],
        outputs=[status_output, synthesis_display]
    )


    # Search Index Button Click
    def handle_search_index(faiss_index_s, faiss_metadata_s, query):
         if not query: return "Please enter search query.", None
         results = search_faiss(faiss_index_s, faiss_metadata_s, query, k=10)
         if not results: return "No results found.", None
         # Format for DataFrame
         df_data = [[res.get('text', '')[:150]+'...', res.get('url', 'N/A'), f"{res.get('score', 0):.2f}"] for res in results]
         results_df = pd.DataFrame(df_data, columns=["Text Snippet", "Source URL", "Score"])
         return f"Found {len(results)} results.", results_df

    search_button.click(
         handle_search_index,
         inputs=[faiss_index_state, faiss_metadata_state, search_query_input],
         outputs=[status_output, search_results_display]
    )

    # --- Community Handlers ---
    def handle_new_post(username, title, content, community_posts_s):
         if not username: return "Enter username first.", community_posts_s, format_community_posts(community_posts_s)
         if not title or not content: return "Title and content required.", community_posts_s, format_community_posts(community_posts_s)

         new_post = {'id': str(uuid.uuid4()), 'user_id': username, 'timestamp': datetime.datetime.now().isoformat(), 'title': title, 'content': content, 'likes': 0, 'comments': []}
         community_posts_s.append(new_post)
         save_community_posts(community_posts_s) # Save updated list
         return "Post submitted.", community_posts_s, format_community_posts(community_posts_s)

    post_button.click(
        handle_new_post,
        inputs=[username_input, post_title_input, post_content_input, community_posts_state],
        outputs=[status_output, community_posts_state, community_feed_display] # Update state and display
    )

    # Initial load of community posts display
    demo.load(lambda posts: format_community_posts(posts), inputs=community_posts_state, outputs=community_feed_display)


    # --- Profile Handlers ---
    def handle_save_goals(username, user_data_s, goal1, goal2):
         if not username: return "Enter username first.", user_data_s
         user_data_s["profile"] = user_data_s.get("profile", {})
         user_data_s["profile"]["goals"] = {"goal1": goal1, "goal2": goal2}
         save_user_data(username, user_data_s)
         return "Goals saved!", user_data_s

    save_goals_button.click(
        handle_save_goals,
        inputs=[username_input, user_data_state, profile_goal1_input, profile_goal2_input],
        outputs=[status_output, user_data_state] # Update user data state
    )


# Launch the Gradio app
if __name__ == "__main__":
    demo.launch(debug=True) # Share=True to create public link if needed