Update app.py

app.py

@@ -1,117 +1,966 @@
-# Hospital Queue Management System - Gradio App for Hugging Face
-# Features: Multiple Doctors, Patient Queue, Phone Number Status Check
+# Enhanced Hospital Queue Management System - Gradio App for Hugging Face
+# Features: Multiple Doctors, Patient Queue, Phone Number Status Check, Appointment Scheduling, Estimated Wait Times
 
 import sqlite3
 import gradio as gr
+import pandas as pd
+import time
+from datetime import datetime, timedelta
+import random
+import string
+import os
 
 # ---------------------------
 # DATABASE SETUP
 # ---------------------------
-conn = sqlite3.connect("hospital.db", check_same_thread=False)
+def get_db_connection():
+    """Create a database connection with proper error handling"""
+    try:
+        conn = sqlite3.connect("hospital.db", check_same_thread=False)
+        conn.row_factory = sqlite3.Row  # Return rows as dictionaries
+        return conn
+    except sqlite3.Error as e:
+        print(f"Database connection error: {e}")
+        return None
+
+conn = get_db_connection()
 cursor = conn.cursor()
+
+# Create tables with improved schema
 cursor.execute('''CREATE TABLE IF NOT EXISTS doctors (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
-    name TEXT NOT NULL
+    name TEXT NOT NULL,
+    specialty TEXT,
+    avg_consultation_time INTEGER DEFAULT 15,  # in minutes
+    available BOOLEAN DEFAULT 1
 )''')
+
 cursor.execute('''CREATE TABLE IF NOT EXISTS patients (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
-    name TEXT,
-    phone TEXT,
+    name TEXT NOT NULL,
+    phone TEXT NOT NULL,
+    email TEXT,
     symptoms TEXT,
+    priority INTEGER DEFAULT 3,  # 1=emergency, 2=urgent, 3=normal
     doctor_id INTEGER,
     queue_number INTEGER,
+    token TEXT UNIQUE,
+    registration_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    estimated_start_time TIMESTAMP,
     status TEXT DEFAULT 'Waiting',
+    completed_time TIMESTAMP,
+    notes TEXT,
+    FOREIGN KEY (doctor_id) REFERENCES doctors(id)
+)''')
+
+cursor.execute('''CREATE TABLE IF NOT EXISTS appointments (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    patient_name TEXT NOT NULL,
+    phone TEXT NOT NULL,
+    email TEXT,
+    doctor_id INTEGER,
+    appointment_date TEXT,
+    appointment_time TEXT,
+    reason TEXT,
+    status TEXT DEFAULT 'Scheduled',
     FOREIGN KEY (doctor_id) REFERENCES doctors(id)
 )''')
+
+cursor.execute('''CREATE TABLE IF NOT EXISTS notifications (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    patient_id INTEGER,
+    message TEXT,
+    sent_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (patient_id) REFERENCES patients(id)
+)''')
+
 conn.commit()
 
 # Seed doctors if table is empty
 cursor.execute("SELECT COUNT(*) FROM doctors")
 if cursor.fetchone()[0] == 0:
-    doctors = [("Dr. Smith",), ("Dr. Lee",), ("Dr. Patel",)]
-    cursor.executemany("INSERT INTO doctors (name) VALUES (?)", doctors)
+    doctors = [
+        ("Dr. Smith", "General Medicine", 15, 1),
+        ("Dr. Lee", "Pediatrics", 20, 1),
+        ("Dr. Patel", "Cardiology", 25, 1),
+        ("Dr. Johnson", "Orthopedics", 20, 1),
+        ("Dr. Garcia", "Dermatology", 15, 1)
+    ]
+    cursor.executemany("INSERT INTO doctors (name, specialty, avg_consultation_time, available) VALUES (?, ?, ?, ?)", doctors)
     conn.commit()
 
 # ---------------------------
-# CORE FUNCTIONS
+# HELPER FUNCTIONS
 # ---------------------------
