create app.py

app.py

@@ -0,0 +1,646 @@
+import gradio as gr
+import sqlite3
+import bcrypt
+from datetime import datetime
+import re
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers import AutoTokenizer, AutoModel, AutoModelForSequenceClassification
+import os
+import logging
+from dotenv import load_dotenv
+from openai import OpenAI
+load_dotenv()  # Loads .env file
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+import json
+from fpdf import FPDF
+
+# --------------------------
+# Environment Setup
+# --------------------------
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print("Using device:", device)
+
+# --------------------------
+# Global Tokenizer and Hybrid Model for Treatment Prediction
+# --------------------------
+tokenizer = AutoTokenizer.from_pretrained("emilyalsentzer/Bio_ClinicalBERT")
+
+
+class HybridMentalHealthModel(nn.Module):
+    def __init__(self, bert_model, num_genders, num_medications, num_therapies, hidden_size=128):
+        super(HybridMentalHealthModel, self).__init__()
+        self.bert = AutoModel.from_pretrained(bert_model)
+        bert_output_size = self.bert.config.hidden_size
+        self.age_fc = nn.Linear(1, 16)
+        self.gender_fc = nn.Embedding(num_genders, 16)
+        self.fc = nn.Linear(bert_output_size + 32, hidden_size)
+        self.medication_head = nn.Linear(hidden_size, num_medications)
+        self.therapy_head = nn.Linear(hidden_size, num_therapies)
+
+    def forward(self, input_ids, attention_mask, age, gender):
+        bert_output = self.bert(input_ids=input_ids, attention_mask=attention_mask).last_hidden_state[:, 0, :]
+        age_out = self.age_fc(age)
+        gender_out = self.gender_fc(gender)
+        combined = torch.cat((bert_output, age_out, gender_out), dim=1)
+        hidden = torch.relu(self.fc(combined))
+        return self.medication_head(hidden), self.therapy_head(hidden)
+
+
+# --------------------------
+# Global Label Mappings and Age Scaler
+# --------------------------
+medication_classes = ["Anxiolytics", "Benzodiazepines", "Antidepressants", "Mood Stabilizers", "Antipsychotics", "Stimulants"]
+therapy_classes = ["Cognitive Behavioral Therapy", "Dialectical Behavioral Therapy", "Interpersonal Therapy", "Mindfulness-Based Therapy"]  # Update with your types
+gender_classes = ["Male", "Female", "Other"]
+
+medication_encoder = {name: idx for idx, name in enumerate(medication_classes)}
+inv_medication_encoder = {idx: name for name, idx in medication_encoder.items()}
+therapy_encoder = {name: idx for idx, name in enumerate(therapy_classes)}
+inv_therapy_encoder = {idx: name for name, idx in therapy_encoder.items()}
+gender_encoder = {name: idx for idx, name in enumerate(gender_classes)}
+
+mean_age = 50
+std_age = 10
+
+def scale_age(age):
+    return (age - mean_age) / std_age
+
+# --------------------------
+# Load the Hybrid Model (Treatment Prediction)
+# --------------------------
+num_genders = len(gender_classes)
+num_medications = len(medication_classes)
+num_therapies = len(therapy_classes)
+MODEL_SAVE_PATH = "22.03.2025-16.02-ML128E10"  # Update accordingly
+
+model = HybridMentalHealthModel("emilyalsentzer/Bio_ClinicalBERT", num_genders, num_medications, num_therapies)
+state_dict = torch.load(MODEL_SAVE_PATH, map_location=device)
+if "gender_fc.weight" in state_dict:
+    del state_dict["gender_fc.weight"]
+model.load_state_dict(state_dict, strict=False)
+model.to(device)
+model.eval()
+
+# --------------------------
+# Global Diagnosis Model (Mental Health Diagnosis)
+# --------------------------
+diagnosis_tokenizer = AutoTokenizer.from_pretrained("ethandavey/mental-health-diagnosis-bert")  # Update with your model ID
+diagnosis_model = AutoModelForSequenceClassification.from_pretrained("ethandavey/mental-health-diagnosis-bert")  # Update with your model ID
+diagnosis_model.to(device)
+diagnosis_model.eval()
+
+def predict_disease(text):
+    inputs = diagnosis_tokenizer(text, return_tensors="pt", padding=True, truncation=True, max_length=128)
+    inputs = {k: v.to(device) for k, v in inputs.items()}
+    with torch.no_grad():
+        outputs = diagnosis_model(**inputs)
+        probabilities = F.softmax(outputs.logits, dim=1).squeeze()
+    label_mapping = {0: "Anxiety", 1: "Normal", 2: "Depression", 3: "Suicidal", 4: "Stress"}
+
+    topk = torch.topk(probabilities, k=3)
+    top_preds = [(label_mapping[i.item()], probabilities[i].item()) for i in topk.indices]
+    return top_preds
+
+
+def predict_med_therapy(symptoms, age, gender):
+    encoding = tokenizer(symptoms, return_tensors="pt", truncation=True, padding='max_length', max_length=128)
+    input_ids = encoding["input_ids"].to(device)
+    attention_mask = encoding["attention_mask"].to(device)
+    age_norm = torch.tensor([[scale_age(age)]], dtype=torch.float32).to(device)
+    gender_idx = gender_encoder.get(gender, 0)
+    gender_tensor = torch.tensor([gender_idx], dtype=torch.long).to(device)
+    with torch.no_grad():
+        med_logits, therapy_logits = model(input_ids, attention_mask, age_norm, gender_tensor)
+    med_probabilities = torch.softmax(med_logits, dim=1)
+    therapy_probabilities = torch.softmax(therapy_logits, dim=1)
+    med_pred = torch.argmax(med_probabilities, dim=1).item()
+    therapy_pred = torch.argmax(therapy_probabilities, dim=1).item()
+    med_confidence = med_probabilities[0][med_pred].item()
+    therapy_confidence = therapy_probabilities[0][therapy_pred].item()
+    predicted_med = inv_medication_encoder.get(med_pred, "Unknown")
+    predicted_therapy = inv_therapy_encoder.get(therapy_pred, "Unknown")
+    return (predicted_med, med_confidence), (predicted_therapy, therapy_confidence)
+
+# --------------------------
+# OpenAI Functions (Summarization and Explanation)
+# --------------------------
+def get_concise_rewrite(text, max_tokens, temperature=0.7):
+    messages = [
+        {"role": "system", "content": "You are an expert rewriting assistant. Rewrite the given statement into a concise version while preserving its tone and vocabulary."},
+        {"role": "user", "content": text}
+    ]
+    try:
+        response = client.chat.completions.create(model="gpt-4o-mini", messages=messages, max_tokens=max_tokens, temperature=temperature)
+        concise_text = response.choices[0].message.content.strip()
+    except Exception as e:
+        concise_text = f"API call failed: {e}"
+    return concise_text
+
+def get_explanation(patient_statement, predicted_diagnosis):
+    messages = [
+        {"role": "system", "content": "You are an expert mental health assistant. Provide a concise, evidence-based explanation of how the patient's statement supports the diagnosis."},
+        {"role": "user", "content": f"Patient statement: {patient_statement}\nPredicted diagnosis: {predicted_diagnosis}\nExplain briefly."}
+    ]
+    try:
+        response = client.chat.completions.create(model="gpt-4o-mini", messages=messages, max_tokens=256)
+        explanation = response.choices[0].message.content.strip()
+    except Exception as e:
+        explanation = "API call failed."
+    return explanation
+
+# --------------------------
+# Database Functions
+# --------------------------
+def init_db():
+    conn = sqlite3.connect("users.db")
+    c = conn.cursor()
+    c.execute("""
+        CREATE TABLE IF NOT EXISTS users (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT UNIQUE NOT NULL,
+            password TEXT NOT NULL,
+            full_name TEXT,
+            email TEXT
+        )
+    """)
+    c.execute("""
+        CREATE TABLE IF NOT EXISTS chat_history (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT NOT NULL,
+            message TEXT NOT NULL,
+            response TEXT NOT NULL,
+            timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
+    c.execute("""
+        CREATE TABLE IF NOT EXISTS patient_sessions (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT,
+            patient_name TEXT,
+            age REAL,
+            gender TEXT,
+            symptoms TEXT,
+            diagnosis TEXT,
+            medication TEXT,
+            therapy TEXT,
+            summary TEXT,
+            explanation TEXT,
+            pdf_report TEXT,
+            session_timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+            appointment_date DATE
+        )
+    """)
+    conn.commit()
+    conn.close()
+
+def register_user(username, password, full_name, email):
+    if not re.fullmatch(r"[^@]+@[^@]+\.[^@]+", email):
+        return "Invalid email format."
+    if len(password) <= 8:
+        return "Password must be more than 8 characters."
+    conn = sqlite3.connect("users.db")
+    c = conn.cursor()
+    hashed = bcrypt.hashpw(password.encode(), bcrypt.gensalt())
+    try:
+        c.execute("INSERT INTO users (username, password, full_name, email) VALUES (?, ?, ?, ?)", (username, hashed, full_name, email))
+        conn.commit()
+        return "User registered successfully."
+    except sqlite3.IntegrityError:
+        return "Username already exists."
+    finally:
+        conn.close()
+
+def login_user(username, password):
+    conn = sqlite3.connect("users.db")
+    c = conn.cursor()
+    c.execute("SELECT password FROM users WHERE username = ?", (username,))
+    user = c.fetchone()
+    conn.close()
+    if user and bcrypt.checkpw(password.encode(), user[0]):
+        return True
+    return False
+
+def get_user_info(username):
+    conn = sqlite3.connect("users.db")
+    c = conn.cursor()
+    c.execute("SELECT username, email, full_name FROM users WHERE username = ?", (username,))
+    user = c.fetchone()
+    conn.close()
+    if user:
+        return f"Username: {user[0]}\nFull Name: {user[2]}\nEmail: {user[1]}"
+    else:
+        return "User info not found."
+
+def get_chat_history(username):
+    conn = sqlite3.connect("users.db")
+    c = conn.cursor()
+    c.execute("SELECT message, response, timestamp FROM chat_history WHERE username = ? ORDER BY timestamp DESC", (username,))
+    history = c.fetchall()
+    conn.close()
+    return history
+
+def get_patient_sessions(filter_name="", filter_date=""):
+    conn = sqlite3.connect("users.db")
+    c = conn.cursor()
+    query = "SELECT patient_name, age, gender, symptoms, diagnosis, medication, therapy, summary, explanation, pdf_report, session_timestamp FROM patient_sessions WHERE 1=1"
+    params = []
+    if filter_name:
+        query += " AND patient_name LIKE ?"
+        params.append(f"%{filter_name}%")
+    if filter_date:
+        query += " AND DATE(session_timestamp)=?"
+        params.append(filter_date)
+    c.execute(query, params)
+    sessions = c.fetchall()
+    conn.close()
+    return sessions
+
+def insert_patient_session(session_data):
+    conn = sqlite3.connect("users.db")
+    c = conn.cursor()
+    c.execute("""
+        INSERT INTO patient_sessions (username, patient_name, age, gender, symptoms, diagnosis, medication, therapy, summary, explanation, pdf_report, appointment_date)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    """, (
+        session_data.get("username"), session_data.get("patient_name"), session_data.get("age"), session_data.get("gender"),
+        session_data.get("symptoms"), session_data.get("diagnosis"), session_data.get("medication"),
+        session_data.get("therapy"), session_data.get("summary"), session_data.get("explanation"),
+        session_data.get("pdf_report"), session_data.get("appointment_date")))
+    conn.commit()
+    conn.close()
+
+# --------------------------
+# PDF Report Generation Function
+# --------------------------
+def generate_pdf_report(session_data):
+    pdf = FPDF()
+    pdf.add_page()
+    pdf.set_font("Arial", size=12)
+    pdf.cell(200, 10, txt="Patient Session Report", ln=True, align='C')
+    pdf.ln(10)
+    for key, value in session_data.items():
+        pdf.multi_cell(0, 10, txt=f"{key.capitalize()}: {value}")
+    reports_dir = "reports"
+    os.makedirs(reports_dir, exist_ok=True)
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    filename = f"{reports_dir}/{session_data.get('patient_name')}_{timestamp}.pdf"
+    pdf.output(filename)
+    return filename
+
+# --------------------------
+# Helper: Autofill Previous Patient Info
+# --------------------------
+def get_previous_patient_info(selected_patient):
+    conn = sqlite3.connect("users.db")
+    c = conn.cursor()
+    c.execute("SELECT patient_name, age, gender FROM patient_sessions WHERE patient_name=? ORDER BY session_timestamp DESC LIMIT 1", (selected_patient,))
+    record = c.fetchone()
+    conn.close()
+    if record:
+        return record[0], record[1], record[2]
+    else:
+        return "", None, ""
+
+def get_previous_patients():
+    conn = sqlite3.connect("users.db")
+    c = conn.cursor()
+    c.execute("SELECT DISTINCT patient_name FROM patient_sessions")
+    records = c.fetchall()
+    conn.close()
+    return [r[0] for r in records]
+
+# --------------------------
+# Gradio UI Setup with External CSS
+# --------------------------
+with gr.Blocks(css=open("styles.css", "r").read(), theme="soft") as app:
+    user_session = gr.State(value="")
+    profile_visible = gr.State(value=False)
+    session_data_state = gr.State(value="")
+
+    with gr.Row(elem_id="header") as header_row:
+        with gr.Column(scale=8):
+            gr.Markdown("## Mental Health Chatbot")
+        with gr.Column(scale=4) as profile_container:
+            profile_button = gr.Button("👤", elem_id="profile_button", variant="secondary")
+            with gr.Column(visible=False, elem_id="profile_info_box") as profile_info_box:
+                profile_info = gr.HTML()
+                logout_button = gr.Button("Logout", elem_id="logout_button")
+
+    with gr.Column(visible=True, elem_id="login_page") as login_page:
+        gr.Markdown("## Login")
+        with gr.Row():
+            username_login = gr.Textbox(label="Username")
+            password_login = gr.Textbox(label="Password", type="password")
+        login_btn = gr.Button("Login")
+        login_output = gr.Textbox(label="Login Status", interactive=False)
+        gr.Markdown("New user? Click below to register.")
+        go_to_register = gr.Button("Go to Register")
+
+    with gr.Column(visible=False, elem_id="register_page") as register_page:
+        gr.Markdown("## Register")
+        new_username = gr.Textbox(label="New Username")
+        new_password = gr.Textbox(label="New Password", type="password")
+        full_name = gr.Textbox(label="Full Name")
+        email = gr.Textbox(label="Email")
+        register_btn = gr.Button("Register")
+        register_output = gr.Textbox(label="Registration Status", interactive=False)
+        gr.Markdown("Already have an account?")
+        back_to_login = gr.Button("Back to Login")
+
+    with gr.Tabs(visible=False, elem_id="main_panel") as main_panel:
+        with gr.Tab("Chatbot"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    previous_patient = gr.Dropdown(label="Previous Patients", choices=[], interactive=True)
+                    patient_name_input = gr.Textbox(placeholder="Enter patient name", label="Patient Name")
+                    gender_input = gr.Dropdown(choices=list(gender_encoder.keys()), label="Gender")
+                    age_input = gr.Number(label="Age")
+                    symptoms_input = gr.Textbox(placeholder="Describe symptoms", label="Symptoms", lines=4)
+                    submit = gr.Button("Submit")
+                    generate_report_btn = gr.Button("Generate Report", visible=False)
+                with gr.Column(scale=1):
+                    with gr.Row():
+                        with gr.Column(scale=4, min_width=240):  # Textbox column
+                            diagnosis_textbox = gr.Textbox(label="Diagnosis", 
+                                                        interactive=False)
+                        with gr.Column(scale=1, min_width=120):  # Confidence column
+                            diagnosis_conf_html = gr.HTML(elem_classes=["confidence-container"])
+
+                    with gr.Row():
+                        with gr.Column(scale=4, min_width=240):
+                            medication_textbox = gr.Textbox(label="Medication", 
+                                                        interactive=False)
+                        with gr.Column(scale=1, min_width=120):
+                            medication_conf_html = gr.HTML(elem_classes=["confidence-container"])
+
+                    with gr.Row():
+                        with gr.Column(scale=4, min_width=240):
+                            therapy_textbox = gr.Textbox(label="Therapy", 
+                                                    interactive=False)
+                        with gr.Column(scale=1, min_width=120):
+                            therapy_conf_html = gr.HTML(elem_classes=["confidence-container"])
+                    summary_textbox = gr.Textbox(label="Concise Summary", interactive=False)
+                    explanation_textbox = gr.Textbox(label="Explanation", interactive=False)
+            with gr.Row():
+                report_download = gr.File(label="Download Report", interactive=False)
+
+            def handle_chat_extended(patient_name, gender, age, symptoms):
+                if age is None or age <= 0:
+                    error_msg = "Age must be greater than 0."
+                    return (error_msg, "", error_msg, "", error_msg, "", error_msg, error_msg, gr.update(visible=False))
+                
+                if age > 150:
+                    error_msg2 = "Age must be lower than 150"
+                    return (error_msg2, "", error_msg2, "", error_msg2, "", error_msg2, error_msg2, gr.update(visible=False))
+                
+                if len(symptoms.split()) > 512:
+                    msg = "Input exceeds maximum allowed length of 512 words."
+                    return (msg, "", msg, "", msg, "", msg, msg, gr.update(visible=False))
+
+                full_statement = f"Patient Name: {patient_name}, Gender: {gender}, Age: {age}, Symptoms: {symptoms}"
+                summary = get_concise_rewrite(full_statement, max_tokens=150, temperature=0.7)
+
+                # Predict top 3 diagnoses
+                diagnosis_preds = predict_disease(full_statement)  # Now returns list of (label, confidence)
+                diagnosis_display = "\n".join([f"{label}" for label, _ in diagnosis_preds])
+
+                def get_confidence_class(percentage):
+                    if percentage <= 50:
+                        return "confidence-low"
+                    elif percentage <= 74:
+                        return "confidence-medium"
+                    else:
+                        return "confidence-high"
+
+                diagnosis_conf_html_val = "<div class='confidence-multi'>" + "<br>".join([
+                    f"<div class='confidence-display'><span class='confidence-value {get_confidence_class(conf * 100)}'>{conf * 100:.1f}% confidence</span></div>"
+                    for _, conf in diagnosis_preds
+                ]) + "</div>"
+
+                # Predict medication and therapy
+                (med_pred, med_conf), (therapy_pred, therapy_conf) = predict_med_therapy(symptoms, age, gender)
+                med_percentage = med_conf * 100
+                therapy_percentage = therapy_conf * 100
+
+                def get_conf_html(percentage):
+                    return f"""
+                    <div class="confidence-display">
+                        <span class="confidence-value {get_confidence_class(percentage)}">
+                            {percentage:.1f}% confidence
+                        </span>
+                    </div>
+                    """
+
+                medication_conf_html_val = get_conf_html(med_percentage)
+                therapy_conf_html_val = get_conf_html(therapy_percentage)
+
+                # Explanation
+                top_diag_labels = ", ".join([label for label, _ in diagnosis_preds])
+                explanation = get_explanation(full_statement, f"{top_diag_labels}, {med_pred} and {therapy_pred}")
+
+                # Prepare session data
+                top_diag_with_conf = ", ".join([f"{label} ({conf * 100:.1f}%)" for label, conf in diagnosis_preds])
+                session_data = {
+                    "patient_name": patient_name,
+                    "age": age,
+                    "gender": gender,
+                    "symptoms": symptoms,
+                    "diagnosis": top_diag_with_conf,
+                    "medication": f"{med_pred} ({med_percentage:.1f}% confidence)",
+                    "therapy": f"{therapy_pred} ({therapy_percentage:.1f}% confidence)",
+                    "summary": summary,
+                    "explanation": explanation,
+                    "session_timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                }
+                session_data_state.value = json.dumps(session_data)
+
+                # Save to chat history
+                conn = sqlite3.connect("users.db")
+                c = conn.cursor()
+                if user_session.value:
+                    c.execute("INSERT INTO chat_history (username, message, response) VALUES (?, ?, ?)",
+                            (user_session.value, full_statement, top_diag_with_conf))
+                    conn.commit()
+                conn.close()
+
+                return (
+                    diagnosis_display, diagnosis_conf_html_val,
+                    med_pred, medication_conf_html_val,
+                    therapy_pred, therapy_conf_html_val,
+                    summary, explanation,
+                    gr.update(visible=True)
+                )
+
+
+            submit.click(handle_chat_extended,
+                         inputs=[patient_name_input, gender_input, age_input, symptoms_input],
+                         outputs=[diagnosis_textbox, diagnosis_conf_html, medication_textbox, medication_conf_html,
+                                  therapy_textbox, therapy_conf_html, summary_textbox, explanation_textbox,
+                                  generate_report_btn])
+
+            def handle_generate_report():
+                try:
+                    data = json.loads(session_data_state.value)
+                except:
+                    return None
+                pdf_file = generate_pdf_report(data)
+                data["username"] = user_session.value
+                data["appointment_date"] = ""
+                data["pdf_report"] = pdf_file
+                insert_patient_session(data)
+                return pdf_file
+
+            generate_report_btn.click(handle_generate_report, outputs=report_download)
+
+            def autofill_previous(selected_patient):
+                name, age_val, gender_val = get_previous_patient_info(selected_patient)
+                return name, age_val, gender_val
+
+            previous_patient.change(autofill_previous,
+                                    inputs=[previous_patient],
+                                    outputs=[patient_name_input, age_input, gender_input])
+
+        with gr.Tab("Chat History"):
+            history_output = gr.Textbox(label="Chat History", interactive=False)
+            load_history_btn = gr.Button("Load History")
+
+            def load_history():
+                if user_session.value:
+                    history = get_chat_history(user_session.value)
+                    return "\n".join([f"[{h[2]}] {h[0]}\nBot: {h[1]}" for h in history])
+                else:
+                    return "Please log in to view history."
+
+            load_history_btn.click(load_history, outputs=history_output)
+
+        with gr.Tab("Book an Appointment"):
+            with gr.Row():
+                with gr.Column():
+                    patient_name_appt = gr.Textbox(label="Patient Name", placeholder="Enter your name")
+                    doctor_name = gr.Dropdown(choices=["Dr. Smith", "Dr. Johnson", "Dr. Lee"], label="Select Doctor")
+                    appointment_date = gr.Textbox(label="Appointment Date", placeholder="YYYY-MM-DD")
+                    appointment_time = gr.Textbox(label="Appointment Time", placeholder="HH:MM (24-hour format)")
+                    reason = gr.TextArea(label="Reason for Visit", placeholder="Describe your symptoms or reason for the visit")
+                    book_button = gr.Button("Book Appointment")
+                with gr.Column():
+                    booking_output = gr.Textbox(label="Booking Confirmation", interactive=False)
+
+            def book_appointment(patient_name, doctor_name, appointment_date, appointment_time, reason):
+                if not user_session.value:
+                    return "Please log in to book an appointment."
+                patient_name = (patient_name or "").strip()
+                doctor_name = (doctor_name or "").strip()
+                appointment_date = (appointment_date or "").strip()
+                appointment_time = (appointment_time or "").strip()
+                reason = (reason or "").strip()
+                if not (patient_name and doctor_name and appointment_date and appointment_time and reason):
+                    return "Please fill in all the fields."
+                if not re.fullmatch(r"[A-Za-z ]+", patient_name):
+                    return "Patient name should contain only letters and spaces."
+                try:
+                    datetime.strptime(appointment_date, "%Y-%m-%d")
+                except ValueError:
+                    return "Appointment date must be in YYYY-MM-DD format."
+                try:
+                    datetime.strptime(appointment_time, "%H:%M")
+                except ValueError:
+                    return "Appointment time must be in HH:MM (24-hour) format."
+                confirmation = (f"Appointment booked for {patient_name} with {doctor_name} on {appointment_date} at {appointment_time}.\n\n"
+                                f"Reason: {reason}")
+                return confirmation
+
+            book_button.click(book_appointment,
+                              inputs=[patient_name_appt, doctor_name, appointment_date, appointment_time, reason],
+                              outputs=booking_output)
+
+        with gr.Tab("Patient Sessions"):
+            gr.Markdown("### Search Patient Sessions")
+            search_name = gr.Textbox(label="Patient Name (optional)")
+            search_date = gr.Textbox(label="Date (YYYY-MM-DD, optional)")
+            search_button = gr.Button("Search")
+            sessions_output = gr.Textbox(label="Sessions", interactive=False)
+
+            def search_sessions(name, date):
+                sessions = get_patient_sessions(filter_name=name, filter_date=date)
+                if sessions:
+                    output = "\n\n".join([f"Patient: {s[0]}\nAge: {s[1]}\nGender: {s[2]}\nSymptoms: {s[3]}\nDiagnosis: {s[4]}\nMedication: {s[5]}\nTherapy: {s[6]}\nSummary: {s[7]}\nExplanation: {s[8]}\nReport: {s[9]}\nSession Time: {s[10]}" for s in sessions])
+                    return output
+                else:
+                    return "No sessions found."
+
+            search_button.click(search_sessions, inputs=[search_name, search_date], outputs=sessions_output)
+
+    def handle_login(username, password):
+        if login_user(username, password):
+            user_session.value = username
+            prev_choices = get_previous_patients()
+            return (f"Welcome, {username}!",
+                    gr.update(visible=True),
+                    gr.update(visible=False),
+                    gr.update(visible=True),
+                    gr.update(choices=prev_choices))
+        else:
+            return "Invalid credentials.", gr.update(), gr.update(), gr.update(), gr.update()
+
+    def handle_register(username, password, full_name, email):
+        return register_user(username, password, full_name, email)
+
+    def go_to_register_page():
+        return gr.update(visible=False), gr.update(visible=True)
+
+    def back_to_login_page():
+        return gr.update(visible=True), gr.update(visible=False)
+
+    login_btn.click(handle_login,
+                    inputs=[username_login, password_login],
+                    outputs=[login_output, main_panel, login_page, header_row])
+    go_to_register.click(go_to_register_page, outputs=[login_page, register_page])
+    register_btn.click(handle_register,
+                       inputs=[new_username, new_password, full_name, email],
+                       outputs=register_output)
+    back_to_login.click(back_to_login_page, outputs=[login_page, register_page])
+
+
+    # Toggle profile function
+    def toggle_profile(user, current_visible):
+        if not user:
+            return gr.update(visible=False), False, ""
+        new_visible = not current_visible
+        info = get_user_info(user) if new_visible else ""
+        return gr.update(visible=new_visible), new_visible, info
+
+
+    # Connect profile button click with correct input order:
+    profile_button.click(
+        toggle_profile,
+        inputs=[user_session, profile_visible],
+        outputs=[profile_info_box, profile_visible, profile_info]
+    )
+
+
+    # Handle login: update previous patients dropdown
+    def handle_login(username, password):
+        if login_user(username, password):
+            user_session.value = username
+            prev_choices = get_previous_patients()
+            return (f"Welcome, {username}!",
+                    gr.update(visible=True),  # main_panel visible
+                    gr.update(visible=False),  # login_page hidden
+                    gr.update(visible=True),  # header_row visible
+                    gr.update(choices=prev_choices))  # update dropdown choices
+        else:
+            return "Invalid credentials.", gr.update(), gr.update(), gr.update(), gr.update()
+
+
+    # Connect login button click:
+    login_btn.click(
+        handle_login,
+        inputs=[username_login, password_login],
+        outputs=[login_output, main_panel, login_page, header_row, previous_patient]
+    )
+
+init_db()
+app.launch()