app.py

# filename: app_gemini_serper_v3.py
import gradio as gr
import pandas as pd
import numpy as np
import plotly.graph_objects as go
import plotly.express as px
from datetime import datetime, timedelta
import random
import json
import os
import time
import requests # For Serper API
from typing import List, Dict, Any, Optional
import logging
from dotenv import load_dotenv
import uuid
import re

# --- Google AI Integration ---
import google.generativeai as genai
from google.api_core import exceptions as google_exceptions

# --- Load environment variables ---
load_dotenv()

# --- Set up logging ---
logging.basicConfig(level=logging.INFO,
                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__) # Use __name__ for logger

# --- Configure API keys ---
GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
SERPER_API_KEY = os.getenv("SERPER_API_KEY")

if not GOOGLE_API_KEY:
    logger.warning("GOOGLE_API_KEY not found. AI features will not work.")
if not SERPER_API_KEY:
    logger.warning("SERPER_API_KEY not found. Live web search features will not work.")

# --- Initialize the Google AI client ---
try:
    genai.configure(api_key=GOOGLE_API_KEY)
    logger.info("Google AI client configured successfully.")
except Exception as e:
    logger.error(f"Failed to configure Google AI client: {e}")
    genai = None # Prevent further calls if config fails

# --- Model configuration ---
# Using gemini-1.5-flash-latest as the state-of-the-art, fast model
MODEL_ID = "gemini-1.5-flash-latest"
if genai:
    try:
        gemini_model = genai.GenerativeModel(
            MODEL_ID,
            # System instruction is now passed during generation, not model init
            # safety_settings adjusted for potentially sensitive career/emotion talk
            safety_settings=[
                {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
                {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
                {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_ONLY_HIGH"},
                {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
            ]
        )
        logger.info(f"Google AI Model '{MODEL_ID}' initialized.")
    except Exception as e:
        logger.error(f"Failed to initialize Google AI Model '{MODEL_ID}': {e}")
        gemini_model = None
else:
    gemini_model = None

# --- Constants ---
# Enhanced emotions and goals for richer profile
EMOTIONS = ["Unmotivated 😩", "Anxious 😥", "Confused 🤔", "Excited 🎉", "Overwhelmed 🤯", "Discouraged 😔", "Hopeful ✨", "Focused 😎", "Stuck 🧱"]
GOAL_TYPES = [
    "Get a job (Big Company) 🏢", "Get a job (Startup) 🌱", "Find an Internship 🎓", "Freelance/Contract Work 💼",
    "Change Careers 🚀", "Improve Specific Skills 💡", "Build Professional Network 🤝", "Leadership Development 📈", "Explore Options 🤔"
]
USER_DB_PATH = "user_database_v3.json" # New DB file for new structure
RESUME_FOLDER = "user_resumes_v3"
PORTFOLIO_FOLDER = "user_portfolios_v3"
os.makedirs(RESUME_FOLDER, exist_ok=True)
os.makedirs(PORTFOLIO_FOLDER, exist_ok=True)

# --- Tool Definitions for Google AI (Gemini) ---
# Note: Schema is slightly different from OpenAI's

# 1. Document Template Generator
generate_document_template_func = genai.protos.FunctionDeclaration(
    name="generate_document_template",
    description="Generate a document template (like a resume or cover letter) based on type, career field, and experience level.",
    parameters=genai.protos.Schema(
        type=genai.protos.Type.OBJECT,
        properties={
            "document_type": genai.protos.Schema(type=genai.protos.Type.STRING, description="e.g., Resume, Cover Letter, LinkedIn Summary"),
            "career_field": genai.protos.Schema(type=genai.protos.Type.STRING, description="Target industry or field"),
            "experience_level": genai.protos.Schema(type=genai.protos.Type.STRING, description="e.g., Entry, Mid, Senior, Student")
        },
        required=["document_type"]
    )
)

# 2. Personalized Routine Creator
create_personalized_routine_func = genai.protos.FunctionDeclaration(
    name="create_personalized_routine",
    description="Create a personalized daily or weekly career development routine based on the user's current emotion, goals, and available time.",
    parameters=genai.protos.Schema(
        type=genai.protos.Type.OBJECT,
        properties={
            "emotion": genai.protos.Schema(type=genai.protos.Type.STRING, description="User's current primary emotion"),
            "goal": genai.protos.Schema(type=genai.protos.Type.STRING, description="User's primary career goal"),
            "available_time_minutes": genai.protos.Schema(type=genai.protos.Type.INTEGER, description="Average minutes per day user can dedicate"),
            "routine_length_days": genai.protos.Schema(type=genai.protos.Type.INTEGER, description="Desired length of the routine in days (e.g., 7 for weekly)")
        },
        required=["emotion", "goal"]
    )
)

# 3. Resume Analyzer
analyze_resume_func = genai.protos.FunctionDeclaration(
    name="analyze_resume",
    description="Analyze the provided resume text and provide feedback, comparing it against the user's stated career goal. Provides strengths, weaknesses, and suggestions.",
    parameters=genai.protos.Schema(
        type=genai.protos.Type.OBJECT,
        properties={
            "resume_text": genai.protos.Schema(type=genai.protos.Type.STRING, description="The full text content of the user's resume"),
            "career_goal": genai.protos.Schema(type=genai.protos.Type.STRING, description="The specific career goal to analyze against")
        },
        required=["resume_text", "career_goal"]
    )
)

# 4. Portfolio Analyzer
analyze_portfolio_func = genai.protos.FunctionDeclaration(
    name="analyze_portfolio",
    description="Analyze a user's portfolio based on a URL (if provided) and a description, offering feedback relative to their career goal.",
    parameters=genai.protos.Schema(
        type=genai.protos.Type.OBJECT,
        properties={
            "portfolio_url": genai.protos.Schema(type=genai.protos.Type.STRING, description="URL link to the online portfolio (optional)"),
            "portfolio_description": genai.protos.Schema(type=genai.protos.Type.STRING, description="User's description of the portfolio content and purpose"),
            "career_goal": genai.protos.Schema(type=genai.protos.Type.STRING, description="The specific career goal to analyze against")
        },
        required=["portfolio_description", "career_goal"]
    )
)

# 5. Skill Extractor & Rater (from Resume)
extract_and_rate_skills_from_resume_func = genai.protos.FunctionDeclaration(
    name="extract_and_rate_skills_from_resume",
    description="Extracts key skills from resume text and rates them on a scale of 1-10 based on apparent proficiency shown in the resume. Useful for identifying strengths and gaps.",
    parameters=genai.protos.Schema(
        type=genai.protos.Type.OBJECT,
        properties={
            "resume_text": genai.protos.Schema(type=genai.protos.Type.STRING, description="The full text content of the user's resume"),
            "max_skills": genai.protos.Schema(type=genai.protos.Type.INTEGER, description="Maximum number of skills to extract (default 8)")
        },
        required=["resume_text"]
    )
)

# 6. NEW: Live Web Search for Opportunities (Serper API)
search_web_serper_func = genai.protos.FunctionDeclaration(
    name="search_jobs_courses_skills",
    description="Search the web for relevant job openings, online courses, or skills development resources based on the user's goals, location, and potentially identified skill gaps.",
    parameters=genai.protos.Schema(
        type=genai.protos.Type.OBJECT,
        properties={
            "search_query": genai.protos.Schema(type=genai.protos.Type.STRING, description="The specific search query (e.g., 'remote data analyst jobs in California', 'online Python courses for beginners', 'project management certifications')"),
            "search_type": genai.protos.Schema(type=genai.protos.Type.STRING, description="Type of search: 'jobs', 'courses', 'skills', or 'general'"),
            "location": genai.protos.Schema(type=genai.protos.Type.STRING, description="Geographical location for the search (if applicable, e.g., 'London, UK')")
        },
        required=["search_query", "search_type"]
    )
)


# Combine all tool function declarations for the API call
tools_list_gemini = [
    generate_document_template_func,
    create_personalized_routine_func,
    analyze_resume_func,
    analyze_portfolio_func,
    extract_and_rate_skills_from_resume_func,
    search_web_serper_func
]

# --- User Database Functions (Enhanced Profile) ---
def load_user_database():
    try:
        with open(USER_DB_PATH, 'r', encoding='utf-8') as file: db = json.load(file)
        # Basic validation and migration for chat history (similar to previous)
        for user_id in db.get('users', {}):
            profile = db['users'][user_id]
            if 'chat_history' not in profile or not isinstance(profile['chat_history'], list): profile['chat_history'] = []
            else:
                 # Gemini uses 'parts' not 'content', and roles 'user'/'model'
                 fixed_history = []
                 for msg in profile['chat_history']:
                     if isinstance(msg, dict) and 'role' in msg and 'parts' in msg:
                          # Basic check, can be more robust
                         if msg['role'] in ['user', 'model'] and isinstance(msg['parts'], list):
                             fixed_history.append(msg)
                     elif isinstance(msg, dict) and 'role' == 'function': # Gemini uses role 'function' for tool responses
                         # Ensure it has necessary fields (name, response)
                         if 'name' in msg and 'response' in msg:
                             fixed_history.append(msg)
                 profile['chat_history'] = fixed_history

            # Ensure other lists exist
            for key in ['recommendations', 'daily_emotions', 'completed_tasks', 'routine_history', 'strengths', 'areas_for_development', 'values']:
                 if key not in profile or not isinstance(profile.get(key), list):
                     profile[key] = []
            # Ensure basic string fields exist
            for key in ['name', 'location', 'current_emotion', 'career_goal', 'industry', 'preferred_work_style', 'long_term_aspirations', 'resume_path', 'portfolio_path']:
                 if key not in profile:
                     profile[key] = ""
            if 'progress_points' not in profile: profile['progress_points'] = 0
            if 'experience_level' not in profile: profile['experience_level'] = "Not specified" # Add experience level

        return db
    except (FileNotFoundError, json.JSONDecodeError): logger.info(f"DB file '{USER_DB_PATH}' not found/invalid. Creating new."); db = {'users': {}}; save_user_database(db); return db
    except Exception as e: logger.error(f"Error loading DB from {USER_DB_PATH}: {e}"); return {'users': {}}

def save_user_database(db):
    try:
        with open(USER_DB_PATH, 'w', encoding='utf-8') as file: json.dump(db, file, indent=4, ensure_ascii=False)
    except Exception as e: logger.error(f"Error saving DB to {USER_DB_PATH}: {e}")

def get_user_profile(user_id):
    db = load_user_database()
    if user_id not in db.get('users', {}):
        db['users'] = db.get('users', {})
        # Initialize enhanced profile structure
        db['users'][user_id] = {
            "user_id": user_id,
            "name": "",
            "location": "",
            "industry": "", # NEW: Target industry
            "experience_level": "Not specified", # NEW: e.g., Entry, Mid, Senior
            "preferred_work_style": "Any", # NEW: Remote, Hybrid, On-site, Any
            "values": [], # NEW: List of values (e.g., "work-life balance", "impact", "learning")
            "strengths": [], # NEW: User-identified or AI-suggested strengths
            "areas_for_development": [], # NEW: User-identified or AI-suggested areas
            "long_term_aspirations": "", # NEW: Goals beyond the immediate one

            "current_emotion": "",
            "career_goal": "",
            "progress_points": 0,
            "completed_tasks": [],
            "upcoming_events": [], # Consider adding events scheduling later
            "routine_history": [],
            "daily_emotions": [],
            "resume_path": "",
            "portfolio_path": "",
            "recommendations": [],
            "chat_history": [], # Stores history in Gemini format {role: 'user'/'model', parts: [{'text': '...'}]} or {role: 'function', name:'...', response:{...}}
            "joined_date": datetime.now().isoformat()
        }
        save_user_database(db)

    # Ensure lists and basic fields exist on subsequent loads (handled mostly in load_user_database)
    profile = db.get('users', {}).get(user_id, {})
    # Add simple check for chat history format upon retrieval
    if 'chat_history' not in profile or not isinstance(profile.get('chat_history'), list):
        profile['chat_history'] = []
    # Ensure other critical lists exist
    for key in ['recommendations', 'daily_emotions', 'completed_tasks', 'routine_history', 'strengths', 'areas_for_development', 'values']:
         if key not in profile: profile[key] = []


    return profile

# --- Database Update Functions (largely similar, adjust chat message structure) ---
def update_user_profile(user_id, updates):
    # (Keep existing logic, ensure keys match new profile)
    db = load_user_database()
    if user_id in db.get('users', {}):
        profile = db['users'][user_id]
        for key, value in updates.items():
            # Maybe add some validation here later if needed
            profile[key] = value
        save_user_database(db)
        return profile
    else:
        logger.warning(f"Attempted update non-existent profile: {user_id}")
        return None

def add_task_to_user(user_id, task):
    # (Keep existing logic)
    db = load_user_database(); profile = db.get('users', {}).get(user_id)
    if profile:
        if 'completed_tasks' not in profile or not isinstance(profile['completed_tasks'], list): profile['completed_tasks'] = []
        task_with_date = { "task": task, "date": datetime.now().isoformat() }
        profile['completed_tasks'].append(task_with_date)
        profile['progress_points'] = profile.get('progress_points', 0) + random.randint(10, 25) # Gamification element
        save_user_database(db); return profile
    return None

def add_emotion_record(user_id, emotion):
    # (Keep existing logic)
    cleaned_emotion = emotion.split(" ")[0] if " " in emotion else emotion
    db = load_user_database(); profile = db.get('users', {}).get(user_id)
    if profile:
        if 'daily_emotions' not in profile or not isinstance(profile['daily_emotions'], list): profile['daily_emotions'] = []
        emotion_record = { "emotion": cleaned_emotion, "date": datetime.now().isoformat() }
        profile['daily_emotions'].append(emotion_record)
        profile['current_emotion'] = cleaned_emotion # Update current emotion too
        save_user_database(db); return profile
    return None

def add_routine_to_user(user_id, routine):
    # (Keep existing logic)
    db = load_user_database(); profile = db.get('users', {}).get(user_id)
    if profile:
        if 'routine_history' not in profile or not isinstance(profile['routine_history'], list): profile['routine_history'] = []
        try: days_delta = int(routine.get('days', 7))
        except: days_delta = 7
        end_date = (datetime.now() + timedelta(days=days_delta)).isoformat()
        routine_with_date = { "routine": routine, "start_date": datetime.now().isoformat(), "end_date": end_date, "completion": 0 }
        profile['routine_history'].insert(0, routine_with_date) # Add to beginning
        profile['routine_history'] = profile['routine_history'][:10] # Keep last 10 routines
        save_user_database(db); return profile
    return None

def save_user_resume(user_id, resume_text):
    # (Keep existing logic)
    if not resume_text: return None
    filename, filepath = f"{user_id}_resume.txt", os.path.join(RESUME_FOLDER, f"{user_id}_resume.txt")
    try:
        with open(filepath, 'w', encoding='utf-8') as file: file.write(resume_text)
        update_user_profile(user_id, {"resume_path": filepath})
        logger.info(f"Resume saved: {filepath}"); return filepath
    except Exception as e: logger.error(f"Error saving resume {filepath}: {e}"); return None

def save_user_portfolio(user_id, portfolio_url, portfolio_description):
    # (Keep existing logic)
    if not portfolio_description: return None
    filename, filepath = f"{user_id}_portfolio.json", os.path.join(PORTFOLIO_FOLDER, f"{user_id}_portfolio.json")
    portfolio_content = {"url": portfolio_url, "description": portfolio_description, "saved_date": datetime.now().isoformat()}
    try:
        with open(filepath, 'w', encoding='utf-8') as file: json.dump(portfolio_content, file, indent=4, ensure_ascii=False)
        update_user_profile(user_id, {"portfolio_path": filepath})
        logger.info(f"Portfolio saved: {filepath}"); return filepath
    except Exception as e: logger.error(f"Error saving portfolio {filepath}: {e}"); return None

def add_recommendation_to_user(user_id, recommendation):
    # (Keep existing logic - potentially refine recommendation structure later)
    db = load_user_database(); profile = db.get('users', {}).get(user_id)
    if profile:
        if 'recommendations' not in profile or not isinstance(profile['recommendations'], list): profile['recommendations'] = []
        # Example structure: { 'title': 'Update LinkedIn', 'description': 'Focus on...', 'priority': 'High', 'action_type': 'Skill Building' }
        recommendation_with_date = {"recommendation": recommendation, "date": datetime.now().isoformat(), "status": "pending"}
        profile['recommendations'].insert(0, recommendation_with_date) # Add to beginning
        profile['recommendations'] = profile['recommendations'][:20] # Limit size
        save_user_database(db); return profile
    return None

def add_chat_message(user_id, role, parts_or_func_response):
    """Adds a message to the user's chat history using Gemini format."""
    db = load_user_database()
    profile = db.get('users', {}).get(user_id)
    if not profile:
        logger.warning(f"Profile not found for {user_id} when adding chat message.")
        return None

    if 'chat_history' not in profile or not isinstance(profile['chat_history'], list):
        profile['chat_history'] = []

    if role not in ['user', 'model', 'function']: # Gemini roles: 'user', 'model' (for assistant), 'function' (for tool results)
        logger.warning(f"Invalid role '{role}' for Gemini chat history.")
        return profile

    message = {"role": role}
    if role == 'user' or role == 'model':
        # Expecting parts_or_func_response to be a list of parts, e.g., [{'text': '...'}],
        # but handle simple string input for convenience
        if isinstance(parts_or_func_response, str):
            message['parts'] = [{'text': parts_or_func_response}]
        elif isinstance(parts_or_func_response, list):
            # Basic validation: Ensure it's a list of dicts with 'text'
            if all(isinstance(p, dict) and 'text' in p for p in parts_or_func_response):
                 message['parts'] = parts_or_func_response
            else:
                 logger.warning(f"Invalid parts format for role {role}: {parts_or_func_response}")
                 return profile # Don't save invalid structure
        else:
             logger.warning(f"Invalid content type for role {role}: {type(parts_or_func_response)}")
             return profile # Don't save invalid structure

    elif role == 'function':
        # Expecting parts_or_func_response to be a dict like {'name': 'func_name', 'response': {'content': ...}}
        if isinstance(parts_or_func_response, dict) and 'name' in parts_or_func_response and 'response' in parts_or_func_response:
            message.update(parts_or_func_response) # Merge the dict
        else:
            logger.warning(f"Invalid function response format: {parts_or_func_response}")
            return profile # Don't save invalid structure

    profile['chat_history'].append(message)

    # Limit history size (keep system prompt implicit for now, or add explicitly if needed)
    max_history_turns = 25 # Keep last 25 pairs (user + model/function)
    if len(profile['chat_history']) > max_history_turns * 2:
        profile['chat_history'] = profile['chat_history'][-(max_history_turns * 2):]

    save_user_database(db)
    return profile


# --- Basic Routine Fallback Function (keep as is, provides robustness) ---
def generate_basic_routine(emotion, goal, available_time=60, days=7):
    # (Code identical to the provided version - a good fallback)
    logger.info(f"Generating basic fallback routine for emotion={emotion}, goal={goal}")
    # ... (rest of the function code remains the same) ...
    routine_types = {
        "job_search": [ {"name": "Research Target Companies", "points": 15, "duration": 20, "description": "Identify 3 potential employers aligned with your goal."}, {"name": "Update LinkedIn Section", "points": 15, "duration": 25, "description": "Refine one section of your LinkedIn profile (e.g., summary, experience)."}, {"name": "Practice STAR Method", "points": 20, "duration": 15, "description": "Outline one experience using the STAR method for interviews."}, {"name": "Find Networking Event", "points": 10, "duration": 10, "description": "Look for one relevant online or local networking event."} ],
        "skill_building": [ {"name": "Online Tutorial (1 Module)", "points": 25, "duration": 45, "description": "Complete one module of a relevant online course/tutorial."}, {"name": "Read Industry Blog/Article", "points": 10, "duration": 15, "description": "Read and summarize one article about trends in your field."}, {"name": "Small Project Task", "points": 30, "duration": 60, "description": "Dedicate time to a specific task within a personal project."}, {"name": "Review Skill Documentation", "points": 15, "duration": 30, "description": "Read documentation or examples for a skill you're learning."} ],
        "motivation_wellbeing": [ {"name": "Mindful Reflection", "points": 10, "duration": 10, "description": "Spend 10 minutes reflecting on progress and challenges without judgment."}, {"name": "Set 1-3 Daily Intentions", "points": 10, "duration": 5, "description": "Define small, achievable goals for the day."}, {"name": "Short Break/Walk", "points": 15, "duration": 15, "description": "Take a brief break away from screens, preferably with light movement."}, {"name": "Connect with Support", "points": 20, "duration": 20, "description": "Briefly chat with a friend, mentor, or peer about your journey."} ] }
    cleaned_emotion = emotion.split(" ")[0].lower() if " " in emotion else emotion.lower()
    negative_emotions = ["unmotivated", "anxious", "confused", "overwhelmed", "discouraged", "stuck"] # Added 'stuck'
    if any(term in goal.lower() for term in ["job", "internship", "company", "freelance", "contract"]): base_type = "job_search"
    elif any(term in goal.lower() for term in ["skill", "learn", "development"]): base_type = "skill_building"
    elif "network" in goal.lower(): base_type = "job_search" # Networking often related to job search
    else: base_type = "skill_building" # Default
    include_wellbeing = cleaned_emotion in negative_emotions or "overwhelmed" in cleaned_emotion
    daily_tasks_list = []
    for day in range(1, days + 1):
        day_tasks, remaining_time, tasks_added_count = [], available_time, 0
        possible_tasks = routine_types[base_type].copy()
        if include_wellbeing: possible_tasks.extend(routine_types["motivation_wellbeing"])
        random.shuffle(possible_tasks)
        for task in possible_tasks:
            # Ensure task has duration and check remaining time
            if task.get("duration", 0) > 0 and task["duration"] <= remaining_time and tasks_added_count < 3: # Max 3 tasks/day
                day_tasks.append(task); remaining_time -= task["duration"]; tasks_added_count += 1
            if remaining_time < 10 or tasks_added_count >= 3: break # Stop if little time left or max tasks reached
        daily_tasks_list.append({"day": day, "tasks": day_tasks})
    routine = {"name": f"{days}-Day Focus Plan", "description": f"A focused {days}-day plan to help you with '{goal}', especially while feeling {cleaned_emotion}. We'll do this step-by-step!", "days": days, "daily_tasks": daily_tasks_list}
    return routine # Return dict directly

# --- Tool Implementation Functions ---
# Note: These functions now return Python dicts/strings directly.
# The main AI interaction logic will handle packaging them for Gemini API.

def generate_document_template(document_type: str, career_field: str = "", experience_level: str = "") -> Dict[str, str]:
    """Generates a basic markdown template for the specified document type."""
    logger.info(f"Executing tool: generate_document_template(type='{document_type}', field='{career_field}', exp='{experience_level}')")
    template = f"## Basic Template: {document_type}\n\n"
    template += f"**Target Field:** {career_field or 'Not specified'}\n"
    template += f"**Experience Level:** {experience_level or 'Not specified'}\n\n---\n\n"

    # Using triple quotes correctly
    if "resume" in document_type.lower():
        template += """
### Contact Information
* Name:
* Phone:
* Email:
* LinkedIn URL:
* Portfolio URL (Optional):

### Summary/Objective
* _[ 2-3 sentences summarizing your key skills, experience, and career goals, tailored to the job/field. Make it impactful! ]_

### Experience
**Company Name | Location | Job Title | Start Date – End Date**
* Accomplishment 1 (Use action verbs: Led, Managed, Developed, Increased X by Y%. Quantify results!)
* Accomplishment 2
* _[ Repeat for other relevant positions ]_

### Education
**University/Institution Name | Degree | Graduation Date (or Expected)**
* Relevant coursework, honors, activities (Optional)

### Skills
* **Technical Skills:** [ e.g., Python, Java, SQL, MS Excel, Google Analytics, Figma, AWS ]
* **Languages:** [ e.g., English (Native), Spanish (Fluent) ]
* **Other:** [ Certifications, relevant tools, methodologies like Agile/Scrum ]
"""
    elif "cover letter" in document_type.lower():
        template += """
[Your Name]
[Your Address]
[Your Phone]
[Your Email]

[Date]

[Hiring Manager Name (if known), or 'Hiring Team']
[Hiring Manager Title (if known)]
[Company Name]
[Company Address]

**Subject: Application for [Job Title] Position - [Your Name]**

Dear [Mr./Ms./Mx. Last Name or Hiring Team],

**Introduction:** State the position you're applying for and where you saw it. Express genuine enthusiasm for the role *and* the company. Briefly highlight 1-2 key qualifications that make you a perfect fit right from the start.
* _[ Example: I am writing to express my strong interest in the [Job Title] position advertised on [Platform]. With my background in [Relevant Field] and proven ability to [Key Skill Relevant to Job], I am confident I can bring significant value to [Company Name]'s mission in [Specific Area Company Works In]. ]_

**Body Paragraph(s):** This is where you connect your experience to the job description. Don't just list duties; show *impact*. Use examples (think STAR method: Situation, Task, Action, Result). Explain *why* you're drawn to *this specific company* – mention their values, projects, or recent news. Show you've done your homework!
* _[ Example: In my previous role at [Previous Company], I spearheaded a project that [Quantifiable achievement relevant to new job], demonstrating my expertise in [Skill required by new job]. I admire [Company Name]'s innovative approach to [Specific Company Initiative], and I believe my skills in [Another Relevant Skill] align perfectly with the requirements of this role and your company culture. ]_

**Conclusion:** Reiterate your strong interest and suitability. Briefly summarize your key selling points. State your call to action confidently (e.g., "I am eager to discuss how my skills can benefit [Company Name]..."). Thank the reader for their time and consideration.
* _[ Example: Thank you for considering my application. My attached resume provides further detail on my qualifications. I am excited about the potential to contribute to your team and look forward to hearing from you soon regarding an interview. ]_

Sincerely,

[Your Typed Name]
"""
    elif "linkedin summary" in document_type.lower():
         template += """
### LinkedIn Summary / About Section Template

**Headline:** [ Make this keyword-rich and concise! Who are you professionally? What's your focus? e.g., 'Software Engineer specializing in AI & Cloud | Python | Ex-Google | Building Innovative Solutions' OR 'Marketing Manager | Driving Growth for SaaS Startups | Content Strategy & Demand Generation' ]

**About Section:**

* **[ Paragraph 1: Hook & Overview ]** Start with a compelling statement about your passion, mission, or core expertise. Who are you, what do you do, and what drives you? Use keywords relevant to your target roles/industry. Think of this as your elevator pitch.
* **[ Paragraph 2: Key Skills & Experience Highlights ]** Detail your core competencies, both technical and soft skills. Mention significant experiences, types of projects, or industries you've worked in. Quantify achievements whenever possible (e.g., 'Managed budgets up to $X', 'Increased user engagement by Y%'). Tailor this to attract your desired audience (recruiters, clients, collaborators).
* **[ Paragraph 3: Career Goals & What You're Seeking (Optional but Recommended) ]** Briefly state your current career aspirations. What kind of opportunities, connections, or challenges are you looking for? Be specific if possible (e.g., 'Seeking opportunities in AI ethics', 'Open to collaborating on open-source projects').
* **[ Paragraph 4: Call to Action / Personality (Optional) ]** You might invite relevant connections, mention personal interests related to your field, or add a touch of personality to make you more memorable. What makes you, you?
* **[ Specialties/Keywords: ]** _[ List 5-15 key terms separated by commas or bullet points that recruiters might search for. e.g., Project Management, Data Analysis, Agile Methodologies, Content Strategy, Python, Java, Cloud Security, UX/UI Design, B2B Marketing ]_
"""
    else:
         template += "[ Template structure for this document type will be provided here. Let me know what you need! ]"

    # Return as a dictionary for Gemini function response
    return {"template_markdown": template}

def create_personalized_routine(emotion: str, goal: str, available_time_minutes: int = 60, routine_length_days: int = 7) -> Dict[str, Any]:
    """Creates a personalized routine, trying AI first, then falling back to basic."""
    logger.info(f"Executing tool: create_personalized_routine(emo='{emotion}', goal='{goal}', time={available_time_minutes}, days={routine_length_days})")
    # In a real scenario, you might try a *brief* internal AI call here first
    # for a more nuanced routine before falling back. For now, use fallback directly.
    logger.warning("Using basic fallback for create_personalized_routine for robustness.")
    try:
        routine = generate_basic_routine(emotion, goal, available_time_minutes, routine_length_days)
        if not routine or not isinstance(routine, dict): # generate_basic_routine returns a dict
             raise ValueError("Basic routine generation failed to return a valid dictionary.")
        # Add a supportive message within the routine data
        routine['support_message'] = f"Hey, I know feeling {emotion} while aiming for '{goal}' can be tough. We've got this routine to help break it down. One step at a time, okay? You're doing great just by planning!"
        return routine # Return the dict directly
    except Exception as e:
        logger.error(f"Error in create_personalized_routine fallback: {e}")
        # Return an error structure
        return {"error": f"Couldn't create a routine right now due to an error: {e}. Maybe try simplifying the goal or adjusting the time?"}

def analyze_resume(resume_text: str, career_goal: str) -> Dict[str, Any]:
    """Provides analysis of the resume (Simulated - AI analysis would replace this)."""
    logger.info(f"Executing tool: analyze_resume(goal='{career_goal}', len={len(resume_text)})")
    # !! Placeholder Analysis !! Replace with actual AI call in production if desired,
    # but the main AI handles this via system prompt now. This function is for the TOOL call.
    logger.warning("Using placeholder analysis for analyze_resume tool.")
    analysis = {
        "strengths": [
            "Clear contact information.",
            "Uses some action verbs.",
            f"Mentions skills relevant to '{career_goal}' (needs verification)."
            ],
        "areas_for_improvement": [
            "Quantify achievements more (e.g., 'Increased X by Y%').",
            f"Ensure skills section is tailored specifically for '{career_goal}' roles.",
            "Check for consistent formatting and tense.",
            "Add a compelling summary/objective statement at the top."
            ],
        "format_feedback": "Overall format seems clean, but check for consistency.",
        "content_feedback": f"Content shows potential relevance to '{career_goal}', but needs more specific examples and quantified results.",
        "keyword_suggestions": ["Review job descriptions for "+ career_goal +" and incorporate relevant keywords like 'Keyword1', 'Keyword2', 'Keyword3'."],
        "next_steps": [
            "Revise bullet points under 'Experience' to include measurable results.",
            "Tailor the Summary/Objective and Skills sections for each application.",
            "Proofread carefully for any typos or grammatical errors."
            ]
        }
    return {"analysis": analysis} # Return dict

def analyze_portfolio(portfolio_description: str, career_goal: str, portfolio_url: str = "") -> Dict[str, Any]:
    """Provides analysis of the portfolio (Simulated - AI analysis would replace this)."""
    logger.info(f"Executing tool: analyze_portfolio(goal='{career_goal}', url='{portfolio_url}', desc_len={len(portfolio_description)})")
    # !! Placeholder Analysis !!
    logger.warning("Using placeholder analysis for analyze_portfolio tool.")
    analysis = {
        "alignment_with_goal": f"Based on the description, seems moderately aligned with '{career_goal}'. Review specific projects.",
        "strengths": [
            "Includes a variety of projects (based on description).",
            "Clear description provided helps understand context."
             ] + (["Portfolio URL provided for direct review."] if portfolio_url else []),
        "areas_for_improvement": [
            f"Ensure project descriptions clearly link skills used to '{career_goal}' requirements.",
            "Consider adding 1-2 detailed case studies for key projects.",
            "Make sure navigation is intuitive (if URL provided)."
            ],
        "presentation_feedback": "Description is helpful. " + (f"Review URL ({portfolio_url}) for visual appeal and clarity." if portfolio_url else "Consider creating an online portfolio if you don't have one."),
        "next_steps": [
            "Highlight 2-3 projects most relevant to '{career_goal}' prominently.",
            "Get feedback from peers or mentors in your target field.",
            "Ensure contact information is easily accessible."
            ]
        }
    return {"analysis": analysis} # Return dict

def extract_and_rate_skills_from_resume(resume_text: str, max_skills: int = 8) -> Dict[str, Any]:
    """Extracts and rates skills from resume text (Simulated - AI could do this better)."""
    logger.info(f"Executing tool: extract_skills(len={len(resume_text)}, max={max_skills})")
    # !! Placeholder Extraction !!
    logger.warning("Using placeholder skill extraction for extract_and_rate_skills_from_resume tool.")
    possible = ["Python", "Java", "JavaScript", "Project Management", "Communication", "Data Analysis", "Teamwork", "Leadership", "SQL", "React", "Customer Service", "Problem Solving", "Cloud Computing", "AWS", "Azure", "GCP", "Agile Methodologies", "Machine Learning", "Marketing", "SEO", "Content Creation"]
    found = []
    resume_lower = resume_text.lower()
    # Basic keyword spotting
    for skill in possible:
        # Use word boundaries to avoid matching substrings (e.g., 'java' in 'javascript')
        if re.search(r'\b' + re.escape(skill.lower()) + r'\b', resume_lower):
             # Simulate rating based on frequency or context (very basic here)
             score = random.randint(4, 9)
             if "lead" in resume_lower or "manage" in resume_lower or "develop" in resume_lower:
                 score = min(10, score + random.randint(0, 1)) # Slightly boost if leadership words present
             found.append({"name": skill, "score": score})
        if len(found) >= max_skills: break

    # Fallback if nothing found but resume is substantial
    if not found and len(resume_text) > 100:
        found = [
            {"name": "Communication", "score": random.randint(5,8)},
            {"name": "Teamwork", "score": random.randint(5,8)},
            {"name": "Problem Solving", "score": random.randint(5,8)},
        ]
    logger.info(f"Extracted skills (placeholder): {[s['name'] for s in found]}")
    return {"skills": found[:max_skills]} # Return dict


# --- NEW: Serper Web Search Implementation ---
def search_web_serper(search_query: str, search_type: str = 'general', location: str = None) -> Dict[str, Any]:
    """Performs a web search using the Serper API."""
    logger.info(f"Executing tool: search_web_serper(query='{search_query}', type='{search_type}', loc='{location}')")
    if not SERPER_API_KEY:
        logger.error("SERPER_API_KEY not configured.")
        return {"error": "Web search functionality is not configured."}

    api_url = "https://google.serper.dev/search"
    payload = json.dumps({
        "q": search_query,
        "location": location if location else None, # Add location if provided
        # Add other params like 'num' for number of results if needed
    })
    headers = {
        'X-API-KEY': SERPER_API_KEY,
        'Content-Type': 'application/json'
    }

    try:
        response = requests.post(api_url, headers=headers, data=payload, timeout=10) # Added timeout
        response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
        results = response.json()

        # Extract relevant information based on search type (simplified)
        extracted_results = []
        if search_type == 'jobs':
            # Look for job postings, titles, companies
            if 'jobs' in results: # Serper might have a dedicated jobs structure
                 for job in results['jobs'][:5]: # Limit to top 5
                      extracted_results.append({
                          "title": job.get('title'),
                          "company": job.get('company_name'),
                          "location": job.get('location'),
                          "link": job.get('link') # Assuming Serper provides a direct link
                      })
            elif 'organic' in results: # Fallback to organic results
                 for item in results['organic'][:5]:
                     # Basic check if title sounds like a job
                     if any(kw in item.get('title', '').lower() for kw in ['hiring', 'job', 'career', 'vacancy']):
                        extracted_results.append({
                             "title": item.get('title'),
                             "snippet": item.get('snippet'),
                             "link": item.get('link')
                         })
        elif search_type in ['courses', 'skills']:
             # Extract organic results (titles, links, snippets)
             if 'organic' in results:
                  for item in results['organic'][:5]:
                      extracted_results.append({
                          "title": item.get('title'),
                          "snippet": item.get('snippet'),
                          "link": item.get('link')
                      })
        else: # General search
             if 'organic' in results:
                  for item in results['organic'][:3]: # Limit general results
                       extracted_results.append({
                          "title": item.get('title'),
                          "snippet": item.get('snippet'),
                          "link": item.get('link')
                       })
            # Maybe include answer box if relevant?
             if 'answerBox' in results:
                 extracted_results.insert(0, { # Put answer box first
                     "type": "Answer Box",
                     "title": results['answerBox'].get('title'),
                     "snippet": results['answerBox'].get('snippet') or results['answerBox'].get('answer'),
                     "link": results['answerBox'].get('link')
                 })


        logger.info(f"Serper search successful for '{search_query}'. Found {len(extracted_results)} relevant items.")
        return {"search_results": extracted_results} # Return dict

    except requests.exceptions.RequestException as e:
        logger.error(f"Serper API request failed: {e}")
        return {"error": f"Web search failed: {e}"}
    except Exception as e:
        logger.error(f"Error processing Serper response: {e}")
        return {"error": "Failed to process web search results."}


# --- AI Interaction Logic (Using Google Gemini) ---
def get_ai_response(user_id: str, user_input: str) -> str:
    """Gets response from Google Gemini, handling context, system prompt, and function calls."""
    logger.info(f"Getting AI response for user {user_id}. Input: '{user_input[:100]}...'")

    if not gemini_model:
        logger.error("Gemini model not initialized.")
        return "I'm sorry, my AI core isn't available right now. Please check the configuration."

    try:
        user_profile = get_user_profile(user_id)
        if not user_profile:
             logger.error(f"Failed profile retrieval for {user_id}.")
             return "Uh oh, I couldn't access your profile details right now. Let's try again in a moment?"

        # **INVESTOR NOTE:** The system prompt defines Aishura's unique empathetic persona and strategic approach.
        # This blend of emotional intelligence and career coaching is our key differentiator.
        current_emotion_display = user_profile.get('current_emotion', 'how you feel')
        user_name = user_profile.get('name', 'there')
        career_goal = user_profile.get('career_goal', 'your goals')
        location = user_profile.get('location', 'your area')
        industry = user_profile.get('industry', 'your field')
        exp_level = user_profile.get('experience_level', 'your experience level')

        system_prompt = f"""
        You are Aishura, an advanced AI career assistant built on Google's Gemini model. Your core mission is to provide **empathetic, supportive, and highly personalized career guidance**. You are talking to {user_name}.

        **Your Persona & Communication Style:**
        * **Empathetic & Validating:** ALWAYS acknowledge the user's feelings ({current_emotion_display}). Use phrases like "I hear you," "It sounds like things are tough/exciting," "That makes total sense," "I get it." Validate their experience.
        * **Collaborative & Supportive:** Use "we," "us," "together." Frame guidance as a partnership. Phrases: "Okay, let's figure this out together.", "We can tackle this step-by-step.", "I'm here to help you navigate this."
        * **Positive & Action-Oriented:** While validating struggles, gently guide towards positive next steps. Focus on what *can* be done. Be realistic but hopeful.
        * **Personalized:** Reference the user's profile details subtly: name ({user_name}), goal ({career_goal}), location ({location}), industry ({industry}), experience ({exp_level}).
        * **Concise & Clear:** Use markdown for readability (lists, bolding). Avoid jargon. Get to the point while remaining warm.

        **Core Functionality - How to Respond:**
        1.  **Acknowledge & Empathize:** Start by acknowledging their input and expressed emotion (e.g., "Hey {user_name}, I hear that you're feeling {current_emotion_display}. It's completely understandable given [mention context from user input or goal].").
        2.  **Address the Query Directly:** Answer their specific question or respond to their statement clearly.
        3.  **Leverage Tools Strategically:**
            * **Proactive Suggestions:** If they mention needing a resume, cover letter, or LinkedIn help, suggest using `generate_document_template`. If they feel stuck or need structure, suggest `create_personalized_routine`. If they mention their resume or portfolio, offer to analyze it (`analyze_resume`, `analyze_portfolio`). If they want to understand their skills better from their resume, suggest `extract_and_rate_skills_from_resume`.
            * **Web Search (`search_jobs_courses_skills`):**
                * **Use ONLY when the user explicitly asks for job openings, courses, skill resources, or specific company information.**
                * Construct a specific `search_query` based on their request, `career_goal`, `location`, `industry`, and potentially `areas_for_development`.
                * Specify `search_type` ('jobs', 'courses', 'skills', 'general').
                * Include `location` if relevant and available.
                * **Crucially:** Present the search results clearly. Mention they are *live* results but listings change quickly. Don't just dump links; summarize findings. E.g., "Okay, I found a few promising [type] results for you based on our search:"
            * **Do NOT Use Tools If:** The user is just chatting, venting, or asking for general advice that doesn't map directly to a tool's function. Handle these conversationally.
        4.  **Synthesize Tool Results:** When a tool (especially search) provides results, don't just output the raw data. Explain *why* these results are relevant to the user and their goals. Integrate the findings into your conversational response.
        5.  **Maintain Context:** Remember the conversation flow and user profile details.
        6.  **Handle Errors Gracefully:** If a tool fails or returns an error, apologize and explain simply (e.g., "Hmm, I couldn't fetch the [tool purpose] just now. Maybe we can try searching differently, or focus on [alternative action]?"). Do not show technical error messages to the user.

        **Example Snippets:**
        * "I got you. Feeling {emotion} is tough, but we'll break down this {goal} together."
        * "Okay, based on your goal of {goal} and feeling {emotion}, how about we create a manageable routine? I can use the `create_personalized_routine` tool if you'd like."
        * "Finding jobs can be draining. Want me to run a quick search for '{goal}' roles in {location} using the `search_jobs_courses_skills` tool?"
        """

        # Prepare message history for Gemini API
        # Convert stored format {role: 'user'/'model'/'function', parts/response} to API format
        gemini_history = []
        for msg in user_profile.get('chat_history', []):
            if msg['role'] == 'function':
                 # Convert tool/function response format
                 gemini_history.append(genai.protos.Content(
                     parts=[genai.protos.Part(
                         function_response=genai.protos.FunctionResponse(name=msg['name'], response=msg['response'])
                     )]
                 ))
            elif 'parts' in msg: # Should be 'user' or 'model'
                 # Ensure parts format is correct (list of Part objects)
                 # Assuming stored parts are like [{'text': '...'}]
                try:
                    api_parts = [genai.protos.Part(text=p['text']) for p in msg.get('parts', []) if 'text' in p]
                    if api_parts: # Only add if there are valid parts
                        gemini_history.append(genai.protos.Content(role=msg['role'], parts=api_parts))
                except Exception as e:
                    logger.warning(f"Skipping invalid message structure in history: {msg} - Error: {e}")


        # --- Main AI Interaction Loop (Handles Function Calling) ---
        current_input_parts = [genai.protos.Part(text=user_input)]
        prompt_content = genai.protos.Content(role='user', parts=current_input_parts)
        full_prompt_history = gemini_history + [prompt_content]

        logger.info(f"Sending {len(full_prompt_history)} history entries to Gemini model {MODEL_ID}.")

        # **INVESTOR NOTE:** The use of Gemini 1.5 Flash ensures rapid responses, crucial for user engagement.
        # The integrated function calling allows seamless access to specialized tools and live data (Serper).
        try:
            response = gemini_model.generate_content(
                full_prompt_history,
                generation_config=genai.types.GenerationConfig(temperature=0.7, max_output_tokens=1500),
                tools=tools_list_gemini, # Pass the list of function declarations
                tool_config=genai.types.ToolConfig(function_calling_config="AUTO"), # Let model decide when to call functions
                system_instruction=genai.protos.Content(parts=[genai.protos.Part(text=system_prompt)]) # System prompt passed here
            )

            response_message = response.candidates[0].content
            finish_reason = response.candidates[0].finish_reason

        except google_exceptions.ResourceExhausted as e:
             logger.error(f"Google API Quota Error: {e}")
             return "I'm experiencing high demand right now. Let's try that again in a moment?"
        except google_exceptions.GoogleAPIError as e:
             logger.error(f"Google API Error: {e}")
             return f"Sorry, there was an issue connecting to my AI brain ({e.message}). Could you try again?"
        except Exception as e:
             logger.exception(f"Unexpected error during Gemini API call: {e}")
             return "Oh dear, something unexpected happened on my end. Let's pause and retry?"


        # Check if the model decided to call a function
        if response_message.parts[0].function_call.name:
            function_call = response_message.parts[0].function_call
            func_name = function_call.name
            func_args = dict(function_call.args) # Arguments are provided as a dict

            logger.info(f"Gemini requested tool call: '{func_name}' with args: {func_args}")

            # Add the user message and the assistant's function call request to history
            add_chat_message(user_id, "user", user_input) # Store user input as text
            add_chat_message(user_id, "model", [{'text': f"Thinking... (using tool {func_name})"}]) # Placeholder text, real call stored below

            # --- Call the appropriate Python function ---
            available_functions = {
                "generate_document_template": generate_document_template,
                "create_personalized_routine": create_personalized_routine,
                "analyze_resume": analyze_resume,
                "analyze_portfolio": analyze_portfolio,
                "extract_and_rate_skills_from_resume": extract_and_rate_skills_from_resume,
                "search_jobs_courses_skills": search_web_serper, # Add Serper function
            }

            function_to_call = available_functions.get(func_name)
            function_response_content = None

            if function_to_call:
                try:
                    # Special handling for functions needing profile context or saving files
                    if func_name == "analyze_resume":
                        if 'career_goal' not in func_args: func_args['career_goal'] = career_goal
                        save_user_resume(user_id, func_args.get('resume_text', '')) # Save resume if text provided
                    elif func_name == "analyze_portfolio":
                        if 'career_goal' not in func_args: func_args['career_goal'] = career_goal
                        save_user_portfolio(user_id, func_args.get('portfolio_url', ''), func_args.get('portfolio_description', ''))
                    elif func_name == "search_jobs_courses_skills":
                        # Ensure location from profile is used if not specified in args
                         if 'location' not in func_args or not func_args['location']:
                             func_args['location'] = location if location != 'your area' else None # Pass None if default

                    # Call the function with unpacked arguments
                    logger.info(f"Calling function '{func_name}' with args: {func_args}")
                    function_response_content = function_to_call(**func_args) # Expecting a dict or string
                    logger.info(f"Function '{func_name}' returned type: {type(function_response_content)}")

                    # Prepare response structure for Gemini
                    tool_response_for_api = genai.protos.Part(
                        function_response=genai.protos.FunctionResponse(
                            name=func_name,
                            response={'content': function_response_content} # Gemini expects response in a 'content' key
                        )
                    )
                    # Store tool call result in DB
                    add_chat_message(user_id, 'function', {'name': func_name, 'response': {'content': function_response_content}})


                except TypeError as e:
                     logger.error(f"Argument mismatch for function {func_name}. Args: {func_args}, Error: {e}")
                     error_response = {"error": f"Internal error: Tool '{func_name}' called with incorrect arguments."}
                     tool_response_for_api = genai.protos.Part(function_response=genai.protos.FunctionResponse(name=func_name, response={'content': error_response}))
                     add_chat_message(user_id, 'function', {'name': func_name, 'response': {'content': error_response}})
                except Exception as e:
                    logger.exception(f"Error executing function {func_name}: {e}")
                    error_response = {"error": f"Sorry, I encountered an error while trying to use the '{func_name}' tool. Please try again or ask differently."}
                    # Prepare error response for Gemini
                    tool_response_for_api = genai.protos.Part(
                        function_response=genai.protos.FunctionResponse(
                            name=func_name,
                            response={'content': error_response} # Send error back to model
                        )
                    )
                    # Store error result in DB
                    add_chat_message(user_id, 'function', {'name': func_name, 'response': {'content': error_response}})

            else:
                logger.warning(f"Function {func_name} not implemented.")
                error_response = {"error": f"Tool '{func_name}' is not available."}
                tool_response_for_api = genai.protos.Part(
                    function_response=genai.protos.FunctionResponse(
                        name=func_name,
                        response={'content': error_response}
                    )
                )
                add_chat_message(user_id, 'function', {'name': func_name, 'response': {'content': error_response}})


            # --- Send function response back to the model ---
            logger.info(f"Sending function response for '{func_name}' back to Gemini.")
            try:
                second_response = gemini_model.generate_content(
                    # History includes original user prompt, model's func call, and the func response part
                    gemini_history + [prompt_content, response_message, genai.protos.Content(parts=[tool_response_for_api])],
                    generation_config=genai.types.GenerationConfig(temperature=0.7, max_output_tokens=1500),
                    system_instruction=genai.protos.Content(parts=[genai.protos.Part(text=system_prompt)]) # Re-send system prompt
                )
                final_response_text = second_response.candidates[0].content.parts[0].text
                logger.info("Received final response after tool call.")

            except google_exceptions.GoogleAPIError as e:
                 logger.error(f"Google API Error on second call: {e}")
                 final_response_text = f"Sorry, there was an issue processing the results from the tool ({e.message}). Let's try again?"
            except Exception as e:
                 logger.exception(f"Unexpected error during second Gemini call: {e}")
                 final_response_text = "Oh dear, something went wrong while processing the tool's results. Could we try that step again?"

            # Store final assistant response
            add_chat_message(user_id, "model", final_response_text)
            return final_response_text

        else: # No function call, just a text response
            logger.info("No tool call requested by Gemini.")
            final_response_text = response_message.parts[0].text
            # Store user input and assistant response
            add_chat_message(user_id, "user", user_input)
            add_chat_message(user_id, "model", final_response_text)
            return final_response_text

    except Exception as e:
        logger.exception(f"Unexpected error in get_ai_response: {e}")
        return "An unexpected error occurred. Please try again later."


# --- Recommendation Generation (Placeholder - Keep disabled or implement simple keyword based) ---
def gen_recommendations_simple(user_id):
    """Generate simple recommendations based on profile keywords (Placeholder)."""
    logger.info(f"Generating simple recommendations for user {user_id}")
    profile = get_user_profile(user_id)
    recs = []
    goal = profile.get('career_goal', '').lower()
    emotion = profile.get('current_emotion', '').lower()

    # Simple keyword triggers
    if 'job' in goal or 'internship' in goal:
        recs.append({"title": "Refine Resume", "description": f"Tailor your resume for '{goal}' roles. Use keywords from job descriptions.", "priority": "High", "action_type": "Job Application"})
        recs.append({"title": "Practice Interviewing", "description": "Use the STAR method to prepare answers for common behavioral questions.", "priority": "Medium", "action_type": "Skill Building"})
        recs.append({"title": "Network Actively", "description": f"Connect with people in '{profile.get('industry', 'your')}' industry on LinkedIn or attend virtual events.", "priority": "Medium", "action_type": "Networking"})

    if 'skill' in goal:
        recs.append({"title": "Identify Learning Resources", "description": f"Find online courses (Coursera, Udemy, edX) or tutorials for the skills needed for '{goal}'.", "priority": "High", "action_type": "Skill Building"})
        recs.append({"title": "Start a Small Project", "description": f"Apply newly learned skills in a personal project to build portfolio evidence.", "priority": "Medium", "action_type": "Skill Building"})

    if emotion in ["anxious", "overwhelmed", "stuck", "unmotivated", "discouraged"]:
         recs.append({"title": "Focus on Small Wins", "description": "Break down larger tasks into very small, achievable steps. Celebrate completing them!", "priority": "High", "action_type": "Wellbeing"})
         recs.append({"title": "Schedule Breaks", "description": "Ensure you take regular short breaks to avoid burnout. Step away from the screen.", "priority": "Medium", "action_type": "Wellbeing"})

    # Add recommendations to user profile (limited number)
    if recs:
        # Only add if substantially different from latest pending ones
        current_recs = profile.get('recommendations', [])
        pending_titles = {r['recommendation'].get('title') for r in current_recs if r.get('status') == 'pending'}
        new_recs_to_add = [r for r in recs if r.get('title') not in pending_titles]

        for rec in new_recs_to_add[:3]: # Add max 3 new ones
            add_recommendation_to_user(user_id, rec)

    return # Returns None, updates DB directly


# --- Chart and Visualization Functions (Keep as is) ---
# (create_emotion_chart, create_progress_chart, create_routine_completion_gauge, create_skill_radar_chart remain unchanged)
# ... (Previous chart functions code - no changes needed here) ...
def create_emotion_chart(user_id):
    user_profile = get_user_profile(user_id); records = user_profile.get('daily_emotions', [])
    if not records: fig = go.Figure(); fig.add_annotation(text="No emotion data yet. How are you feeling today?", showarrow=False); fig.update_layout(title="Your Emotional Journey"); return fig
    # Added more emotions to map
    vals = {"Unmotivated": 1, "Discouraged": 1.5, "Stuck": 2, "Anxious": 2.5, "Confused": 3, "Overwhelmed": 3.5, "Hopeful": 4.5, "Focused": 5, "Excited": 6}
    dates = [datetime.fromisoformat(r['date']) for r in records]; scores = [vals.get(r['emotion'], 3) for r in records]; names = [r['emotion'] for r in records]
    df = pd.DataFrame({'Date': dates, 'Score': scores, 'Emotion': names}).sort_values('Date')
    fig = px.line(df, x='Date', y='Score', markers=True, labels={"Score": "State"}, title="Your Emotional Journey")
    fig.update_traces(hovertemplate='%{x|%Y-%m-%d %H:%M}<br>Feeling: %{text}', text=df['Emotion']); fig.update_yaxes(tickvals=list(vals.values()), ticktext=list(vals.keys())); return fig

def create_progress_chart(user_id):
    user_profile = get_user_profile(user_id); tasks = user_profile.get('completed_tasks', [])
    if not tasks: fig = go.Figure(); fig.add_annotation(text="No tasks completed yet. Let's add one!", showarrow=False); fig.update_layout(title="Progress Points"); return fig
    tasks.sort(key=lambda x: datetime.fromisoformat(x['date']))
    dates, points, labels, cum_pts = [], [], [], 0; pts_task = user_profile.get('progress_points', 0) # Start from current total
    task_dates = {} # Track points per day
    for task in tasks:
        task_date_str = datetime.fromisoformat(task['date']).strftime('%Y-%m-%d')
        pts = task.get('points', random.randint(10, 25)) # Use stored points if available
        if task_date_str not in task_dates: task_dates[task_date_str] = {'date': datetime.fromisoformat(task['date']).date(), 'points': 0, 'tasks': []}
        task_dates[task_date_str]['points'] += pts
        task_dates[task_date_str]['tasks'].append(task['task'])

    # Aggregate points daily for chart
    sorted_dates = sorted(task_dates.keys())
    cumulative_points = 0
    chart_dates, chart_points, chart_tasks = [], [], []
    for date_str in sorted_dates:
        day_data = task_dates[date_str]
        cumulative_points += day_data['points']
        chart_dates.append(day_data['date'])
        chart_points.append(cumulative_points)
        chart_tasks.append("<br>".join(day_data['tasks'])) # Combine tasks for hover

    if not chart_dates: # Handle case if somehow no dates processed
         fig = go.Figure(); fig.add_annotation(text="Error processing task data.", showarrow=False); fig.update_layout(title="Progress Points"); return fig


    df = pd.DataFrame({'Date': chart_dates, 'Points': chart_points, 'Tasks': chart_tasks})
    fig = px.line(df, x='Date', y='Points', markers=True, title="Progress Journey"); fig.update_traces(hovertemplate='%{x|%Y-%m-%d}<br>Points: %{y}<br>Tasks:<br>%{text}', text=df['Tasks']); return fig


def create_routine_completion_gauge(user_id):
    user_profile = get_user_profile(user_id); routines = user_profile.get('routine_history', [])
    if not routines: fig = go.Figure(go.Indicator(mode="gauge", value=0, title={'text': "Active Routine"})); fig.add_annotation(text="No routine active. Create one?", showarrow=False); return fig
    latest = routines[0]; completion = latest.get('completion', 0); name = latest.get('routine', {}).get('name', 'Routine')
    fig = go.Figure(go.Indicator(mode="gauge+number", value=completion, domain={'x': [0, 1], 'y': [0, 1]}, title={'text': f"{name} (%)"},
        gauge={'axis': {'range': [0, 100]}, 'bar': {'color': "cornflowerblue"}, 'bgcolor': "white", 'steps': [{'range': [0, 50], 'color': 'whitesmoke'}, {'range': [50, 80], 'color': 'lightgray'}], 'threshold': {'line': {'color': "green", 'width': 4}, 'thickness': 0.75, 'value': 90}})); return fig

def create_skill_radar_chart(user_id):
    logger.info(f"Creating skill chart for {user_id}"); user_profile = get_user_profile(user_id); path = user_profile.get('resume_path')
    if not path or not os.path.exists(path): logger.warning("No resume found for skill chart."); fig = go.Figure(); fig.add_annotation(text="Upload or Analyze Resume for Skill Chart", showarrow=False); fig.update_layout(title="Identified Skills"); return fig
    try:
        with open(path, 'r', encoding='utf-8') as f: text = f.read()
        # Use the tool function to get skills (even if simulated)
        skills_data = extract_and_rate_skills_from_resume(resume_text=text) # Returns a dict
        if 'skills' in skills_data and skills_data['skills']:
            skills = skills_data['skills'][:8] # Limit to 8 for readability
            cats = [s['name'] for s in skills]; vals = [s['score'] for s in skills]
            if len(cats) < 3: # Radar needs >= 3 points
                 fig = go.Figure(); fig.add_annotation(text="Need at least 3 skills identified for radar chart.", showarrow=False); fig.update_layout(title="Identified Skills"); return fig

            # Ensure the plot loops back
            if len(cats) > 2:
                cats.append(cats[0])
                vals.append(vals[0])

            fig = go.Figure();
            fig.add_trace(go.Scatterpolar(
                r=vals,
                theta=cats,
                fill='toself',
                name='Skills',
                hovertemplate='Skill: %{theta}<br>Score: %{r}<extra></extra>' # Custom hover
            ))
            fig.update_layout(
                 polar=dict(radialaxis=dict(visible=True, range=[0, 10], showline=False, ticksuffix=' pts')), # Added units
                 showlegend=False,
                 title="Skill Assessment (from Resume)"
            )
            logger.info(f"Created radar chart with {len(skills)} skills."); return fig
        else: logger.warning("No skills extracted for chart."); fig = go.Figure(); fig.add_annotation(text="No skills extracted from resume yet.", showarrow=False); fig.update_layout(title="Identified Skills"); return fig
    except Exception as e: logger.exception(f"Error creating skill chart: {e}"); fig = go.Figure(); fig.add_annotation(text="Error analyzing skills.", showarrow=False); fig.update_layout(title="Identified Skills"); return fig


# --- Gradio Interface Components ---
# **INVESTOR NOTE:** The Gradio interface provides an accessible and interactive front-end.
# We prioritize a clean UX, focusing on the chat interaction while making powerful tools easily accessible.
def create_interface():
    """Create the Gradio interface for Aishura v3"""
    # Use a persistent session ID or implement user login for production
    session_user_id = str(uuid.uuid4()) # Simple session ID for demo purposes
    logger.info(f"Initializing Gradio interface for session user ID: {session_user_id}")
    get_user_profile(session_user_id) # Initialize profile if it doesn't exist

    # --- Event Handlers ---
    def welcome(name, location, emotion, goal, industry, exp_level, work_style):
        logger.info(f"Welcome: name='{name}', loc='{location}', emo='{emotion}', goal='{goal}', industry='{industry}', exp='{exp_level}', work='{work_style}'")
        if not all([name, location, emotion, goal]):
            # Basic validation
            return ("Please fill in your Name, Location, Emotion, and Goal to get started!", gr.update(visible=True), gr.update(visible=False), gr.update(), gr.update(), gr.update(), gr.update(), gr.update())

        # Clean goal text (remove emoji if present)
        cleaned_goal = goal.rsplit(" ", 1)[0] if goal[-1].isnumeric() == False and goal[-2] == " " else goal

        # Update profile with initial info
        profile_updates = {
            "name": name,
            "location": location,
            "career_goal": cleaned_goal,
            "industry": industry,
            "experience_level": exp_level,
            "preferred_work_style": work_style
        }
        update_user_profile(session_user_id, profile_updates)
        add_emotion_record(session_user_id, emotion) # Add initial emotion

        # **INVESTOR NOTE:** The initial interaction immediately personalizes the experience and sets an empathetic tone.
        initial_input = f"Hi Aishura! I'm {name} from {location}. I'm focusing on '{cleaned_goal}' in the {industry} industry ({exp_level}, preferring {work_style} work). Right now, I'm feeling {emotion}. Can you help me get started?"

        # Get the first AI response
        ai_response = get_ai_response(session_user_id, initial_input)

        # Prepare chat history display for Gradio
        # Gemini uses {role: 'user'/'model', parts: [{'text': '...'}]}
        # Gradio chatbot expects [[user_msg, assistant_msg], ...]
        initial_chat_display = [[initial_input, ai_response]]

        # Update charts
        e_fig, p_fig, r_fig, s_fig = create_emotion_chart(session_user_id), create_progress_chart(session_user_id), create_routine_completion_gauge(session_user_id), create_skill_radar_chart(session_user_id)
        recs_md = display_recommendations(session_user_id) # Display initial recommendations

        return (
            gr.update(value=initial_chat_display), # Update chatbot
            gr.update(visible=False), # Hide welcome group
            gr.update(visible=True), # Show main interface
            gr.update(value=e_fig), gr.update(value=p_fig), gr.update(value=r_fig), gr.update(value=s_fig), # Update plots
            gr.update(value=recs_md) # Update recommendations markdown
        )

    def chat_submit(message_text, history_list_list):
        """Handles chatbot submission, gets AI response, updates history and recommendations."""
        logger.info(f"Chat submit for {session_user_id}: '{message_text[:50]}...'")
        if not message_text:
            return history_list_list, "" # Return current history and clear textbox

        # Append user message to Gradio display history immediately
        history_list_list.append([message_text, None]) # Add placeholder for assistant response
        yield history_list_list, "" # Update UI immediately, clear textbox

        # Get AI response (which also updates the internal DB history)
        ai_response_text = get_ai_response(session_user_id, message_text)

        # Update the placeholder in Gradio display history with the actual response
        history_list_list[-1][1] = ai_response_text

        # Generate and display recommendations
        gen_recommendations_simple(session_user_id) # Generate based on latest interaction (simple version)
        recs_md = display_recommendations(session_user_id)

        # Update UI again with the final response and recommendations
        yield history_list_list, gr.update(value=recs_md)


    # --- Tool Interface Handlers (Manual Trigger from UI) ---
    # These call the *implementation* functions directly, bypassing AI unless needed internally
    def generate_template_interface_handler(doc_type, career_field, experience):
        logger.info(f"Manual Template UI: type='{doc_type}'")
        # Call implementation directly
        result_dict = generate_document_template(doc_type, career_field, experience)
        return result_dict.get('template_markdown', "Error generating template.")

    def create_routine_interface_handler(emotion, goal, time_available, days):
        logger.info(f"Manual Routine UI: emo='{emotion}', goal='{goal}'")
        cleaned_emotion = emotion.split(" ")[0] if " " in emotion else emotion
        # Call implementation directly (uses fallback basic generator)
        result_dict = create_personalized_routine(cleaned_emotion, goal, int(time_available), int(days))

        if "error" in result_dict:
            return f"Error: {result_dict['error']}", gr.update()

        # Save routine to user profile
        add_routine_to_user(session_user_id, result_dict)

        # Format for display
        md = f"# {result_dict.get('name', 'Your Routine')}\n\n"
        md += f"_{result_dict.get('support_message', result_dict.get('description', ''))}_\n\n---\n\n" # Use support message
        for day in result_dict.get('daily_tasks', []):
            md += f"## Day {day.get('day', '?')}\n"
            tasks = day.get('tasks', [])
            if not tasks:
                md += "- Rest day or catch-up.\n"
            else:
                for task in tasks:
                    md += f"- **{task.get('name', 'Task')}** ({task.get('duration', '?')} min)\n"
                    md += f"  - _{task.get('description', '...')}_\n"
            md += "\n"

        gauge = create_routine_completion_gauge(session_user_id)
        return md, gr.update(value=gauge) # Update markdown and gauge plot

    def analyze_resume_interface_handler(resume_file):
        logger.info(f"Manual Resume Analysis UI: file={resume_file}")
        if resume_file is None:
            return "Please upload a resume file.", gr.update(value=None), gr.update(value=None)

        try:
             # Read text content from uploaded file object
             with open(resume_file.name, 'r', encoding='utf-8') as f:
                 resume_text = f.read()
             logger.info(f"Read {len(resume_text)} characters from uploaded resume.")
        except Exception as e:
             logger.error(f"Error reading uploaded resume file: {e}")
             return f"Error reading file: {e}", gr.update(value=None), gr.update(value=None)


        if not resume_text:
            return "Resume file seems empty.", gr.update(value=None), gr.update(value=None)

        profile = get_user_profile(session_user_id)
        goal = profile.get('career_goal', 'Not specified')

        # Save resume text to user profile (associates it)
        resume_path = save_user_resume(session_user_id, resume_text)
        if not resume_path:
             return "Could not save resume file for analysis.", gr.update(value=None), gr.update(value=None)


        # Call analysis tool implementation function
        analysis_result = analyze_resume(resume_text, goal) # Returns dict

        try:
            analysis = analysis_result.get('analysis', {})
            md = f"## Resume Analysis (Simulated)\n\n**Analyzing for Goal:** '{goal}'\n\n"
            md += "**Strengths Identified:**\n" + "\n".join([f"* {s}" for s in analysis.get('strengths', ["None identified."])]) + "\n\n"
            md += "**Areas for Improvement:**\n" + "\n".join([f"* {s}" for s in analysis.get('areas_for_improvement', ["None identified."])]) + "\n\n"
            md += f"**Format Feedback:** {analysis.get('format_feedback', 'N/A')}\n"
            md += f"**Content Alignment:** {analysis.get('content_feedback', 'N/A')}\n"
            md += f"**Suggested Keywords:** {', '.join(analysis.get('keyword_suggestions', ['N/A']))}\n\n"
            md += "**Recommended Next Steps:**\n" + "\n".join([f"* {s}" for s in analysis.get('next_steps', ["Review suggestions."])])

            # Update skill chart based on the new resume analysis
            skill_fig = create_skill_radar_chart(session_user_id)

            return md, gr.update(value=skill_fig), gr.update(value=resume_path) # Return analysis text, skill chart, and path

        except Exception as e:
            logger.exception("Error formatting resume analysis results.")
            return "Error displaying analysis results.", gr.update(value=None), gr.update(value=None)

    def analyze_portfolio_interface_handler(portfolio_url, portfolio_description):
        logger.info(f"Manual Portfolio Analysis UI: url='{portfolio_url}'")
        if not portfolio_description:
            return "Please provide a description of your portfolio."

        profile = get_user_profile(session_user_id)
        goal = profile.get('career_goal', 'Not specified')

        # Save portfolio info
        portfolio_path = save_user_portfolio(session_user_id, portfolio_url, portfolio_description)
        if not portfolio_path:
             return "Could not save portfolio details."


        # Call analysis tool implementation function
        analysis_result = analyze_portfolio(portfolio_description, goal, portfolio_url) # Returns dict

        try:
            analysis = analysis_result.get('analysis', {})
            md = f"## Portfolio Analysis (Simulated)\n\n**Analyzing for Goal:** '{goal}'\n"
            if portfolio_url: md += f"**URL:** {portfolio_url}\n\n"
            else: md += "\n"

            md += f"**Alignment with Goal:** {analysis.get('alignment_with_goal', 'N/A')}\n\n"
            md += "**Strengths Based on Description:**\n" + "\n".join([f"* {s}" for s in analysis.get('strengths', ["N/A"])]) + "\n\n"
            md += "**Areas for Improvement:**\n" + "\n".join([f"* {s}" for s in analysis.get('areas_for_improvement', ["N/A"])]) + "\n\n"
            md += f"**Presentation Feedback:** {analysis.get('presentation_feedback', 'N/A')}\n\n"
            md += "**Recommended Next Steps:**\n" + "\n".join([f"* {s}" for s in analysis.get('next_steps', ["Review suggestions."])])

            return md

        except Exception as e:
            logger.exception("Error formatting portfolio analysis results.")
            return "Error displaying analysis results."

    # --- Progress Tracking Handlers ---
    def complete_task_handler(task_name):
        logger.info(f"Complete Task UI for {session_user_id}: task='{task_name}'")
        if not task_name:
            return ("Please enter the task you completed.", "", gr.update(), gr.update(), gr.update())

        updated_profile = add_task_to_user(session_user_id, task_name)

        # Update routine completion if a routine is active
        if updated_profile and updated_profile.get('routine_history'):
            db = load_user_database() # Reload DB after add_task potentially saved it
            profile = db.get('users', {}).get(session_user_id)
            if profile and profile.get('routine_history'): # Check again after reload
                 latest_routine = profile['routine_history'][0]
                 # Simple completion increment - could be smarter based on task type/routine content
                 increment = random.randint(5, 15)
                 latest_routine['completion'] = min(100, latest_routine.get('completion', 0) + increment)
                 save_user_database(db) # Save updated routine completion

        # Update charts
        e_fig, p_fig, g_fig = create_emotion_chart(session_user_id), create_progress_chart(session_user_id), create_routine_completion_gauge(session_user_id)

        return (f"Awesome job completing '{task_name}'! Keep up the great work!", "", gr.update(value=e_fig), gr.update(value=p_fig), gr.update(value=g_fig))

    def update_emotion_handler(emotion):
        logger.info(f"Update Emotion UI for {session_user_id}: emotion='{emotion}'")
        if not emotion:
            return "Please select how you're feeling.", gr.update()

        add_emotion_record(session_user_id, emotion)
        e_fig = create_emotion_chart(session_user_id)
        cleaned_display = emotion.split(" ")[0] if " " in emotion else emotion

        return f"Got it. Acknowledging how you feel ({cleaned_display}) is a great step.", gr.update(value=e_fig)

    def display_recommendations(current_user_id):
        """Formats latest recommendations into Markdown for display."""
        logger.info(f"Displaying recommendations for {current_user_id}")
        profile = get_user_profile(current_user_id)
        recs = profile.get('recommendations', [])

        if not recs:
            return "Chat with me about your goals and challenges, and I can suggest some next steps! 😊"

        # Show only pending recommendations, most recent first
        pending_recs = [r for r in recs if r.get('status') == 'pending'][:5] # Get latest 5 pending

        if not pending_recs:
            return "No pending recommendations right now. Great job, or let's chat to find new ones!"

        md = "### ✨ Here are a few things we could focus on:\n\n"
        for i, entry in enumerate(pending_recs, 1):
            rec = entry.get('recommendation', {})
            md += f"**{i}. {rec.get('title', 'Recommendation')}**\n"
            md += f"   - {rec.get('description', 'No description.')}\n"
            md += f"   - *Priority: {rec.get('priority', 'Medium')} | Type: {rec.get('action_type', 'General')}*\n---\n"
        return md

    # --- Build Gradio Interface ---
    with gr.Blocks(theme=gr.themes.Soft(primary_hue="sky", secondary_hue="blue", font=[gr.themes.GoogleFont("Poppins"), "Arial", "sans-serif"]), title="Aishura v3") as app:
        gr.Markdown("# Aishura - Your Empathetic AI Career Copilot 🚀")
        gr.Markdown("_Leveraging Google Gemini & Real-Time Data_")

        # Session state to store user ID (alternative to global variable)
        # user_id_state = gr.State(session_user_id) # Can use state if needed

        # Welcome Screen
        with gr.Group(visible=True) as welcome_group:
            gr.Markdown("## Welcome! Let's personalize your journey.")
            gr.Markdown("Tell me a bit about yourself so I can help you better.")
            with gr.Row():
                with gr.Column():
                    name_input = gr.Textbox(label="What's your first name?")
                    location_input = gr.Textbox(label="Where are you located (City, Country)?", placeholder="e.g., London, UK")
                    industry_input = gr.Textbox(label="What's your primary industry or field?", placeholder="e.g., Technology, Healthcare, Finance")
                with gr.Column():
                    emotion_dropdown = gr.Dropdown(choices=EMOTIONS, label="How are you feeling right now?")
                    goal_dropdown = gr.Dropdown(choices=GOAL_TYPES, label="What's your main career goal currently?") # Label updated
                    exp_level_dropdown = gr.Dropdown(choices=["Student", "Entry-Level (0-2 yrs)", "Mid-Level (3-7 yrs)", "Senior-Level (8+ yrs)", "Executive"], label="What's your experience level?")
                    work_style_dropdown = gr.Dropdown(choices=["On-site", "Hybrid", "Remote", "Any"], label="Preferred work style?", value="Any")

            welcome_button = gr.Button("✨ Start My Journey with Aishura ✨", variant="primary")
            welcome_output = gr.Markdown()

        # Main Interface (Hidden initially)
        with gr.Group(visible=False) as main_interface:
            with gr.Tabs():
                # --- Chat Tab ---
                with gr.TabItem("💬 Chat with Aishura"):
                    with gr.Row():
                        with gr.Column(scale=3):
                             # Using Gradio's ChatInterface structure for simplicity
                             chatbot_display = gr.Chatbot(
                                 label="Aishura",
                                 height=600,
                                 show_copy_button=True,
                                 bubble_full_width=False, # Modern look
                                 avatar_images=(None, "https://img.icons8.com/external-those-icons-lineal-color-those-icons/96/external-AI-artificial-intelligence-those-icons-lineal-color-those-icons-9.png") # Example AI avatar
                             )
                             msg_textbox = gr.Textbox(
                                 show_label=False,
                                 placeholder="Type your message here... ask for help, share progress, or just vent!",
                                 container=False,
                                 scale=1 # Take full width below chatbot
                             )
                             # Submit button (optional, hitting Enter also works)
                             # submit_btn = gr.Button("Send", variant="secondary", size="sm")

                        with gr.Column(scale=1):
                            gr.Markdown("### Recommendations")
                            recommendation_output = gr.Markdown("Loading recommendations...")
                            refresh_recs_button = gr.Button("🔄 Refresh Recs")
                            gr.Markdown("---")
                            gr.Markdown("### Quick Actions")
                            # Add quick action buttons later? e.g., "Summarize my progress"

                # --- Analysis & Tools Tab ---
                with gr.TabItem("🛠️ Analyze & Tools"):
                     with gr.Tabs():
                        with gr.TabItem("📄 Resume Hub"):
                            gr.Markdown("### Analyze Your Resume")
                            gr.Markdown("Upload your resume (TXT or PDF - text readable) for analysis and skill identification.")
                            # Use File upload component
                            resume_file_input = gr.File(label="Upload Resume (.txt, .pdf)", file_types=['.txt', '.pdf'])
                            # Display path of saved resume
                            resume_path_display = gr.Textbox(label="Current Resume File", interactive=False)
                            analyze_resume_button = gr.Button("Analyze Uploaded Resume", variant="primary")
                            resume_analysis_output = gr.Markdown("Analysis will appear here...")
                            gr.Markdown("---")
                            gr.Markdown("### Generate Document Templates")
                            doc_type_dropdown = gr.Dropdown(choices=["Resume", "Cover Letter", "LinkedIn Summary", "Networking Email"], label="Document Type")
                            doc_field_input = gr.Textbox(label="Target Career Field (Optional)", placeholder="e.g., Software Engineering")
                            doc_exp_dropdown = gr.Dropdown(choices=["Student", "Entry-Level", "Mid-Level", "Senior-Level"], label="Experience Level")
                            generate_template_button = gr.Button("Generate Template")
                            template_output_md = gr.Markdown("Template will appear here...")


                        with gr.TabItem("🎨 Portfolio Hub"):
                            gr.Markdown("### Analyze Your Portfolio")
                            portfolio_url_input = gr.Textbox(label="Portfolio URL (Optional)", placeholder="https://yourportfolio.com")
                            portfolio_desc_input = gr.Textbox(label="Describe your portfolio's content and purpose", lines=5, placeholder="e.g., Collection of web development projects using React and Node.js...")
                            analyze_portfolio_button = gr.Button("Analyze Portfolio Info", variant="primary")
                            portfolio_analysis_output = gr.Markdown("Analysis will appear here...")

                        with gr.TabItem("📅 Routine Builder"):
                            gr.Markdown("### Create a Personalized Routine")
                            gr.Markdown("Feeling stuck? Let's build a manageable routine based on how you feel and your goals.")
                            routine_emotion_dropdown = gr.Dropdown(choices=EMOTIONS, label="How are you feeling?")
                            profile = get_user_profile(session_user_id) # Get goal from profile for default
                            routine_goal_input = gr.Textbox(label="Main Goal for this Routine", value=profile.get('career_goal', ''))
                            routine_time_slider = gr.Slider(15, 120, 45, step=15, label="Minutes you can dedicate per day")
                            routine_days_slider = gr.Slider(3, 21, 7, step=1, label="Length of routine (days)")
                            create_routine_button = gr.Button("Create My Routine", variant="primary")
                            routine_output_md = gr.Markdown("Your personalized routine will appear here...")


                # --- Progress Tab ---
                with gr.TabItem("📈 Track Your Journey"):
                    gr.Markdown("## Your Progress Dashboard")
                    with gr.Row():
                        with gr.Column(scale=1):
                            gr.Markdown("### ✅ Log Completed Task")
                            task_input = gr.Textbox(label="What did you accomplish?", placeholder="e.g., Updated resume, Applied for job X, Completed course module")
                            complete_button = gr.Button("Log Task", variant="primary")
                            task_output = gr.Markdown()
                            gr.Markdown("---")
                            gr.Markdown("### 😊 How are you feeling now?")
                            new_emotion_dropdown = gr.Dropdown(choices=EMOTIONS, label="Select current emotion")
                            emotion_button = gr.Button("Update Emotion")
                            emotion_output = gr.Markdown()
                        with gr.Column(scale=2):
                            gr.Markdown("### Emotional Journey")
                            emotion_chart_output = gr.Plot(label="Emotion Trend") # Init Plot
                            gr.Markdown("### Active Routine Progress")
                            routine_gauge_output = gr.Plot(label="Routine Completion") # Init Plot

                    with gr.Row():
                         with gr.Column(scale=1):
                             gr.Markdown("### Progress Points")
                             progress_chart_output = gr.Plot(label="Progress Points Over Time") # Init Plot
                         with gr.Column(scale=1):
                             gr.Markdown("### Skills Assessment (from Resume)")
                             skill_radar_chart_output = gr.Plot(label="Skills Radar") # Init Plot


        # --- Event Wiring ---
        welcome_button.click(
            fn=welcome,
            inputs=[name_input, location_input, emotion_dropdown, goal_dropdown, industry_input, exp_level_dropdown, work_style_dropdown],
            outputs=[chatbot_display, welcome_group, main_interface, emotion_chart_output, progress_chart_output, routine_gauge_output, skill_radar_chart_output, recommendation_output] # Added rec output
        )

        # Chat submission
        msg_textbox.submit(
             fn=chat_submit,
             inputs=[msg_textbox, chatbot_display],
             outputs=[chatbot_display, recommendation_output] # Chatbot updated progressively, recs at end
        ).then(lambda: gr.update(value=""), outputs=[msg_textbox]) # Clear textbox after submit


        refresh_recs_button.click(
            fn=lambda: display_recommendations(session_user_id),
            outputs=[recommendation_output]
        )

        # Tool Handlers
        analyze_resume_button.click(
            fn=analyze_resume_interface_handler,
            inputs=[resume_file_input], # Changed to file input
            outputs=[resume_analysis_output, skill_radar_chart_output, resume_path_display] # Added path display
        )
        analyze_portfolio_button.click(
            fn=analyze_portfolio_interface_handler,
            inputs=[portfolio_url_input, portfolio_desc_input],
            outputs=[portfolio_analysis_output]
        )
        generate_template_button.click(
            fn=generate_template_interface_handler,
            inputs=[doc_type_dropdown, doc_field_input, doc_exp_dropdown],
            outputs=[template_output_md]
        )
        create_routine_button.click(
            fn=create_routine_interface_handler,
            inputs=[routine_emotion_dropdown, routine_goal_input, routine_time_slider, routine_days_slider],
            outputs=[routine_output_md, routine_gauge_output] # Updates routine text and gauge
        )

        # Progress Handlers
        complete_button.click(
            fn=complete_task_handler,
            inputs=[task_input],
            outputs=[task_output, task_input, emotion_chart_output, progress_chart_output, routine_gauge_output] # Clear input, update charts
        )
        emotion_button.click(
            fn=update_emotion_handler,
            inputs=[new_emotion_dropdown],
            outputs=[emotion_output, emotion_chart_output] # Update status text and emotion chart
        )

    return app

# --- Main Execution ---
if __name__ == "__main__":
    print("\n--- Aishura v3 Configuration Check ---")
    if not GOOGLE_API_KEY:
        print("⚠️ WARNING: GOOGLE_API_KEY not found in environment variables. AI features DISABLED.")
    else:
        print("✅ GOOGLE_API_KEY found.")
    if not SERPER_API_KEY:
        print("⚠️ WARNING: SERPER_API_KEY not found. Live web search DISABLED.")
    else:
        print("✅ SERPER_API_KEY found.")
    if not gemini_model:
         print("❌ ERROR: Google Gemini model failed to initialize. AI features DISABLED.")
    else:
         print(f"✅ Google Gemini model '{MODEL_ID}' initialized.")
    print("-------------------------------------\n")

    logger.info("Starting Aishura v3 Gradio application...")
    aishura_app = create_interface()
    # Share=True generates a public link (useful for demos)
    # Set debug=True for more verbose Gradio logs if needed
    aishura_app.launch(share=False, debug=False)
    logger.info("Aishura Gradio application stopped.")