-def register_patient(name, phone, symptoms, doctor_name):
-    cursor.execute("SELECT id FROM doctors WHERE name=?", (doctor_name,))
-    doctor_id = cursor.fetchone()[0]
-    cursor.execute("SELECT MAX(queue_number) FROM patients WHERE doctor_id=?", (doctor_id,))
-    last_queue = cursor.fetchone()[0]
-    next_queue = 1 if last_queue is None else last_queue + 1
-    cursor.execute("INSERT INTO patients (name, phone, symptoms, doctor_id, queue_number) VALUES (?, ?, ?, ?, ?)",
-                   (name, phone, symptoms, doctor_id, next_queue))
+def generate_token():
+    """Generate a unique alphanumeric token for patients"""
+    token = ''.join(random.choices(string.ascii_uppercase + string.digits, k=6))
+    return token
+
+def calculate_wait_time(doctor_id, queue_position):
+    """Calculate estimated wait time based on doctor's avg consultation time and queue position"""
+    cursor.execute("SELECT avg_consultation_time FROM doctors WHERE id=?", (doctor_id,))
+    avg_time = cursor.fetchone()[0]
+    
+    # Count how many patients are currently in consultation (usually just 1)
+    cursor.execute("SELECT COUNT(*) FROM patients WHERE doctor_id=? AND status='In Consultation'", (doctor_id,))
+    in_consultation = cursor.fetchone()[0]
+    
+    # Calculate wait time: (patients ahead + in consultation) * avg time
+    wait_minutes = (queue_position - 1 + in_consultation) * avg_time
+    
+    # Add some randomness to make it realistic (±20%)
+    variation = random.uniform(0.8, 1.2)
+    wait_minutes = int(wait_minutes * variation)
+    
+    return wait_minutes
+
+def format_wait_time(minutes):
+    """Format wait time into hours and minutes"""
+    if minutes < 60:
+        return f"{minutes} minutes"
+    hours = minutes // 60
+    mins = minutes % 60
+    return f"{hours} hour{'s' if hours > 1 else ''} {mins} minutes"
+
+def update_all_wait_times():
+    """Update estimated wait times for all waiting patients"""
+    # Get all waiting patients
+    cursor.execute("""
+        SELECT p.id, p.doctor_id, p.queue_number 
+        FROM patients p 
+        WHERE p.status='Waiting' 
+        ORDER BY p.doctor_id, p.queue_number
+    """)
+    waiting_patients = cursor.fetchall()
+    
+    # Group by doctor
+    for doctor_id in set([p[1] for p in waiting_patients]):
+        # Get all patients for this doctor
+        doctor_patients = [p for p in waiting_patients if p[1] == doctor_id]
+        
+        # Update wait time for each patient
+        for patient in doctor_patients:
+            wait_minutes = calculate_wait_time(doctor_id, patient[2])
+            estimated_time = datetime.now() + timedelta(minutes=wait_minutes)
+            cursor.execute(
+                "UPDATE patients SET estimated_start_time=? WHERE id=?", 
+                (estimated_time.strftime('%Y-%m-%d %H:%M:%S'), patient[0])
+            )
+    
     conn.commit()
-    return f"Registered! Your queue number is {next_queue} with {doctor_name}."
 
