Upload 16 files

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+src/eHealth[[:space:]]in[[:space:]]Wound[[:space:]]Care.pdf filter=lfs diff=lfs merge=lfs -text
+src/evaluation.pdf filter=lfs diff=lfs merge=lfs -text
+src/IWGDF[[:space:]]Guideline.pdf filter=lfs diff=lfs merge=lfs -text

enhanced_app.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+
+import os
+import sys
+import logging
+import traceback
+import gradio as gr
+from datetime import datetime
+
+# Add src directory to path
+sys.path.append(os.path.join(os.path.dirname(__file__), 'src'))
+
+# Import original modules (copy from original bot)
+from src.config import Config
+from src.auth import AuthManager
+
+# Import enhanced modules
+from src.dashboard_database_manager import DashboardDatabaseManager
+from src.enhanced_ai_processor import EnhancedAIProcessor
+from src.enhanced_ui_components import EnhancedUIComponents
+
+# Logging setup
+logging.basicConfig(
+    level=logging.INFO, 
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('smartheal_enhanced.log'),
+        logging.StreamHandler()
+    ]
+)
+
+class EnhancedSmartHealApp:
+    """Enhanced SmartHeal Application with Dashboard Integration"""
+    
+    def __init__(self):
+        self.ui_components = None
+        try:
+            logging.info("🚀 Initializing Enhanced SmartHeal App...")
+            
+            # Initialize configuration
+            self.config = Config()
+            logging.info("✅ Configuration loaded")
+            
+            # Initialize enhanced database manager
+            self.database_manager = DashboardDatabaseManager(self.config.get_mysql_config())
+            logging.info("✅ Enhanced database manager initialized")
+            
+            # Initialize authentication manager
+            self.auth_manager = AuthManager(self.database_manager)
+            logging.info("✅ Authentication manager initialized")
+            
+            # Initialize enhanced AI processor
+            self.ai_processor = EnhancedAIProcessor()
+            logging.info("✅ Enhanced AI processor initialized")
+            
+            # Initialize enhanced UI components
+            self.ui_components = EnhancedUIComponents(
+                self.auth_manager,
+                self.database_manager,
+                self.ai_processor
+            )
+            logging.info("✅ Enhanced UI components initialized")
+            
+            # Create database tables if they don't exist
+            self._ensure_database_tables()
+            
+            logging.info("🎉 Enhanced SmartHeal App initialized successfully!")
+            
+        except Exception as e:
+            logging.error(f"❌ Initialization error: {e}")
+            traceback.print_exc()
+            raise
+    
+    def _ensure_database_tables(self):
+        """Ensure all required database tables exist"""
+        try:
+            # Check if dashboard tables exist, if not create them
+            tables_to_check = [
+                'ai_analyses',
+                'analysis_sessions', 
+                'bot_interactions',
+                'questionnaire_responses',
+                'wound_images'
+            ]
+            
+            for table in tables_to_check:
+                result = self.database_manager.execute_query_one(f"SHOW TABLES LIKE '{table}'")
+                if not result:
+                    logging.warning(f"Table '{table}' not found in database")
+                else:
+                    logging.info(f"✅ Table '{table}' exists")
+            
+            logging.info("✅ Database table check completed")
+            
+        except Exception as e:
+            logging.error(f"❌ Error checking database tables: {e}")
+    
+    def launch(self, port=7860, share=True, server_name="0.0.0.0"):
+        """Launch the enhanced application"""
+        try:
+            logging.info(f"🌐 Launching Enhanced SmartHeal App on {server_name}:{port}")
+            
+            # Create the interface
+            interface = self.ui_components.create_interface()
+            
+            # Launch with enhanced configuration
+            interface.launch(
+                server_name=server_name,
+                server_port=port,
+                share=share,
+                show_error=True,
+                quiet=False,
+                favicon_path="favicon.ico" if os.path.exists("favicon.ico") else None
+            )
+            
+        except Exception as e:
+            logging.error(f"❌ Error launching application: {e}")
+            raise
+    
+    def get_status(self):
+        """Get application status"""
+        try:
+            status = {
+                'app_initialized': self.ui_components is not None,
+                'database_connected': self.database_manager.get_connection() is not None,
+                'ai_models_loaded': len(self.ai_processor.models_cache) > 0,
+                'dashboard_integration': self.ui_components.dashboard_integration.get_integration_status() if self.ui_components else {},
+                'timestamp': datetime.now().isoformat()
+            }
+            
+            return status
+            
+        except Exception as e:
+            logging.error(f"Error getting status: {e}")
+            return {'error': str(e), 'timestamp': datetime.now().isoformat()}
+
+def main():
+    """Main application entry point"""
+    try:
+        print("=" * 60)
+        print("🏥 SmartHeal AI - Enhanced Edition")
+        print("Advanced Wound Care Analysis with Dashboard Integration")
+        print("=" * 60)
+        
+        # Initialize and launch the app
+        app = EnhancedSmartHealApp()
+        
+        # Print status
+        status = app.get_status()
+        print("\n📊 Application Status:")
+        print(f"  • App Initialized: {status.get('app_initialized', False)}")
+        print(f"  • Database Connected: {status.get('database_connected', False)}")
+        print(f"  • AI Models Loaded: {status.get('ai_models_loaded', False)}")
+        
+        dashboard_status = status.get('dashboard_integration', {})
+        print(f"  • Dashboard API: {dashboard_status.get('api_running', False)}")
+        print(f"  • Dashboard DB: {dashboard_status.get('database_connected', False)}")
+        
+        print("\n🚀 Starting application...")
+        print("📱 Access the application at: http://localhost:7860")
+        print("📊 Dashboard API available at: http://localhost:5001")
+        print("📈 Dashboard Integration: Real-time analytics enabled")
+        print("\n⚠️  Press Ctrl+C to stop the application")
+        print("=" * 60)
+        
+        # Launch the application
+        app.launch()
+        
+    except KeyboardInterrupt:
+        print("\n\n👋 Application interrupted by user.")
+        logging.info("Application interrupted by user")
+    except Exception as e:
+        print(f"\n❌ Application failed to start: {e}")
+        logging.error(f"Application failed to start: {e}")
+        traceback.print_exc()
+        raise
+
+if __name__ == "__main__":
+    main()
+

requirements.txt

@@ -0,0 +1,57 @@
+# Enhanced SmartHeal Bot Requirements
+# --- Core Python Packages ---
+numpy
+pillow
+opencv-python
+matplotlib
+requests
+tqdm
+pypdf
+
+# --- Deep Learning ---
+torch>=2.0.0
+tensorflow
+transformers>=4.40.0
+accelerate
+bitsandbytes
+tf-keras
+
+# --- Hugging Face ---
+huggingface-hub
+sentence-transformers
+
+# --- LangChain & RAG ---
+langchain>=0.1.14
+faiss-cpu
+pymupdf
+langchain-community
+
+# --- YOLO Detection ---
+ultralytics
+
+# --- Gradio UI ---
+gradio>=4.28.0
+spaces
+
+# --- Logging & Utility ---
+python-dotenv
+
+# --- Database ---
+mysql-connector-python>=8.0.0
+
+# --- Enhanced Dashboard Integration ---
+flask>=2.3.0
+flask-cors>=4.0.0
+flask-login>=0.6.0
+sqlalchemy>=1.4.0
+werkzeug>=2.3.0
+bcrypt>=4.0.0
+
+# --- Additional Analytics ---
+pandas>=1.5.0
+scikit-learn>=1.1.0
+seaborn>=0.11.0
+
+# --- Development Tools ---
+pytest>=7.0.0
+black>=22.0.0

src/IWGDF Guideline.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da4378da81d438142a096c37f21bd47270b44fd13e9177732ee5a1b02c0a8703
+size 1032231

src/auth.py

@@ -0,0 +1,164 @@
+import logging
+from datetime import datetime
+import hashlib
+
+class AuthManager:
+    """Authentication and user management"""
+    
+    def __init__(self, db_manager):
+        """Initialize auth manager with database manager"""
+        self.db = db_manager
+    
+    def hash_password(self, password):
+        """Simple password hashing (in production, use bcrypt or similar)"""
+        return hashlib.sha256(password.encode()).hexdigest()
+    
+    def authenticate_user(self, username, password):
+        """Authenticate user and return user data"""
+        try:
+            user = self.db.execute_query_one(
+                "SELECT id, username, email, name, role, org FROM users WHERE username = %s",
+                (username,)
+            )
+            
+            if not user:
+                logging.warning(f"User not found: {username}")
+                return None
+            
+            user_password = self.db.execute_query_one(
+                "SELECT password FROM users WHERE username = %s",
+                (username,)
+            )
+            
+            if not user_password:
+                logging.warning(f"Password not found for user: {username}")
+                return None
+            
+            stored_password = user_password['password']
+            
+            # Check if stored password is hashed (64 chars) or plain text
+            is_hashed = len(stored_password) == 64 and all(c in '0123456789abcdef' for c in stored_password)
+            
+            if is_hashed:
+                # Compare with hashed input
+                password_match = stored_password == self.hash_password(password)
+            else:
+                # Compare with plain text (for legacy compatibility)
+                password_match = stored_password == password
+            
+            logging.info(f"Debug - Username: {username}, Password type: {'hashed' if is_hashed else 'plain'}")
+            
+            if not password_match:
+                logging.warning(f"Invalid password for user: {username}")
+                return None
+            
+            # Update last login (use updated_at since last_login column may not exist)
+            try:
+                self.db.execute_query(
+                    "UPDATE users SET updated_at = %s WHERE id = %s",
+                    (datetime.now(), user['id'])
+                )
+            except Exception as e:
+                logging.warning(f"Could not update last login: {e}")
+            
+            logging.info(f"User authenticated successfully: {username}")
+            return user
+            
+        except Exception as e:
+            logging.error(f"Authentication error: {e}")
+            return None
+    
+    def get_user_data(self, username):
+        """Get user data by username - for compatibility with UI"""
+        try:
+            user = self.db.execute_query_one(
+                "SELECT id, username, email, name, role, org FROM users WHERE username = %s",
+                (username,)
+            )
+            
+            if user:
+                logging.info(f"Retrieved user data for: {username}")
+                return user
+            else:
+                logging.warning(f"User not found: {username}")
+                return None
+                
+        except Exception as e:
+            logging.error(f"Error getting user data: {e}")
+            return None
+    
+    def create_user(self, username, email, password, name, role, org_name="", 
+                   phone="", country_code="", department="", location="", organization_id=None):
+        """Create a new user account"""
+        try:
+            # Check if user already exists
+            existing_user = self.db.execute_query_one(
+                "SELECT id FROM users WHERE username = %s OR email = %s",
+                (username, email)
+            )
+            
+            if existing_user:
+                logging.warning(f"User already exists: {username} or {email}")
+                return False
+            
+            # Create organization if role is organization
+            if role == 'organization':
+                org_result = self.db.execute_query(
+                    """INSERT INTO organizations (name, email, phone, country_code, department, location, created_at) 
+                       VALUES (%s, %s, %s, %s, %s, %s, %s)""",
+                    (org_name or name, email, phone, country_code, department, location, datetime.now())
+                )
+                
+                if not org_result:
+                    logging.error("Failed to create organization")
+                    return False
+                
+                # Get the organization ID
+                org_id = self.db.execute_query_one(
+                    "SELECT id FROM organizations WHERE email = %s ORDER BY created_at DESC LIMIT 1",
+                    (email,)
+                )
+                organization_id = org_id['id'] if org_id else None
+            
+            # Create user with hashed password
+            hashed_password = self.hash_password(password)
+            user_result = self.db.execute_query(
+                """INSERT INTO users (username, email, password, name, role, org, created_at) 
+                   VALUES (%s, %s, %s, %s, %s, %s, %s)""",
+                (username, email, hashed_password, name, role, organization_id, datetime.now())
+            )
+            
+            if user_result:
+                logging.info(f"User created successfully: {username}")
+                return True
+            else:
+                logging.error(f"Failed to create user: {username}")
+                return False
+            
+        except Exception as e:
+            logging.error(f"User creation error: {e}")
+            return False
+    
+    def get_user_by_id(self, user_id):
+        """Get user by ID"""
+        try:
+            user = self.db.execute_query_one(
+                "SELECT id, username, email, name, role, org FROM users WHERE id = %s",
+                (user_id,)
+            )
+            return user
+        except Exception as e:
+            logging.error(f"Error fetching user by ID: {e}")
+            return None
+    
+    def update_user_last_login(self, user_id):
+        """Update user's last login timestamp"""
+        try:
+            result = self.db.execute_query(
+                "UPDATE users SET updated_at = %s WHERE id = %s",
+                (datetime.now(), user_id)
+            )
+            return bool(result)
+        except Exception as e:
+            logging.error(f"Error updating last login: {e}")
+            return False

src/auth_manager.py

@@ -0,0 +1,143 @@
+import logging
+from datetime import datetime
+from src.database_manager import DatabaseManager
+
+class AuthManager:
+    def __init__(self):
+        self.db_manager = DatabaseManager()
+    
+    def authenticate_user(self, username, password):
+        """Authenticate user and return user data"""
+        try:
+            # Find user by username
+            user = self.db_manager.execute_query_one(
+                "SELECT id, username, email, name, role, org FROM users WHERE username = %s",
+                (username,)
+            )
+            
+            if not user:
+                return None
+            
+            # Check password (plaintext comparison as per requirements)
+            user_password = self.db_manager.execute_query_one(
+                "SELECT password FROM users WHERE username = %s",
+                (username,)
+            )
+            
+            if not user_password or user_password['password'] != password:
+                return None
+            
+            # Update last login
+            self.db_manager.execute_query(
+                "UPDATE users SET last_login = %s WHERE id = %s",
+                (datetime.now(), user['id'])
+            )
+            
+            return user
+            
+        except Exception as e:
+            logging.error(f"Authentication error: {e}")
+            return None
+    
+    def create_user(self, username, email, password, name, role, org_name="", phone="", 
+                   country_code="", department="", location="", organization_id=None):
+        """Create a new user account"""
+        try:
+            # Check if username or email already exists
+            existing_user = self.db_manager.execute_query_one(
+                "SELECT id FROM users WHERE username = %s OR email = %s",
+                (username, email)
+            )
+            
+            if existing_user:
+                return False
+            
+            # Handle organization creation
+            if role == 'organization':
+                # Create organization entry first
+                org_result = self.db_manager.execute_query(
+                    """INSERT INTO organizations (name, email, phone, country_code, department, location, created_at) 
+                       VALUES (%s, %s, %s, %s, %s, %s, %s)""",
+                    (org_name or name, email, phone, country_code, department, location, datetime.now())
+                )
+                
+                if not org_result:
+                    return False
+                
+                # Get the organization ID
+                org_id = self.db_manager.execute_query_one(
+                    "SELECT id FROM organizations WHERE email = %s ORDER BY created_at DESC LIMIT 1",
+                    (email,)
+                )
+                organization_id = org_id['id'] if org_id else None
+            
+            # Create user entry
+            user_result = self.db_manager.execute_query(
+                """INSERT INTO users (username, email, password, name, role, org, created_at) 
+                   VALUES (%s, %s, %s, %s, %s, %s, %s)""",
+                (username, email, password, name, role, organization_id, datetime.now())
+            )
+            
+            return bool(user_result)
+            
+        except Exception as e:
+            logging.error(f"User creation error: {e}")
+            return False
+    
+    def get_organizations(self):
+        """Get list of all organizations"""
+        try:
+            organizations = self.db_manager.execute_query(
+                "SELECT id, name FROM organizations ORDER BY name",
+                fetch=True
+            )
+            return organizations or []
+        except Exception as e:
+            logging.error(f"Error fetching organizations: {e}")
+            return []
+    
+    def get_organization_practitioners(self, organization_id):
+        """Get practitioners for an organization"""
+        try:
+            practitioners = self.db_manager.execute_query(
+                """SELECT id, username, name, email, created_at, last_login 
+                   FROM users WHERE org = %s AND role = 'practitioner' 
+                   ORDER BY created_at DESC""",
+                (organization_id,),
+                fetch=True
+            )
+            return practitioners or []
+        except Exception as e:
+            logging.error(f"Error fetching practitioners: {e}")
+            return []
+    
+    def update_user_profile(self, user_id, name=None, email=None):
+        """Update user profile information"""
+        try:
+            if name:
+                self.db_manager.execute_query(
+                    "UPDATE users SET name = %s WHERE id = %s",
+                    (name, user_id)
+                )
+            
+            if email:
+                # Check if email is already taken by another user
+                existing = self.db_manager.execute_query_one(
+                    "SELECT id FROM users WHERE email = %s AND id != %s",
+                    (email, user_id)
+                )
+                
+                if not existing:
+                    self.db_manager.execute_query(
+                        "UPDATE users SET email = %s WHERE id = %s",
+                        (email, user_id)
+                    )
+                    return True
+                else:
+                    return False
+            
+            return True
+            
+        except Exception as e:
+            logging.error(f"Error updating user profile: {e}")
+            return False

