Enhance Gradio UI with new dashboard features for orders and drivers management

ui/app.py

@@ -1,6 +1,6 @@
 """
 FleetMind MCP - Gradio Web Interface
-Simple dashboard to interact with the MCP server and database
+Enhanced 3-tab dashboard: Chat, Orders, Drivers
 """
 
 import sys
@@ -20,222 +20,363 @@ from chat.conversation import ConversationManager
 from chat.geocoding import GeocodingService
 import uuid
 
-# Global session storage (simple in-memory store)
+# Global session storage
 SESSIONS = {}
 
+# Initialize chat engine and geocoding service
+chat_engine = ChatEngine()
+geocoding_service = GeocodingService()
+
 # ============================================
-# DATABASE FUNCTIONS
+# STATISTICS FUNCTIONS
 # ============================================
 
-def get_database_status():
-    """Check if database is connected"""
+def get_orders_stats():
+    """Get order statistics by status"""
     try:
-        if test_connection():
-            return "✅ Connected", "success"
-        else:
-            return "❌ Disconnected", "error"
+        query = """
+            SELECT
+                COUNT(*) as total,
+                COUNT(CASE WHEN status = 'pending' THEN 1 END) as pending,
+                COUNT(CASE WHEN status = 'assigned' THEN 1 END) as assigned,
+                COUNT(CASE WHEN status = 'in_transit' THEN 1 END) as in_transit,
+                COUNT(CASE WHEN status = 'delivered' THEN 1 END) as delivered,
+                COUNT(CASE WHEN status = 'failed' THEN 1 END) as failed,
+                COUNT(CASE WHEN status = 'cancelled' THEN 1 END) as cancelled
+            FROM orders
+        """
+        result = execute_query(query)
+        if result:
+            return result[0]
+        return {"total": 0, "pending": 0, "assigned": 0, "in_transit": 0, "delivered": 0, "failed": 0, "cancelled": 0}
     except Exception as e:
-        return f"❌ Error: {str(e)}", "error"
+        print(f"Error getting order stats: {e}")
+        return {"total": 0, "pending": 0, "assigned": 0, "in_transit": 0, "delivered": 0, "failed": 0, "cancelled": 0}
 
 
-def get_orders_summary():
-    """Get summary of orders by status"""
+def get_drivers_stats():
+    """Get driver statistics by status"""
     try:
         query = """
             SELECT
-                status,
-                COUNT(*) as count
-            FROM orders
-            GROUP BY status
-            ORDER BY count DESC
+                COUNT(*) as total,
+                COUNT(CASE WHEN status = 'active' THEN 1 END) as active,
+                COUNT(CASE WHEN status = 'busy' THEN 1 END) as busy,
+                COUNT(CASE WHEN status = 'offline' THEN 1 END) as offline,
+                COUNT(CASE WHEN status = 'unavailable' THEN 1 END) as unavailable
+            FROM drivers
         """
-        results = execute_query(query)
+        result = execute_query(query)
+        if result:
+            return result[0]
+        return {"total": 0, "active": 0, "busy": 0, "offline": 0, "unavailable": 0}
+    except Exception as e:
+        print(f"Error getting driver stats: {e}")
+        return {"total": 0, "active": 0, "busy": 0, "offline": 0, "unavailable": 0}
 
-        if not results:
-            return "No orders in database"
 
-        summary = "**Orders Summary:**\n\n"
-        for row in results:
-            summary += f"- {row['status'].upper()}: {row['count']}\n"
+# ============================================
+# ORDERS FUNCTIONS
+# ============================================
 
-        return summary
-    except Exception as e:
-        return f"Error: {str(e)}"
+def get_all_orders(status_filter="all", priority_filter="all", payment_filter="all", search_term=""):
+    """Get orders with filters"""
+    try:
+        where_clauses = []
+        params = []
 
+        if status_filter and status_filter != "all":
+            where_clauses.append("status = %s")
+            params.append(status_filter)
 
-def get_all_orders():
-    """Get all orders from database"""
-    try:
-        query = """
+        if priority_filter and priority_filter != "all":
+            where_clauses.append("priority = %s")
+            params.append(priority_filter)
+
+        if payment_filter and payment_filter != "all":
+            where_clauses.append("payment_status = %s")
+            params.append(payment_filter)
+
+        if search_term:
+            where_clauses.append("(order_id ILIKE %s OR customer_name ILIKE %s OR customer_phone ILIKE %s)")
+            search_pattern = f"%{search_term}%"
+            params.extend([search_pattern, search_pattern, search_pattern])
+
+        where_sql = " WHERE " + " AND ".join(where_clauses) if where_clauses else ""
+
+        query = f"""
             SELECT
                 order_id,
                 customer_name,
                 delivery_address,
                 status,
                 priority,