-def check_status(phone):
-    cursor.execute("SELECT d.name, p.queue_number, p.status FROM patients p JOIN doctors d ON p.doctor_id = d.id WHERE p.phone=? ORDER BY p.id DESC LIMIT 1", (phone,))
-    result = cursor.fetchone()
-    if result:
-        return f"Doctor: {result[0]}\nQueue #: {result[1]}\nStatus: {result[2]}"
-    return "Phone number not found."
+# ---------------------------
+# CORE FUNCTIONS
+# ---------------------------
+def register_patient(name, phone, email, symptoms, priority, doctor_name):
+    """Register a new patient with improved data validation and wait time estimation"""
+    # Input validation
+    if not name or not phone or not doctor_name:
+        return "Error: Name, phone number, and doctor selection are required."
+    
+    try:
+        # Get doctor details
+        cursor.execute("SELECT id, available FROM doctors WHERE name=?", (doctor_name,))
+        doctor_result = cursor.fetchone()
+        
+        if not doctor_result:
+            return f"Error: Doctor {doctor_name} not found."
+        
+        doctor_id, is_available = doctor_result
+        
+        if not is_available:
+            return f"Sorry, {doctor_name} is currently not available. Please select another doctor."
+        
+        # Check if patient with same phone is already in queue
+        cursor.execute("SELECT id FROM patients WHERE phone=? AND status IN ('Waiting', 'In Consultation')", (phone,))
+        if cursor.fetchone():
+            return "This phone number is already registered in the active queue."
+        
+        # Get next queue number
+        cursor.execute("SELECT MAX(queue_number) FROM patients WHERE doctor_id=?", (doctor_id,))
+        last_queue = cursor.fetchone()[0]
+        next_queue = 1 if last_queue is None else last_queue + 1
+        
+        # Generate unique token
+        token = generate_token()
+        while True:
+            # Check if token already exists
+            cursor.execute("SELECT id FROM patients WHERE token=?", (token,))
+            if not cursor.fetchone():
+                break
+            token = generate_token()  # Generate new token if exists
+            
+        # Calculate estimated wait time
+        wait_minutes = calculate_wait_time(doctor_id, next_queue)
+        estimated_time = datetime.now() + timedelta(minutes=wait_minutes)
+        
+        # Insert patient
+        cursor.execute("""
+            INSERT INTO patients 
+            (name, phone, email, symptoms, priority, doctor_id, queue_number, token, estimated_start_time, status) 
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """, (name, phone, email, symptoms, priority, doctor_id, next_queue, token, 
+              estimated_time.strftime('%Y-%m-%d %H:%M:%S'), 'Waiting'))
+        conn.commit()
+        
+        # Get patient ID for notification
+        patient_id = cursor.lastrowid
+        
+        # Add welcome notification
+        notification_msg = f"Welcome {name}! You are registered with {doctor_name}. Your token is {token} and queue number is {next_queue}."
+        cursor.execute("INSERT INTO notifications (patient_id, message) VALUES (?, ?)", 
+                      (patient_id, notification_msg))
+        conn.commit()
+        
+        # Update wait times for all patients
+        update_all_wait_times()
+        
+        # Format response
+        wait_time_str = format_wait_time(wait_minutes)
+        return f"Registered successfully!\n\nYour token: {token}\nQueue number: {next_queue}\nDoctor: {doctor_name}\nEstimated wait time: {wait_time_str}"
+        
+    except Exception as e:
+        conn.rollback()
+        return f"An error occurred: {str(e)}"
+
+def check_status(phone_or_token):
+    """Check patient status by phone or token"""
+    if not phone_or_token:
+        return "Please enter a phone number or token."
+        
+    try:
+        # Try to find by token first (more specific)
+        cursor.execute("""
+            SELECT 
+                p.id, p.name, p.token, p.queue_number, p.status, p.estimated_start_time,
+                d.name as doctor_name, d.specialty
+            FROM patients p 
+            JOIN doctors d ON p.doctor_id = d.id 
+            WHERE p.token=? AND p.status IN ('Waiting', 'In Consultation')
+            LIMIT 1
+        """, (phone_or_token,))
+        
+        result = cursor.fetchone()
+        
+        # If not found by token, try phone
+        if not result:
+            cursor.execute("""
+                SELECT 
+                    p.id, p.name, p.token, p.queue_number, p.status, p.estimated_start_time,
+                    d.name as doctor_name, d.specialty
+                FROM patients p 
+                JOIN doctors d ON p.doctor_id = d.id 
+                WHERE p.phone=? AND p.status IN ('Waiting', 'In Consultation')
+                ORDER BY p.id DESC LIMIT 1
+            """, (phone_or_token,))
+            result = cursor.fetchone()
+        
+        if not result:
+            return "No active registration found. If you've already completed your visit or haven't registered yet, please check with reception."
+        
+        # Format estimated time
+        estimated_time = datetime.strptime(result[5], '%Y-%m-%d %H:%M:%S') if result[5] else None
+        now = datetime.now()
+        
+        if estimated_time and estimated_time > now:
+            time_diff = estimated_time - now
+            wait_minutes = int(time_diff.total_seconds() / 60)
+            wait_str = format_wait_time(wait_minutes)
+        else:
+            wait_str = "You should be called soon"
+        
+        status_info = f"""
+        Patient: {result[1]}
+        Token: {result[2]}
+        Queue #: {result[3]}
+        Status: {result[4]}
+        Doctor: {result[6]} ({result[7]})
+        """
+        
+        if result[4] == 'Waiting':
+            status_info += f"Estimated wait: {wait_str}"
+            
+        # Get any notifications
+        cursor.execute("""
+            SELECT message FROM notifications 
+            WHERE patient_id=? 
+            ORDER BY sent_time DESC LIMIT 1
+        """, (result[0],))
+        
+        notification = cursor.fetchone()
+        if notification:
+            status_info += f"\n\nNotification: {notification[0]}"
+            
+        return status_info
+        
+    except Exception as e:
+        return f"Error checking status: {str(e)}"
 
 def get_doctor_queue(doctor_name):