src/best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dc7b01e2bf4e70eca6321059de6f0965612ad5cca55154e8adb0ea15c77e350d
+size 136689065

src/config.py

@@ -0,0 +1,76 @@
+import os
+import logging
+from pathlib import Path
+
+class Config:
+    """Configuration management for SmartHeal application"""
+    
+    def __init__(self):
+        """Initialize configuration with environment variables and defaults"""
+        
+        # Database configuration
+        self.MYSQL_CONFIG = {
+            "host": os.getenv("MYSQL_HOST", "sg-nme-web545.main-hosting.eu"),
+            "user": os.getenv("MYSQL_USER", "u124249738_SmartHealApp"),
+            "password": os.getenv("MYSQL_PASSWORD", "I^4y1b12y"),
+            "database": os.getenv("MYSQL_DATABASE", "u124249738_SmartHealAppDB"),
+            "port": int(os.getenv("MYSQL_PORT", 3306))
+        }
+        
+        # Application directories
+        self.UPLOADS_DIR = os.getenv("UPLOADS_DIR", "uploads")
+        self.MODELS_DIR = os.getenv("MODELS_DIR", "models")
+        
+        # AI/ML configuration
+        self.HF_TOKEN = os.getenv("HF_TOKEN")
+        self.OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+        
+        # AI Model Configuration
+        # AI Model Configuration
+        self.YOLO_MODEL_PATH = os.getenv("YOLO_MODEL_PATH", "src/best.pt")
+        self.SEG_MODEL_PATH = os.getenv("SEG_MODEL_PATH", "src/segmentation_model.h5")
+
+        self.MEDGEMMA_MODEL = os.getenv("MEDGEMMA_MODEL", "google/medgemma-4b-it")
+        self.WOUND_CLASSIFICATION_MODEL = os.getenv("WOUND_CLASSIFICATION_MODEL", "Hemg/Wound-classification")
+        self.EMBEDDING_MODEL = os.getenv("EMBEDDING_MODEL", "sentence-transformers/all-MiniLM-L6-v2")
+        
+        # AI Processing Configuration
+        self.PIXELS_PER_CM = int(os.getenv("PIXELS_PER_CM", "37"))
+        self.MAX_NEW_TOKENS = int(os.getenv("MAX_NEW_TOKENS", "512"))
+        self.DATASET_ID = os.getenv("DATASET_ID", "")
+        self.GUIDELINE_PDFS = [
+            os.path.join("src", "eHealth in Wound Care.pdf"),
+            os.path.join("src", "IWGDF Guideline.pdf"),
+            os.path.join("src", "evaluation.pdf")
+        ]
+
+        
+        # Application settings
+        self.DEBUG = os.getenv("DEBUG", "False").lower() == "true"
+        self.LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO")
+        
+        # Create required directories
+        self._create_directories()
+        
+        logging.info("✅ Configuration initialized")
+    
+    def _create_directories(self):
+        """Create required directories if they don't exist"""
+        directories = [self.UPLOADS_DIR, self.MODELS_DIR]
+        
+        for directory in directories:
+            if not os.path.exists(directory):
+                os.makedirs(directory, exist_ok=True)
+                logging.info(f"Created directory: {directory}")
+    
+    def get_mysql_config(self):
+        """Get MySQL configuration dictionary"""
+        return self.MYSQL_CONFIG.copy()
+    
+    def get_upload_path(self, filename):
+        """Get full path for uploaded file"""
+        return os.path.join(self.UPLOADS_DIR, filename)
+    
+    def get_model_path(self, model_name):
+        """Get full path for model file"""
+        return os.path.join(self.MODELS_DIR, model_name)

src/dashboard_api.py

@@ -0,0 +1,408 @@
+from flask import Flask, jsonify, request
+from flask_cors import CORS
+import logging
+from datetime import datetime, timedelta
+import json
+from typing import Dict, Any, List, Optional
+import threading
+import time
+
+from .dashboard_database_manager import DashboardDatabaseManager
+
+class DashboardAPI:
+    """API layer for dashboard integration"""
+    
+    def __init__(self, database_manager: DashboardDatabaseManager, port: int = 5001):
+        self.database_manager = database_manager
+        self.port = port
+        self.app = Flask(__name__)
+        CORS(self.app)  # Enable CORS for all routes
+        
+        # Configure logging
+        logging.basicConfig(level=logging.INFO)
+        self.logger = logging.getLogger(__name__)
+        
+        # Setup routes
+        self._setup_routes()
+        
+        # Background thread for API server
+        self.api_thread = None
+        self.running = False
+    
+    def _setup_routes(self):
+        """Setup API routes for dashboard integration"""
+        
+        @self.app.route('/api/health', methods=['GET'])
+        def health_check():
+            """Health check endpoint"""
+            return jsonify({
+                'status': 'healthy',
+                'timestamp': datetime.now().isoformat(),
+                'service': 'SmartHeal Bot API'
+            })
+        
+        @self.app.route('/api/bot/analytics', methods=['GET'])
+        def get_bot_analytics():
+            """Get comprehensive bot analytics for dashboard"""
+            try:
+                analytics_data = self.database_manager.get_analytics_data()
+                
+                # Add trend data for charts
+                analytics_data.update(self._get_trend_data())
+                
+                return jsonify({
+                    'success': True,
+                    'data': analytics_data,
+                    'timestamp': datetime.now().isoformat()
+                })
+                
+            except Exception as e:
+                self.logger.error(f"Error getting bot analytics: {e}")
+                return jsonify({
+                    'success': False,
+                    'error': str(e),
+                    'timestamp': datetime.now().isoformat()
+                }), 500
+        
+        @self.app.route('/api/bot/analytics/details/<int:analysis_id>', methods=['GET'])
+        def get_analysis_details(analysis_id):
+            """Get detailed analysis information"""
+            try:
+                query = "SELECT * FROM ai_analyses WHERE id = %s"
+                analysis = self.database_manager.execute_query_one(query, (analysis_id,))
+                
+                if not analysis:
+                    return jsonify({
+                        'success': False,
+                        'error': 'Analysis not found'
+                    }), 404
+                
+                # Convert datetime objects to strings for JSON serialization
+                if analysis.get('created_at'):
+                    analysis['created_at'] = analysis['created_at'].isoformat()
+                
+                return jsonify({
+                    'success': True,
+                    'data': analysis,
+                    'timestamp': datetime.now().isoformat()
+                })
+                
+            except Exception as e:
+                self.logger.error(f"Error getting analysis details: {e}")
+                return jsonify({
+                    'success': False,
+                    'error': str(e)
+                }), 500
+        
+        @self.app.route('/api/bot/interactions', methods=['GET'])
+        def get_bot_interactions():
+            """Get bot interaction history"""
+            try:
+                limit = request.args.get('limit', 50, type=int)
+                interactions = self.database_manager.get_interaction_history(limit)
+                
+                # Convert datetime objects for JSON serialization
+                for interaction in interactions:
+                    if interaction.get('interacted_at'):
+                        interaction['interacted_at'] = interaction['interacted_at'].isoformat()
+                
+                return jsonify({
+                    'success': True,
+                    'data': interactions,
+                    'count': len(interactions),
+                    'timestamp': datetime.now().isoformat()
+                })
+                
+            except Exception as e:
+                self.logger.error(f"Error getting bot interactions: {e}")
+                return jsonify({
+                    'success': False,
+                    'error': str(e)
+                }), 500
+        
+        @self.app.route('/api/bot/sessions', methods=['GET'])
+        def get_session_analytics():
+            """Get session analytics"""
+            try:
+                session_data = self.database_manager.get_session_analytics()
+                
+                return jsonify({
+                    'success': True,
+                    'data': session_data,
+                    'timestamp': datetime.now().isoformat()
+                })
+                
+            except Exception as e:
+                self.logger.error(f"Error getting session analytics: {e}")
+                return jsonify({
+                    'success': False,
+                    'error': str(e)
+                }), 500
+        
+        @self.app.route('/api/bot/stats/summary', methods=['GET'])
+        def get_summary_stats():
+            """Get summary statistics for dashboard widgets"""
+            try:
+                # Get basic counts
+                total_analyses = self.database_manager.execute_query_one("SELECT COUNT(*) as count FROM ai_analyses")
+                total_patients = self.database_manager.execute_query_one("SELECT COUNT(DISTINCT patient_id) as count FROM bot_interactions WHERE patient_id IS NOT NULL")
+                total_sessions = self.database_manager.execute_query_one("SELECT COUNT(*) as count FROM analysis_sessions")
+                
+                # Get today's activity
+                today_analyses = self.database_manager.execute_query_one("""
+                    SELECT COUNT(*) as count FROM ai_analyses 
+                    WHERE DATE(created_at) = CURDATE()
+                """)
+                
+                # Get average metrics
+                avg_processing_time = self.database_manager.execute_query_one("""
+                    SELECT AVG(processing_time) as avg_time FROM ai_analyses 
+                    WHERE processing_time IS NOT NULL
+                """)
+                
+                avg_risk_score = self.database_manager.execute_query_one("""
+                    SELECT AVG(risk_score) as avg_risk FROM ai_analyses 
+                    WHERE risk_score IS NOT NULL
+                """)
+                
+                summary = {
+                    'total_analyses': total_analyses['count'] if total_analyses else 0,
+                    'total_patients': total_patients['count'] if total_patients else 0,
+                    'total_sessions': total_sessions['count'] if total_sessions else 0,
+                    'today_analyses': today_analyses['count'] if today_analyses else 0,
+                    'avg_processing_time': round(avg_processing_time['avg_time'], 2) if avg_processing_time and avg_processing_time['avg_time'] else 0,
+                    'avg_risk_score': round(avg_risk_score['avg_risk'], 1) if avg_risk_score and avg_risk_score['avg_risk'] else 0
+                }
+                
+                return jsonify({
+                    'success': True,
+                    'data': summary,
+                    'timestamp': datetime.now().isoformat()
+                })
+                
+            except Exception as e:
+                self.logger.error(f"Error getting summary stats: {e}")
+                return jsonify({
+                    'success': False,
+                    'error': str(e)
+                }), 500
+        
+        @self.app.route('/api/bot/models/performance', methods=['GET'])
+        def get_model_performance():
+            """Get AI model performance metrics"""
+            try:
+                performance_data = self.database_manager.execute_query("""
+                    SELECT 
+                        model_version,
+                        COUNT(*) as total_analyses,
+                        AVG(processing_time) as avg_processing_time,
+                        AVG(risk_score) as avg_risk_score,
+                        MIN(created_at) as first_used,
+                        MAX(created_at) as last_used
+                    FROM ai_analyses 
+                    WHERE model_version IS NOT NULL
+                    GROUP BY model_version
+                    ORDER BY last_used DESC
+                """, fetch=True)
+                
+                # Convert datetime objects for JSON serialization
+                for model in performance_data:
+                    if model.get('first_used'):
+                        model['first_used'] = model['first_used'].isoformat()
+                    if model.get('last_used'):
+                        model['last_used'] = model['last_used'].isoformat()
+                    if model.get('avg_processing_time'):
+                        model['avg_processing_time'] = round(model['avg_processing_time'], 2)
+                    if model.get('avg_risk_score'):
+                        model['avg_risk_score'] = round(model['avg_risk_score'], 1)
+                
+                return jsonify({
+                    'success': True,
+                    'data': performance_data or [],
+                    'timestamp': datetime.now().isoformat()
+                })
+                
+            except Exception as e:
+                self.logger.error(f"Error getting model performance: {e}")
+                return jsonify({
+                    'success': False,
+                    'error': str(e)
+                }), 500
+    
+    def _get_trend_data(self) -> Dict[str, Any]:
+        """Get trend data for dashboard charts"""
+        try:
+            # Get last 30 days of analysis data
+            trend_data = self.database_manager.execute_query("""
+                SELECT 
+                    DATE(created_at) as analysis_date,
+                    COUNT(*) as count
+                FROM ai_analyses 
+                WHERE created_at >= DATE_SUB(CURDATE(), INTERVAL 30 DAY)
+                GROUP BY DATE(created_at)
+                ORDER BY analysis_date
+            """, fetch=True)
+            
+            # Prepare data for Chart.js
+            labels = []
+            data = []
+            
+            if trend_data:
+                for row in trend_data:
+                    labels.append(row['analysis_date'].strftime('%Y-%m-%d'))
+                    data.append(row['count'])
+            
+            # Get risk level distribution
+            risk_distribution = self.database_manager.execute_query("""
+                SELECT risk_level, COUNT(*) as count 
+                FROM ai_analyses 
+                GROUP BY risk_level
+            """, fetch=True)
+            
+            risk_labels = []
+            risk_data = []
+            
+            if risk_distribution:
+                for row in risk_distribution:
+                    risk_labels.append(row['risk_level'])
+                    risk_data.append(row['count'])
+            
+            # Get processing time distribution
+            processing_time_data = self.database_manager.execute_query("""
+                SELECT 
+                    CASE 
+                        WHEN processing_time < 1 THEN '< 1s'
+                        WHEN processing_time < 2 THEN '1-2s'
+                        WHEN processing_time < 5 THEN '2-5s'
+                        WHEN processing_time < 10 THEN '5-10s'
+                        ELSE '> 10s'
+                    END as time_range,
+                    COUNT(*) as count
+                FROM ai_analyses 
+                WHERE processing_time IS NOT NULL
+                GROUP BY time_range
+                ORDER BY 
+                    CASE 
+                        WHEN processing_time < 1 THEN 1
+                        WHEN processing_time < 2 THEN 2
+                        WHEN processing_time < 5 THEN 3
+                        WHEN processing_time < 10 THEN 4
+                        ELSE 5
+                    END
+            """, fetch=True)
+            
+            processing_labels = []
+            processing_data = []
+            
+            if processing_time_data:
+                for row in processing_time_data:
+                    processing_labels.append(row['time_range'])
+                    processing_data.append(row['count'])
+            
+            return {
+                'trend_labels': labels,
+                'trend_data': data,
+                'risk_level_labels': risk_labels,
+                'risk_level_data': risk_data,
+                'processing_time_labels': processing_labels,
+                'processing_time_data': processing_data
+            }
+            
+        except Exception as e:
+            self.logger.error(f"Error getting trend data: {e}")
+            return {
+                'trend_labels': [],
+                'trend_data': [],
+                'risk_level_labels': [],
+                'risk_level_data': [],
+                'processing_time_labels': [],
+                'processing_time_data': []
+            }
+    
+    def start_api_server(self):
+        """Start the API server in a background thread"""
+        if self.running:
+            self.logger.warning("API server is already running")
+            return
+        
+        def run_server():
+            try:
+                self.logger.info(f"Starting SmartHeal Bot API server on port {self.port}")
+                self.app.run(host='0.0.0.0', port=self.port, debug=False, threaded=True)
+            except Exception as e:
+                self.logger.error(f"Error starting API server: {e}")
+        
+        self.running = True
+        self.api_thread = threading.Thread(target=run_server, daemon=True)
+        self.api_thread.start()
+        
+        # Give the server a moment to start
+        time.sleep(1)
+        self.logger.info(f"✅ SmartHeal Bot API server started on http://0.0.0.0:{self.port}")
+    
+    def stop_api_server(self):
+        """Stop the API server"""
+        self.running = False
+        if self.api_thread and self.api_thread.is_alive():
+            self.logger.info("Stopping SmartHeal Bot API server")
+            # Note: Flask development server doesn't have a clean shutdown method
+            # In production, you would use a proper WSGI server like Gunicorn
+    
+    def is_running(self) -> bool:
+        """Check if the API server is running"""
+        return self.running and self.api_thread and self.api_thread.is_alive()
+
+class DashboardIntegrationManager:
+    """Manager class for dashboard integration functionality"""
+    
+    def __init__(self, database_manager: DashboardDatabaseManager):
+        self.database_manager = database_manager
+        self.api = DashboardAPI(database_manager)
+        self.logger = logging.getLogger(__name__)
+    
+    def start_integration(self):
+        """Start dashboard integration services"""
+        try:
+            self.api.start_api_server()
+            self.logger.info("✅ Dashboard integration started successfully")
+        except Exception as e:
+            self.logger.error(f"❌ Failed to start dashboard integration: {e}")
+    
+    def stop_integration(self):
+        """Stop dashboard integration services"""
+        try:
+            self.api.stop_api_server()
+            self.logger.info("✅ Dashboard integration stopped")
+        except Exception as e:
+            self.logger.error(f"❌ Error stopping dashboard integration: {e}")
+    
+    def log_analysis_session(self, session_data: Dict[str, Any]) -> Optional[int]:
+        """Log an analysis session for dashboard tracking"""
+        try:
+            session_id = self.database_manager.save_analysis_session(session_data)
+            if session_id:
+                self.logger.info(f"✅ Analysis session logged with ID: {session_id}")
+            return session_id
+        except Exception as e:
+            self.logger.error(f"❌ Error logging analysis session: {e}")
+            return None
+    
+    def log_bot_interaction(self, interaction_data: Dict[str, Any]) -> Optional[int]:
+        """Log a bot interaction for dashboard tracking"""
+        try:
+            interaction_id = self.database_manager.save_bot_interaction(interaction_data)
+            if interaction_id:
+                self.logger.info(f"✅ Bot interaction logged with ID: {interaction_id}")
+            return interaction_id
+        except Exception as e:
+            self.logger.error(f"❌ Error logging bot interaction: {e}")
+            return None
+    
+    def get_integration_status(self) -> Dict[str, Any]:
+        """Get the status of dashboard integration"""
+        return {
+            'api_running': self.api.is_running(),
+            'database_connected': self.database_manager.get_connection() is not None,
+            'timestamp': datetime.now().isoformat()
+        }
+