+                assigned_driver_id,
+                time_window_end,
                 created_at
             FROM orders
+            {where_sql}
             ORDER BY created_at DESC
-            LIMIT 50
+            LIMIT 100
         """
-        results = execute_query(query)
+
+        results = execute_query(query, tuple(params) if params else ())
 
         if not results:
-            return [["No orders found", "", "", "", "", ""]]
+            return [["-", "-", "-", "-", "-", "-", "-"]]
 
-        # Convert to list of lists for Gradio dataframe
+        # Format data for table
         data = []
         for row in results:
+            # Truncate address if too long
+            address = row['delivery_address']
+            if len(address) > 40:
+                address = address[:37] + "..."
+
+            # Format deadline
+            deadline = row['time_window_end'].strftime("%Y-%m-%d %H:%M") if row['time_window_end'] else "No deadline"
+
+            # Driver ID or "Unassigned"
+            driver = row['assigned_driver_id'] if row['assigned_driver_id'] else "Unassigned"
+
             data.append([
                 row['order_id'],
                 row['customer_name'],
-                row['delivery_address'][:50] + "..." if len(row['delivery_address']) > 50 else row['delivery_address'],
+                address,
                 row['status'],
                 row['priority'],
-                str(row['created_at'])
+                driver,
+                deadline
             ])
 
         return data
     except Exception as e:
-        return [[f"Error: {str(e)}", "", "", "", "", ""]]
+        print(f"Error fetching orders: {e}")
+        return [[f"Error: {str(e)}", "", "", "", "", "", ""]]
 
 
-def create_sample_order():
-    """Create a sample order for testing"""
-    try:
-        now = datetime.now()
-        order_id = f"ORD-{now.strftime('%Y%m%d%H%M%S')}"
+def get_order_details(order_id):
+    """Get complete order details"""
+    if not order_id or order_id == "-":
+        return "Select an order from the table to view details"
 
+    try:
         query = """