-    cursor.execute("SELECT id FROM doctors WHERE name=?", (doctor_name,))
-    doctor_id = cursor.fetchone()[0]
-    cursor.execute("SELECT id, name, queue_number, status FROM patients WHERE doctor_id=? ORDER BY queue_number", (doctor_id,))
-    rows = cursor.fetchall()
-    return rows
+    """Get current queue for a specific doctor"""
+    try:
+        cursor.execute("SELECT id FROM doctors WHERE name=?", (doctor_name,))
+        doctor_id = cursor.fetchone()[0]
+        
+        cursor.execute("""
+            SELECT 
+                id, name, queue_number, priority, 
+                strftime('%H:%M', registration_time) as reg_time, 
+                status, phone, token 
+            FROM patients 
+            WHERE doctor_id=? AND status IN ('Waiting', 'In Consultation')
+            ORDER BY 
+                CASE status 
+                    WHEN 'In Consultation' THEN 0 
+                    ELSE 1 
+                END,
+                priority, queue_number
+        """, (doctor_id,))
+        
+        rows = cursor.fetchall()
+        
+        # Convert to list of lists for gradio dataframe
+        result = []
+        for row in rows:
+            # Format priority as text
+            priority_text = {1: "Emergency", 2: "Urgent", 3: "Normal"}.get(row[3], "Normal")
+            
+            result.append([row[0], row[1], row[2], priority_text, row[4], row[5], row[6], row[7]])
+            
+        return result
+        
+    except Exception as e:
+        print(f"Error getting doctor queue: {e}")
+        return []
+
+def get_doctor_availability():
+    """Get the list of available doctors with their specialties"""
+    cursor.execute("""
+        SELECT id, name, specialty, available 
+        FROM doctors 
+        ORDER BY name
+    """)
+    doctors = cursor.fetchall()
+    
+    # Format for display
+    result = []
+    for doc in doctors:
+        status = "Available" if doc[3] else "Unavailable"
+        result.append([doc[0], doc[1], doc[2], status])
+    
+    return result
+
+def toggle_doctor_availability(doctor_id):
+    """Toggle a doctor's availability status"""
+    try:
+        if not doctor_id:
+            return "Please select a doctor."
+            
+        cursor.execute("SELECT available FROM doctors WHERE id=?", (doctor_id,))
+        current_status = cursor.fetchone()[0]
+        
+        # Toggle status
+        new_status = 0 if current_status else 1
+        cursor.execute("UPDATE doctors SET available=? WHERE id=?", (new_status, doctor_id))
+        conn.commit()
+        
+        status_text = "available" if new_status else "unavailable"
+        return f"Doctor status updated to {status_text}"
+        
+    except Exception as e:
+        conn.rollback()
+        return f"Error updating status: {str(e)}"
 
 def call_next(doctor_name):
-    cursor.execute("SELECT id FROM doctors WHERE name=?", (doctor_name,))
-    doctor_id = cursor.fetchone()[0]
-    cursor.execute("SELECT id, name FROM patients WHERE doctor_id=? AND status='Waiting' ORDER BY queue_number ASC LIMIT 1", (doctor_id,))
-    patient = cursor.fetchone()
-    if patient:
+    """Call the next patient in queue with notifications"""
+    try:
+        cursor.execute("SELECT id FROM doctors WHERE name=?", (doctor_name,))
+        doctor_id = cursor.fetchone()[0]
+        
+        # First check if any patient is currently in consultation
+        cursor.execute("""
+            SELECT id, name 
+            FROM patients 
+            WHERE doctor_id=? AND status='In Consultation'
+            LIMIT 1
+        """, (doctor_id,))
+        current_patient = cursor.fetchone()
+        
+        if current_patient:
+            return f"{current_patient[1]} is currently in consultation. Please complete their visit before calling the next patient."
+        
+        # Find next patient based on priority and queue number
+        cursor.execute("""
+            SELECT id, name, token, queue_number, phone 
+            FROM patients 
+            WHERE doctor_id=? AND status='Waiting' 
+            ORDER BY priority, queue_number ASC 
+            LIMIT 1
+        """, (doctor_id,))
+        
+        patient = cursor.fetchone()
+        
+        if not patient:
+            return "No patients waiting."
+        
+        # Update patient status
         cursor.execute("UPDATE patients SET status='In Consultation' WHERE id=?", (patient[0],))
+        
+        # Create notification
+        notification_msg = f"It's your turn! Please proceed to {doctor_name}'s room immediately."
+        cursor.execute("INSERT INTO notifications (patient_id, message) VALUES (?, ?)", 
+                      (patient[0], notification_msg))
+        
         conn.commit()
-        return f"Calling {patient[1]} for consultation."
-    return "No patients waiting."
+        
+        # Update wait times for all remaining patients
+        update_all_wait_times()
+        
+        # Return formatted message
+        return f"Now calling: {patient[1]} (Token: {patient[2]}, Queue #: {patient[3]})"
+        
+    except Exception as e:
+        conn.rollback()
+        return f"Error calling next patient: {str(e)}"
 
