Update app.py

app.py

@@ -1,31 +1,51 @@
 import gradio as gr
-import requests
 import os
+import json
+import datetime
+import hashlib
+import requests
+from pathlib import Path
+
+# --- Configuration & Constants ---
+
+# Load API key from Gradio Secrets (Ensure this is set in your deployment environment)
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")
 
-# Load API key from Gradio Secrets
-GROQ_API_KEY = os.getenv("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")
+# User data storage configuration
+SECURE_DATA_DIR = Path(".secure_data")
+USERS_FILE = SECURE_DATA_DIR / "users_encrypted.json"
+USER_DATA_DIR = Path("user_data")
 
-# Constants
+# Constants for UI
 COUNTRIES = [
-    "Pakistan", "India", "Nigeria", "United States", "United Kingdom",
-    "Germany", "Canada", "Australia", "Bangladesh", "Egypt"
+    "United States", "United Kingdom", "Canada", "Australia", "Germany",
+    "Pakistan", "India", "Nigeria", "Bangladesh", "Egypt"
 ]
 DEGREES = ["Bachelor", "Master", "PhD"]
-EMAIL_PURPOSES = ["Inquiry", "Follow-up", "Recommendation"]
+EMAIL_PURPOSES = ["Scholarship Inquiry", "Follow-up on Application", "Requesting Recommendation Letter"]
 COMMON_QUESTIONS = [
     "Tell me about yourself.",
     "Why are you interested in this scholarship?",
-    "What are your strengths and weaknesses?",
-    "Describe a challenge you’ve overcome.",
-    "Where do you see yourself in 5 years?"
+    "What are your academic strengths and weaknesses?",
+    "Describe a significant challenge you have overcome.",
+    "What are your long-term career goals?",
+    "How will this scholarship help you achieve your goals?"
 ]
 
-# === Helper to call Groq API ===
+# --- Initial Setup ---
+# Create necessary directories
+SECURE_DATA_DIR.mkdir(exist_ok=True)
+USER_DATA_DIR.mkdir(exist_ok=True)
+
+
+# === Core Helper Functions ===
+
 def call_groq_api(messages, model="llama3-8b-8192", timeout=60):
+    """Helper function to make API calls to Groq."""
     if not GROQ_API_KEY:
-        return "Error: GROQ_API_KEY is missing. Set it in Gradio Secrets."
+        return "Error: GROQ_API_KEY is not configured. Please set it in your environment's secrets."
     try:
-        resp = requests.post(
+        response = requests.post(
             "https://api.groq.com/openai/v1/chat/completions",
             headers={
                 "Authorization": f"Bearer {GROQ_API_KEY}",
@@ -34,236 +54,401 @@ def call_groq_api(messages, model="llama3-8b-8192", timeout=60):
             json={"model": model, "messages": messages},
             timeout=timeout
         )
-        if resp.status_code != 200:
-            return f"API error {resp.status_code}: {resp.text}"
-        data = resp.json()
-        choices = data.get("choices")
-        if not choices:
-            return f"No choices returned. Full response: {data}"
-        return choices[0]["message"]["content"].strip()
+        response.raise_for_status()  # Raise an exception for bad status codes (4xx or 5xx)
+        data = response.json()
+        if "choices" in data and data["choices"]:
+            return data["choices"][0]["message"]["content"].strip()
+        return f"API returned an unexpected response structure: {data}"
+    except requests.exceptions.RequestException as e:
+        return f"API request failed: {e}"
     except Exception as e:
-        return f"Request failed: {e}"
+        return f"An unexpected error occurred: {e}"
 
-# === Feature Functions ===
 
-def ai_generate_scholarships(country, university):
-    if not country or not university:
-        return "Please select a country and enter a university."
-    system = (
-        "You are ScholarGPT, an expert assistant that helps students explore scholarships. "
-        "Provide 3‑5 fully funded scholarships formatted as HTML cards."
-    )
-    user = f"List 3‑5 fully funded scholarships at {university} in {country}."
-    return call_groq_api([
-        {"role": "system", "content": system},
-        {"role": "user", "content": user}
-    ])
+# === User Management Functions (from Streamlit app) ===
+
+def hash_password(password):
+    """Hashes a password with a salt for secure storage."""
+    salt = "scholar_gpt_gradio_salt_2025"  # A unique salt for this application
+    return hashlib.sha256((password + salt).encode()).hexdigest()
+
+def load_users():
+    """Loads the user database from a JSON file."""
+    if USERS_FILE.exists():
+        try:
+            with open(USERS_FILE, "r") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, FileNotFoundError):
+            return {}
+    return {}
+
+def save_users(users):
+    """Saves the user database to a JSON file."""
+    with open(USERS_FILE, "w") as f:
+        json.dump(users, f, indent=4)
+
+def get_user_data_path(username, filename):
+    """Gets the path to a specific user's data file."""
+    user_dir = USER_DATA_DIR / username
+    user_dir.mkdir(exist_ok=True)
+    return user_dir / filename
+
+def signup_user(username, password, email):
+    """Registers a new user."""
+    if not all([username, password, email]):
+        return "Please fill out all fields.", False
+    if "@" not in email or "." not in email:
+        return "Please enter a valid email address.", False
+
+    users = load_users()
+    if username in users:
+        return "Username already exists. Please choose another one.", False
 
-def scholarship_finder(country, degree, gpa, field):
+    users[username] = {
+        "password": hash_password(password),
+        "email": email,
+        "created_at": datetime.datetime.now().isoformat()
+    }
+    save_users(users)
+    # Create the user's directory upon signup
+    (USER_DATA_DIR / username).mkdir(exist_ok=True)
+    return "Account created successfully! You can now log in.", True
+
+def login_user(username, password):
+    """Logs in an existing user."""
+    if not all([username, password]):
+        return "Please enter both username and password.", False
+
+    users = load_users()
+    if username not in users or users[username]["password"] != hash_password(password):
+        return "Invalid username or password.", False
+
+    return f"Welcome back, {username}!", True
+
+def save_user_journal(username, user_input, response):
+    """Saves an interaction to the user's journal."""
+    if not username:
+        return
+
+    journal_path = get_user_data_path(username, "journal.json")
+    entry = {
+        "timestamp": datetime.datetime.now().isoformat(),
+        "your_query": user_input,
+        "ai_response": response
+    }
+    journal = []
+    if journal_path.exists():
+        with open(journal_path, "r") as f:
+            try:
+                journal = json.load(f)
+            except json.JSONDecodeError:
+                journal = [] # Reset if file is corrupted
+    journal.append(entry)
+    with open(journal_path, "w") as f:
+        json.dump(journal, f, indent=4)
+
+def load_user_journal(username):
+    """Loads a user's journal and formats it for display."""
+    if not username:
+        return "Please log in to see your journal."
+
+    journal_path = get_user_data_path(username, "journal.json")
+    if not journal_path.exists():
+        return "No journal entries yet. Start interacting with the tools!"
+
+    with open(journal_path, "r") as f:
+        try:
+            journal = json.load(f)
+        except json.JSONDecodeError:
+            return "Could not load journal."
+
+    if not journal:
+        return "No journal entries yet."
+
+    # Format for display in Markdown
+    formatted_journal = "## Your Interaction History\n\n"
+    for entry in reversed(journal): # Show most recent first
+        ts = datetime.datetime.fromisoformat(entry['timestamp']).strftime('%Y-%m-%d %H:%M:%S')
+        formatted_journal += f"**On {ts}, you asked:**\n"
+        formatted_journal += f"> _{entry['your_query']}_\n\n"
+        formatted_journal += f"**ScholarGPT Responded:**\n"
+        formatted_journal += f"_{entry['ai_response']}_\n\n---\n\n"
+    return formatted_journal
+
+
+# === AI Feature Functions ===
+
+def scholarship_finder(country, degree, gpa, field, username):
     if not all([country, degree, field]) or gpa is None:
-        return "Please fill in all fields."
-    try:
-        gpa_val = float(gpa)
-    except:
-        return "Enter a valid numeric GPA."
-    system = "You are ScholarGPT, an expert assistant that helps students find scholarships."
-    user = (
-        f"I am from {country}, seeking {degree} scholarships; "
-        f"GPA: {gpa_val}, Field: {field}. "
-        "List matching scholarships with name, university, country, required GPA, and field."
+        return "Please fill in all fields to find scholarships."
+    prompt = (
+        f"I am a student from {country} looking for a {degree} program in the field of {field}. "
+        f"My GPA is {gpa}. Please find 5 fully-funded scholarship opportunities that match my profile. "
+        "For each, provide the scholarship name, the university, the country, and a brief description. "
+        "Format the output clearly in Markdown."
     )
-    return call_groq_api([
-        {"role": "system", "content": system},
-        {"role": "user", "content": user}
-    ])
-
-def sop_generator(full_name, university, degree_program, background, academic_goals, ambitions):
-    if not all([full_name.strip(), university.strip(), degree_program.strip(),
-                background.strip(), academic_goals.strip(), ambitions.strip()]):
-        return "Please fill in all fields."
-    system = "You are ScholarGPT, an expert assistant that writes formal SOPs for scholarship applications."
-    user = (
-        f"Write a Statement of Purpose for {full_name} applying to {university} for {degree_program}. "
-        f"Background: {background}. Goals: {academic_goals}. Ambitions: {ambitions}."
+    messages = [
+        {"role": "system", "content": "You are ScholarGPT, an expert AI assistant that finds scholarships for students based on their profile."},
+        {"role": "user", "content": prompt}
+    ]
+    response = call_groq_api(messages)
+    save_user_journal(username, f"Find scholarships for {degree} in {field} from {country} with GPA {gpa}", response)
+    return response
+
+def sop_generator(full_name, university, degree_program, background, goals, username):
+    if not all([full_name, university, degree_program, background, goals]):
+        return "Please provide all details to generate a Statement of Purpose."
+    prompt = (
+        f"Please write a compelling and professional Statement of Purpose (SOP). Here are the details:\n"
+        f"- **Applicant Name:** {full_name}\n"
+        f"- **Target University:** {university}\n"
+        f"- **Degree Program:** {degree_program}\n"
+        f"- **Personal & Academic Background:** {background}\n"
+        f"- **Future Goals & Ambitions:** {goals}\n\n"
+        "The SOP should be well-structured, formal, and highlight the applicant's suitability for the program."
     )
-    return call_groq_api([
-        {"role": "system", "content": system},
-        {"role": "user", "content": user}
-    ], timeout=90)
-
-def eligibility_checker(gpa, country, degree_completed):
-    if gpa is None or not country or not degree_completed:
-        return "Please fill in all fields."
-    try:
-        gpa_val = float(gpa)
-    except:
-        return "Enter a valid numeric GPA."
-    if gpa_val >= 3.0 and degree_completed == "Bachelor":
-        return f"✅ Eligible! (GPA: {gpa_val}, Degree: {degree_completed})"
-    else:
-        return f"❌ Not eligible. (GPA: {gpa_val}, Degree: {degree_completed})"
-
-def mentor_chat(user_message, chat_history):
-    history = chat_history or []
-    history.append(("user", user_message))
-    messages = [{"role": "system", "content": "You are MentorGPT, a friendly academic mentor."}]
-    for role, msg in history:
-        messages.append({"role": role, "content": msg})
-    reply = call_groq_api(messages)
-    history.append(("assistant", reply))
-    # Convert to list of (user, assistant) pairs
-    pairs = [(history[i][1], history[i+1][1]) for i in range(0, len(history)-1, 2)]
-    return pairs, history
-
-def email_template(recipient, university, purpose):
-    if not all([recipient.strip(), university.strip(), purpose.strip()]):
-        return "Please fill in all fields."
-    system = "You are ScholarGPT, an assistant that drafts formal academic emails."
-    user = (
-        f"Draft a formal email to {recipient} at {university}. Purpose: {purpose}. "
-        "Include subject, greeting, body, and closing."
+    messages = [
+        {"role": "system", "content": "You are ScholarGPT, an expert academic writer specializing in creating powerful Statements of Purpose for university applications."},
+        {"role": "user", "content": prompt}
+    ]
+    response = call_groq_api(messages, timeout=90)
+    save_user_journal(username, f"Generate SOP for {degree_program} at {university}", response)
+    return response
+
+def email_template_generator(recipient, university, purpose, username):
+    if not all([recipient, university, purpose]):
+        return "Please fill in all fields to generate an email."
+    prompt = (
+        f"Please draft a formal and respectful email for the following purpose:\n"
+        f"- **Recipient:** {recipient}\n"
+        f"- **University:** {university}\n"
+        f"- **Purpose of Email:** {purpose}\n\n"
+        "The email should include a clear subject line, a proper greeting, a concise body, and a professional closing."
     )
-    return call_groq_api([
-        {"role": "system", "content": system},
-        {"role": "user", "content": user}
-    ])
-
-def sop_resume_generator(university, field_study, background):
-    if not all([university.strip(), field_study.strip(), background.strip()]):
-        return "", ""
-    system = "You are ScholarGPT, an assistant that generates SOPs and resumes."
-    user = (
-        f"Generate an SOP and a resume draft for someone applying to {university} in {field_study}. "
-        f"Background: {background}."
+    messages = [
+        {"role": "system", "content": "You are ScholarGPT, an AI assistant that drafts professional academic emails."},
+        {"role": "user", "content": prompt}
+    ]
+    response = call_groq_api(messages)
+    save_user_journal(username, f"Draft email to {recipient} for {purpose}", response)
+    return response
+
+def interview_coach(question, user_answer, username):
+    if not question or not user_answer:
+        return "Please select a question and provide your answer for feedback."
+    prompt = (
+        f"I am preparing for a scholarship interview. Please provide constructive feedback on my answer.\n\n"
+        f"**Interview Question:** \"{question}\"\n\n"
+        f"**My Answer:** \"{user_answer}\"\n\n"
+        "Please analyze my answer and suggest improvements to make it more impactful, confident, and professional. "
+        "Structure your feedback into 'Strengths' and 'Areas for Improvement'."
     )
-    content = call_groq_api([
-        {"role": "system", "content": system},
-        {"role": "user", "content": user}
-    ], timeout=90)
-    # Split by marker
-    if "### Resume" in content:
-        sop, resume = content.split("### Resume", 1)
-        return sop.replace("### SOP", "").strip(), resume.strip()
-    else:
-        return content, "No resume generated."
-
-def checklist_generator(degree_type, country, scholarship_name):
-    if not all([degree_type, country, scholarship_name.strip()]):
+    messages = [
+        {"role": "system", "content": "You are MentorGPT, an expert interview coach who helps students excel in scholarship interviews."},
+        {"role": "user", "content": prompt}
+    ]
+    response = call_groq_api(messages, timeout=90)
+    save_user_journal(username, f"Get feedback for interview question: {question}", response)
+    return response
+
+def checklist_generator(degree_type, country, scholarship_name, username):
+    if not all([degree_type, country, scholarship_name]):
         return []
-    system = "You are ScholarGPT, an assistant that creates application document checklists."
-    user = (
-        f"Generate a checklist of required documents for a {degree_type} scholarship application "
-        f"to {scholarship_name} in {country}."
+    prompt = (
+        f"Please generate a comprehensive checklist of required documents for a {degree_type} scholarship application "
+        f"for the '{scholarship_name}' in {country}. List only the document names."
     )
-    content = call_groq_api([
-        {"role": "system", "content": system},
-        {"role": "user", "content": user}
-    ])
-    # Parse bullets
-    items = [line.strip("- ").strip() for line in content.splitlines() if line.strip()]
+    messages = [
+        {"role": "system", "content": "You are ScholarGPT, an assistant that creates application document checklists. Provide only a list of items."},
+        {"role": "user", "content": prompt}
+    ]
+    content = call_groq_api(messages)
+    # Parse the response into a list of checklist items
+    items = [line.strip("-* ").strip() for line in content.splitlines() if line.strip() and len(line) > 2]
+    save_user_journal(username, f"Generate checklist for {scholarship_name}", str(items))
     return items
 
-def improve_answer(question, user_answer):
-    if not question or not user_answer.strip():
-        return "Please select a question and provide your answer."
-    system = "You are MentorGPT, an interview coach."
-    user = (
-        f"Interview Question: {question}\n"
-        f"User Answer: {user_answer}\n"
-        "Suggest improvements to make the answer more confident and professional."
+# --- Gradio UI ---
+
+# Define custom CSS for styling the application
+custom_css = """
+body { background-color: #F0F2F6; }
+.gradio-container {
+    font-family: 'Inter', sans-serif;
+    border-radius: 16px !important;
+    box-shadow: 0 8px 32px 0 rgba(31, 38, 135, 0.17);
+}
+#app_title {
+    text-align: center;
+    font-size: 3em;
+    color: #1E3A8A; /* Dark Blue */
+    font-weight: 700;
+}
+#app_subtitle {
+    text-align: center;
+    font-size: 1.2em;
+    color: #4B5563; /* Gray */
+    margin-top: -15px;
+}
+.gr-button {
+    background-image: linear-gradient(to right, #1E3A8A 0%, #3B82F6 100%);
+    color: white;
+    font-weight: bold;
+    border-radius: 8px;
+}
+.gr-button:hover {
+    box-shadow: 0 4px 15px 0 rgba(59, 130, 246, 0.4);
+}
+#auth_message {
+    text-align: center;
+    font-weight: bold;
+    padding: 10px;
+    border-radius: 8px;
+}
+.success { color: #15803D; background-color: #F0FDF4; }
+.error { color: #B91C1C; background-color: #FEF2F2; }
+#logout_button { background: #DC2626; }
+"""
+
+with gr.Blocks(theme=gr.themes.Soft(), css=custom_css) as demo:
+    # --- State Management ---
+    logged_in_user = gr.State(None) # Stores the username of the logged-in user
+
+    # --- UI Definition ---
+    gr.Markdown("# 🎓 ScholarGPT", elem_id="app_title")
+    gr.Markdown("_Your AI-Powered Mentor for Securing Global Scholarships_", elem_id="app_subtitle")
+
+    # --- Main Application Interface (Initially Hidden) ---
+    with gr.Column(visible=False) as app_container:
+        with gr.Row():
+            welcome_text = gr.Markdown()
+            with gr.Column(scale=1, min_width=150):
+                logout_button = gr.Button("Logout", elem_id="logout_button")
+
+        with gr.Tabs() as app_tabs:
+            # --- Scholarship Finder Tab ---
+            with gr.TabItem("🔎 Scholarship Finder"):
+                with gr.Row():
+                    sf_country = gr.Dropdown(label="Your Country of Origin", choices=COUNTRIES, value=COUNTRIES[5])
+                    sf_degree = gr.Dropdown(label="Desired Degree Level", choices=DEGREES, value=DEGREES[1])
+                    sf_gpa = gr.Number(label="Your Current GPA (out of 4.0)", value=3.5, precision=2)
+                sf_field = gr.Textbox(label="Your Field of Interest", placeholder="e.g., Artificial Intelligence, Public Health")
+                sf_btn = gr.Button("Find My Scholarships")
+                sf_out = gr.Markdown(label="Matching Scholarships")
+
+            # --- SOP Generator Tab ---
+            with gr.TabItem("✍️ SOP Generator"):
+                so_name = gr.Textbox(label="Your Full Name")
+                with gr.Row():
+                    so_univ = gr.Textbox(label="Target University")
+                    so_prog = gr.Textbox(label="Target Degree Program")
+                so_back = gr.Textbox(label="Your Personal & Academic Background", lines=4, placeholder="Describe your journey, key achievements, and relevant experiences.")
+                so_goals = gr.Textbox(label="Your Future Goals & Ambitions", lines=3, placeholder="What do you want to achieve after this degree?")
+                so_btn = gr.Button("Generate My SOP")
+                so_out = gr.Textbox(label="Generated Statement of Purpose", lines=15, interactive=True, show_copy_button=True)
+
+            # --- Email Generator Tab ---
+            with gr.TabItem("✉️ Email Generator"):
+                et_recipient = gr.Textbox(label="Recipient's Name & Title", placeholder="e.g., Dr. Jane Doe, Admissions Committee")
+                et_university = gr.Textbox(label="University Name")
+                et_purpose = gr.Dropdown(label="Purpose of Email", choices=EMAIL_PURPOSES, value=EMAIL_PURPOSES[0])
+                et_btn = gr.Button("Generate Formal Email")
+                et_out = gr.Textbox(label="Generated Email Draft", lines=15, interactive=True, show_copy_button=True)
+
+            # --- Interview Coach Tab ---
+            with gr.TabItem("💬 Interview Coach"):
+                iq_question = gr.Dropdown(label="Select a Common Interview Question", choices=COMMON_QUESTIONS, value=COMMON_QUESTIONS[0])
+                iq_answer = gr.Textbox(label="Your Answer", lines=5, placeholder="Type your response here...")
+                iq_btn = gr.Button("Get Feedback on My Answer")
+                iq_out = gr.Markdown(label="AI Coach's Feedback")
+
+            # --- Document Checklist Tab ---
+            with gr.TabItem("✅ Application Checklist"):
+                dc_degree = gr.Dropdown(label="Degree Type", choices=DEGREES, value=DEGREES[1])
+                dc_country = gr.Dropdown(label="Country Applying To", choices=COUNTRIES, value=COUNTRIES[0])
+                dc_scholarship = gr.Textbox(label="Specific Scholarship Name", placeholder="e.g., Fulbright Scholarship")
+                dc_btn = gr.Button("Generate Document Checklist")
+                dc_out = gr.CheckboxGroup(label="Required Documents", choices=[])
+
+            # --- My Journal Tab ---
+            with gr.TabItem("📓 My Journal"):
+                journal_out = gr.Markdown(label="Your Saved Interactions")
+                # The journal is loaded when the tab is selected
+
+
+    # --- Authentication Interface (Initially Visible) ---
+    with gr.Column(visible=True) as auth_container:
+        with gr.Tabs() as auth_tabs:
+            # --- Login Tab ---
+            with gr.TabItem("Login"):
+                login_user_input = gr.Textbox(label="Username")
+                login_pass_input = gr.Textbox(label="Password", type="password")
+                login_btn = gr.Button("Login")
+                login_message = gr.Markdown(elem_classes=["auth_message"])
+
+            # --- Signup Tab ---
+            with gr.TabItem("Sign Up"):
+                signup_user_input = gr.Textbox(label="Choose a Username")
+                signup_email_input = gr.Textbox(label="Email Address")
+                signup_pass_input = gr.Textbox(label="Create a Password", type="password")
+                signup_btn = gr.Button("Create Account")
+                signup_message = gr.Markdown(elem_classes=["auth_message"])
+
+    # --- Event Handling & Logic ---
+
+    # --- Authentication Logic ---
+    def handle_login(username, password):
+        message, success = login_user(username, password)
+        if success:
+            # Hide auth UI, show app UI
+            return {
+                auth_container: gr.update(visible=False),
+                app_container: gr.update(visible=True),
+                login_message: gr.update(value=f"<p class='success'>{message}</p>"),
+                welcome_text: gr.update(value=f"### Welcome, {username}!"),
+                logged_in_user: username
+            }
+        else:
+            return {login_message: gr.update(value=f"<p class='error'>{message}</p>")}
+
+    def handle_signup(username, password, email):
+        message, success = signup_user(username, password, email)
+        if success:
+            return {signup_message: gr.update(value=f"<p class='success'>{message}</p>")}
+        else:
+            return {signup_message: gr.update(value=f"<p class='error'>{message}</p>")}
+
+    def handle_logout():
+        # Show auth UI, hide app UI, reset state
+        return {
+            auth_container: gr.update(visible=True),
+            app_container: gr.update(visible=False),
+            logged_in_user: None,
+            login_user_input: "", # Clear fields
+            login_pass_input: ""
+        }
+
+    # Bind auth functions to buttons
+    login_btn.click(handle_login, inputs=[login_user_input, login_pass_input], outputs=[auth_container, app_container, login_message, welcome_text, logged_in_user])
+    signup_btn.click(handle_signup, inputs=[signup_user_input, signup_pass_input, signup_email_input], outputs=[signup_message])
+    logout_button.click(handle_logout, outputs=[auth_container, app_container, logged_in_user, login_user_input, login_pass_input])
+
+
+    # --- App Feature Logic ---
+    # Bind AI functions to their respective buttons
+    sf_btn.click(scholarship_finder, inputs=[sf_country, sf_degree, sf_gpa, sf_field, logged_in_user], outputs=sf_out)
+    so_btn.click(sop_generator, inputs=[so_name, so_univ, so_prog, so_back, so_goals, logged_in_user], outputs=so_out)
+    et_btn.click(email_template_generator, inputs=[et_recipient, et_university, et_purpose, logged_in_user], outputs=et_out)
+    iq_btn.click(interview_coach, inputs=[iq_question, iq_answer, logged_in_user], outputs=iq_out)
+    dc_btn.click(checklist_generator, inputs=[dc_degree, dc_country, dc_scholarship, logged_in_user], outputs=dc_out)
+
+    # Load journal when the 'My Journal' tab is selected
+    app_tabs.select(
+        lambda tab_index, username: load_user_journal(username) if tab_index == 5 else gr.update(),
+        inputs=[app_tabs, logged_in_user],
+        outputs=journal_out
     )
-    return call_groq_api([
-        {"role": "system", "content": system},
-        {"role": "user", "content": user}
-    ], timeout=60)
-
-# === Build Gradio Interface ===
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🎓 ScholarGPT Assistant\n*Your AI mentor for fully funded scholarships*")
-    with gr.Tab("Scholarship Explorer"):
-        ex_country = gr.Dropdown(label="Country", choices=COUNTRIES, value=COUNTRIES[0])
-        ex_univ = gr.Textbox(label="University Name", placeholder="e.g. MIT")
-        ex_btn = gr.Button("Explore Scholarships")
-        ex_out = gr.HTML()
-        ex_btn.click(ai_generate_scholarships, [ex_country, ex_univ], ex_out)
-
-    with gr.Tab("Scholarship Finder"):
-        sf_country = gr.Dropdown(label="Country", choices=COUNTRIES, value=COUNTRIES[0])
-        sf_degree = gr.Dropdown(label="Degree Level", choices=DEGREES, value=DEGREES[0])
-        sf_gpa = gr.Number(label="Your GPA", value=3.0, precision=2)
-        sf_field = gr.Textbox(label="Field of Interest", placeholder="e.g. Computer Science")
-        sf_btn = gr.Button("Find Scholarships")
-        sf_out = gr.Markdown()
-        sf_btn.click(scholarship_finder, [sf_country, sf_degree, sf_gpa, sf_field], sf_out)
-
-    with gr.Tab("SOP Generator"):
-        so_name = gr.Textbox(label="Full Name")
-        so_univ = gr.Textbox(label="University")
-        so_prog = gr.Textbox(label="Degree Program")
-        so_back = gr.Textbox(label="Personal Background", lines=2)
-        so_goals = gr.Textbox(label="Academic Goals", lines=2)
-        so_amb = gr.Textbox(label="Future Ambitions", lines=2)
-        so_btn = gr.Button("Generate SOP")
-        so_out = gr.Textbox(lines=12, interactive=True, show_copy_button=True)
-        so_btn.click(sop_generator,
-                     [so_name, so_univ, so_prog, so_back, so_goals, so_amb],
-                     so_out)
-
-    with gr.Tab("Eligibility Checker"):
-        ec_gpa = gr.Number(label="GPA", value=3.0, precision=2)
-        ec_country = gr.Dropdown(label="Country", choices=COUNTRIES, value=COUNTRIES[0])
-        ec_degree = gr.Dropdown(label="Degree Completed", choices=DEGREES, value=DEGREES[0])
-        ec_btn = gr.Button("Check Eligibility")
-        ec_out = gr.Markdown()
-        ec_btn.click(eligibility_checker, [ec_gpa, ec_country, ec_degree], ec_out)
-
-    with gr.Tab("Mentor Chat"):
-        chat_bot = gr.Chatbot()
-        user_msg = gr.Textbox(label="Your Question", placeholder="Ask anything…")
-        chat_state = gr.State([])
-        send_btn = gr.Button("Send")
-        send_btn.click(mentor_chat, [user_msg, chat_state], [chat_bot, chat_state])
-
-    with gr.Tab("Email Templates"):
-        et_recipient = gr.Textbox(label="Recipient Name", placeholder="e.g. Dr. Smith")
-        et_university = gr.Textbox(label="University Name", placeholder="e.g. MIT")
-        et_purpose = gr.Dropdown(label="Purpose", choices=EMAIL_PURPOSES, value=EMAIL_PURPOSES[0])
-        et_btn = gr.Button("Generate Email")
-        et_out = gr.Textbox(lines=12, interactive=True, show_copy_button=True)
-        et_btn.click(email_template, [et_recipient, et_university, et_purpose], et_out)
-
-    with gr.Tab("SOP & Resume Generator"):
-        sr_univ = gr.Textbox(label="University Name", placeholder="e.g. MIT")
-        sr_field = gr.Textbox(label="Field of Study", placeholder="e.g. AI")
-        sr_back = gr.Textbox(label="Personal Background", placeholder="Briefly describe yourself")
-        sr_btn = gr.Button("Generate SOP & Resume")
-        sop_out = gr.Textbox(lines=12, interactive=True, show_copy_button=True, label="Generated SOP")
-        resume_out = gr.Textbox(lines=12, interactive=True, show_copy_button=True, label="Generated Resume")
-        sr_btn.click(sop_resume_generator, [sr_univ, sr_field, sr_back], [sop_out, resume_out])
-
-    with gr.Tab("Document Checklist"):
-        dc_degree = gr.Dropdown(label="Degree Type", choices=DEGREES, value=DEGREES[1])
-        dc_country = gr.Dropdown(label="Country Applying To", choices=COUNTRIES, value=COUNTRIES[0])
-        dc_scholarship = gr.Textbox(label="Scholarship Name", placeholder="e.g. Fulbright")
-        dc_btn = gr.Button("Generate Checklist")
-        dc_out = gr.CheckboxGroup(label="Checklist Items", choices=[])
-        dc_btn.click(checklist_generator, [dc_degree, dc_country, dc_scholarship], dc_out)
-
-    with gr.Tab("Interview Guide"):
-        iq_question = gr.Dropdown(label="Select Question", choices=COMMON_QUESTIONS)
-        iq_answer = gr.Textbox(label="Your Answer", lines=4, placeholder="Type your answer here…")
-        iq_btn = gr.Button("Improve Answer")
-        iq_out = gr.Markdown(label="Suggestions")
-        iq_tips = gr.Markdown(
-            "**Interview Tips:**\n"
-            "- Practice aloud using the STAR method.\n"
-            "- Keep answers concise and structured.\n"
-            "- Maintain confidence and good posture.\n"
-            "- Research the scholarship thoroughly."
-        )
-        iq_btn.click(improve_answer, [iq_question, iq_answer], iq_out)
 
-    gr.Markdown("\n---\n_Powered by Gradio & Groq API_")
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(debug=True)