-            INSERT INTO orders (
-                order_id, customer_name, customer_phone, customer_email,
-                delivery_address, delivery_lat, delivery_lng,
-                time_window_start, time_window_end,
-                priority, weight_kg, status
-            ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
+            SELECT * FROM orders WHERE order_id = %s
         """
+        results = execute_query(query, (order_id,))
 
-        params = (
-            order_id,
-            "Sample Customer",
-            "+1-555-0100",
-            "[email protected]",
-            "456 Sample Street, San Francisco, CA 94103",
-            37.7749,
-            -122.4194,
-            now + timedelta(hours=2),
-            now + timedelta(hours=6),
-            "standard",
-            10.5,
-            "pending"
-        )
+        if not results:
+            return f"Order {order_id} not found"
+
+        order = results[0]
+
+        # Format the details nicely
+        details = f"""
+# Order Details: {order_id}
+
+## Customer Information
+- **Name:** {order['customer_name']}
+- **Phone:** {order['customer_phone'] or 'N/A'}
+- **Email:** {order['customer_email'] or 'N/A'}
+
+## Delivery Information
+- **Address:** {order['delivery_address']}
+- **Coordinates:** ({order['delivery_lat']}, {order['delivery_lng']})
+- **Time Window:** {order['time_window_start']} to {order['time_window_end']}
+
+## Package Details
+- **Weight:** {order['weight_kg'] or 'N/A'} kg
+- **Volume:** {order['volume_m3'] or 'N/A'} m³
+- **Is Fragile:** {"Yes" if order['is_fragile'] else "No"}
+- **Requires Signature:** {"Yes" if order['requires_signature'] else "No"}
+- **Requires Cold Storage:** {"Yes" if order['requires_cold_storage'] else "No"}
+
+## Order Status
+- **Status:** {order['status']}
+- **Priority:** {order['priority']}
+- **Assigned Driver:** {order['assigned_driver_id'] or 'Unassigned'}
+
+## Payment
+- **Order Value:** ${order['order_value'] or '0.00'}
+- **Payment Status:** {order['payment_status']}
+
+## Special Instructions
+{order['special_instructions'] or 'None'}
+
+## Timestamps
+- **Created:** {order['created_at']}
+- **Updated:** {order['updated_at']}
+- **Delivered:** {order['delivered_at'] or 'Not delivered yet'}
+"""
+        return details
 
-        execute_write(query, params)
-        return f"✅ Order {order_id} created successfully!", get_all_orders()
     except Exception as e:
-        return f"❌ Error: {str(e)}", get_all_orders()
+        return f"Error fetching order details: {str(e)}"
 
 
-def search_orders(search_term):
-    """Search orders by customer name or order ID"""
+# ============================================
+# DRIVERS FUNCTIONS
+# ============================================
+
+def get_all_drivers(status_filter="all", vehicle_filter="all", search_term=""):
+    """Get drivers with filters"""
     try:
-        if not search_term:
-            return get_all_orders()
+        where_clauses = []
+        params = []
 
-        query = """
+        if status_filter and status_filter != "all":
+            where_clauses.append("status = %s")
+            params.append(status_filter)
+
+        if vehicle_filter and vehicle_filter != "all":
+            where_clauses.append("vehicle_type = %s")
+            params.append(vehicle_filter)
+
+        if search_term:
+            where_clauses.append("(driver_id ILIKE %s OR name ILIKE %s OR phone ILIKE %s OR vehicle_plate ILIKE %s)")
+            search_pattern = f"%{search_term}%"
+            params.extend([search_pattern, search_pattern, search_pattern, search_pattern])
+
+        where_sql = " WHERE " + " AND ".join(where_clauses) if where_clauses else ""
+
+        query = f"""
             SELECT
-                order_id,
-                customer_name,
-                delivery_address,
+                driver_id,
+                name,
+                phone,
                 status,
-                priority,
-                created_at
-            FROM orders
-            WHERE
-                order_id ILIKE %s OR
-                customer_name ILIKE %s
-            ORDER BY created_at DESC
-            LIMIT 50
+                vehicle_type,
+                vehicle_plate,
+                current_lat,
+                current_lng,
+                last_location_update
+            FROM drivers
+            {where_sql}
+            ORDER BY name ASC
+            LIMIT 100
         """
 
-        search_pattern = f"%{search_term}%"
-        results = execute_query(query, (search_pattern, search_pattern))
+        results = execute_query(query, tuple(params) if params else ())
 
         if not results:
-            return [["No matching orders found", "", "", "", "", ""]]
+            return [["-", "-", "-", "-", "-", "-", "-"]]
 
+        # Format data for table
         data = []
         for row in results:
+            # Format location
+            if row['current_lat'] and row['current_lng']:
+                location = f"{row['current_lat']:.4f}, {row['current_lng']:.4f}"
+            else:
+                location = "No location"
+
+            # Format last update
+            last_update = row['last_location_update'].strftime("%Y-%m-%d %H:%M") if row['last_location_update'] else "Never"
+
             data.append([
-                row['order_id'],
-                row['customer_name'],
-                row['delivery_address'][:50] + "..." if len(row['delivery_address']) > 50 else row['delivery_address'],
+                row['driver_id'],
+                row['name'],
+                row['phone'] or "N/A",
                 row['status'],
-                row['priority'],
-                str(row['created_at'])
+                f"{row['vehicle_type']} - {row['vehicle_plate'] or 'N/A'}",
+                location,
+                last_update
             ])
 
         return data
     except Exception as e:
-        return [[f"Error: {str(e)}", "", "", "", "", ""]]
+        print(f"Error fetching drivers: {e}")
+        return [[f"Error: {str(e)}", "", "", "", "", "", ""]]
+
+
+def get_driver_details(driver_id):
+    """Get complete driver details"""
+    if not driver_id or driver_id == "-":
+        return "Select a driver from the table to view details"
+
+    try:
+        query = """
+            SELECT * FROM drivers WHERE driver_id = %s
+        """
+        results = execute_query(query, (driver_id,))
+
+        if not results:
+            return f"Driver {driver_id} not found"
+
+        driver = results[0]
+
+        # Parse skills (handle both list and JSON string)
+        if driver['skills']:
+            if isinstance(driver['skills'], list):
+                skills = driver['skills']
+            else:
+                skills = json.loads(driver['skills'])
+        else:
+            skills = []
+        skills_str = ", ".join(skills) if skills else "None"
+
+        # Format the details nicely
+        details = f"""
+# Driver Details: {driver_id}
+
+## Personal Information
+- **Name:** {driver['name']}
+- **Phone:** {driver['phone'] or 'N/A'}
+- **Email:** {driver['email'] or 'N/A'}
+
+## Current Location
+- **Coordinates:** ({driver['current_lat']}, {driver['current_lng']})
+- **Last Update:** {driver['last_location_update'] or 'Never updated'}
+
+## Status
+- **Status:** {driver['status']}
+
+## Vehicle Information
+- **Type:** {driver['vehicle_type']}
+- **Plate:** {driver['vehicle_plate'] or 'N/A'}
+- **Capacity (kg):** {driver['capacity_kg'] or 'N/A'}
+- **Capacity (m³):** {driver['capacity_m3'] or 'N/A'}
+
+## Skills & Certifications
+{skills_str}
+
+## Timestamps
+- **Created:** {driver['created_at']}
+- **Updated:** {driver['updated_at']}
+"""
+        return details
+
+    except Exception as e:
+        return f"Error fetching driver details: {str(e)}"
 
 
 # ============================================
 # CHAT FUNCTIONS
 # ============================================
 
-# Initialize chat engine and geocoding service
-chat_engine = ChatEngine()
-geocoding_service = GeocodingService()
-
-
 def get_api_status():
     """Get API status for chat"""
-    # Get full status for all providers
     full_status = chat_engine.get_full_status()
     selected = full_status["selected"]
     claude_status = full_status["claude"]["status"]
     gemini_status = full_status["gemini"]["status"]
-
     geocoding_status = geocoding_service.get_status()
 
-    # Mark selected provider
     claude_marker = "🎯 **ACTIVE** - " if selected == "anthropic" else ""
     gemini_marker = "🎯 **ACTIVE** - " if selected == "gemini" else ""
 
-    return f"""### API Status
-
-**AI Provider:**
-
-**Claude (Anthropic):**
-{claude_marker}{claude_status}
-
-**Gemini (Google):**
-{gemini_marker}{gemini_status}
-
-*💡 Switch provider by setting `AI_PROVIDER=anthropic` or `AI_PROVIDER=gemini` in .env*
+    return f"""**AI Provider:**
 
----
+**Claude:** {claude_marker}{claude_status}
+**Gemini:** {gemini_marker}{gemini_status}
 
-**Geocoding:**
-
-**HERE Maps:**
-{geocoding_status}
+**Geocoding:** {geocoding_status}
 """
 
 
 def handle_chat_message(message, session_id):
-    """
-    Handle chat message from user
-
-    Args:
-        message: User's message
-        session_id: Session identifier string
-
-    Returns:
-        Updated chatbot history, tool display, session_id
-    """
-    # Get or create conversation for this session
+    """Handle chat message from user"""
     if session_id not in SESSIONS:
         SESSIONS[session_id] = ConversationManager()
         welcome = chat_engine.get_welcome_message()
@@ -246,226 +387,101 @@ def handle_chat_message(message, session_id):
     if not message.strip():
         return conversation.get_formatted_history(), conversation.get_tool_calls(), session_id
 
-    # Process message through chat engine
     response, tool_calls = chat_engine.process_message(message, conversation)
-
-    # Return updated UI
     return conversation.get_formatted_history(), conversation.get_tool_calls(), session_id
 
 
 def reset_conversation(session_id):
     """Reset conversation to start fresh"""
-    # Create new session ID for fresh conversation
     new_session_id = str(uuid.uuid4())
-
-    # Create new conversation for this session
     new_conversation = ConversationManager()
-
-    # Add welcome message
     welcome = chat_engine.get_welcome_message()
     new_conversation.add_message("assistant", welcome)
-
-    # Store in sessions
     SESSIONS[new_session_id] = new_conversation
 
     return (
         new_conversation.get_formatted_history(),
-        [],  # Clear tool calls
+        [],
         new_session_id
     )
 
 
 def get_initial_chat():
     """Get initial chat state with welcome message"""
-    # Create new session ID
     session_id = str(uuid.uuid4())
-
-    # Create conversation for this session
     conversation = ConversationManager()
     welcome = chat_engine.get_welcome_message()
     conversation.add_message("assistant", welcome)
-
-    # Store in sessions
     SESSIONS[session_id] = conversation
 
     return conversation.get_formatted_history(), [], session_id
 
 
-# ============================================
-# MCP SERVER INFO
-# ============================================
-
-def get_mcp_server_info():
-    """Get MCP server information"""
-    mcp_info = {
-        "server_name": "dispatch-coordinator-mcp",
-        "version": "1.0.0",
-        "status": "Ready",
-        "tools": [
-            "route_optimizer",
-            "geocoder",
-            "weather_monitor",
-            "traffic_checker",
-            "distance_matrix",
-            "order_manager"
-        ]
-    }
-
-    return f"""
-### MCP Server Information
-
-**Name:** {mcp_info['server_name']}
-**Version:** {mcp_info['version']}
-**Status:** 🟢 {mcp_info['status']}
-
-**Available Tools ({len(mcp_info['tools'])}):**
-{chr(10).join([f"- {tool}" for tool in mcp_info['tools']])}
-"""
-
-
 # ============================================
 # GRADIO INTERFACE
 # ============================================
 
 def create_interface():
-    """Create the Gradio interface"""
+    """Create the Gradio interface with 3 enhanced tabs"""
 
-    with gr.Blocks(theme=gr.themes.Soft(), title="FleetMind MCP Dashboard") as app:
+    with gr.Blocks(theme=gr.themes.Soft(), title="FleetMind Dispatch System") as app:
 
-        gr.Markdown("# 🚚 FleetMind MCP Dashboard")
-        gr.Markdown("*Autonomous Dispatch Coordinator powered by MCP and PostgreSQL*")
+        gr.Markdown("# 🚚 FleetMind Dispatch System")
+        gr.Markdown("*AI-Powered Delivery Coordination*")
 
         with gr.Tabs():
 
             # ==========================================
-            # TAB 1: OVERVIEW
-            # ==========================================
-            with gr.Tab("📊 Overview"):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        gr.Markdown("### System Status")
-                        db_status = gr.Textbox(
-                            label="Database Connection",
-                            value=get_database_status()[0],
-                            interactive=False
-                        )
-                        refresh_status_btn = gr.Button("🔄 Refresh Status", size="sm")
-
-                        gr.Markdown("---")
-                        orders_summary = gr.Markdown(get_orders_summary())
-
-                    with gr.Column(scale=2):
-                        mcp_info = gr.Markdown(get_mcp_server_info())
-
-                # Refresh status button action
-                refresh_status_btn.click(
-                    fn=lambda: get_database_status()[0],
-                    outputs=db_status
-                )
-
-            # ==========================================
-            # TAB 2: ORDERS MANAGEMENT
+            # TAB 1: CHAT
             # ==========================================
-            with gr.Tab("📦 Orders"):
-                gr.Markdown("### Orders Management")
-
-                with gr.Row():
-                    search_box = gr.Textbox(
-                        placeholder="Search by Order ID or Customer Name...",
-                        label="Search Orders",
-                        scale=3
-                    )
-                    search_btn = gr.Button("🔍 Search", scale=1)
-                    create_btn = gr.Button("➕ Create Sample Order", scale=1, variant="primary")
-
-                create_result = gr.Textbox(label="Result", visible=False)
-
-                orders_table = gr.Dataframe(
-                    headers=["Order ID", "Customer", "Delivery Address", "Status", "Priority", "Created At"],
-                    datatype=["str", "str", "str", "str", "str", "str"],
-                    label="Orders List",
-                    value=get_all_orders(),
-                    interactive=False,
-                    wrap=True
-                )
-
-                refresh_orders_btn = gr.Button("🔄 Refresh Orders")
-
-                # Button actions
-                create_btn.click(
-                    fn=create_sample_order,
-                    outputs=[create_result, orders_table]
-                ).then(
-                    fn=lambda: gr.update(visible=True),
-                    outputs=create_result
-                ).then(
-                    fn=lambda: get_orders_summary(),
-                    outputs=orders_summary
-                )
-
-                search_btn.click(
-                    fn=search_orders,
-                    inputs=search_box,
-                    outputs=orders_table
-                )
-
-                search_box.submit(
-                    fn=search_orders,
-                    inputs=search_box,
-                    outputs=orders_table
-                )
-
-                refresh_orders_btn.click(
-                    fn=get_all_orders,
-                    outputs=orders_table
-                ).then(
-                    fn=lambda: get_orders_summary(),
-                    outputs=orders_summary
-                )
-
-            # ==========================================
-            # TAB 3: AI CHAT
-            # ==========================================
-            with gr.Tab("💬 Chat"):
+            with gr.Tab("💬 Chat Assistant"):
                 provider_name = chat_engine.get_provider_name()
                 model_name = chat_engine.get_model_name()
 
-                gr.Markdown(f"### AI Order Assistant")
-                gr.Markdown(f"*Powered by: **{provider_name}** ({model_name})*")
+                gr.Markdown(f"### AI Dispatch Assistant")
+                gr.Markdown(f"*Powered by {provider_name} ({model_name})*")
 
-                # API Status
-                api_status = gr.Markdown(get_api_status())
+                # Quick Action Buttons
+                gr.Markdown("**Quick Actions:**")
+                with gr.Row():
+                    quick_create_order = gr.Button("📦 Create Order", size="sm")
+                    quick_view_orders = gr.Button("📋 View Orders", size="sm")
+                    quick_view_drivers = gr.Button("👥 View Drivers", size="sm")
+                    quick_check_status = gr.Button("📊 Check Status", size="sm")
 
                 # Chat interface
                 chatbot = gr.Chatbot(
-                    label="Order Assistant",
-                    height=500,
+                    label="Chat with AI Assistant",
+                    height=600,
                     type="messages",
-                    show_copy_button=True
+                    show_copy_button=True,
+                    avatar_images=("👤", "🤖")
                 )
 
                 msg_input = gr.Textbox(
-                    placeholder="e.g., 'Create an order for John Doe at 123 Main St, deliver by 5 PM'",
+                    placeholder="Type your message here... (e.g., 'Create order for John at 123 Main St' or 'Show me available drivers')",
                     label="Your Message",
-                    lines=2
+                    lines=3
                 )
 
                 with gr.Row():
-                    send_btn = gr.Button("📤 Send", variant="primary", scale=2)
-                    clear_btn = gr.Button("🔄 Clear Chat", scale=1)
+                    send_btn = gr.Button("📤 Send Message", variant="primary", scale=3)
+                    clear_btn = gr.Button("🗑️ Clear Chat", scale=1)
+
+                # API Status in accordion
+                with gr.Accordion("🔧 System Status", open=False):
+                    api_status = gr.Markdown(get_api_status())
 
-                # Tool usage display (reasoning transparency)
-                with gr.Accordion("🔧 Tool Usage (AI Reasoning)", open=False):
-                    gr.Markdown("See what tools the AI is using behind the scenes:")
-                    tool_display = gr.JSON(label="Tools Called")
+                # Tool usage display
+                with gr.Accordion("🛠️ Tool Usage Log", open=False):
+                    gr.Markdown("*See what tools the AI is using behind the scenes*")
+                    tool_display = gr.JSON(label="Tools Called", value=[])
 
-                # Conversation state - use session ID instead of complex object
+                # Session state
                 session_id_state = gr.State(value=None)
 
                 # Event handlers
                 def send_message(message, sess_id):
-                    """Handle send button click"""
-                    # Auto-initialize session if None
                     if sess_id is None:
                         sess_id = str(uuid.uuid4())
                         SESSIONS[sess_id] = ConversationManager()
@@ -473,7 +489,31 @@ def create_interface():
                         SESSIONS[sess_id].add_message("assistant", welcome)
 
                     chat_history, tools, new_sess_id = handle_chat_message(message, sess_id)
-                    return chat_history, tools, new_sess_id, ""  # Clear input
+                    return chat_history, tools, new_sess_id, ""
+
+                # Quick action functions
+                def quick_action(prompt):
+                    return prompt
+
+                quick_create_order.click(
+                    fn=lambda: "Create a new order",
+                    outputs=msg_input
+                )
+
+                quick_view_orders.click(
+                    fn=lambda: "Show me all orders",
+                    outputs=msg_input
+                )
+
+                quick_view_drivers.click(
+                    fn=lambda: "Show me all available drivers",
+                    outputs=msg_input
+                )
+
+                quick_check_status.click(
+                    fn=lambda: "What is the current status of orders and drivers?",
+                    outputs=msg_input
+                )
 
                 send_btn.click(
                     fn=send_message,
@@ -494,56 +534,232 @@ def create_interface():
                 )
 
             # ==========================================
-            # TAB 4: MCP TOOLS (Coming Soon)
+            # TAB 2: ORDERS
             # ==========================================
-            with gr.Tab("🔧 MCP Tools"):
-                gr.Markdown("### MCP Tools")
-                gr.Markdown("*MCP tool integration coming soon...*")
-
-                gr.Markdown("""
-                Available tools:
-                - **route_optimizer** - Optimize delivery routes
-                - **geocoder** - Convert addresses to coordinates
-                - **weather_monitor** - Check weather conditions
-                - **traffic_checker** - Monitor traffic conditions
-                - **distance_matrix** - Calculate distances
-                - **order_manager** - Manage orders via MCP
-                """)
+            with gr.Tab("📦 Orders Management"):
+                gr.Markdown("### Orders Dashboard")
+
+                # Statistics Cards
+                def update_order_stats():
+                    stats = get_orders_stats()
+                    return (
+                        f"**Total:** {stats['total']}",
+                        f"**Pending:** {stats['pending']}",
+                        f"**In Transit:** {stats['in_transit']}",
+                        f"**Delivered:** {stats['delivered']}"
+                    )
+
+                with gr.Row():
+                    stat_total = gr.Markdown("**Total:** 0")
+                    stat_pending = gr.Markdown("**Pending:** 0")
+                    stat_transit = gr.Markdown("**In Transit:** 0")
+                    stat_delivered = gr.Markdown("**Delivered:** 0")
+
+                gr.Markdown("---")
+
+                # Filters
+                gr.Markdown("**Filters:**")
+                with gr.Row():
+                    status_filter = gr.Dropdown(
+                        choices=["all", "pending", "assigned", "in_transit", "delivered", "failed", "cancelled"],
+                        value="all",
+                        label="Status",
+                        scale=1
+                    )
+                    priority_filter = gr.Dropdown(
+                        choices=["all", "standard", "express", "urgent"],
+                        value="all",
+                        label="Priority",
+                        scale=1
+                    )
+                    payment_filter = gr.Dropdown(
+                        choices=["all", "pending", "paid", "cod"],
+                        value="all",
+                        label="Payment",
+                        scale=1
+                    )
+                    search_orders = gr.Textbox(
+                        placeholder="Search by Order ID, Customer, Phone...",
+                        label="Search",
+                        scale=2
+                    )
+
+                with gr.Row():
+                    apply_filters_btn = gr.Button("🔍 Apply Filters", variant="primary", scale=1)
+                    refresh_orders_btn = gr.Button("🔄 Refresh", scale=1)
+
+                # Orders Table
+                orders_table = gr.Dataframe(
+                    headers=["Order ID", "Customer", "Address", "Status", "Priority", "Driver", "Deadline"],
+                    datatype=["str", "str", "str", "str", "str", "str", "str"],
+                    label="Orders List (Click row to view details)",
+                    value=get_all_orders(),
+                    interactive=False,
+                    wrap=True
+                )
+
+                # Order Details
+                gr.Markdown("---")
+                gr.Markdown("**Order Details:**")
+                order_details = gr.Markdown("*Select an order from the table above to view full details*")
+
+                # Event handlers
+                def filter_and_update_orders(status, priority, payment, search):
+                    return get_all_orders(status, priority, payment, search)
+
+                def refresh_orders_and_stats(status, priority, payment, search):
+                    stats = update_order_stats()
+                    table = get_all_orders(status, priority, payment, search)
+                    return stats[0], stats[1], stats[2], stats[3], table
+
+                def show_order_details(evt: gr.SelectData, table_data):
+                    try:
+                        # table_data is a pandas DataFrame from Gradio
+                        if hasattr(table_data, 'iloc'):
+                            # DataFrame - use iloc to access row and column
+                            order_id = table_data.iloc[evt.index[0], 0]
+                        else:
+                            # List of lists - use standard indexing
+                            order_id = table_data[evt.index[0]][0]
+                        return get_order_details(order_id)
+                    except Exception as e:
+                        return f"Error: {str(e)}"
+
+                apply_filters_btn.click(
+                    fn=filter_and_update_orders,
+                    inputs=[status_filter, priority_filter, payment_filter, search_orders],
+                    outputs=orders_table
+                )
+
+                refresh_orders_btn.click(
+                    fn=refresh_orders_and_stats,
+                    inputs=[status_filter, priority_filter, payment_filter, search_orders],
+                    outputs=[stat_total, stat_pending, stat_transit, stat_delivered, orders_table]
+                )
+
+                orders_table.select(
+                    fn=show_order_details,
+                    inputs=[orders_table],
+                    outputs=order_details
+                )
 
             # ==========================================
-            # TAB 5: DATABASE INFO
+            # TAB 3: DRIVERS
             # ==========================================
-            with gr.Tab("💾 Database"):
-                gr.Markdown("### Database Information")
-
-                db_info = gr.Markdown(f"""
-                **Database:** PostgreSQL
-                **Name:** fleetmind
-                **Host:** localhost
-                **Port:** 5432
-
-                **Tables:**
-                - orders (26 columns)
-                - drivers (coming soon)
-                - assignments (coming soon)
-                - exceptions (coming soon)
-                """)
-
-                test_db_btn = gr.Button("🧪 Test Connection", variant="primary")
-                test_result = gr.Textbox(label="Test Result", interactive=False)
-
-                test_db_btn.click(
-                    fn=lambda: "✅ Connection successful!" if test_connection() else "❌ Connection failed",
-                    outputs=test_result
+            with gr.Tab("👥 Drivers Management"):
+                gr.Markdown("### Drivers Dashboard")
+
+                # Statistics Cards
+                def update_driver_stats():
+                    stats = get_drivers_stats()
+                    return (
+                        f"**Total:** {stats['total']}",
+                        f"**Active:** {stats['active']}",
+                        f"**Busy:** {stats['busy']}",
+                        f"**Offline:** {stats['offline']}"
+                    )
+
+                with gr.Row():
+                    driver_stat_total = gr.Markdown("**Total:** 0")
+                    driver_stat_active = gr.Markdown("**Active:** 0")
+                    driver_stat_busy = gr.Markdown("**Busy:** 0")
+                    driver_stat_offline = gr.Markdown("**Offline:** 0")
+
+                gr.Markdown("---")
+
+                # Filters
+                gr.Markdown("**Filters:**")
+                with gr.Row():
+                    driver_status_filter = gr.Dropdown(
+                        choices=["all", "active", "busy", "offline", "unavailable"],
+                        value="all",
+                        label="Status",
+                        scale=1
+                    )
+                    vehicle_filter = gr.Dropdown(
+                        choices=["all", "van", "truck", "car", "motorcycle"],
+                        value="all",
+                        label="Vehicle Type",
+                        scale=1
+                    )
+                    search_drivers = gr.Textbox(
+                        placeholder="Search by Driver ID, Name, Phone, Plate...",
+                        label="Search",
+                        scale=2
+                    )
+
+                with gr.Row():
+                    apply_driver_filters_btn = gr.Button("🔍 Apply Filters", variant="primary", scale=1)
+                    refresh_drivers_btn = gr.Button("🔄 Refresh", scale=1)
+
+                # Drivers Table
+                drivers_table = gr.Dataframe(
+                    headers=["Driver ID", "Name", "Phone", "Status", "Vehicle", "Location", "Last Update"],
+                    datatype=["str", "str", "str", "str", "str", "str", "str"],
+                    label="Drivers List (Click row to view details)",
+                    value=get_all_drivers(),
+                    interactive=False,
+                    wrap=True
+                )
+
+                # Driver Details
+                gr.Markdown("---")
+                gr.Markdown("**Driver Details:**")
+                driver_details = gr.Markdown("*Select a driver from the table above to view full details*")
+
+                # Event handlers
+                def filter_and_update_drivers(status, vehicle, search):
+                    return get_all_drivers(status, vehicle, search)
+
+                def refresh_drivers_and_stats(status, vehicle, search):
+                    stats = update_driver_stats()
+                    table = get_all_drivers(status, vehicle, search)
+                    return stats[0], stats[1], stats[2], stats[3], table
+
+                def show_driver_details(evt: gr.SelectData, table_data):
+                    try:
+                        # table_data is a pandas DataFrame from Gradio
+                        if hasattr(table_data, 'iloc'):
+                            # DataFrame - use iloc to access row and column
+                            driver_id = table_data.iloc[evt.index[0], 0]
+                        else:
+                            # List of lists - use standard indexing
+                            driver_id = table_data[evt.index[0]][0]
+                        return get_driver_details(driver_id)
+                    except Exception as e:
+                        return f"Error: {str(e)}"
+
+                apply_driver_filters_btn.click(
+                    fn=filter_and_update_drivers,
+                    inputs=[driver_status_filter, vehicle_filter, search_drivers],
+                    outputs=drivers_table
+                )
+
+                refresh_drivers_btn.click(
+                    fn=refresh_drivers_and_stats,
+                    inputs=[driver_status_filter, vehicle_filter, search_drivers],
+                    outputs=[driver_stat_total, driver_stat_active, driver_stat_busy, driver_stat_offline, drivers_table]
+                )
+
+                drivers_table.select(
+                    fn=show_driver_details,
+                    inputs=[drivers_table],
+                    outputs=driver_details
                 )
 
         gr.Markdown("---")
-        gr.Markdown("*FleetMind MCP v1.0.0 - Built with Gradio, PostgreSQL, and FastMCP*")
+        gr.Markdown("*FleetMind v1.0 - AI-Powered Dispatch Coordination*")
 
-        # Initialize chat on app load (deferred to avoid blocking)
+        # Initialize chat and stats on load
         app.load(
             fn=get_initial_chat,
             outputs=[chatbot, tool_display, session_id_state]
+        ).then(
+            fn=update_order_stats,
+            outputs=[stat_total, stat_pending, stat_transit, stat_delivered]
+        ).then(
+            fn=update_driver_stats,
+            outputs=[driver_stat_total, driver_stat_active, driver_stat_busy, driver_stat_offline]
         )
 
     return app
@@ -555,26 +771,23 @@ def create_interface():
 
 if __name__ == "__main__":
     print("=" * 60)
-    print("FleetMind MCP - Starting Gradio Server")
+    print("FleetMind - Starting Enhanced UI")
     print("=" * 60)
 
-    # Check database connection
     print("\nChecking database connection...")
     if test_connection():
         print("✅ Database connected")
     else:
         print("❌ Database connection failed")
-        print("Please check your .env file and PostgreSQL server")
 
     print("\nStarting Gradio interface...")
     print("=" * 60)
 
-    # Create and launch the interface
     app = create_interface()
     app.launch(
-        server_name="0.0.0.0",  # Allow external connections for HF Spaces
+        server_name="0.0.0.0",
         server_port=7860,
         share=False,
         show_error=True,
-        show_api=False  # Disable API docs to avoid schema parsing bug
+        show_api=False
     )