-def complete_patient(patient_id):
-    cursor.execute("UPDATE patients SET status='Completed' WHERE id=?", (patient_id,))
-    conn.commit()
-    return f"Patient ID {patient_id} marked as completed."
+def complete_patient(patient_id, notes=""):
+    """Mark patient consultation as completed with optional notes"""
+    try:
+        if not patient_id:
+            return "Please select a patient to mark as completed."
+            
+        # Update patient status and add completion time
+        cursor.execute(
+            "UPDATE patients SET status='Completed', completed_time=?, notes=? WHERE id=?", 
+            (datetime.now().strftime('%Y-%m-%d %H:%M:%S'), notes, patient_id)
+        )
+        
+        # Get patient info for confirmation
+        cursor.execute("SELECT name, token FROM patients WHERE id=?", (patient_id,))
+        patient = cursor.fetchone()
+        
+        conn.commit()
+        
+        # Update wait times for all remaining patients
+        update_all_wait_times()
+        
+        return f"Patient {patient[0]} (Token: {patient[1]}) marked as completed."
+        
+    except Exception as e:
+        conn.rollback()
+        return f"Error completing patient visit: {str(e)}"
+
+def schedule_appointment(name, phone, email, doctor_name, date, time, reason):
+    """Schedule a future appointment"""
+    try:
+        # Validate inputs
+        if not name or not phone or not doctor_name or not date or not time:
+            return "Error: Name, phone, doctor, date and time are required fields."
+            
+        # Get doctor ID
+        cursor.execute("SELECT id FROM doctors WHERE name=?", (doctor_name,))
+        doctor_result = cursor.fetchone()
+        
+        if not doctor_result:
+            return f"Error: Doctor {doctor_name} not found."
+            
+        doctor_id = doctor_result[0]
+        
+        # Check if time slot is available
+        cursor.execute("""
+            SELECT COUNT(*) FROM appointments 
+            WHERE doctor_id=? AND appointment_date=? AND appointment_time=? AND status='Scheduled'
+        """, (doctor_id, date, time))
+        
+        if cursor.fetchone()[0] > 0:
+            return f"Sorry, {doctor_name} is already booked at {time} on {date}. Please select another time."
+            
+        # Insert appointment
+        cursor.execute("""
+            INSERT INTO appointments
+            (patient_name, phone, email, doctor_id, appointment_date, appointment_time, reason, status)
+            VALUES (?, ?, ?, ?, ?, ?, ?, 'Scheduled')
+        """, (name, phone, email, doctor_id, date, time, reason))
+        
+        conn.commit()
+        
+        return f"Appointment scheduled successfully for {name} with {doctor_name} on {date} at {time}."
+        
+    except Exception as e:
+        conn.rollback()
+        return f"Error scheduling appointment: {str(e)}"
+
+def get_appointments(date=None, doctor_name=None):
+    """Get list of appointments by date and/or doctor"""
+    try:
+        query = """
+            SELECT 
+                a.id, a.patient_name, a.phone, a.appointment_time, 
+                d.name as doctor_name, a.reason, a.status
+            FROM appointments a
+            JOIN doctors d ON a.doctor_id = d.id
+            WHERE 1=1
+        """
+        params = []
+        
+        if date:
+            query += " AND a.appointment_date = ?"
+            params.append(date)
+            
+        if doctor_name and doctor_name != "All Doctors":
+            query += " AND d.name = ?"
+            params.append(doctor_name)
+            
+        query += " ORDER BY a.appointment_time"
+        
+        cursor.execute(query, params)
+        appointments = cursor.fetchall()
+        
+        # Format for display
+        result = []
+        for appt in appointments:
+            result.append([appt[0], appt[1], appt[2], appt[3], appt[4], appt[5], appt[6]])
+            
+        return result
+        
+    except Exception as e:
+        print(f"Error getting appointments: {e}")
+        return []
+
+def get_daily_stats():
+    """Get daily statistics for the dashboard"""
+    try:
+        today = datetime.now().strftime('%Y-%m-%d')
+        
+        # Total patients today
+        cursor.execute("""
+            SELECT COUNT(*) FROM patients 
+            WHERE date(registration_time) = ?
+        """, (today,))
+        total_patients = cursor.fetchone()[0]
+        
+        # Waiting patients
+        cursor.execute("SELECT COUNT(*) FROM patients WHERE status='Waiting'")
+        waiting_patients = cursor.fetchone()[0]
+        
+        # In consultation
+        cursor.execute("SELECT COUNT(*) FROM patients WHERE status='In Consultation'")
+        in_consultation = cursor.fetchone()[0]
+        
+        # Completed today
+        cursor.execute("""
+            SELECT COUNT(*) FROM patients 
+            WHERE status='Completed' AND date(completed_time) = ?
+        """, (today,))
+        completed_today = cursor.fetchone()[0]
+        
+        # Average wait time today
+        cursor.execute("""
+            SELECT AVG(
+                (julianday(completed_time) - julianday(registration_time)) * 24 * 60
+            ) FROM patients 
+            WHERE status='Completed' AND date(completed_time) = ?
+        """, (today,))
+        avg_wait_time = cursor.fetchone()[0]
+        avg_wait_formatted = f"{int(avg_wait_time)} minutes" if avg_wait_time else "N/A"
+        
+        return {
+            "total_patients": total_patients,
+            "waiting": waiting_patients,
+            "in_consultation": in_consultation,
+            "completed": completed_today,
+            "avg_wait_time": avg_wait_formatted
+        }
+        
+    except Exception as e:
+        print(f"Error getting stats: {e}")
+        return {
+            "total_patients": 0,
+            "waiting": 0,
+            "in_consultation": 0,
+            "completed": 0,
+            "avg_wait_time": "N/A"
+        }
 
 # ---------------------------
 # GRADIO INTERFACE
 # ---------------------------