src/dashboard_database_manager.py

@@ -0,0 +1,571 @@
+import mysql.connector
+from mysql.connector import Error
+import logging
+from datetime import datetime
+import json
+import uuid
+import os
+from PIL import Image
+from typing import Dict, Any, Optional, List
+
+class DashboardDatabaseManager:
+    """Enhanced database manager for SmartHeal bot with dashboard integration"""
+    
+    def __init__(self, mysql_config):
+        """Initialize database manager with MySQL configuration"""
+        self.mysql_config = mysql_config
+        self.test_connection()
+    
+    def test_connection(self):
+        """Test database connection"""
+        try:
+            connection = self.get_connection()
+            if connection:
+                connection.close()
+                logging.info("✅ Database connection successful")
+            else:
+                logging.error("❌ Database connection failed")
+        except Exception as e:
+            logging.error(f"Database connection test failed: {e}")
+    
+    def get_connection(self):
+        """Get a database connection"""
+        try:
+            connection = mysql.connector.connect(**self.mysql_config)
+            return connection
+        except Error as e:
+            logging.error(f"Error connecting to MySQL: {e}")
+            return None
+    
+    def execute_query(self, query, params=None, fetch=False):
+        """Execute a query and return results if fetch=True"""
+        connection = self.get_connection()
+        if not connection:
+            return None
+            
+        cursor = None
+        try:
+            cursor = connection.cursor(dictionary=True)
+            cursor.execute(query, params or ())
+            
+            if fetch:
+                result = cursor.fetchall()
+            else:
+                connection.commit()
+                result = cursor.rowcount
+                
+            return result
+        except Error as e:
+            logging.error(f"Error executing query: {e}")
+            if connection:
+                connection.rollback()
+            return None
+        finally:
+            if cursor:
+                cursor.close()
+            if connection and connection.is_connected():
+                connection.close()
+    
+    def execute_query_one(self, query, params=None):
+        """Execute a query and return one result"""
+        connection = self.get_connection()
+        if not connection:
+            return None
+            
+        cursor = None
+        try:
+            cursor = connection.cursor(dictionary=True)
+            cursor.execute(query, params or ())
+            result = cursor.fetchone()
+            return result
+        except Error as e:
+            logging.error(f"Error executing query: {e}")
+            return None
+        finally:
+            if cursor:
+                cursor.close()
+            if connection and connection.is_connected():
+                connection.close()
+    
+    def get_last_insert_id(self, connection, cursor):
+        """Get the last inserted ID"""
+        return cursor.lastrowid
+    
+    def save_questionnaire_response(self, questionnaire_data: Dict[str, Any], user_id: int) -> Optional[int]:
+        """
+        Save questionnaire response to dashboard-compatible tables
+        """
+        connection = None
+        cursor = None
+        try:
+            connection = self.get_connection()
+            if not connection:
+                return None
+            cursor = connection.cursor()
+
+            # (1) Create or get patient
+            patient_id = self._create_or_get_patient(cursor, questionnaire_data)
+            if not patient_id:
+                raise Exception("Failed to get or create patient")
+
+            # (2) Get or create default questionnaire
+            questionnaire_id = self._get_or_create_default_questionnaire(cursor)
+            if not questionnaire_id:
+                raise Exception("Failed to get or create questionnaire")
+
+            # (3) Prepare response_data JSON
+            response_data = {
+                'patient_info': {
+                    'name': questionnaire_data.get('patient_name', ''),
+                    'age': questionnaire_data.get('patient_age', 0),
+                    'gender': questionnaire_data.get('patient_gender', '')
+                },
+                'wound_details': {
+                    'location': questionnaire_data.get('wound_location', ''),
+                    'duration': questionnaire_data.get('wound_duration', ''),
+                    'pain_level': questionnaire_data.get('pain_level', 0),
+                    'moisture_level': questionnaire_data.get('moisture_level', ''),
+                    'infection_signs': questionnaire_data.get('infection_signs', ''),
+                    'diabetic_status': questionnaire_data.get('diabetic_status', '')
+                },
+                'medical_history': {
+                    'previous_treatment': questionnaire_data.get('previous_treatment', ''),
+                    'medical_history': questionnaire_data.get('medical_history', ''),
+                    'medications': questionnaire_data.get('medications', ''),
+                    'allergies': questionnaire_data.get('allergies', ''),
+                    'additional_notes': questionnaire_data.get('additional_notes', '')
+                }
+            }
+
+            # (4) Insert into questionnaire_responses
+            insert_resp = """
+                INSERT INTO questionnaire_responses
+                    (questionnaire_id, patient_id, practitioner_id, response_data, submitted_at)
+                VALUES (%s, %s, %s, %s, %s)
+            """
+            cursor.execute(insert_resp, (
+                questionnaire_id,
+                patient_id,
+                user_id,
+                json.dumps(response_data),
+                datetime.now()
+            ))
+            response_id = cursor.lastrowid
+
+            connection.commit()
+            logging.info(f"✅ Saved questionnaire response ID {response_id}")
+            return response_id
+
+        except Exception as e:
+            logging.error(f"❌ Error saving questionnaire response: {e}")
+            if connection:
+                connection.rollback()
+            return None
+        finally:
+            if cursor:
+                cursor.close()
+            if connection:
+                connection.close()
+    
+    def _get_or_create_default_questionnaire(self, cursor) -> Optional[int]:
+        """Get or create default questionnaire"""
+        try:
+            # Check if default questionnaire exists
+            cursor.execute("SELECT id FROM questionnaires WHERE name = 'Default Patient Assessment' LIMIT 1")
+            questionnaire_row = cursor.fetchone()
+            
+            if questionnaire_row:
+                return questionnaire_row[0]
+            
+            # Create default questionnaire
+            cursor.execute("""
+                INSERT INTO questionnaires (name, description, created_at) 
+                VALUES ('Default Patient Assessment', 'Standard patient wound assessment form', NOW())
+            """)
+            return cursor.lastrowid
+            
+        except Exception as e:
+            logging.error(f"Error getting/creating questionnaire: {e}")
+            return None
+    
+    def _create_or_get_patient(self, cursor, questionnaire_data: Dict[str, Any]) -> Optional[int]:
+        """Create or get existing patient record"""
+        try:
+            # Check if patient exists by name and age
+            select_query = """
+            SELECT id FROM patients 
+            WHERE name = %s AND age = %s
+            LIMIT 1
+            """
+            cursor.execute(select_query, (
+                questionnaire_data.get('patient_name', ''),
+                questionnaire_data.get('patient_age', 0)
+            ))
+            
+            existing_patient = cursor.fetchone()
+            if existing_patient:
+                return existing_patient[0]
+            
+            # Create new patient
+            patient_uuid = str(uuid.uuid4())
+            insert_query = """
+            INSERT INTO patients (
+                uuid, name, age, gender, illness, allergy, notes, created_at
+            ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
+            """
+            
+            cursor.execute(insert_query, (
+                patient_uuid,
+                questionnaire_data.get('patient_name', ''),
+                questionnaire_data.get('patient_age', 0),
+                questionnaire_data.get('patient_gender', ''),
+                questionnaire_data.get('medical_history', ''),
+                questionnaire_data.get('allergies', ''),
+                questionnaire_data.get('additional_notes', ''),
+                datetime.now()
+            ))
+            
+            return cursor.lastrowid
+            
+        except Exception as e:
+            logging.error(f"Error creating/getting patient: {e}")
+            return None
+    
+    def save_wound_image(self, questionnaire_response_id: int, image, original_filename: str = None) -> Optional[int]:
+        """Save wound image to filesystem and database"""
+        try:
+            # Generate unique filename
+            image_id = str(uuid.uuid4())
+            filename = f"wound_{image_id}.jpg"
+            file_path = os.path.join("uploads", filename)
+            
+            # Ensure uploads directory exists
+            os.makedirs("uploads", exist_ok=True)
+            
+            # Save image to disk
+            if hasattr(image, 'save'):
+                image.save(file_path, format='JPEG', quality=95)
+                
+                # Get image dimensions and file size
+                width, height = image.size
+                file_size = os.path.getsize(file_path)
+                
+                # Save to wound_images table
+                query = """
+                INSERT INTO wound_images (
+                    questionnaire_id, image_url, original_filename, file_size, 
+                    image_width, image_height, created_at
+                ) VALUES (%s, %s, %s, %s, %s, %s, %s)
+                """
+                
+                params = (
+                    questionnaire_response_id,
+                    file_path,
+                    original_filename or filename,
+                    file_size,
+                    width,
+                    height,
+                    datetime.now()
+                )
+                
+                result = self.execute_query(query, params)
+                if result:
+                    # Get the inserted ID
+                    connection = self.get_connection()
+                    cursor = connection.cursor()
+                    cursor.execute("SELECT LAST_INSERT_ID()")
+                    image_db_id = cursor.fetchone()[0]
+                    cursor.close()
+                    connection.close()
+                    
+                    logging.info(f"✅ Image saved with ID: {image_db_id}")
+                    return image_db_id
+                
+        except Exception as e:
+            logging.error(f"❌ Error saving wound image: {e}")
+            
+        return None
+    
+    def save_ai_analysis(self, analysis_data: Dict[str, Any]) -> Optional[int]:
+        """
+        Save AI analysis results to dashboard-compatible ai_analyses table
+        """
+        try:
+            query = """
+            INSERT INTO ai_analyses (
+                questionnaire_id, image_id, analysis_data, summary, recommendations,
+                risk_score, risk_level, wound_type, wound_dimensions, processing_time,
+                model_version, created_at
+            ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
+            """
+            
+            # Calculate risk level based on risk score
+            risk_score = analysis_data.get('risk_score', 0)
+            if risk_score >= 70:
+                risk_level = 'High'
+            elif risk_score >= 40:
+                risk_level = 'Moderate'
+            else:
+                risk_level = 'Low'
+            
+            # Format wound dimensions
+            visual_results = analysis_data.get('visual_results', {})
+            wound_dimensions = f"{visual_results.get('length_cm', 0)}x{visual_results.get('breadth_cm', 0)} cm"
+            
+            params = (
+                analysis_data.get('questionnaire_id'),
+                analysis_data.get('image_id'),
+                json.dumps(analysis_data.get('analysis_data', {})),
+                analysis_data.get('summary', ''),
+                analysis_data.get('recommendations', ''),
+                risk_score,
+                risk_level,
+                visual_results.get('wound_type', 'Unknown'),
+                wound_dimensions,
+                analysis_data.get('processing_time', 0.0),
+                analysis_data.get('model_version', 'v1.0'),
+                datetime.now()
+            )
+            
+            result = self.execute_query(query, params)
+            if result:
+                # Get the inserted ID
+                connection = self.get_connection()
+                cursor = connection.cursor()
+                cursor.execute("SELECT LAST_INSERT_ID()")
+                analysis_id = cursor.fetchone()[0]
+                cursor.close()
+                connection.close()
+                
+                logging.info(f"✅ AI analysis saved with ID: {analysis_id}")
+                return analysis_id
+                
+        except Exception as e:
+            logging.error(f"❌ Error saving AI analysis: {e}")
+            
+        return None
+    
+    def save_analysis_session(self, session_data: Dict[str, Any]) -> Optional[int]:
+        """
+        Save analysis session data for dashboard analytics
+        """
+        try:
+            query = """
+            INSERT INTO analysis_sessions (
+                user_id, questionnaire_id, image_id, analysis_id, 
+                session_duration, created_at
+            ) VALUES (%s, %s, %s, %s, %s, %s)
+            """
+            
+            params = (
+                session_data.get('user_id'),
+                session_data.get('questionnaire_id'),
+                session_data.get('image_id'),
+                session_data.get('analysis_id'),
+                session_data.get('session_duration', 0.0),
+                datetime.now()
+            )
+            
+            result = self.execute_query(query, params)
+            if result:
+                connection = self.get_connection()
+                cursor = connection.cursor()
+                cursor.execute("SELECT LAST_INSERT_ID()")
+                session_id = cursor.fetchone()[0]
+                cursor.close()
+                connection.close()
+                
+                logging.info(f"✅ Analysis session saved with ID: {session_id}")
+                return session_id
+                
+        except Exception as e:
+            logging.error(f"❌ Error saving analysis session: {e}")
+            
+        return None
+    
+    def save_bot_interaction(self, interaction_data: Dict[str, Any]) -> Optional[int]:
+        """
+        Save bot interaction data for dashboard analytics
+        """
+        try:
+            query = """
+            INSERT INTO bot_interactions (
+                patient_id, practitioner_id, input_text, output_text,
+                wound_image_url, interaction_type, interacted_at
+            ) VALUES (%s, %s, %s, %s, %s, %s, %s)
+            """
+            
+            params = (
+                interaction_data.get('patient_id'),
+                interaction_data.get('practitioner_id'),
+                interaction_data.get('input_text', ''),
+                interaction_data.get('output_text', ''),
+                interaction_data.get('wound_image_url', ''),
+                interaction_data.get('interaction_type', 'analysis'),
+                datetime.now()
+            )
+            
+            result = self.execute_query(query, params)
+            if result:
+                connection = self.get_connection()
+                cursor = connection.cursor()
+                cursor.execute("SELECT LAST_INSERT_ID()")
+                interaction_id = cursor.fetchone()[0]
+                cursor.close()
+                connection.close()
+                
+                logging.info(f"✅ Bot interaction saved with ID: {interaction_id}")
+                return interaction_id
+                
+        except Exception as e:
+            logging.error(f"❌ Error saving bot interaction: {e}")
+            
+        return None
+    
+    def get_analytics_data(self) -> Dict[str, Any]:
+        """
+        Get comprehensive analytics data for dashboard
+        """
+        try:
+            analytics = {}
+            
+            # Total analyses
+            total_analyses = self.execute_query_one("SELECT COUNT(*) as count FROM ai_analyses")
+            analytics['total_analyses'] = total_analyses['count'] if total_analyses else 0
+            
+            # Average processing time
+            avg_time = self.execute_query_one("SELECT AVG(processing_time) as avg_time FROM ai_analyses WHERE processing_time IS NOT NULL")
+            analytics['avg_processing_time'] = round(avg_time['avg_time'], 2) if avg_time and avg_time['avg_time'] else 0
+            
+            # High risk count
+            high_risk = self.execute_query_one("SELECT COUNT(*) as count FROM ai_analyses WHERE risk_level = 'High'")
+            analytics['high_risk_count'] = high_risk['count'] if high_risk else 0
+            
+            # Average risk score
+            avg_risk = self.execute_query_one("SELECT AVG(risk_score) as avg_risk FROM ai_analyses WHERE risk_score IS NOT NULL")
+            analytics['avg_risk_score'] = round(avg_risk['avg_risk'], 1) if avg_risk and avg_risk['avg_risk'] else 0
+            
+            # Risk level distribution
+            risk_distribution = self.execute_query("""
+                SELECT risk_level, COUNT(*) as count 
+                FROM ai_analyses 
+                GROUP BY risk_level
+            """, fetch=True)
+            
+            analytics['risk_level_distribution'] = {}
+            if risk_distribution:
+                for row in risk_distribution:
+                    analytics['risk_level_distribution'][row['risk_level']] = row['count']
+            
+            # Recent analyses
+            recent_analyses = self.execute_query("""
+                SELECT * FROM ai_analyses 
+                ORDER BY created_at DESC 
+                LIMIT 10
+            """, fetch=True)
+            analytics['recent_analyses'] = recent_analyses or []
+            
+            # Model performance
+            model_performance = self.execute_query("""
+                SELECT 
+                    model_version,
+                    COUNT(*) as count,
+                    AVG(processing_time) as avg_processing_time,
+                    AVG(risk_score) as avg_risk_score
+                FROM ai_analyses 
+                WHERE model_version IS NOT NULL
+                GROUP BY model_version
+            """, fetch=True)
+            analytics['model_performance'] = model_performance or []
+            
+            # Today's analyses
+            today_analyses = self.execute_query_one("""
+                SELECT COUNT(*) as count 
+                FROM ai_analyses 
+                WHERE DATE(created_at) = CURDATE()
+            """)
+            analytics['analyses_today'] = today_analyses['count'] if today_analyses else 0
+            
+            # This week's analyses
+            week_analyses = self.execute_query_one("""
+                SELECT COUNT(*) as count 
+                FROM ai_analyses 
+                WHERE YEARWEEK(created_at) = YEARWEEK(NOW())
+            """)
+            analytics['analyses_this_week'] = week_analyses['count'] if week_analyses else 0
+            
+            # Unique questionnaires
+            unique_questionnaires = self.execute_query_one("""
+                SELECT COUNT(DISTINCT questionnaire_id) as count 
+                FROM ai_analyses
+            """)
+            analytics['unique_questionnaires'] = unique_questionnaires['count'] if unique_questionnaires else 0
+            
+            # Analyses with images
+            with_images = self.execute_query_one("""
+                SELECT COUNT(*) as count 
+                FROM ai_analyses 
+                WHERE image_id IS NOT NULL
+            """)
+            analytics['analyses_with_images'] = with_images['count'] if with_images else 0
+            
+            return analytics
+            
+        except Exception as e:
+            logging.error(f"❌ Error getting analytics data: {e}")
+            return {}
+    
+    def get_interaction_history(self, limit: int = 50) -> List[Dict[str, Any]]:
+        """
+        Get bot interaction history for dashboard
+        """
+        try:
+            query = """
+            SELECT bi.*, p.name as patient_name, u.name as practitioner_name
+            FROM bot_interactions bi
+            LEFT JOIN patients p ON bi.patient_id = p.id
+            LEFT JOIN users u ON bi.practitioner_id = u.id
+            ORDER BY bi.interacted_at DESC
+            LIMIT %s
+            """
+            
+            interactions = self.execute_query(query, (limit,), fetch=True)
+            return interactions or []
+            
+        except Exception as e:
+            logging.error(f"❌ Error getting interaction history: {e}")
+            return []
+    
+    def get_session_analytics(self) -> Dict[str, Any]:
+        """
+        Get session analytics for dashboard
+        """
+        try:
+            analytics = {}
+            
+            # Total sessions
+            total_sessions = self.execute_query_one("SELECT COUNT(*) as count FROM analysis_sessions")
+            analytics['total_sessions'] = total_sessions['count'] if total_sessions else 0
+            
+            # Average session duration
+            avg_duration = self.execute_query_one("""
+                SELECT AVG(session_duration) as avg_duration 
+                FROM analysis_sessions 
+                WHERE session_duration IS NOT NULL
+            """)
+            analytics['avg_session_duration'] = round(avg_duration['avg_duration'], 2) if avg_duration and avg_duration['avg_duration'] else 0
+            
+            # Sessions today
+            today_sessions = self.execute_query_one("""
+                SELECT COUNT(*) as count 
+                FROM analysis_sessions 
+                WHERE DATE(created_at) = CURDATE()
+            """)
+            analytics['sessions_today'] = today_sessions['count'] if today_sessions else 0
+            
+            return analytics
+            
+        except Exception as e:
+            logging.error(f"❌ Error getting session analytics: {e}")
+            return {}
+