+def get_doctor_names():
+    """Get list of available doctor names"""
+    cursor.execute("SELECT name FROM doctors WHERE available=1 ORDER BY name")
+    doctors = [row[0] for row in cursor.fetchall()]
+    return doctors
 
-doctor_names = [row[0] for row in cursor.execute("SELECT name FROM doctors").fetchall()]
+def get_all_doctor_names():
+    """Get list of all doctor names regardless of availability"""
+    cursor.execute("SELECT name FROM doctors ORDER BY name")
+    doctors = [row[0] for row in cursor.fetchall()]
+    return doctors
 
-with gr.Blocks() as demo:
-    gr.Markdown("# 🏥 Hospital Queue Management System")
+# Create the Gradio interface with theme and improved UI
+theme = gr.themes.Soft(
+    primary_hue="blue",
+    secondary_hue="indigo",
+)
 
+with gr.Blocks(theme=theme, title="Hospital Queue Management System") as demo:
+    gr.Markdown("# 🏥 Hospital Queue Management System")
+    
+    # Dashboard Tab
+    with gr.Tab("📊 Dashboard"):
+        gr.Markdown("### Today's Statistics")
+        
+        with gr.Row():
+            total_count = gr.Textbox(label="Total Patients Today")
+            waiting_count = gr.Textbox(label="Currently Waiting")
+            consulting_count = gr.Textbox(label="In Consultation")
+            completed_count = gr.Textbox(label="Completed Today")
+            avg_wait = gr.Textbox(label="Average Wait Time")
+            
+        refresh_stats_btn = gr.Button("Refresh Statistics")
+        
+        def update_dashboard():
+            stats = get_daily_stats()
+            return [
+                stats["total_patients"],
+                stats["waiting"],
+                stats["in_consultation"],
+                stats["completed"],
+                stats["avg_wait_time"]
+            ]
+            
+        refresh_stats_btn.click(
+            fn=update_dashboard, 
+            inputs=[], 
+            outputs=[total_count, waiting_count, consulting_count, completed_count, avg_wait]
+        )
+        
+        # Initialize dashboard
+        demo.load(
+            fn=update_dashboard, 
+            inputs=[], 
+            outputs=[total_count, waiting_count, consulting_count, completed_count, avg_wait]
+        )
+    
+    # Patient Registration Tab
     with gr.Tab("➕ Register Patient"):
+        gr.Markdown("### New Patient Registration")
+        
+        with gr.Row():
+            name = gr.Textbox(label="Patient Name*", placeholder="Enter full name")
+            phone = gr.Textbox(label="Phone Number*", placeholder="Enter phone number")
+            
         with gr.Row():
-            name = gr.Textbox(label="Patient Name")
-            phone = gr.Textbox(label="Phone Number")
-        symptoms = gr.Textbox(label="Symptoms")
-        doctor = gr.Dropdown(choices=doctor_names, label="Select Doctor")
-        register_btn = gr.Button("Register")
-        register_output = gr.Textbox(label="Response")
-        register_btn.click(fn=register_patient, inputs=[name, phone, symptoms, doctor], outputs=register_output)
+            email = gr.Textbox(label="Email (Optional)", placeholder="Enter email address")
+            priority = gr.Dropdown(
+                choices=[
+                    {"label": "Normal", "value": 3},
+                    {"label": "Urgent", "value": 2},
+                    {"label": "Emergency", "value": 1}
+                ],
+                label="Priority",
+                value=3
+            )
+            
+        symptoms = gr.Textbox(
+            label="Symptoms/Reason for Visit",
+            placeholder="Briefly describe the symptoms or reason for visit",
+            lines=3
+        )
+        
+        doctor = gr.Dropdown(
+            choices=get_doctor_names,
+            label="Select Doctor*",
+            info="Only shows available doctors"
+        )
+        
+        register_btn = gr.Button("Register Patient", variant="primary")
+        register_output = gr.Textbox(label="Registration Details", lines=6)
+        
+        register_btn.click(
+            fn=register_patient, 
+            inputs=[name, phone, email, symptoms, priority, doctor], 
+            outputs=register_output
+        )
 
+    # Status Check Tab
     with gr.Tab("🔍 Check My Status"):
-        phone_lookup = gr.Textbox(label="Enter Your Phone Number")
-        check_btn = gr.Button("Check Status")
-        status_output = gr.Textbox(label="Queue Info")
+        gr.Markdown("### Patient Status Lookup")
+        
+        phone_lookup = gr.Textbox(
+            label="Enter Your Phone Number or Token", 
+            placeholder="Enter phone number or 6-digit token",
+            info="You can use either your phone number or token to check your status"
+        )
+        
+        check_btn = gr.Button("Check Status", variant="primary")
+        status_output = gr.Textbox(label="Your Status", lines=8)
+        
         check_btn.click(fn=check_status, inputs=phone_lookup, outputs=status_output)
 