src/eHealth in Wound Care.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dde88c1c1d7d295c7f2c53375b9cd69c0cef029e273c89374d92f1375c2c5038
+size 907639

src/enhanced_ai_processor.py

@@ -0,0 +1,613 @@
+import os
+import logging
+import cv2
+import numpy as np
+from PIL import Image
+import torch
+import json
+from datetime import datetime
+import tensorflow as tf
+from transformers import pipeline
+from ultralytics import YOLO
+from tensorflow.keras.models import load_model
+from langchain_community.document_loaders import PyPDFLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_community.vectorstores import FAISS
+from huggingface_hub import HfApi, HfFolder
+import spaces
+import time
+from typing import Dict, Any, Optional, Tuple
+
+from .config import Config
+
+class EnhancedAIProcessor:
+    """Enhanced AI processor with dashboard integration and analytics tracking"""
+    
+    def __init__(self):
+        self.models_cache = {}
+        self.knowledge_base_cache = {}
+        self.config = Config()
+        self.px_per_cm = self.config.PIXELS_PER_CM
+        self.model_version = "v1.2.0"  # Version for tracking
+        self._initialize_models()
+
+    def _initialize_models(self):
+        """Initialize all AI models including real-time models"""
+        try:
+            # Set HuggingFace token
+            if self.config.HF_TOKEN:
+                HfFolder.save_token(self.config.HF_TOKEN)
+                logging.info("HuggingFace token set successfully")
+
+            # Initialize MedGemma pipeline for medical text generation
+            try:
+                self.models_cache["medgemma_pipe"] = pipeline(
+                    "image-text-to-text",
+                    model="google/medgemma-4b-it",
+                    torch_dtype=torch.bfloat16,
+                    offload_folder="offload",
+                    device_map="auto",
+                    token=self.config.HF_TOKEN
+                )
+                logging.info("✅ MedGemma pipeline loaded successfully")
+            except Exception as e:
+                logging.warning(f"MedGemma pipeline not available: {e}")
+
+            # Initialize YOLO model for wound detection
+            try:
+                self.models_cache["det"] = YOLO(self.config.YOLO_MODEL_PATH)
+                logging.info("✅ YOLO detection model loaded successfully")
+            except Exception as e:
+                logging.warning(f"YOLO model not available: {e}")
+
+            # Initialize segmentation model
+            try:
+                self.models_cache["seg"] = load_model(self.config.SEG_MODEL_PATH, compile=False)
+                logging.info("✅ Segmentation model loaded successfully")
+            except Exception as e:
+                logging.warning(f"Segmentation model not available: {e}")
+
+            # Initialize wound classification model
+            try:
+                self.models_cache["cls"] = pipeline(
+                    "image-classification", 
+                    model="Hemg/Wound-classification", 
+                    token=self.config.HF_TOKEN, 
+                    device="cpu"
+                )
+                logging.info("✅ Wound classification model loaded successfully")
+            except Exception as e:
+                logging.warning(f"Wound classification model not available: {e}")
+
+            # Initialize embedding model for knowledge base
+            try:
+                self.models_cache["embedding_model"] = HuggingFaceEmbeddings(
+                    model_name="sentence-transformers/all-MiniLM-L6-v2", 
+                    model_kwargs={'device': 'cpu'}
+                )
+                logging.info("✅ Embedding model loaded successfully")
+            except Exception as e:
+                logging.warning(f"Embedding model not available: {e}")
+
+            logging.info("✅ All models loaded.")
+            self._load_knowledge_base()
+
+        except Exception as e:
+            logging.error(f"Error initializing AI models: {e}")
+
+    def _load_knowledge_base(self):
+        """Load knowledge base from PDF guidelines"""
+        try:
+            documents = []
+            for pdf_path in self.config.GUIDELINE_PDFS:
+                if os.path.exists(pdf_path):
+                    loader = PyPDFLoader(pdf_path)
+                    docs = loader.load()
+                    documents.extend(docs)
+                    logging.info(f"Loaded PDF: {pdf_path}")
+
+            if documents and 'embedding_model' in self.models_cache:
+                # Split documents into chunks
+                text_splitter = RecursiveCharacterTextSplitter(
+                    chunk_size=1000,
+                    chunk_overlap=100
+                )
+                chunks = text_splitter.split_documents(documents)
+                
+                # Create vector store
+                vectorstore = FAISS.from_documents(chunks, self.models_cache['embedding_model'])
+                self.knowledge_base_cache['vectorstore'] = vectorstore
+                logging.info(f"✅ Knowledge base loaded with {len(chunks)} chunks")
+            else:
+                self.knowledge_base_cache['vectorstore'] = None
+                logging.warning("Knowledge base not available - no PDFs found or embedding model unavailable")
+
+        except Exception as e:
+            logging.warning(f"Knowledge base loading error: {e}")
+            self.knowledge_base_cache['vectorstore'] = None
+
+    def perform_comprehensive_analysis(self, image_pil: Image.Image, patient_info: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Perform comprehensive analysis with enhanced tracking for dashboard integration
+        """
+        start_time = time.time()
+        
+        try:
+            # Perform visual analysis
+            visual_results = self.perform_visual_analysis(image_pil)
+            
+            # Query guidelines for context
+            guideline_query = f"wound care {visual_results.get('wound_type', 'general')} treatment recommendations"
+            guideline_context = self.query_guidelines(guideline_query)
+            
+            # Generate comprehensive report
+            report = self.generate_final_report(patient_info, visual_results, guideline_context, image_pil)
+            
+            # Calculate processing time
+            processing_time = round(time.time() - start_time, 2)
+            
+            # Calculate risk score based on multiple factors
+            risk_score = self._calculate_risk_score(visual_results, patient_info)
+            
+            # Prepare comprehensive analysis data
+            analysis_data = {
+                'visual_results': visual_results,
+                'patient_info': patient_info,
+                'guideline_context': guideline_context,
+                'report': report,
+                'processing_time': processing_time,
+                'risk_score': risk_score,
+                'model_version': self.model_version,
+                'analysis_timestamp': datetime.now().isoformat(),
+                'analysis_metadata': {
+                    'models_used': list(self.models_cache.keys()),
+                    'image_dimensions': image_pil.size,
+                    'guideline_sources': len(guideline_context.split('\n\n')) if guideline_context else 0
+                }
+            }
+            
+            logging.info(f"✅ Comprehensive analysis completed in {processing_time}s with risk score {risk_score}")
+            return analysis_data
+            
+        except Exception as e:
+            processing_time = round(time.time() - start_time, 2)
+            logging.error(f"❌ Analysis failed after {processing_time}s: {e}")
+            
+            # Return error analysis data
+            return {
+                'error': str(e),
+                'processing_time': processing_time,
+                'risk_score': 0,
+                'model_version': self.model_version,
+                'analysis_timestamp': datetime.now().isoformat()
+            }
+
+    def perform_visual_analysis(self, image_pil: Image.Image) -> Dict[str, Any]:
+        """Perform comprehensive visual analysis of wound image with enhanced tracking"""
+        try:
+            # Convert PIL to OpenCV format
+            image_cv = cv2.cvtColor(np.array(image_pil), cv2.COLOR_RGB2BGR)
+    
+            # YOLO detection
+            if 'det' not in self.models_cache:
+                raise ValueError("YOLO detection model not available.")
+    
+            results = self.models_cache['det'].predict(image_cv, verbose=False, device="cpu")
+    
+            if not results or not results[0].boxes:
+                raise ValueError("No wound detected in the image.")
+    
+            # Extract bounding box
+            box = results[0].boxes[0].xyxy[0].cpu().numpy().astype(int)
+            x1, y1, x2, y2 = box
+            region_cv = image_cv[y1:y2, x1:x2]
+    
+            # Save detection image with timestamp
+            detection_image_cv = image_cv.copy()
+            cv2.rectangle(detection_image_cv, (x1, y1), (x2, y2), (0, 255, 0), 2)
+            os.makedirs(os.path.join(self.config.UPLOADS_DIR, "analysis"), exist_ok=True)
+            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+            detection_image_path = os.path.join(self.config.UPLOADS_DIR, "analysis", f"detection_{timestamp}.png")
+            cv2.imwrite(detection_image_path, detection_image_cv)
+            detection_image_pil = Image.fromarray(cv2.cvtColor(detection_image_cv, cv2.COLOR_BGR2RGB))
+    
+            # Initialize outputs
+            length = breadth = area = 0
+            segmentation_image_pil = None
+            segmentation_image_path = None
+            segmentation_confidence = 0.0
+    
+            # Segmentation (optional)
+            if 'seg' in self.models_cache:
+                input_size = self.models_cache['seg'].input_shape[1:3]  # (height, width)
+                resized_region = cv2.resize(region_cv, (input_size[1], input_size[0]))
+    
+                seg_input = np.expand_dims(resized_region / 255.0, 0)
+                mask_pred = self.models_cache['seg'].predict(seg_input, verbose=0)[0]
+                mask_np = (mask_pred[:, :, 0] > 0.5).astype(np.uint8)
+                
+                # Calculate segmentation confidence
+                segmentation_confidence = float(np.mean(mask_pred[:, :, 0]))
+    
+                # Resize mask back to original region size
+                mask_resized = cv2.resize(mask_np, (region_cv.shape[1], region_cv.shape[0]), interpolation=cv2.INTER_NEAREST)
+    
+                # Overlay mask on region for visualization
+                overlay = region_cv.copy()
+                overlay[mask_resized == 1] = [0, 0, 255]  # Red overlay
+    
+                # Blend overlay for final output
+                segmented_visual = cv2.addWeighted(region_cv, 0.7, overlay, 0.3, 0)
+    
+                # Save segmentation image
+                segmentation_image_path = os.path.join(self.config.UPLOADS_DIR, "analysis", f"segmentation_{timestamp}.png")
+                cv2.imwrite(segmentation_image_path, segmented_visual)
+                segmentation_image_pil = Image.fromarray(cv2.cvtColor(segmented_visual, cv2.COLOR_BGR2RGB))
+    
+                # Wound measurements from resized mask
+                contours, _ = cv2.findContours(mask_resized, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+                if contours:
+                    cnt = max(contours, key=cv2.contourArea)
+                    x, y, w, h = cv2.boundingRect(cnt)
+                    length = round(h / self.px_per_cm, 2)
+                    breadth = round(w / self.px_per_cm, 2)
+                    area = round(cv2.contourArea(cnt) / (self.px_per_cm ** 2), 2)
+    
+            # Classification with confidence tracking
+            wound_type = "Unknown"
+            classification_confidence = 0.0
+            classification_scores = []
+            
+            if 'cls' in self.models_cache:
+                try:
+                    region_pil = Image.fromarray(cv2.cvtColor(region_cv, cv2.COLOR_BGR2RGB))
+                    cls_result = self.models_cache['cls'](region_pil)
+                    
+                    if cls_result:
+                        best_result = max(cls_result, key=lambda x: x['score'])
+                        wound_type = best_result['label']
+                        classification_confidence = float(best_result['score'])
+                        classification_scores = [{'label': r['label'], 'score': float(r['score'])} for r in cls_result]
+                        
+                except Exception as e:
+                    logging.warning(f"Wound classification error: {e}")
+    
+            return {
+                'wound_type': wound_type,
+                'length_cm': length,
+                'breadth_cm': breadth,
+                'surface_area_cm2': area,
+                'detection_confidence': float(results[0].boxes[0].conf.cpu().item()),
+                'segmentation_confidence': segmentation_confidence,
+                'classification_confidence': classification_confidence,
+                'classification_scores': classification_scores,
+                'bounding_box': box.tolist(),
+                'detection_image_path': detection_image_path,
+                'detection_image_pil': detection_image_pil,
+                'segmentation_image_path': segmentation_image_path,
+                'segmentation_image_pil': segmentation_image_pil,
+                'analysis_quality': {
+                    'detection_quality': 'high' if float(results[0].boxes[0].conf.cpu().item()) > 0.8 else 'medium',
+                    'segmentation_quality': 'high' if segmentation_confidence > 0.7 else 'medium',
+                    'classification_quality': 'high' if classification_confidence > 0.8 else 'medium'
+                }
+            }
+    
+        except Exception as e:
+            logging.error(f"Visual analysis error: {e}")
+            raise ValueError(f"Visual analysis failed: {str(e)}")
+
+    def _calculate_risk_score(self, visual_results: Dict[str, Any], patient_info: Dict[str, Any]) -> int:
+        """
+        Calculate comprehensive risk score (0-100) based on visual analysis and patient data
+        """
+        try:
+            risk_score = 0
+            
+            # Wound size risk (0-25 points)
+            area = visual_results.get('surface_area_cm2', 0)
+            if area > 10:
+                risk_score += 25
+            elif area > 5:
+                risk_score += 15
+            elif area > 2:
+                risk_score += 10
+            else:
+                risk_score += 5
+            
+            # Wound type risk (0-20 points)
+            wound_type = visual_results.get('wound_type', '').lower()
+            high_risk_types = ['ulcer', 'necrotic', 'infected', 'diabetic']
+            medium_risk_types = ['pressure', 'venous', 'arterial']
+            
+            if any(risk_type in wound_type for risk_type in high_risk_types):
+                risk_score += 20
+            elif any(risk_type in wound_type for risk_type in medium_risk_types):
+                risk_score += 15
+            else:
+                risk_score += 10
+            
+            # Patient factors (0-30 points)
+            age = patient_info.get('patient_age', 0)
+            if age > 70:
+                risk_score += 15
+            elif age > 50:
+                risk_score += 10
+            else:
+                risk_score += 5
+            
+            # Diabetic status
+            diabetic_status = patient_info.get('diabetic_status', '').lower()
+            if 'yes' in diabetic_status or 'diabetic' in diabetic_status:
+                risk_score += 15
+            
+            # Pain level (0-10 points)
+            pain_level = patient_info.get('pain_level', 0)
+            if pain_level > 7:
+                risk_score += 10
+            elif pain_level > 4:
+                risk_score += 7
+            else:
+                risk_score += 3
+            
+            # Infection signs (0-15 points)
+            infection_signs = patient_info.get('infection_signs', '').lower()
+            if 'yes' in infection_signs or 'present' in infection_signs:
+                risk_score += 15
+            elif 'possible' in infection_signs or 'mild' in infection_signs:
+                risk_score += 10
+            else:
+                risk_score += 5
+            
+            # Ensure score is within 0-100 range
+            risk_score = min(max(risk_score, 0), 100)
+            
+            logging.info(f"Calculated risk score: {risk_score}")
+            return risk_score
+            
+        except Exception as e:
+            logging.error(f"Error calculating risk score: {e}")
+            return 50  # Default medium risk
+
+    def query_guidelines(self, query: str) -> str:
+        """Query the knowledge base for relevant guidelines with enhanced tracking"""
+        try:
+            vector_store = self.knowledge_base_cache.get("vectorstore")
+            if not vector_store:
+                return "Knowledge base unavailable - clinical guidelines not loaded"
+
+            # Retrieve relevant documents
+            retriever = vector_store.as_retriever(search_kwargs={"k": 10})
+            docs = retriever.invoke(query)
+            
+            if not docs:
+                return "No relevant guidelines found for the query"
+
+            # Format the results with enhanced metadata
+            formatted_results = []
+            for i, doc in enumerate(docs):
+                source = doc.metadata.get('source', 'Unknown')
+                page = doc.metadata.get('page', 'N/A')
+                content = doc.page_content.strip()
+                
+                # Add relevance indicator
+                relevance = f"Result {i+1}/10"
+                formatted_results.append(f"[{relevance}] Source: {source}, Page: {page}\nContent: {content}")
+
+            guideline_text = "\n\n".join(formatted_results)
+            logging.info(f"Retrieved {len(docs)} guideline documents for query: {query[:50]}...")
+            return guideline_text
+
+        except Exception as e:
+            logging.error(f"Guidelines query error: {e}")
+            return f"Error querying guidelines: {str(e)}"
+
+    def generate_final_report(self, patient_info: Dict[str, Any], visual_results: Dict[str, Any], 
+                            guideline_context: str, image_pil: Image.Image, max_new_tokens: int = None) -> str:
+        """Generate comprehensive medical report using MedGemma with enhanced tracking"""
+        try:
+            if 'medgemma_pipe' not in self.models_cache:
+                return self._generate_fallback_report(patient_info, visual_results, guideline_context)
+
+            max_tokens = max_new_tokens or self.config.MAX_NEW_TOKENS
+            
+            # Get detection and segmentation images if available
+            detection_image = visual_results.get('detection_image_pil', None)
+            segmentation_image = visual_results.get('segmentation_image_pil', None)
+            
+            # Create enhanced prompt with quality indicators
+            analysis_quality = visual_results.get('analysis_quality', {})
+            prompt = f"""
+# SmartHeal AI Wound Care Report
+
+## Patient Information
+{self._format_patient_info(patient_info)}
+
+## Visual Analysis Summary
+- Wound Type: {visual_results.get('wound_type', 'Unknown')} (Confidence: {visual_results.get('classification_confidence', 0):.2f})
+- Dimensions: {visual_results.get('length_cm', 0)} × {visual_results.get('breadth_cm', 0)} cm
+- Surface Area: {visual_results.get('surface_area_cm2', 0)} cm²
+- Detection Quality: {analysis_quality.get('detection_quality', 'medium')}
+- Segmentation Quality: {analysis_quality.get('segmentation_quality', 'medium')}
+
+## Clinical Reference Guidelines
+{guideline_context[:2000]}...
+
+## Analysis Request
+You are SmartHeal-AI Agent, a specialized wound care AI with expertise in clinical assessment and evidence-based treatment planning.
+
+Based on the comprehensive data provided (patient information, precise wound measurements, clinical guidelines, and visual analysis), generate a structured clinical report with the following sections:
+
+### 1. Clinical Assessment
+- Detailed wound characterization based on visual analysis
+- Tissue type assessment (granulation, slough, necrotic, epithelializing)
+- Peri-wound skin condition evaluation
+- Infection risk assessment
+
+### 2. Treatment Recommendations
+- Specific wound care dressing recommendations based on wound characteristics
+- Topical treatments if indicated
+- Debridement recommendations if needed
+- Pressure offloading strategies if applicable
+
+### 3. Risk Stratification
+- Patient-specific risk factors analysis
+- Healing prognosis assessment
+- Complications to monitor
+
+### 4. Follow-up Plan
+- Recommended assessment frequency
+- Key monitoring parameters
+- Escalation criteria for specialist referral
+
+Generate a concise, evidence-based report suitable for clinical documentation.
+"""
+
+            # Prepare messages for MedGemma with all available images
+            content_list = [{"type": "text", "text": prompt}]
+            
+            # Add images in order of importance
+            if image_pil:
+                content_list.insert(0, {"type": "image", "image": image_pil})
+                
+            if detection_image:
+                content_list.insert(1, {"type": "image", "image": detection_image})
+                
+            if segmentation_image:
+                content_list.insert(2, {"type": "image", "image": segmentation_image})
+            
+            messages = [
+                {
+                    "role": "system",
+                    "content": [{"type": "text", "text": "You are a specialized medical AI assistant for wound care with expertise in clinical assessment, treatment planning, and evidence-based recommendations. Provide structured, actionable clinical reports."}],
+                },
+                {
+                    "role": "user",
+                    "content": content_list
+                }
+            ]
+
+            # Generate report using MedGemma
+            output = self.models_cache['medgemma_pipe'](
+                text=messages,
+                max_new_tokens=max_tokens,
+                do_sample=False,
+            )
+            
+            generated_content = output[0]['generated_text']
+            
+            # Extract the assistant's response
+            if isinstance(generated_content, list):
+                for message in generated_content:
+                    if message.get('role') == 'assistant':
+                        report_content = message.get('content', '')
+                        if isinstance(report_content, list):
+                            report_text = ''.join([item.get('text', '') for item in report_content if item.get('type') == 'text'])
+                        else:
+                            report_text = str(report_content)
+                        break
+                else:
+                    report_text = str(generated_content)
+            else:
+                report_text = str(generated_content)
+            
+            # Add metadata to report
+            report_with_metadata = f"""
+{report_text}
+
+---
+**Report Metadata:**
+- Generated by: SmartHeal AI v{self.model_version}
+- Analysis Quality: Detection ({analysis_quality.get('detection_quality', 'medium')}), Segmentation ({analysis_quality.get('segmentation_quality', 'medium')})
+- Generated at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+"""
+            
+            logging.info("✅ MedGemma report generated successfully")
+            return report_with_metadata
+            
+        except Exception as e:
+            logging.error(f"MedGemma report generation error: {e}")
+            return self._generate_fallback_report(patient_info, visual_results, guideline_context)
+
+    def _format_patient_info(self, patient_info: Dict[str, Any]) -> str:
+        """Format patient information for report"""
+        formatted = f"""
+- Name: {patient_info.get('patient_name', 'N/A')}
+- Age: {patient_info.get('patient_age', 'N/A')} years
+- Gender: {patient_info.get('patient_gender', 'N/A')}
+- Wound Location: {patient_info.get('wound_location', 'N/A')}
+- Wound Duration: {patient_info.get('wound_duration', 'N/A')}
+- Pain Level: {patient_info.get('pain_level', 'N/A')}/10
+- Diabetic Status: {patient_info.get('diabetic_status', 'N/A')}
+- Infection Signs: {patient_info.get('infection_signs', 'N/A')}
+- Previous Treatment: {patient_info.get('previous_treatment', 'N/A')}
+- Medical History: {patient_info.get('medical_history', 'N/A')}
+- Current Medications: {patient_info.get('medications', 'N/A')}
+- Known Allergies: {patient_info.get('allergies', 'N/A')}
+"""
+        return formatted.strip()
+
+    def _generate_fallback_report(self, patient_info: Dict[str, Any], visual_results: Dict[str, Any], 
+                                guideline_context: str) -> str:
+        """Generate fallback report when MedGemma is not available"""
+        
+        wound_type = visual_results.get('wound_type', 'Unknown')
+        length = visual_results.get('length_cm', 0)
+        breadth = visual_results.get('breadth_cm', 0)
+        area = visual_results.get('surface_area_cm2', 0)
+        
+        # Basic risk assessment
+        risk_factors = []
+        if patient_info.get('patient_age', 0) > 65:
+            risk_factors.append("Advanced age")
+        if 'yes' in str(patient_info.get('diabetic_status', '')).lower():
+            risk_factors.append("Diabetes mellitus")
+        if patient_info.get('pain_level', 0) > 6:
+            risk_factors.append("High pain level")
+        if area > 5:
+            risk_factors.append("Large wound size")
+        
+        report = f"""
+# SmartHeal AI Wound Assessment Report
+
+## Clinical Summary
+**Patient:** {patient_info.get('patient_name', 'N/A')}, {patient_info.get('patient_age', 'N/A')} years old {patient_info.get('patient_gender', '')}
+
+**Wound Characteristics:**
+- Type: {wound_type}
+- Location: {patient_info.get('wound_location', 'N/A')}
+- Dimensions: {length} × {breadth} cm (Area: {area} cm²)
+- Duration: {patient_info.get('wound_duration', 'N/A')}
+- Pain Level: {patient_info.get('pain_level', 'N/A')}/10
+
+## Risk Assessment
+**Identified Risk Factors:**
+{chr(10).join(f'- {factor}' for factor in risk_factors) if risk_factors else '- No significant risk factors identified'}
+
+## Treatment Recommendations
+**Wound Care:**
+- Regular wound assessment and documentation
+- Appropriate dressing selection based on wound characteristics
+- Maintain moist wound environment
+- Monitor for signs of infection
+
+**Patient Management:**
+- Pain management as indicated
+- Nutritional assessment and optimization
+- Patient education on wound care
+
+## Follow-up Plan
+- Reassess wound in 1-2 weeks
+- Monitor for signs of healing or deterioration
+- Consider specialist referral if no improvement in 4 weeks
+
+---
+**Report Generated by:** SmartHeal AI Fallback System v{self.model_version}
+**Generated at:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+**Note:** This is a basic assessment. For comprehensive analysis, ensure all AI models are properly loaded.
+"""
+        
+        logging.info("✅ Fallback report generated")
+        return report
+

src/enhanced_ui_components.py

@@ -0,0 +1,890 @@
+import gradio as gr
+import logging
+from datetime import datetime
+import time
+from typing import Dict, Any, Optional, Tuple
+import json
+import os
+from PIL import Image
+
+from .enhanced_ai_processor import EnhancedAIProcessor
+from .dashboard_database_manager import DashboardDatabaseManager
+from .dashboard_api import DashboardIntegrationManager
+from .auth import AuthManager
+
+class EnhancedUIComponents:
+    """Enhanced UI components with dashboard integration and analytics tracking"""
+    
+    def __init__(self, auth_manager: AuthManager, database_manager: DashboardDatabaseManager, 
+                 ai_processor: EnhancedAIProcessor):
+        """Initialize enhanced UI components"""
+        self.auth_manager = auth_manager
+        self.database_manager = database_manager
+        self.ai_processor = ai_processor
+        self.dashboard_integration = DashboardIntegrationManager(database_manager)
+        
+        # Start dashboard integration
+        self.dashboard_integration.start_integration()
+        
+        # UI styling
+        self.theme = gr.themes.Soft()
+        self.custom_css = self._load_custom_css()
+        
+        # Session tracking
+        self.current_session = {}
+        
+        logging.info("✅ Enhanced UI Components initialized with dashboard integration")
+    
+    def _load_custom_css(self):
+        """Load custom CSS for the application"""
+        return """
+        /* Enhanced SmartHeal Application Styling */
+        .main-header {
+            text-align: center;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 2rem;
+            border-radius: 10px;
+            margin-bottom: 2rem;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        }
+        
+        .main-header h1 {
+            margin: 0;
+            font-size: 2.5rem;
+            font-weight: bold;
+        }
+        
+        .main-header p {
+            margin: 0.5rem 0 0 0;
+            font-size: 1.1rem;
+            opacity: 0.9;
+        }
+        
+        .integration-status {
+            background-color: #e8f5e8;
+            border: 1px solid #4caf50;
+            border-radius: 8px;
+            padding: 1rem;
+            margin: 1rem 0;
+            color: #2e7d32;
+        }
+        
+        .analytics-info {
+            background-color: #e3f2fd;
+            border: 1px solid #2196f3;
+            border-radius: 8px;
+            padding: 1rem;
+            margin: 1rem 0;
+            color: #1565c0;
+        }
+        
+        .session-info {
+            background-color: #fff3e0;
+            border: 1px solid #ff9800;
+            border-radius: 8px;
+            padding: 1rem;
+            margin: 1rem 0;
+            color: #ef6c00;
+        }
+        
+        /* Section Headers */
+        .section-header {
+            background-color: #f8f9fa;
+            padding: 1rem;
+            border-radius: 8px;
+            border-left: 4px solid #007bff;
+            margin: 1rem 0;
+            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
+        }
+        
+        .section-header h2 {
+            margin: 0;
+            color: #495057;
+            font-size: 1.3rem;
+        }
+        
+        .section-header h3 {
+            margin: 0;
+            color: #6c757d;
+            font-size: 1.1rem;
+        }
+        
+        /* Result Boxes */
+        .result-box {
+            background-color: #e7f3ff;
+            border: 1px solid #b3d9ff;
+            border-radius: 8px;
+            padding: 1rem;
+            margin: 1rem 0;
+        }
+        
+        .success-box {
+            background-color: #d4edda;
+            border: 1px solid #c3e6cb;
+            border-radius: 8px;
+            padding: 1rem;
+            margin: 1rem 0;
+            color: #155724;
+        }
+        
+        .warning-box {
+            background-color: #fff3cd;
+            border: 1px solid #ffeaa7;
+            border-radius: 8px;
+            padding: 1rem;
+            margin: 1rem 0;
+            color: #856404;
+        }
+        
+        .error-box {
+            background-color: #ffe7e7;
+            border: 1px solid #ffb3b3;
+            border-radius: 8px;
+            padding: 1rem 0;
+            margin: 1rem 0;
+            color: #721c24;
+        }
+        
+        /* Enhanced form styling */
+        .form-group {
+            margin-bottom: 1rem;
+        }
+        
+        .metrics-display {
+            background-color: #f8f9fa;
+            border-radius: 8px;
+            padding: 1rem;
+            margin: 1rem 0;
+            border: 1px solid #dee2e6;
+        }
+        
+        .processing-indicator {
+            background-color: #fff8e1;
+            border: 1px solid #ffcc02;
+            border-radius: 8px;
+            padding: 1rem;
+            margin: 1rem 0;
+            color: #f57f17;
+            text-align: center;
+        }
+        """
+    
+    def create_interface(self):
+        """Create the enhanced Gradio interface with dashboard integration"""
+        
+        with gr.Blocks(theme=self.theme, css=self.custom_css, title="SmartHeal AI - Enhanced") as interface:
+            
+            # Header
+            gr.HTML("""
+            <div class="main-header">
+                <h1>🏥 SmartHeal AI - Enhanced Edition</h1>
+                <p>Advanced Wound Care Analysis with Real-time Dashboard Integration</p>
+            </div>
+            """)
+            
+            # Integration status display
+            integration_status = gr.HTML(self._get_integration_status_html())
+            
+            # Session info
+            session_info = gr.HTML(self._get_session_info_html())
+            
+            with gr.Tabs():
+                
+                # Authentication Tab
+                with gr.Tab("🔐 Authentication"):
+                    with gr.Row():
+                        with gr.Column():
+                            gr.HTML("""
+                            <div class="section-header">
+                                <h2>User Authentication</h2>
+                                <h3>Login to access SmartHeal AI analysis features</h3>
+                            </div>
+                            """)
+                            
+                            username_input = gr.Textbox(
+                                label="Username",
+                                placeholder="Enter your username",
+                                interactive=True
+                            )
+                            password_input = gr.Textbox(
+                                label="Password",
+                                type="password",
+                                placeholder="Enter your password",
+                                interactive=True
+                            )
+                            login_btn = gr.Button("Login", variant="primary")
+                            logout_btn = gr.Button("Logout", variant="secondary")
+                            
+                            auth_status = gr.HTML(value="<div class='warning-box'>Please login to continue</div>")
+                
+                # Enhanced Analysis Tab
+                with gr.Tab("🔬 Wound Analysis"):
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            gr.HTML("""
+                            <div class="section-header">
+                                <h2>Patient Information</h2>
+                                <h3>Complete patient details for comprehensive analysis</h3>
+                            </div>
+                            """)
+                            
+                            # Patient Information
+                            patient_name = gr.Textbox(label="Patient Name", placeholder="Enter patient name")
+                            patient_age = gr.Number(label="Patient Age", value=0, minimum=0, maximum=120)
+                            patient_gender = gr.Dropdown(
+                                label="Gender",
+                                choices=["Male", "Female", "Other"],
+                                value="Male"
+                            )
+                            
+                            # Wound Details
+                            gr.HTML("""
+                            <div class="section-header">
+                                <h2>Wound Information</h2>
+                            </div>
+                            """)
+                            
+                            wound_location = gr.Textbox(label="Wound Location", placeholder="e.g., Left heel, Right forearm")
+                            wound_duration = gr.Textbox(label="Wound Duration", placeholder="e.g., 2 weeks, 1 month")
+                            pain_level = gr.Slider(label="Pain Level (0-10)", minimum=0, maximum=10, value=0, step=1)
+                            
+                            # Clinical Assessment
+                            moisture_level = gr.Dropdown(
+                                label="Moisture Level",
+                                choices=["Dry", "Moist", "Wet", "Macerated"],
+                                value="Moist"
+                            )
+                            infection_signs = gr.Dropdown(
+                                label="Signs of Infection",
+                                choices=["None", "Mild", "Moderate", "Severe"],
+                                value="None"
+                            )
+                            diabetic_status = gr.Dropdown(
+                                label="Diabetic Status",
+                                choices=["No", "Type 1", "Type 2", "Unknown"],
+                                value="No"
+                            )
+                            
+                            # Medical History
+                            gr.HTML("""
+                            <div class="section-header">
+                                <h2>Medical History</h2>
+                            </div>
+                            """)
+                            
+                            previous_treatment = gr.Textbox(
+                                label="Previous Treatment",
+                                placeholder="Describe any previous treatments",
+                                lines=2
+                            )
+                            medical_history = gr.Textbox(
+                                label="Medical History",
+                                placeholder="Relevant medical conditions",
+                                lines=2
+                            )
+                            medications = gr.Textbox(
+                                label="Current Medications",
+                                placeholder="List current medications",
+                                lines=2
+                            )
+                            allergies = gr.Textbox(
+                                label="Known Allergies",
+                                placeholder="List any known allergies",
+                                lines=2
+                            )
+                            additional_notes = gr.Textbox(
+                                label="Additional Notes",
+                                placeholder="Any additional relevant information",
+                                lines=3
+                            )
+                        
+                        with gr.Column(scale=1):
+                            gr.HTML("""
+                            <div class="section-header">
+                                <h2>Wound Image Analysis</h2>
+                                <h3>Upload wound image for AI analysis</h3>
+                            </div>
+                            """)
+                            
+                            # Image Upload
+                            wound_image = gr.Image(
+                                label="Wound Image",
+                                type="pil",
+                                height=400
+                            )
+                            
+                            # Analysis Controls
+                            analyze_btn = gr.Button("🔍 Analyze Wound", variant="primary", size="lg")
+                            
+                            # Processing indicator
+                            processing_status = gr.HTML(visible=False)
+                            
+                            # Analysis Metrics
+                            analysis_metrics = gr.HTML(visible=False)
+                    
+                    # Results Section
+                    with gr.Row():
+                        with gr.Column():
+                            gr.HTML("""
+                            <div class="section-header">
+                                <h2>Analysis Results</h2>
+                                <h3>Comprehensive AI-powered wound assessment</h3>
+                            </div>
+                            """)
+                            
+                            # Visual Analysis Results
+                            with gr.Row():
+                                detection_image = gr.Image(label="Wound Detection", visible=False)
+                                segmentation_image = gr.Image(label="Wound Segmentation", visible=False)
+                            
+                            # Analysis Report
+                            analysis_report = gr.Markdown(visible=False)
+                            
+                            # Download Options
+                            with gr.Row():
+                                download_report = gr.File(label="Download Report", visible=False)
+                                download_images = gr.File(label="Download Analysis Images", visible=False)
+                
+                # Dashboard Integration Tab
+                with gr.Tab("📊 Dashboard Integration"):
+                    gr.HTML("""
+                    <div class="section-header">
+                        <h2>Dashboard Integration Status</h2>
+                        <h3>Real-time connection to SmartHeal Dashboard</h3>
+                    </div>
+                    """)
+                    
+                    dashboard_status = gr.HTML()
+                    
+                    with gr.Row():
+                        refresh_status_btn = gr.Button("🔄 Refresh Status", variant="secondary")
+                        view_analytics_btn = gr.Button("📈 View Analytics", variant="primary")
+                    
+                    # Analytics Summary
+                    analytics_summary = gr.HTML()
+                    
+                    # Recent Activity
+                    recent_activity = gr.HTML()
+            
+            # Event Handlers
+            
+            # Authentication
+            login_btn.click(
+                fn=self._handle_login,
+                inputs=[username_input, password_input],
+                outputs=[auth_status, session_info]
+            )
+            
+            logout_btn.click(
+                fn=self._handle_logout,
+                outputs=[auth_status, session_info]
+            )
+            
+            # Analysis
+            analyze_btn.click(
+                fn=self._start_analysis,
+                inputs=[],
+                outputs=[processing_status, analysis_metrics]
+            ).then(
+                fn=self._perform_enhanced_analysis,
+                inputs=[
+                    patient_name, patient_age, patient_gender, wound_location, wound_duration,
+                    pain_level, moisture_level, infection_signs, diabetic_status,
+                    previous_treatment, medical_history, medications, allergies,
+                    additional_notes, wound_image
+                ],
+                outputs=[
+                    analysis_report, detection_image, segmentation_image,
+                    download_report, download_images, processing_status,
+                    analysis_metrics, session_info
+                ]
+            )
+            
+            # Dashboard Integration
+            refresh_status_btn.click(
+                fn=self._refresh_dashboard_status,
+                outputs=[dashboard_status, analytics_summary]
+            )
+            
+            view_analytics_btn.click(
+                fn=self._get_analytics_summary,
+                outputs=[analytics_summary, recent_activity]
+            )
+            
+            # Auto-refresh integration status on load
+            interface.load(
+                fn=self._refresh_dashboard_status,
+                outputs=[dashboard_status, analytics_summary]
+            )
+        
+        return interface
+    
+    def _get_integration_status_html(self) -> str:
+        """Get HTML for integration status display"""
+        status = self.dashboard_integration.get_integration_status()
+        
+        if status['api_running'] and status['database_connected']:
+            return """
+            <div class="integration-status">
+                ✅ <strong>Dashboard Integration Active</strong><br>
+                API Server: Running | Database: Connected | Real-time Analytics: Enabled
+            </div>
+            """
+        else:
+            return """
+            <div class="error-box">
+                ❌ <strong>Dashboard Integration Issues</strong><br>
+                Please check API server and database connection
+            </div>
+            """
+    
+    def _get_session_info_html(self) -> str:
+        """Get HTML for session information display"""
+        if self.current_session:
+            user_info = self.current_session.get('user_info', {})
+            return f"""
+            <div class="session-info">
+                👤 <strong>Active Session</strong><br>
+                User: {user_info.get('name', 'Unknown')} | 
+                Role: {user_info.get('role', 'Unknown')} | 
+                Session Started: {self.current_session.get('start_time', 'Unknown')}
+            </div>
+            """
+        else:
+            return """
+            <div class="warning-box">
+                ⚠️ <strong>No Active Session</strong><br>
+                Please login to start tracking your analysis session
+            </div>
+            """
+    
+    def _handle_login(self, username: str, password: str) -> Tuple[str, str]:
+        """Handle user login with session tracking"""
+        try:
+            if not username or not password:
+                return (
+                    "<div class='error-box'>❌ Please enter both username and password</div>",
+                    self._get_session_info_html()
+                )
+            
+            # Authenticate user
+            user_info = self.auth_manager.authenticate_user(username, password)
+            
+            if user_info:
+                # Start session tracking
+                self.current_session = {
+                    'user_info': user_info,
+                    'start_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+                    'session_id': f"session_{int(time.time())}",
+                    'analyses_count': 0
+                }
+                
+                return (
+                    f"<div class='success-box'>✅ Welcome, {user_info.get('name', username)}! You are now logged in.</div>",
+                    self._get_session_info_html()
+                )
+            else:
+                return (
+                    "<div class='error-box'>❌ Invalid username or password</div>",
+                    self._get_session_info_html()
+                )
+                
+        except Exception as e:
+            logging.error(f"Login error: {e}")
+            return (
+                f"<div class='error-box'>❌ Login failed: {str(e)}</div>",
+                self._get_session_info_html()
+            )
+    
+    def _handle_logout(self) -> Tuple[str, str]:
+        """Handle user logout"""
+        try:
+            if self.current_session:
+                # Log session end
+                session_duration = time.time() - datetime.strptime(
+                    self.current_session['start_time'], '%Y-%m-%d %H:%M:%S'
+                ).timestamp()
+                
+                session_data = {
+                    'user_id': self.current_session['user_info'].get('id'),
+                    'session_duration': round(session_duration / 60, 2),  # Convert to minutes
+                    'analyses_count': self.current_session.get('analyses_count', 0)
+                }
+                
+                # Clear session
+                self.current_session = {}
+                
+                return (
+                    "<div class='warning-box'>👋 You have been logged out successfully</div>",
+                    self._get_session_info_html()
+                )
+            else:
+                return (
+                    "<div class='warning-box'>⚠️ No active session to logout</div>",
+                    self._get_session_info_html()
+                )
+                
+        except Exception as e:
+            logging.error(f"Logout error: {e}")
+            return (
+                f"<div class='error-box'>❌ Logout error: {str(e)}</div>",
+                self._get_session_info_html()
+            )
+    
+    def _start_analysis(self) -> Tuple[str, str]:
+        """Start analysis process with status indicators"""
+        return (
+            """
+            <div class="processing-indicator" style="display: block;">
+                🔄 <strong>Analysis in Progress...</strong><br>
+                Please wait while we process your wound image and patient data
+            </div>
+            """,
+            """
+            <div class="metrics-display">
+                <strong>Analysis Metrics:</strong><br>
+                Status: Initializing...<br>
+                Processing Time: 0.0s<br>
+                Models Loading: ⏳
+            </div>
+            """
+        )
+    
+    def _perform_enhanced_analysis(self, patient_name: str, patient_age: int, patient_gender: str,
+                                 wound_location: str, wound_duration: str, pain_level: int,
+                                 moisture_level: str, infection_signs: str, diabetic_status: str,
+                                 previous_treatment: str, medical_history: str, medications: str,
+                                 allergies: str, additional_notes: str, wound_image) -> Tuple:
+        """Perform enhanced analysis with dashboard integration"""
+        
+        start_time = time.time()
+        
+        try:
+            # Check authentication
+            if not self.current_session:
+                return (
+                    "❌ **Authentication Required**\n\nPlease login before performing analysis.",
+                    None, None, None, None,
+                    "<div class='error-box'>❌ Authentication required</div>",
+                    "<div class='error-box'>Please login to continue</div>",
+                    self._get_session_info_html()
+                )
+            
+            # Validate inputs
+            if not wound_image:
+                return (
+                    "❌ **Image Required**\n\nPlease upload a wound image for analysis.",
+                    None, None, None, None,
+                    "<div class='error-box'>❌ Wound image required</div>",
+                    "<div class='error-box'>Please upload an image</div>",
+                    self._get_session_info_html()
+                )
+            
+            if not patient_name.strip():
+                return (
+                    "❌ **Patient Name Required**\n\nPlease enter the patient's name.",
+                    None, None, None, None,
+                    "<div class='error-box'>❌ Patient name required</div>",
+                    "<div class='error-box'>Please enter patient name</div>",
+                    self._get_session_info_html()
+                )
+            
+            # Prepare patient information
+            patient_info = {
+                'patient_name': patient_name,
+                'patient_age': patient_age,
+                'patient_gender': patient_gender,
+                'wound_location': wound_location,
+                'wound_duration': wound_duration,
+                'pain_level': pain_level,
+                'moisture_level': moisture_level,
+                'infection_signs': infection_signs,
+                'diabetic_status': diabetic_status,
+                'previous_treatment': previous_treatment,
+                'medical_history': medical_history,
+                'medications': medications,
+                'allergies': allergies,
+                'additional_notes': additional_notes
+            }
+            
+            # Save questionnaire response to dashboard database
+            user_id = self.current_session['user_info'].get('id')
+            questionnaire_id = self.database_manager.save_questionnaire_response(patient_info, user_id)
+            
+            if not questionnaire_id:
+                logging.warning("Failed to save questionnaire response")
+            
+            # Save wound image
+            image_id = None
+            if questionnaire_id:
+                image_id = self.database_manager.save_wound_image(questionnaire_id, wound_image, "wound_analysis.jpg")
+            
+            # Perform comprehensive AI analysis
+            analysis_results = self.ai_processor.perform_comprehensive_analysis(wound_image, patient_info)
+            
+            processing_time = analysis_results.get('processing_time', 0)
+            
+            # Save AI analysis results to dashboard database
+            analysis_data = {
+                'questionnaire_id': questionnaire_id,
+                'image_id': image_id,
+                'analysis_data': analysis_results,
+                'summary': analysis_results.get('report', '')[:1000],  # First 1000 chars as summary
+                'recommendations': analysis_results.get('report', ''),
+                'risk_score': analysis_results.get('risk_score', 0),
+                'processing_time': processing_time,
+                'model_version': analysis_results.get('model_version', 'v1.0'),
+                'visual_results': analysis_results.get('visual_results', {})
+            }
+            
+            analysis_id = self.database_manager.save_ai_analysis(analysis_data)
+            
+            # Log analysis session
+            session_data = {
+                'user_id': user_id,
+                'questionnaire_id': questionnaire_id,
+                'image_id': image_id,
+                'analysis_id': analysis_id,
+                'session_duration': processing_time
+            }
+            
+            self.dashboard_integration.log_analysis_session(session_data)
+            
+            # Log bot interaction
+            interaction_data = {
+                'patient_id': None,  # Would need to get from patients table
+                'practitioner_id': user_id,
+                'input_text': f"Wound analysis for {patient_name}",
+                'output_text': analysis_results.get('report', '')[:500],  # First 500 chars
+                'wound_image_url': f"uploads/wound_analysis_{int(time.time())}.jpg",
+                'interaction_type': 'wound_analysis'
+            }
+            
+            self.dashboard_integration.log_bot_interaction(interaction_data)
+            
+            # Update session count
+            self.current_session['analyses_count'] = self.current_session.get('analyses_count', 0) + 1
+            
+            # Prepare results for display
+            visual_results = analysis_results.get('visual_results', {})
+            report = analysis_results.get('report', 'Analysis completed but no report generated.')
+            
+            # Get analysis images
+            detection_image = visual_results.get('detection_image_pil')
+            segmentation_image = visual_results.get('segmentation_image_pil')
+            
+            # Create downloadable report
+            report_file = self._create_report_file(analysis_results, patient_info)
+            
+            # Create metrics display
+            metrics_html = f"""
+            <div class="metrics-display">
+                <strong>Analysis Completed Successfully!</strong><br>
+                Processing Time: {processing_time}s<br>
+                Risk Score: {analysis_results.get('risk_score', 0)}/100<br>
+                Wound Type: {visual_results.get('wound_type', 'Unknown')}<br>
+                Surface Area: {visual_results.get('surface_area_cm2', 0)} cm²<br>
+                Model Version: {analysis_results.get('model_version', 'v1.0')}<br>
+                Dashboard Integration: ✅ Active
+            </div>
+            """
+            
+            success_status = f"""
+            <div class="success-box">
+                ✅ <strong>Analysis Completed Successfully!</strong><br>
+                Processing Time: {processing_time}s | Risk Score: {analysis_results.get('risk_score', 0)}/100<br>
+                Results saved to dashboard for real-time analytics
+            </div>
+            """
+            
+            return (
+                report,
+                detection_image,
+                segmentation_image,
+                report_file,
+                None,  # Images download placeholder
+                success_status,
+                metrics_html,
+                self._get_session_info_html()
+            )
+            
+        except Exception as e:
+            processing_time = time.time() - start_time
+            error_message = str(e)
+            logging.error(f"Analysis error: {error_message}")
+            
+            error_status = f"""
+            <div class="error-box">
+                ❌ <strong>Analysis Failed</strong><br>
+                Error: {error_message}<br>
+                Processing Time: {processing_time:.2f}s
+            </div>
+            """
+            
+            error_metrics = f"""
+            <div class="error-box">
+                <strong>Analysis Error:</strong><br>
+                Status: Failed<br>
+                Processing Time: {processing_time:.2f}s<br>
+                Error: {error_message}
+            </div>
+            """
+            
+            return (
+                f"❌ **Analysis Failed**\n\n**Error:** {error_message}\n\nPlease check your inputs and try again.",
+                None, None, None, None,
+                error_status,
+                error_metrics,
+                self._get_session_info_html()
+            )
+    
+    def _create_report_file(self, analysis_results: Dict[str, Any], patient_info: Dict[str, Any]) -> str:
+        """Create downloadable report file"""
+        try:
+            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+            filename = f"wound_analysis_report_{timestamp}.md"
+            filepath = os.path.join("uploads", filename)
+            
+            # Ensure uploads directory exists
+            os.makedirs("uploads", exist_ok=True)
+            
+            # Create comprehensive report
+            report_content = f"""# SmartHeal AI Wound Analysis Report
+
+**Generated:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+**Patient:** {patient_info.get('patient_name', 'N/A')}
+**Analysis ID:** {timestamp}
+
+## Patient Information
+- **Name:** {patient_info.get('patient_name', 'N/A')}
+- **Age:** {patient_info.get('patient_age', 'N/A')} years
+- **Gender:** {patient_info.get('patient_gender', 'N/A')}
+- **Wound Location:** {patient_info.get('wound_location', 'N/A')}
+- **Wound Duration:** {patient_info.get('wound_duration', 'N/A')}
+- **Pain Level:** {patient_info.get('pain_level', 'N/A')}/10
+
+## Analysis Results
+{analysis_results.get('report', 'No report generated')}
+
+## Technical Details
+- **Processing Time:** {analysis_results.get('processing_time', 0)}s
+- **Risk Score:** {analysis_results.get('risk_score', 0)}/100
+- **Model Version:** {analysis_results.get('model_version', 'Unknown')}
+- **Analysis Timestamp:** {analysis_results.get('analysis_timestamp', 'Unknown')}
+
+---
+*Generated by SmartHeal AI Enhanced Edition with Dashboard Integration*
+"""
+            
+            with open(filepath, 'w', encoding='utf-8') as f:
+                f.write(report_content)
+            
+            return filepath
+            
+        except Exception as e:
+            logging.error(f"Error creating report file: {e}")
+            return None
+    
+    def _refresh_dashboard_status(self) -> Tuple[str, str]:
+        """Refresh dashboard integration status"""
+        try:
+            status = self.dashboard_integration.get_integration_status()
+            analytics_data = self.database_manager.get_analytics_data()
+            
+            if status['api_running'] and status['database_connected']:
+                status_html = f"""
+                <div class="integration-status">
+                    ✅ <strong>Dashboard Integration Active</strong><br>
+                    API Server: Running on port 5001<br>
+                    Database: Connected<br>
+                    Last Updated: {status['timestamp']}<br>
+                    <a href="http://localhost:5001/api/health" target="_blank">🔗 Test API Health</a>
+                </div>
+                """
+            else:
+                status_html = f"""
+                <div class="error-box">
+                    ❌ <strong>Dashboard Integration Issues</strong><br>
+                    API Running: {status['api_running']}<br>
+                    Database Connected: {status['database_connected']}<br>
+                    Last Checked: {status['timestamp']}
+                </div>
+                """
+            
+            analytics_html = f"""
+            <div class="analytics-info">
+                📊 <strong>Analytics Summary</strong><br>
+                Total Analyses: {analytics_data.get('total_analyses', 0)}<br>
+                Average Processing Time: {analytics_data.get('avg_processing_time', 0)}s<br>
+                High Risk Cases: {analytics_data.get('high_risk_count', 0)}<br>
+                Average Risk Score: {analytics_data.get('avg_risk_score', 0)}<br>
+                Analyses Today: {analytics_data.get('analyses_today', 0)}
+            </div>
+            """
+            
+            return status_html, analytics_html
+            
+        except Exception as e:
+            logging.error(f"Error refreshing dashboard status: {e}")
+            return (
+                f"<div class='error-box'>❌ Error refreshing status: {str(e)}</div>",
+                "<div class='error-box'>❌ Unable to load analytics</div>"
+            )
+    
+    def _get_analytics_summary(self) -> Tuple[str, str]:
+        """Get comprehensive analytics summary"""
+        try:
+            analytics_data = self.database_manager.get_analytics_data()
+            interaction_history = self.database_manager.get_interaction_history(10)
+            
+            # Create detailed analytics HTML
+            analytics_html = f"""
+            <div class="analytics-info">
+                <h3>📈 Comprehensive Analytics</h3>
+                <strong>Analysis Statistics:</strong><br>
+                • Total Analyses: {analytics_data.get('total_analyses', 0)}<br>
+                • Analyses Today: {analytics_data.get('analyses_today', 0)}<br>
+                • Analyses This Week: {analytics_data.get('analyses_this_week', 0)}<br>
+                • Average Processing Time: {analytics_data.get('avg_processing_time', 0)}s<br>
+                • Average Risk Score: {analytics_data.get('avg_risk_score', 0)}/100<br>
+                <br>
+                <strong>Risk Distribution:</strong><br>
+                • High Risk Cases: {analytics_data.get('high_risk_count', 0)}<br>
+                • Unique Questionnaires: {analytics_data.get('unique_questionnaires', 0)}<br>
+                • Analyses with Images: {analytics_data.get('analyses_with_images', 0)}<br>
+            </div>
+            """
+            
+            # Create recent activity HTML
+            activity_html = "<div class='result-box'><h3>🕒 Recent Activity</h3>"
+            
+            if interaction_history:
+                activity_html += "<ul>"
+                for interaction in interaction_history[:5]:
+                    timestamp = interaction.get('interacted_at', 'Unknown')
+                    if isinstance(timestamp, str):
+                        try:
+                            timestamp = datetime.fromisoformat(timestamp.replace('Z', '+00:00')).strftime('%Y-%m-%d %H:%M')
+                        except:
+                            pass
+                    
+                    activity_html += f"""
+                    <li><strong>{timestamp}</strong> - {interaction.get('interaction_type', 'Unknown')} 
+                    (Patient: {interaction.get('patient_name', 'Unknown')})</li>
+                    """
+                activity_html += "</ul>"
+            else:
+                activity_html += "<p>No recent activity found.</p>"
+            
+            activity_html += "</div>"
+            
+            return analytics_html, activity_html
+            
+        except Exception as e:
+            logging.error(f"Error getting analytics summary: {e}")
+            return (
+                f"<div class='error-box'>❌ Error loading analytics: {str(e)}</div>",
+                "<div class='error-box'>❌ Unable to load recent activity</div>"
+            )
+

src/evaluation.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:990fcd18367f71c1c4729b492d21c18a5b86108a6c86faa98ba63945f29f5816
+size 651978

src/segmentation_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd892723d03aa943b719f97f659bddbaf02ba2670606e2a7b0b553ce661d2f62
+size 65345400

static/style.css

@@ -0,0 +1,391 @@
+/* ================= FORCE LIGHT MODE AND TEXT VISIBILITY ================= */
+/* Override Gradio's root variables and force light mode */
+:root {
+    --background-fill-primary: #FFFFFF !important;
+    --background-fill-secondary: #F7FAFC !important;
+    --text-color-primary: #1A202C !important;
+    --text-color-secondary: #4A5568 !important;
+    --color-accent: #E53E3E !important;
+    --color-accent-soft: #FED7D7 !important;
+    --block-background-fill: #FFFFFF !important;
+    --block-border-color: #E2E8F0 !important;
+    --block-title-text-color: #1A202C !important;
+    --block-label-text-color: #1A202C !important;
+    --block-info-text-color: #4A5568 !important;
+    --input-background-fill: #FFFFFF !important;
+    --input-border-color: #CBD5E0 !important;
+    --input-text-color: #1A202C !important;
+    --button-primary-background-fill: #E53E3E !important;
+    --button-primary-text-color: #FFFFFF !important;
+}
+
+/* Force light theme on the entire application */
+.gradio-container,
+.gradio-container *,
+.gr-app,
+.gr-app * {
+    color-scheme: light !important;
+}
+
+/* ------------------- AGGRESSIVE TEXT VISIBILITY ------------------- */
+/* Force text color on ALL elements */
+.gradio-container,
+.gradio-container *:not(.gr-button):not(.medical-header *),
+.gr-app,
+.gr-app *:not(.gr-button):not(.medical-header *) {
+    color: #1A202C !important;
+    background-color: transparent !important;
+}
+
+/* Specific overrides for common Gradio elements */
+.gr-block,
+.gr-form,
+.gr-box,
+.gr-panel {
+    background-color: #FFFFFF !important;
+    color: #1A202C !important;
+    border: 1px solid #E2E8F0 !important;
+}
+
+/* Input elements */
+.gr-textbox,
+.gr-textbox input,
+.gr-dropdown,
+.gr-dropdown select,
+.gr-number,
+.gr-number input,
+.gr-file,
+.gr-radio,
+.gr-checkbox {
+    background-color: #FFFFFF !important;
+    color: #1A202C !important;
+    border: 2px solid #CBD5E0 !important;
+    border-radius: 8px !important;
+}
+
+/* Labels and text */
+label,
+.gr-input-label,
+.gr-radio label,
+.gr-checkbox label,
+[data-testid="block-label"],
+.gr-form label,
+.gr-markdown,
+.gr-markdown *,
+.gr-output,
+.gr-output * {
+    color: #1A202C !important;
+    background-color: transparent !important;
+}
+
+/* Buttons */
+button.gr-button,
+button.gr-button-primary {
+    background: linear-gradient(135deg, #E53E3E 0%, #C53030 100%) !important;
+    color: #FFFFFF !important;
+    border: none !important;
+    border-radius: 8px !important;
+    font-weight: 600 !important;
+    padding: 12px 24px !important;
+    min-height: 44px !important;
+    font-size: 1rem !important;
+    letter-spacing: 0.3px !important;
+}
+
+button.gr-button:hover,
+button.gr-button-primary:hover {
+    background: linear-gradient(135deg, #C53030 0%, #B91C1C 100%) !important;
+    transform: translateY(-1px) !important;
+    box-shadow: 0 4px 12px rgba(229, 62, 62, 0.3) !important;
+}
+
+button.gr-button:disabled {
+    background: #CBD5E0 !important;
+    color: #1A202C !important;
+}
+
+/* ------------------- GENERAL LAYOUT ------------------- */
+.gradio-container {
+    font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', sans-serif !important;
+    background: #FFFFFF !important;
+    color: #1A202C !important;
+    line-height: 1.6 !important;
+    font-size: 16px !important;
+    text-rendering: optimizeLegibility !important;
+    -webkit-font-smoothing: antialiased !important;
+    -moz-osx-font-smoothing: grayscale !important;
+}
+
+/* Hide default footer */
+footer { display: none !important; }
+
+/* ------------------- HEADER ------------------- */
+.medical-header {
+    background: linear-gradient(135deg, #1b5fc1 0%, #174ea6 100%) !important;
+    padding: 24px !important;
+    text-align: left !important;
+    border-radius: 16px !important;
+    margin-bottom: 32px !important;
+    box-shadow: 0 8px 24px rgba(27, 95, 193, 0.2) !important;
+    display: flex !important;
+    align-items: center !important;
+    flex-wrap: wrap !important;
+}
+
+.medical-header h1 {
+    color: #FFFFFF !important;
+    font-size: 2.75rem !important;
+    font-weight: 700 !important;
+    margin: 0 !important;
+    line-height: 1.2 !important;
+    letter-spacing: -0.025em !important;
+}
+
+.medical-header p {
+    color: #FFFFFF !important;
+    font-size: 1.125rem !important;
+    margin: 8px 0 0 0 !important;
+    font-weight: 400 !important;
+    line-height: 1.5 !important;
+    opacity: 0.95 !important;
+}
+
+.logo-container {
+    display: flex !important;
+    align-items: center !important;
+    justify-content: flex-start !important;
+    flex-wrap: wrap !important;
+}
+
+.logo {
+    width: 64px !important;
+    height: 64px !important;
+    margin-right: 24px !important;
+    border-radius: 16px !important;
+    background: white !important;
+    padding: 8px !important;
+    box-shadow: 0 4px 12px rgba(0,0,0,0.1) !important;
+    flex-shrink: 0 !important;
+}
+
+/* ------------------- DISCLAIMER BOX ------------------- */
+.disclaimer-box {
+    border: 2px solid #FEB2B2 !important;
+    background-color: #FFF5F5 !important;
+    padding: 24px !important;
+    border-radius: 16px !important;
+    margin: 24px 0 !important;
+    box-shadow: 0 2px 8px rgba(254, 178, 178, 0.1) !important;
+}
+
+.disclaimer-box h3 {
+    margin-top: 0 !important;
+    margin-bottom: 12px !important;
+    color: #C53030 !important;
+    font-size: 1.25rem !important;
+    font-weight: 700 !important;
+    line-height: 1.4 !important;
+}
+
+.disclaimer-box p {
+    color: #1A202C !important;
+    margin-bottom: 0 !important;
+    font-size: 1rem !important;
+    line-height: 1.6 !important;
+    font-weight: 400 !important;
+}
+
+/* ------------------- CARDS & TITLES ------------------- */
+.medical-card-title {
+    background: white !important;
+    border-radius: 16px !important;
+    padding: 24px !important;
+    box-shadow: 0 4px 16px rgba(0,0,0,0.08) !important;
+    border: 1px solid #E2E8F0 !important;
+    margin: 20px 0 !important;
+    color: #1A202C !important;
+    font-size: 1.5rem !important;
+    font-weight: 600 !important;
+    line-height: 1.4 !important;
+    text-align: center !important;
+}
+
+/* ------------------- MARKDOWN OUTPUT ------------------- */
+.gr-markdown {
+    background-color: #FFFFFF !important;
+    color: #1A202C !important;
+    padding: 16px !important;
+    border-radius: 8px !important;
+    border: 1px solid #E2E8F0 !important;
+}
+
+.gr-markdown h1,
+.gr-markdown h2,
+.gr-markdown h3,
+.gr-markdown h4,
+.gr-markdown h5,
+.gr-markdown h6 {
+    color: #1A202C !important;
+    font-weight: 700 !important;
+    line-height: 1.3 !important;
+    margin-top: 1.5em !important;
+    margin-bottom: 0.5em !important;
+}
+
+.gr-markdown h1 { font-size: 2rem !important; }
+.gr-markdown h2 { font-size: 1.75rem !important; }
+.gr-markdown h3 { font-size: 1.5rem !important; }
+.gr-markdown h4 { font-size: 1.25rem !important; }
+
+.gr-markdown p,
+.gr-markdown li,
+.gr-markdown span,
+.gr-markdown div {
+    color: #1A202C !important;
+    font-size: 1rem !important;
+    line-height: 1.7 !important;
+    margin-bottom: 1em !important;
+}
+
+.gr-markdown ul,
+.gr-markdown ol {
+    padding-left: 1.5em !important;
+    margin-bottom: 1em !important;
+}
+
+.gr-markdown li {
+    margin-bottom: 0.5em !important;
+}
+
+.gr-markdown strong,
+.gr-markdown b {
+    color: #1A202C !important;
+    font-weight: 700 !important;
+}
+
+.gr-markdown em,
+.gr-markdown i {
+    color: #1A202C !important;
+    font-style: italic !important;
+}
+
+/* ------------------- IMAGE UPLOAD ------------------- */
+.gr-image {
+    border: 3px dashed #CBD5E0 !important;
+    border-radius: 16px !important;
+    background-color: #F7FAFC !important;
+    transition: all 0.2s ease !important;
+}
+
+.gr-image:hover {
+    border-color: #E53E3E !important;
+    background-color: #FFF5F5 !important;
+}
+
+/* ------------------- RADIO BUTTONS ------------------- */
+.gr-radio input[type="radio"] {
+    margin-right: 8px !important;
+    transform: scale(1.2) !important;
+}
+
+.gr-radio label {
+    display: flex !important;
+    align-items: center !important;
+    padding: 8px 0 !important;
+    font-size: 1rem !important;
+    line-height: 1.5 !important;
+    cursor: pointer !important;
+    color: #1A202C !important;
+}
+
+/* ------------------- TABS ------------------- */
+.gr-tab {
+    color: #1A202C !important;
+    font-weight: 500 !important;
+    font-size: 1rem !important;
+    padding: 12px 20px !important;
+    background-color: #F7FAFC !important;
+}
+
+.gr-tab.selected {
+    color: #E53E3E !important;
+    font-weight: 600 !important;
+    border-bottom: 2px solid #E53E3E !important;
+    background-color: #FFFFFF !important;
+}
+
+/* ------------------- FOOTER ------------------- */
+.medical-footer {
+    text-align: center !important;
+    padding: 24px !important;
+    color: #4A5568 !important;
+    font-size: 0.95rem !important;
+    line-height: 1.6 !important;
+    border-top: 1px solid #E2E8F0 !important;
+    margin-top: 40px !important;
+    background-color: #F7FAFC !important;
+    border-radius: 12px !important;
+}
+
+/* ------------------- RESPONSIVE DESIGN ------------------- */
+@media (max-width: 768px) {
+    .medical-header {
+        padding: 20px !important;
+        text-align: center !important;
+    }
+    
+    .medical-header h1 {
+        font-size: 2.25rem !important;
+    }
+    
+    .medical-header p {
+        font-size: 1rem !important;
+    }
+    
+    .logo {
+        margin-right: 16px !important;
+        margin-bottom: 16px !important;
+    }
+    
+    .medical-card-title {
+        font-size: 1.25rem !important;
+        padding: 20px !important;
+    }
+    
+    .gr-button {
+        padding: 12px 24px !important;
+        font-size: 0.95rem !important;
+    }
+}
+
+/* ------------------- ACCESSIBILITY IMPROVEMENTS ------------------- */
+.gr-button:focus {
+    outline: 3px solid rgba(229, 62, 62, 0.5) !important;
+    outline-offset: 2px !important;
+}
+
+.gr-textbox:focus,
+.gr-dropdown:focus,
+.gr-file:focus,
+.gr-number:focus {
+    outline: 3px solid rgba(229, 62, 62, 0.3) !important;
+    outline-offset: 2px !important;
+    border-color: #E53E3E !important;
+}
+
+/* Success/Error status styling */
+.status-success {
+    color: #22C55E !important;
+    background-color: #F0FDF4 !important;
+    border: 1px solid #BBF7D0 !important;
+    padding: 12px !important;
+    border-radius: 8px !important;
+}
+
+.status-error {
+    color: #EF4444 !important;
+    background-color: #FEF2F2 !important;
+    border: 1px solid #FECACA !important;
+    padding: 12px !important;
+    border-radius: 8px !important;
+}