+    # Doctor Panel Tab
     with gr.Tab("🩺 Doctor Panel"):
-        doc_select = gr.Dropdown(choices=doctor_names, label="Select Doctor")
-        call_btn = gr.Button("Call Next Patient")
-        call_output = gr.Textbox(label="Now Calling")
-        queue_table = gr.Dataframe(headers=["ID", "Name", "Queue #", "Status"], interactive=False)
+        gr.Markdown("### Manage Patient Queue")
+        
+        with gr.Row():
+            doc_select = gr.Dropdown(
+                choices=get_all_doctor_names,
+                label="Select Doctor",
+                info="Select doctor to view their queue"
+            )
+            
+            with gr.Column():
+                call_btn = gr.Button("Call Next Patient", variant="primary")
+                call_output = gr.Textbox(label="Now Calling", lines=2)
+        
+        queue_table = gr.Dataframe(
+            headers=["ID", "Name", "Queue #", "Priority", "Reg. Time", "Status", "Phone", "Token"],
+            datatype=["number", "str", "number", "str", "str", "str", "str", "str"],
+            interactive=False,
+            label="Current Queue"
+        )
+        
+        with gr.Row():
+            selected_patient_id = gr.Number(label="Patient ID", precision=0)
+            patient_notes = gr.Textbox(label="Consultation Notes", lines=2)
+            complete_btn = gr.Button("Complete Visit")
+            complete_output = gr.Textbox(label="Result")
+            
         refresh_btn = gr.Button("Refresh Queue")
 
+        # Set up event handlers
         call_btn.click(fn=call_next, inputs=doc_select, outputs=call_output)
-        refresh_btn.click(fn=lambda d: get_doctor_queue(d), inputs=doc_select, outputs=queue_table)
-
+        
+        complete_btn.click(
+            fn=complete_patient, 
+            inputs=[selected_patient_id, patient_notes], 
+            outputs=complete_output
+        )
+        
+        refresh_btn.click(
+            fn=lambda d: get_doctor_queue(d), 
+            inputs=doc_select, 
+            outputs=queue_table
+        )
+        
+        # Update queue when doctor selection changes
+        doc_select.change(
+            fn=lambda d: get_doctor_queue(d), 
+            inputs=doc_select, 
+            outputs=queue_table
+        )
+        
+    # Appointment Scheduling Tab
+    with gr.Tab("📅 Schedule Appointment"):
+        gr.Markdown("### Schedule a Future Appointment")
+        
+        with gr.Row():
+            appt_name = gr.Textbox(label="Patient Name*", placeholder="Enter full name")
+            appt_phone = gr.Textbox(label="Phone Number*", placeholder="Enter phone number")
+            
+        with gr.Row():
+            appt_email = gr.Textbox(label="Email (Optional)", placeholder="Enter email address")
+            appt_doctor = gr.Dropdown(
+                choices=get_all_doctor_names,
+                label="Select Doctor*"
+            )
+            
+        with gr.Row():
+            appt_date = gr.Textbox(
+                label="Appointment Date*", 
+                placeholder="YYYY-MM-DD",
+                info="Enter date in YYYY-MM-DD format"
+            )
+            appt_time = gr.Dropdown(
+                choices=[
+                    "09:00 AM", "09:30 AM", "10:00 AM", "10:30 AM", "11:00 AM", "11:30 AM",
+                    "01:00 PM", "01:30 PM", "02:00 PM", "02:30 PM", "03:00 PM", "03:30 PM",
+                    "04:00 PM", "04:30 PM"
+                ],
+                label="Appointment Time*"
+            )
+            
+        appt_reason = gr.Textbox(
+            label="Reason for Appointment",
+            placeholder="Briefly describe the reason for appointment",
+            lines=3
+        )
+        
+        schedule_btn = gr.Button("Schedule Appointment", variant="primary")
+        schedule_output = gr.Textbox(label="Appointment Details")
+        
+        schedule_btn.click(
+            fn=schedule_appointment, 
+            inputs=[appt_name, appt_phone, appt_email, appt_doctor, appt_date, appt_time, appt_reason], 
+            outputs=schedule_output
+        )
+        
+        # Appointment List
+        gr.Markdown("### View Appointments")
+        
+        with gr.Row():
+            view_date = gr.Textbox(
+                label="Date (YYYY-MM-DD)", 
+                placeholder="Leave empty for all dates",
+                value=datetime.now().strftime('%Y-%m-%d')
+            )
+            view_doctor = gr.Dropdown(
+                choices=["All Doctors"] + get_all_doctor_names(),
+                label="Doctor",
+                value="All Doctors"
+            )
+            view_btn = gr.Button("View Appointments")
+            
+        appointments_table = gr.Dataframe(
+            headers=["ID", "Patient Name", "Phone", "Time", "Doctor", "Reason", "Status"],
+            interactive=False,
+            label="Appointments"
+        )
+        
+        view_btn.click(
+            fn=get_appointments, 
+            inputs=[view_date, view_doctor], 
+            outputs=appointments_table
+        )
+        
+    # Admin Panel Tab    
+    with gr.Tab("⚙️ Admin Panel"):
+        gr.Markdown("### Manage Doctors")
+        
+        # Doctor availability management
+        doctors_table = gr.Dataframe(
+            headers=["ID", "Name", "Specialty", "Status"], 
+            interactive=False,
+            label="Doctors List"
+        )
+        
+        with gr.Row():
+            toggle_doctor_id = gr.Number(label="Doctor ID", precision=0)
+            toggle_btn = gr.Button("Toggle Availability")
+            toggle_output = gr.Textbox(label="Result")
+            
+        refresh_doctors_btn = gr.Button("Refresh Doctors List")
+        
+        # Set up event handlers
+        toggle_btn.click(
+            fn=toggle_doctor_availability, 
+            inputs=toggle_doctor_id, 
+            outputs=toggle_output
+        )
+        
+        refresh_doctors_btn.click(
+            fn=get_doctor_availability,
+            inputs=[],
+            outputs=doctors_table
+        )
+        
+        # Initialize doctors table
+        demo.load(fn=get_doctor_availability, inputs=[], outputs=doctors_table)
+        
+        # System monitoring section
+        gr.Markdown("### System Monitoring")
+        
+        with gr.Row():
+            db_size = gr.Textbox(label="Database Size")
+            system_status = gr.Textbox(label="System Status")
+            
+        def check_system_status():
+            """Check system status and database size"""
+            try:
+                # Get database file size
+                if os.path.exists("hospital.db"):
+                    size_bytes = os.path.getsize("hospital.db")
+                    size_kb = size_bytes / 1024
+                    if size_kb < 1024:
+                        size_str = f"{size_kb:.2f} KB"
+                    else:
+                        size_mb = size_kb / 1024
+                        size_str = f"{size_mb:.2f} MB"
+                else:
+                    size_str = "Database file not found"
+                
+                # Check database connection
+                if conn:
+                    try:
+                        cursor.execute("SELECT COUNT(*) FROM doctors")
+                        cursor.fetchone()
+                        status = "System operational - Database connection OK"
+                    except:
+                        status = "Database connection error"
+                else:
+                    status = "Database connection not established"
+                    
+                return size_str, status
+                
+            except Exception as e:
+                return "Error getting size", f"Error: {str(e)}"
+        
+        check_system_btn = gr.Button("Check System Status")
+        check_system_btn.click(
+            fn=check_system_status,
+            inputs=[],
+            outputs=[db_size, system_status]
+        )
+        
+        # Backup & Maintenance
+        gr.Markdown("### Backup & Maintenance")
+        
+        def backup_database():
+            """Create a backup of the database"""
+            try:
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                backup_file = f"hospital_backup_{timestamp}.db"
+                
+                # Create connection to source and destination databases
+                source_conn = sqlite3.connect("hospital.db")
+                backup_conn = sqlite3.connect(backup_file)
+                
+                # Backup
+                source_conn.backup(backup_conn)
+                
+                # Close connections
+                source_conn.close()
+                backup_conn.close()
+                
+                return f"Backup created successfully: {backup_file}"
+                
+            except Exception as e:
+                return f"Backup failed: {str(e)}"
+        
+        backup_btn = gr.Button("Create Database Backup")
+        backup_output = gr.Textbox(label="Backup Result")
+        
+        backup_btn.click(fn=backup_database, inputs=[], outputs=backup_output)
+        
+        # Emergency queue reset
+        def reset_queue():
+            """Reset the entire patient queue for emergency situations"""
+            try:
+                cursor.execute("UPDATE patients SET status='Completed' WHERE status IN ('Waiting', 'In Consultation')")
+                conn.commit()
+                affected = cursor.rowcount
+                return f"Queue reset successfully. {affected} patients marked as completed."
+            except Exception as e:
+                conn.rollback()
+                return f"Queue reset failed: {str(e)}"
+        
+        with gr.Row():
+            gr.Markdown("### ⚠️ Emergency Queue Reset ⚠️")
+        with gr.Row():
+            reset_confirm = gr.Checkbox(label="I confirm I want to reset all queues")
+            reset_btn = gr.Button("Reset All Queues", variant="stop")
+            reset_output = gr.Textbox(label="Reset Result")
+        
+        def safe_reset_queue(confirmed):
+            if confirmed:
+                return reset_queue()
+            else:
+                return "Please check the confirmation box to reset queues"
+                
+        reset_btn.click(fn=safe_reset_queue, inputs=reset_confirm, outputs=reset_output)
+        
 # ---------------------------
 # LAUNCH APP
 # ---------------------------
-demo.launch()
+demo.launch()