gui.py

"""
MedAI GUI - Modern Medical Report Analysis Interface
Built with CustomTkinter for a professional, modern design
"""

import customtkinter as ctk
from tkinter import filedialog, messagebox
import threading
import os
from pathlib import Path
import json
from datetime import datetime
import tkinter as tk
import numpy as np
from main import MedAI

# Set appearance mode and color theme
ctk.set_appearance_mode("light")  # "light" or "dark"
ctk.set_default_color_theme("blue")  # "blue", "green", "dark-blue"

class MedAIModernGUI:
    def __init__(self):
        # Create main window with enhanced settings
        self.root = ctk.CTk()
        self.root.title("MedAI - Advanced Medical Report Analysis by Dielldev")
        self.root.geometry("1450x950")
        self.root.minsize(1300, 850)
        
        # Set window properties
        self.root.resizable(True, True)
        
        # Try to set window icon (optional - will fail gracefully if icon not found)
        try:
            self.root.iconbitmap("icon.ico")  # Add if you have an icon file
        except:
            pass  # Continue without icon if not found
        
        # Initialize variables
        self.medai = None
        self.current_results = None
        self.selected_file = None
        
        # Create the modern interface
        self.create_widgets()
        
        # Load MedAI in background
        self.load_medai_async()
    
    def darken_color(self, color):
        """Helper method to darken a color for hover effects"""
        color_map = {
            "#3498db": "#2980b9",
            "#e74c3c": "#c0392b", 
            "#2ecc71": "#27ae60",
            "#9b59b6": "#8e44ad"
        }
        return color_map.get(color, color)
    
    def create_widgets(self):
        """Create the modern UI layout"""
        
        # Configure grid layout
        self.root.grid_columnconfigure(1, weight=1)
        self.root.grid_rowconfigure(0, weight=1)
        
        # Create sidebar
        self.create_sidebar()
        
        # Create main content area
        self.create_main_content()
        
        # Show welcome screen
        self.show_welcome_screen()
    
    def create_sidebar(self):
        """Create the left sidebar with controls"""
        
        # Sidebar frame with improved styling
        self.sidebar_frame = ctk.CTkFrame(self.root, width=380, corner_radius=15)
        self.sidebar_frame.grid(row=0, column=0, rowspan=4, sticky="nsew", padx=(15, 8), pady=15)
        self.sidebar_frame.grid_rowconfigure(10, weight=1)
        
        # Header section with enhanced styling
        self.header_frame = ctk.CTkFrame(self.sidebar_frame, fg_color="transparent")
        self.header_frame.grid(row=0, column=0, sticky="ew", padx=0, pady=(20, 15))
        
        # Title and logo with gradient-like effect
        self.logo_label = ctk.CTkLabel(
            self.header_frame, 
            text="🏥 MedAI",
            font=ctk.CTkFont(size=32, weight="bold"),
            text_color=("#1f4e79", "#4a90e2")
        )
        self.logo_label.pack(pady=(0, 2))
        
        self.subtitle_label = ctk.CTkLabel(
            self.header_frame,
            text="Advanced Medical Report Analysis",
            font=ctk.CTkFont(size=13, weight="normal"),
            text_color=("gray50", "gray70")
        )
        self.subtitle_label.pack(pady=(0, 5))
        
        # Add a subtle divider
        self.divider_frame = ctk.CTkFrame(self.header_frame, height=2, fg_color=("gray80", "gray30"))
        self.divider_frame.pack(fill="x", padx=40, pady=(10, 0))
        
        # File Selection Section with improved spacing
        self.file_section_frame = ctk.CTkFrame(self.sidebar_frame, fg_color="transparent")
        self.file_section_frame.grid(row=1, column=0, sticky="ew", padx=20, pady=(20, 10))
        
        self.file_section_label = ctk.CTkLabel(
            self.file_section_frame,
            text="📁 File Analysis",
            font=ctk.CTkFont(size=17, weight="bold"),
            anchor="w"
        )
        self.file_section_label.pack(anchor="w", pady=(0, 8))
        
        # File selection button with improved styling
        self.select_file_btn = ctk.CTkButton(
            self.file_section_frame,
            text="📄 Browse Medical Reports",
            command=self.select_file,
            height=45,
            font=ctk.CTkFont(size=14, weight="bold"),
            corner_radius=12,
            fg_color=("#3498db", "#2980b9"),
            hover_color=("#2980b9", "#1f618d")
        )
        self.select_file_btn.pack(fill="x", pady=(0, 8))
        
        # Selected file display with better styling
        self.file_display_frame = ctk.CTkFrame(self.file_section_frame, corner_radius=8, fg_color=("gray92", "gray20"))
        self.file_display_frame.pack(fill="x", pady=(0, 10))
        
        self.file_path_var = tk.StringVar(value="No file selected")
        self.file_path_label = ctk.CTkLabel(
            self.file_display_frame,
            textvariable=self.file_path_var,
            wraplength=320,
            font=ctk.CTkFont(size=11),
            text_color=("gray40", "gray80"),
            justify="left"
        )
        self.file_path_label.pack(padx=12, pady=8)
        
        # Analyze button with prominent styling
        self.analyze_btn = ctk.CTkButton(
            self.file_section_frame,
            text="🚀 Analyze Report",
            command=self.analyze_report,
            height=50,
            font=ctk.CTkFont(size=16, weight="bold"),
            corner_radius=15,
            fg_color=("#27ae60", "#2ecc71"),
            hover_color=("#229954", "#27ae60"),
            state="disabled"
        )
        self.analyze_btn.pack(fill="x", pady=(5, 0))
        
        # Language selection with improved layout
        self.lang_section_frame = ctk.CTkFrame(self.sidebar_frame, fg_color="transparent")
        self.lang_section_frame.grid(row=2, column=0, sticky="ew", padx=20, pady=(15, 10))
        
        self.lang_section_label = ctk.CTkLabel(
            self.lang_section_frame,
            text="🌐 Language Settings",
            font=ctk.CTkFont(size=17, weight="bold"),
            anchor="w"
        )
        self.lang_section_label.pack(anchor="w", pady=(0, 8))
        
        self.language_var = tk.StringVar(value="English + Albanian")
        self.language_menu = ctk.CTkOptionMenu(
            self.lang_section_frame,
            values=["English + Albanian", "English", "Albanian"],
            variable=self.language_var,
            command=self.on_language_change,
            font=ctk.CTkFont(size=13),
            corner_radius=10,
            height=40
        )
        self.language_menu.pack(fill="x")
        
        # Text Analysis Section with enhanced styling
        self.text_section_frame = ctk.CTkFrame(self.sidebar_frame, fg_color="transparent")
        self.text_section_frame.grid(row=3, column=0, sticky="ew", padx=20, pady=(20, 10))
        
        self.text_section_label = ctk.CTkLabel(
            self.text_section_frame,
            text="📝 Direct Text Analysis",
            font=ctk.CTkFont(size=17, weight="bold"),
            anchor="w"
        )
        self.text_section_label.pack(anchor="w", pady=(0, 8))
        
        # Text input with placeholder styling
        self.text_input_frame = ctk.CTkFrame(self.text_section_frame, corner_radius=12)
        self.text_input_frame.pack(fill="x", pady=(0, 10))
        
        self.text_input = ctk.CTkTextbox(
            self.text_input_frame,
            height=140,
            font=ctk.CTkFont(size=12),
            wrap="word",
            corner_radius=8
        )
        self.text_input.pack(fill="both", expand=True, padx=8, pady=8)
        self.text_input.insert("0.0", "Paste your medical report text here...")
        
        # Analyze text button with distinct styling
        self.analyze_text_btn = ctk.CTkButton(
            self.text_section_frame,
            text="📊 Analyze Text",
            command=self.analyze_text,
            height=45,
            font=ctk.CTkFont(size=14, weight="bold"),
            corner_radius=12,
            fg_color=("#e74c3c", "#c0392b"),
            hover_color=("#c0392b", "#a93226")
        )
        self.analyze_text_btn.pack(fill="x")
        
        # Status and Database Section with refined design
        self.status_section_frame = ctk.CTkFrame(self.sidebar_frame, fg_color="transparent")
        self.status_section_frame.grid(row=4, column=0, sticky="ew", padx=20, pady=(25, 15))
        
        # Status card with elegant design
        self.status_frame = ctk.CTkFrame(self.status_section_frame, corner_radius=15, fg_color=("gray96", "gray17"))
        self.status_frame.pack(fill="x")
        
        # Status header
        self.status_header = ctk.CTkLabel(
            self.status_frame,
            text="⚡ System Status",
            font=ctk.CTkFont(size=15, weight="bold"),
            anchor="w"
        )
        self.status_header.pack(anchor="w", padx=15, pady=(15, 5))
        
        # Progress label with better styling
        self.progress_var = tk.StringVar(value="Initializing MedAI...")
        self.progress_label = ctk.CTkLabel(
            self.status_frame,
            textvariable=self.progress_var,
            font=ctk.CTkFont(size=12, weight="bold"),
            text_color=("#2c3e50", "#ecf0f1")
        )
        self.progress_label.pack(anchor="w", padx=15, pady=(0, 8))
        
        # Progress bar with custom styling
        self.progress_bar = ctk.CTkProgressBar(
            self.status_frame, 
            mode="indeterminate",
            corner_radius=10,
            height=8
        )
        self.progress_bar.pack(fill="x", padx=15, pady=(0, 12))
        self.progress_bar.start()
        
        # Case count with icon
        self.case_count_var = tk.StringVar(value="📊 Cases: Loading...")
        self.case_count_label = ctk.CTkLabel(
            self.status_frame,
            textvariable=self.case_count_var,
            font=ctk.CTkFont(size=12),
            text_color=("gray30", "gray80")
        )
        self.case_count_label.pack(anchor="w", padx=15, pady=(0, 10))
        
        # Action buttons with improved layout
        self.action_buttons_frame = ctk.CTkFrame(self.status_frame, fg_color="transparent")
        self.action_buttons_frame.pack(fill="x", padx=15, pady=(0, 15))
        
        # View cases button
        self.view_cases_btn = ctk.CTkButton(
            self.action_buttons_frame,
            text="👁️ View Database",
            command=self.view_cases,
            height=38,
            font=ctk.CTkFont(size=12, weight="bold"),
            corner_radius=10,
            fg_color=("#9b59b6", "#8e44ad"),
            hover_color=("#8e44ad", "#7d3c98")
        )
        self.view_cases_btn.pack(fill="x")
    
    def create_main_content(self):
        """Create the main content area for results"""
        
        # Main content frame with enhanced styling
        self.main_frame = ctk.CTkFrame(self.root, corner_radius=15)
        self.main_frame.grid(row=0, column=1, sticky="nsew", padx=(8, 15), pady=15)
        self.main_frame.grid_columnconfigure(0, weight=1)
        self.main_frame.grid_rowconfigure(2, weight=1)
        
        # --- Results Header (Initially Hidden) ---
        self.results_header_frame = ctk.CTkFrame(self.main_frame, fg_color="transparent")
        self.results_header_frame.grid_columnconfigure(1, weight=1)
        
        # Header card with gradient-like styling
        self.header_card = ctk.CTkFrame(self.results_header_frame, corner_radius=12, fg_color=("gray97", "gray15"))
        self.header_card.grid(row=0, column=0, columnspan=2, sticky="ew", padx=15, pady=(15, 10))
        self.header_card.grid_columnconfigure(0, weight=1)
        
        self.diagnosis_header_label = ctk.CTkLabel(
            self.header_card, 
            text="", 
            font=ctk.CTkFont(size=26, weight="bold"),
            text_color=("#1a365d", "#90cdf4")
        )
        self.diagnosis_header_label.grid(row=0, column=0, sticky="w", padx=20, pady=(15, 5))
        
        self.confidence_header_label = ctk.CTkLabel(
            self.header_card, 
            text="", 
            font=ctk.CTkFont(size=14),
            text_color=("gray50", "gray70")
        )
        self.confidence_header_label.grid(row=1, column=0, sticky="w", padx=20, pady=(0, 15))
        
        # --- Enhanced Navigation Buttons ---
        self.nav_frame = ctk.CTkFrame(self.main_frame, fg_color="transparent")
        self.nav_frame.grid_columnconfigure((0, 1, 2, 3), weight=1)
        
        self.nav_buttons = {}
        nav_items = [
            ("📋 Summary", "#3498db"),
            ("🩺 Medical Data", "#e74c3c"), 
            ("🔬 Diagnosis", "#2ecc71"),
            ("🔍 Similar Cases", "#9b59b6")
        ]
        
        for i, (item, color) in enumerate(nav_items):
            btn = ctk.CTkButton(
                self.nav_frame,
                text=item,
                font=ctk.CTkFont(size=14, weight="bold"),
                command=lambda view=item: self.switch_view(view),
                corner_radius=12,
                height=45,
                fg_color=color,
                hover_color=self.darken_color(color),
                text_color=("white", "white")  # Ensure text is always visible
            )
            btn.grid(row=0, column=i, padx=8, pady=8, sticky="ew")
            self.nav_buttons[item] = btn
            
        # --- Enhanced Content Frames ---
        self.content_frame = ctk.CTkFrame(self.main_frame, fg_color="transparent")
        self.content_frame.grid(row=2, column=0, sticky="nsew", padx=15, pady=15)
        self.content_frame.grid_rowconfigure(0, weight=1)
        self.content_frame.grid_columnconfigure(0, weight=1)
        
        self.content_frames = {}
        nav_item_names = ["📋 Summary", "🩺 Medical Data", "🔬 Diagnosis", "🔍 Similar Cases"]
        
        for view in nav_item_names:
            frame = ctk.CTkFrame(self.content_frame, corner_radius=12, fg_color=("gray98", "gray14"))
            frame.grid(row=0, column=0, sticky="nsew")
            self.content_frames[view] = frame
            frame.grid_remove() # Hide all frames initially
            
        # --- Populate Content Frames with improved styling ---
        
        # Summary tab with enhanced text area
        self.summary_textbox = ctk.CTkTextbox(
            self.content_frames["📋 Summary"],
            font=ctk.CTkFont(family="Segoe UI", size=13),
            wrap="word",
            corner_radius=8
        )
        self.summary_textbox.pack(fill="both", expand=True, padx=12, pady=12)
        
        # Medical Data tab
        self.create_medical_data_tab()
        
        # Diagnosis tab with enhanced styling
        self.diagnosis_textbox = ctk.CTkTextbox(
            self.content_frames["🔬 Diagnosis"],
            font=ctk.CTkFont(family="Segoe UI", size=13),
            wrap="word",
            corner_radius=8
        )
        self.diagnosis_textbox.pack(fill="both", expand=True, padx=12, pady=12)
        
        # Similar Cases tab with enhanced styling
        self.cases_textbox = ctk.CTkTextbox(
            self.content_frames["🔍 Similar Cases"],
            font=ctk.CTkFont(family="Segoe UI", size=12),
            wrap="word",
            corner_radius=8
        )
        self.cases_textbox.pack(fill="both", expand=True, padx=12, pady=12)
        
        # --- Enhanced Export Buttons ---
        self.export_frame = ctk.CTkFrame(self.main_frame, fg_color="transparent")
        self.export_frame.grid_columnconfigure((0, 1), weight=1)
        
        self.export_summary_btn = ctk.CTkButton(
            self.export_frame,
            text="📄 Export Summary",
            command=self.export_summary,
            font=ctk.CTkFont(size=13, weight="bold"),
            corner_radius=12,
            height=42,
            fg_color=("#27ae60", "#2ecc71"),
            hover_color=("#229954", "#27ae60")
        )
        self.export_summary_btn.grid(row=0, column=0, padx=(15, 8), pady=12, sticky="ew")
        
        self.export_full_btn = ctk.CTkButton(
            self.export_frame,
            text="📑 Export Full Report",
            command=self.export_full_report,
            font=ctk.CTkFont(size=13, weight="bold"),
            corner_radius=12,
            height=42,
            fg_color=("#8e44ad", "#9b59b6"),
            hover_color=("#7d3c98", "#8e44ad")
        )
        self.export_full_btn.grid(row=0, column=1, padx=(8, 15), pady=12, sticky="ew")
        
        # --- Enhanced Welcome Screen ---
        self.welcome_container = ctk.CTkFrame(self.main_frame, corner_radius=15, fg_color=("gray98", "gray14"))
        self.welcome_container.grid(row=0, column=0, rowspan=4, sticky="nsew", padx=15, pady=15)
        self.welcome_container.grid_columnconfigure(0, weight=1)
        self.welcome_container.grid_rowconfigure(1, weight=1)
        
        # Welcome header
        self.welcome_header_frame = ctk.CTkFrame(self.welcome_container, fg_color="transparent")
        self.welcome_header_frame.grid(row=0, column=0, sticky="ew", padx=30, pady=(30, 15))
        
        self.welcome_title = ctk.CTkLabel(
            self.welcome_header_frame,
            text="🏥 Medical Report Analysis",
            font=ctk.CTkFont(size=28, weight="bold"),
            text_color=("#1a365d", "#90cdf4")
        )
        self.welcome_title.pack()
        
        self.welcome_subtitle = ctk.CTkLabel(
            self.welcome_header_frame,
            text="Advanced AI-Powered Medical Intelligence",
            font=ctk.CTkFont(size=14),
            text_color=("gray50", "gray70")
        )
        self.welcome_subtitle.pack(pady=(5, 0))
        
        # Welcome content area
        self.welcome_content = ctk.CTkTextbox(
            self.welcome_container,
            font=ctk.CTkFont(family="Segoe UI", size=13),
            wrap="word",
            corner_radius=8
        )
        self.welcome_content.grid(row=1, column=0, sticky="nsew", padx=20, pady=(0, 30))
        
        self.show_welcome_screen()

    def switch_view(self, view_name):
        """Switch between content views"""
        for view, frame in self.content_frames.items():
            if view == view_name:
                frame.grid()
            else:
                frame.grid_remove()
        
        # Update button appearance - highlight selected button
        for name, btn in self.nav_buttons.items():
            if name == view_name:
                # Make selected button darker and more prominent
                original_color = {
                    "📋 Summary": "#2980b9",
                    "🩺 Medical Data": "#c0392b", 
                    "🔬 Diagnosis": "#27ae60",
                    "🔍 Similar Cases": "#8e44ad"
                }
                btn.configure(fg_color=original_color.get(name, "#2980b9"))
            else:
                # Keep unselected buttons with their original colors but slightly lighter
                original_color = {
                    "📋 Summary": "#3498db",
                    "🩺 Medical Data": "#e74c3c", 
                    "🔬 Diagnosis": "#2ecc71",
                    "🔍 Similar Cases": "#9b59b6"
                }
                btn.configure(fg_color=original_color.get(name, "#3498db"))

    def create_medical_data_tab(self):
        """Create the medical data tab with scrollable frame"""
        
        # Create scrollable frame for medical data with enhanced styling
        self.medical_data_frame = ctk.CTkScrollableFrame(
            self.content_frames["🩺 Medical Data"],
            corner_radius=8,
            fg_color="transparent"
        )
        self.medical_data_frame.pack(fill="both", expand=True, padx=12, pady=12)
        
        # Header for medical data with improved styling
        self.medical_data_header_frame = ctk.CTkFrame(self.medical_data_frame, fg_color="transparent")
        self.medical_data_header_frame.pack(fill="x", pady=(0, 15))
        
        self.medical_data_header = ctk.CTkLabel(
            self.medical_data_header_frame,
            text="📊 Extracted Medical Parameters",
            font=ctk.CTkFont(size=20, weight="bold"),
            text_color=("#2c3e50", "#ecf0f1"),
            anchor="w"
        )
        self.medical_data_header.pack(anchor="w")
        
        self.medical_data_subtitle = ctk.CTkLabel(
            self.medical_data_header_frame,
            text="Organized analysis of medical values with status indicators",
            font=ctk.CTkFont(size=12),
            text_color=("gray50", "gray70"),
            anchor="w"
        )
        self.medical_data_subtitle.pack(anchor="w", pady=(2, 0))
        
        # This will be populated with medical data cards
        self.medical_data_cards = []
    
    def show_welcome_screen(self):
        """Show welcome message in the main area"""
        
        # Ensure results UI is hidden
        self.results_header_frame.grid_remove()
        self.nav_frame.grid_remove()
        self.content_frame.grid_remove()
        self.export_frame.grid_remove()
        
        # Show welcome container
        self.welcome_container.grid()
        
        welcome_text = """
🚀 Welcome to MedAI - Next-Generation Medical Analysis

Experience the future of medical report processing with our advanced AI-powered platform.

✨ CUTTING-EDGE FEATURES:

🔬 Advanced OCR Technology
   • Extract text from PDFs, images, and scanned documents
   • Support for multiple image formats (JPG, PNG, TIFF, BMP)
   • High-precision medical text recognition

🧠 Intelligent AI Analysis
   • Deep learning models for medical data extraction
   • Pattern recognition for symptom identification
   • Predictive diagnosis with confidence scoring

🔍 Smart Case Matching
   • Semantic similarity analysis
   • Historical case database integration
   • Pattern-based diagnostic suggestions

📊 Comprehensive Reporting
   • Detailed medical parameter extraction
   • Professional analysis summaries
   • Exportable reports in multiple formats

� GETTING STARTED:

📁 FILE ANALYSIS METHOD:
   1. Click "Browse Medical Reports" to select your document
   2. Choose from PDF, JPG, PNG, TIFF, or BMP formats
   3. Click "Analyze Report" to process with OCR + AI
   4. View results across multiple organized tabs

📝 DIRECT TEXT METHOD:
   1. Paste medical report text in the left sidebar
   2. Click "Analyze Text" for immediate processing
   3. Perfect for pre-extracted or typed content
   4. Instant analysis without file upload

🌐 LANGUAGE SUPPORT:
   • English - Full medical terminology support
   • Albanian - Comprehensive medical vocabulary
   • Bilingual - Process mixed-language documents

🔐 PRIVACY & SECURITY GUARANTEED:
   ✅ 100% local processing - No cloud uploads
   ✅ Your data never leaves your device
   ✅ HIPAA-compliant by design
   ✅ Enterprise-grade privacy protection

📈 ANALYSIS RESULTS INCLUDE:
   • Extracted medical parameters with normal ranges
   • AI-powered diagnostic predictions
   • Confidence levels and supporting evidence
   • Similar case matches from your database
   • Comprehensive summary reports

⚠️ MEDICAL DISCLAIMER:
This advanced tool is designed for educational, research, and clinical decision support purposes.
Always consult qualified healthcare professionals for medical decisions and final diagnosis.
The AI predictions are meant to assist, not replace, professional medical judgment.

🎯 Ready to revolutionize your medical analysis workflow!
        """
        
        self.welcome_content.delete("0.0", "end")
        self.welcome_content.insert("0.0", welcome_text)
    
    def change_appearance_mode_event(self, new_appearance_mode: str):
        """Change the appearance mode"""
        ctk.set_appearance_mode(new_appearance_mode.lower())
    
    def on_language_change(self, choice):
        """Handle language selection change"""
        lang_map = {
            "English + Albanian": ['eng', 'sqi'],
            "English": ['eng'],
            "Albanian": ['sqi']
        }
        
        selected_langs = lang_map.get(choice, ['eng', 'sqi'])
        
        # Re-load MedAI with new languages
        self.load_medai_async(languages=selected_langs)

    def load_medai_async(self, languages=['eng', 'sqi']):
        """Load MedAI in background thread with specified languages"""
        def load():
            try:
                self.root.after(0, lambda: self.progress_var.set("Loading AI models..."))
                self.root.after(0, lambda: self.progress_bar.start())
                
                from main import MedAI
                self.medai = MedAI(languages=languages)
                
                # Update UI on main thread
                self.root.after(0, self.on_medai_loaded)
                
            except Exception as e:
                self.root.after(0, lambda: self.on_medai_error(str(e)))
        
        thread = threading.Thread(target=load, daemon=True)
        thread.start()
    
    def on_medai_loaded(self):
        """Called when MedAI is successfully loaded"""
        self.progress_bar.stop()
        self.progress_var.set("🟢 System Ready")
        self.case_count_var.set(f"📊 Cases: {len(self.medai.cases_db)}")
        
        # Enable buttons with improved state management
        self.select_file_btn.configure(state="normal")
        self.analyze_text_btn.configure(state="normal")
    
    def on_medai_error(self, error_msg):
        """Called when MedAI loading fails"""
        self.progress_bar.stop()
        self.progress_var.set("❌ System Error")
        messagebox.showerror("Initialization Error", f"Failed to load MedAI: {error_msg}")
    
    def select_file(self):
        """Open file dialog to select medical report"""
        filetypes = [
            ("All Supported", "*.pdf *.jpg *.jpeg *.png *.bmp *.tiff"),
            ("PDF files", "*.pdf"),
            ("Image files", "*.jpg *.jpeg *.png *.bmp *.tiff"),
            ("All files", "*.*")
        ]
        
        filename = filedialog.askopenfilename(
            title="Select Medical Report",
            filetypes=filetypes
        )
        
        if filename:
            self.selected_file = filename
            file_name = Path(filename).name
            # Truncate long filenames for better display
            display_name = file_name if len(file_name) <= 35 else file_name[:32] + "..."
            self.file_path_var.set(f"📄 {display_name}")
            self.analyze_btn.configure(state="normal")
    
    def analyze_report(self):
        """Analyze the selected medical report file"""
        if not self.selected_file:
            messagebox.showwarning("No File Selected", "Please select a medical report file first.")
            return
        
        if not self.medai:
            messagebox.showwarning("System Not Ready", "MedAI is still loading. Please wait.")
            return
        
        def analyze():
            try:
                # Update UI
                self.root.after(0, lambda: self.progress_var.set("🔄 Analyzing report..."))
                self.root.after(0, lambda: self.progress_bar.start())
                
                # Run analysis
                results = self.medai.analyze_report(self.selected_file)
                
                # Update UI with results
                self.root.after(0, lambda: self.progress_bar.stop())
                
                if 'error' in results:
                    self.root.after(0, lambda: self.progress_var.set("❌ Analysis failed"))
                    self.root.after(0, lambda: messagebox.showerror("Analysis Error", results['error']))
                else:
                    self.root.after(0, lambda: self.progress_var.set("✅ Analysis complete"))
                    self.current_results = results
                    self.root.after(0, lambda: self.display_results(results))
                    self.root.after(0, lambda: self.case_count_var.set(f"Cases: {len(self.medai.cases_db)}"))
                
            except Exception as e:
                self.root.after(0, lambda: self.progress_bar.stop())
                self.root.after(0, lambda: self.progress_var.set("❌ Error"))
                self.root.after(0, lambda: messagebox.showerror("Analysis Error", f"Failed to analyze: {str(e)}"))
        
        thread = threading.Thread(target=analyze, daemon=True)
        thread.start()
    
    def analyze_text(self):
        """Analyze text input directly"""
        text = self.text_input.get("0.0", "end").strip()
        
        # Remove placeholder text
        if text == "Paste your medical report text here...":
            text = ""
        
        if not text:
            messagebox.showwarning("No Text Entered", "Please enter medical report text to analyze.")
            return
        
        if not self.medai:
            messagebox.showwarning("System Not Ready", "MedAI is still loading. Please wait.")
            return
        
        def analyze():
            try:
                # Update UI
                self.root.after(0, lambda: self.progress_var.set("🔄 Analyzing text..."))
                self.root.after(0, lambda: self.progress_bar.start())
                
                # Parse medical values
                medical_data = self.medai.parse_medical_values(text)
                
                # Generate embeddings
                embedding = self.medai.generate_embeddings(text)
                
                # Find similar cases
                similar_cases = self.medai.find_similar_cases(embedding)
                
                # Predict diagnosis
                prediction = self.medai.predict_diagnosis(medical_data, similar_cases)
                
                # Generate summary
                summary = self.medai.generate_summary(medical_data, prediction, similar_cases)
                
                # Save case
                self.medai.save_case(text, medical_data, prediction, embedding)
                self.medai.save_data()
                
                # Create results
                results = {
                    'extracted_text': text,
                    'medical_data': medical_data,
                    'prediction': prediction,
                    'similar_cases': similar_cases,
                    'summary': summary
                }
                
                # Update UI
                self.root.after(0, lambda: self.progress_bar.stop())
                self.root.after(0, lambda: self.progress_var.set("✅ Analysis complete"))
                self.current_results = results
                self.root.after(0, lambda: self.display_results(results))
                self.root.after(0, lambda: self.case_count_var.set(f"Cases: {len(self.medai.cases_db)}"))
                
            except Exception as e:
                self.root.after(0, lambda: self.progress_bar.stop())
                self.root.after(0, lambda: self.progress_var.set("❌ Error"))
                self.root.after(0, lambda: messagebox.showerror("Analysis Error", f"Text analysis failed: {str(e)}"))
        
        thread = threading.Thread(target=analyze, daemon=True)
        thread.start()
    
    def display_results(self, results):
        """Display analysis results in the modern GUI"""
        
        # Hide welcome screen, show results UI
        self.welcome_container.grid_remove()
        self.results_header_frame.grid(row=0, column=0, sticky="ew", padx=0, pady=0)
        self.nav_frame.grid(row=1, column=0, sticky="ew", padx=15, pady=(10, 0))
        self.content_frame.grid(row=2, column=0, sticky="nsew", padx=0, pady=0)
        self.export_frame.grid(row=3, column=0, sticky="ew", padx=0, pady=0)
        
        # --- Populate Header ---
        primary_diagnosis = results['prediction']['primary_diagnosis'].replace('_', ' ').title()
        confidence = results['prediction']['confidence']
        
        self.diagnosis_header_label.configure(text=f"🔬 {primary_diagnosis}")
        self.confidence_header_label.configure(text=f"Confidence: {confidence:.0%} • Analysis completed successfully")
        
        # --- Populate Content ---
        # Summary tab
        self.summary_textbox.delete("0.0", "end")
        self.summary_textbox.insert("0.0", results['summary'])
        
        # Medical Data tab
        self.display_medical_data_cards(results['medical_data'])
        
        # Diagnosis tab
        self.display_diagnosis_details(results['prediction'], results['medical_data'])
        
        # Similar Cases tab
        self.display_similar_cases(results['similar_cases'])
        
        # Switch to summary view by default
        self.switch_view("📋 Summary")
    
    def display_medical_data_cards(self, medical_data):
        """Display medical data as modern cards"""
        
        # Clear existing cards
        for card in self.medical_data_cards:
            card.destroy()
        self.medical_data_cards.clear()
        
        if not medical_data:
            # Enhanced no data display
            no_data_frame = ctk.CTkFrame(
                self.medical_data_frame,
                corner_radius=15,
                fg_color=("gray95", "gray20")
            )
            no_data_frame.pack(fill="x", padx=5, pady=20)
            
            no_data_icon = ctk.CTkLabel(
                no_data_frame,
                text="📋",
                font=ctk.CTkFont(size=48)
            )
            no_data_icon.pack(pady=(30, 10))
            
            no_data_label = ctk.CTkLabel(
                no_data_frame,
                text="No Medical Data Extracted",
                font=ctk.CTkFont(size=18, weight="bold"),
                text_color=("gray40", "gray80")
            )
            no_data_label.pack(pady=(0, 10))
            
            no_data_subtitle = ctk.CTkLabel(
                no_data_frame,
                text="The document may not contain structured medical parameters\nor the values could not be automatically detected.",
                font=ctk.CTkFont(size=12),
                text_color=("gray50", "gray70"),
                justify="center"
            )
            no_data_subtitle.pack(pady=(0, 30))
            
            self.medical_data_cards.append(no_data_frame)
            return
        
        # Create cards for each medical parameter
        for i, (key, value) in enumerate(medical_data.items()):
            self.create_medical_data_card(key, value, i)
    
    def create_medical_data_card(self, key, value, index):
        """Create a modern card for medical data"""
        
        # Format the parameter name
        param_name = key.replace('_', ' ').title()
        
        # Get appropriate color and icon based on parameter type
        color_info = self.get_parameter_color_and_icon(key, value)
        
        # Create card frame with enhanced styling
        card_frame = ctk.CTkFrame(
            self.medical_data_frame,
            corner_radius=15,
            fg_color=color_info['bg_color'],
            border_width=2,
            border_color=("gray85", "gray25")
        )
        card_frame.pack(fill="x", padx=5, pady=12)
        
        # Configure grid with better proportions
        card_frame.grid_columnconfigure(1, weight=1)
        
        # Icon/Emoji with enhanced styling
        icon_frame = ctk.CTkFrame(card_frame, fg_color="transparent", width=60)
        icon_frame.grid(row=0, column=0, rowspan=2, padx=20, pady=20, sticky="ns")
        
        icon_label = ctk.CTkLabel(
            icon_frame,
            text=color_info['icon'],
            font=ctk.CTkFont(size=28)
        )
        icon_label.pack(expand=True)
        
        # Parameter name with improved styling
        name_label = ctk.CTkLabel(
            card_frame,
            text=param_name,
            font=ctk.CTkFont(size=18, weight="bold"),
            text_color=color_info['text_color'],
            anchor="w"
        )
        name_label.grid(row=0, column=1, sticky="w", padx=15, pady=(20, 5))
        
        # Value and unit with enhanced presentation
        unit = self.get_unit_for_parameter(key)
        value_text = f"{value} {unit}".strip()
        
        value_label = ctk.CTkLabel(
            card_frame,
            text=value_text,
            font=ctk.CTkFont(size=16, weight="bold"),
            text_color=color_info['value_color'],
            anchor="w"
        )
        value_label.grid(row=1, column=1, sticky="w", padx=15, pady=(0, 20))
        
        # Status indicator with enhanced styling
        status = self.get_parameter_status(key, value)
        if status:
            status_frame = ctk.CTkFrame(card_frame, fg_color="transparent")
            status_frame.grid(row=0, column=2, rowspan=2, padx=20, pady=20, sticky="ns")
            
            status_label = ctk.CTkLabel(
                status_frame,
                text=status['text'],
                font=ctk.CTkFont(size=14, weight="bold"),
                text_color=status['color']
            )
            status_label.pack(expand=True)
        
        self.medical_data_cards.append(card_frame)
    
    def get_parameter_color_and_icon(self, key, value):
        """Get color scheme and icon for medical parameter"""
        
        color_schemes = {
            'blood_pressure': {'icon': '🫀', 'bg_color': '#ffebee', 'text_color': '#c62828', 'value_color': '#d32f2f'},
            'systolic_bp': {'icon': '📈', 'bg_color': '#ffebee', 'text_color': '#c62828', 'value_color': '#d32f2f'},
            'diastolic_bp': {'icon': '📉', 'bg_color': '#ffebee', 'text_color': '#c62828', 'value_color': '#d32f2f'},
            'heart_rate': {'icon': '💓', 'bg_color': '#f3e5f5', 'text_color': '#7b1fa2', 'value_color': '#8e24aa'},
            'temperature': {'icon': '🌡️', 'bg_color': '#fff3e0', 'text_color': '#e65100', 'value_color': '#f57c00'},
            'glucose': {'icon': '🍯', 'bg_color': '#e8f5e8', 'text_color': '#2e7d32', 'value_color': '#388e3c'},
            'weight': {'icon': '⚖️', 'bg_color': '#e3f2fd', 'text_color': '#1565c0', 'value_color': '#1976d2'},
            'height': {'icon': '📏', 'bg_color': '#e3f2fd', 'text_color': '#1565c0', 'value_color': '#1976d2'},
            'cholesterol': {'icon': '🧪', 'bg_color': '#fce4ec', 'text_color': '#ad1457', 'value_color': '#c2185b'},
            'hemoglobin': {'icon': '🩸', 'bg_color': '#ffebee', 'text_color': '#c62828', 'value_color': '#d32f2f'},
            'symptoms': {'icon': '🤒', 'bg_color': '#fff8e1', 'text_color': '#f57f17', 'value_color': '#f9a825'}
        }
        
        return color_schemes.get(key, {
            'icon': '📊', 
            'bg_color': '#f5f5f5', 
            'text_color': '#424242', 
            'value_color': '#616161'
        })
    
    def get_parameter_status(self, key, value):
        """Get status indicator for medical parameter"""
        
        try:
            if key in ['systolic_bp', 'diastolic_bp']:
                val = int(value)
                if key == 'systolic_bp':
                    if val >= 140:
                        return {'text': '⚠️ HIGH', 'color': '#d32f2f'}
                    elif val < 90:
                        return {'text': '⚠️ LOW', 'color': '#1976d2'}
                    else:
                        return {'text': '✅ NORMAL', 'color': '#388e3c'}
                else:  # diastolic_bp
                    if val >= 90:
                        return {'text': '⚠️ HIGH', 'color': '#d32f2f'}
                    elif val < 60:
                        return {'text': '⚠️ LOW', 'color': '#1976d2'}
                    else:
                        return {'text': '✅ NORMAL', 'color': '#388e3c'}
            
            elif key == 'heart_rate':
                val = int(value)
                if val > 100:
                    return {'text': '⚠️ HIGH', 'color': '#d32f2f'}
                elif val < 60:
                    return {'text': '⚠️ LOW', 'color': '#1976d2'}
                else:
                    return {'text': '✅ NORMAL', 'color': '#388e3c'}
            
            elif key == 'glucose':
                val = int(value)
                if val >= 126:
                    return {'text': '⚠️ HIGH', 'color': '#d32f2f'}
                elif val < 70:
                    return {'text': '⚠️ LOW', 'color': '#1976d2'}
                else:
                    return {'text': '✅ NORMAL', 'color': '#388e3c'}
                    
        except (ValueError, TypeError):
            pass
        
        return None
    
    def get_unit_for_parameter(self, parameter):
        """Get appropriate unit for medical parameter"""
        units = {
            'blood_pressure': 'mmHg',
            'systolic_bp': 'mmHg',
            'diastolic_bp': 'mmHg',
            'heart_rate': 'bpm',
            'temperature': '°F',
            'glucose': 'mg/dl',
            'weight': 'lbs',
            'height': 'cm',
            'cholesterol': 'mg/dl',
            'hemoglobin': 'g/dl',
            'symptoms': ''
        }
        return units.get(parameter, '')
    
    def display_diagnosis_details(self, prediction, medical_data):
        """Display detailed diagnosis information"""
        
        diagnosis_text = f"""
🔬 COMPREHENSIVE DIAGNOSIS ANALYSIS

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

🎯 PRIMARY DIAGNOSIS: {prediction['primary_diagnosis'].replace('_', ' ').title()}

📊 CONFIDENCE LEVEL: {prediction['confidence']:.0%}
   └─ Analysis Reliability: {'High' if prediction['confidence'] > 0.8 else 'Medium' if prediction['confidence'] > 0.6 else 'Low'}

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

🚨 MEDICAL INDICATORS DETECTED:
"""
        
        if prediction['triggered_rules']:
            for i, rule in enumerate(prediction['triggered_rules'], 1):
                rule_name = rule.replace('_', ' ').title()
                diagnosis_text += f"   {i}. {rule_name}\n"
        else:
            diagnosis_text += "   • No specific indicators detected\n"
        
        diagnosis_text += f"""
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📋 EXTRACTED MEDICAL VALUES:
"""
        
        if medical_data:
            for key, value in medical_data.items():
                param_name = key.replace('_', ' ').title()
                unit = self.get_unit_for_parameter(key)
                status = self.get_parameter_status(key, value)
                status_text = f" ({status['text']})" if status else ""
                diagnosis_text += f"   • {param_name}: {value} {unit}{status_text}\n"
        else:
            diagnosis_text += "   • No specific medical values extracted\n"
        
        diagnosis_text += f"""
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

🎯 SUPPORTING EVIDENCE:
   • Similar historical cases: {prediction['supporting_cases']}
   • Pattern recognition confidence: {prediction['confidence']:.0%}
   • AI model reliability: Advanced neural embeddings

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

⚠️  IMPORTANT MEDICAL DISCLAIMER:

This automated analysis is designed for educational and research purposes only.
The predictions are based on pattern recognition and rule-based algorithms.

🔸 NOT a substitute for professional medical diagnosis
🔸 NOT intended for clinical decision-making
🔸 ALWAYS consult qualified healthcare professionals
🔸 Seek immediate medical attention for urgent symptoms

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
        """
        
        self.diagnosis_textbox.delete("0.0", "end")
        self.diagnosis_textbox.insert("0.0", diagnosis_text)
    
    def display_similar_cases(self, similar_cases):
        """Display similar cases information"""
        
        if similar_cases:
            cases_text = """
🔍 SIMILAR CASES DATABASE ANALYSIS

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Found matching patterns in your case history database:

"""
            
            for i, (case, similarity) in enumerate(similar_cases, 1):
                case_diagnosis = case.get('diagnosis', 'Unknown').replace('_', ' ').title()
                case_confidence = case.get('confidence', 0)
                case_date = case.get('timestamp', 'Unknown')
                
                cases_text += f"""
📁 CASE #{i}:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

🔬 Diagnosis: {case_diagnosis}
📊 Original Confidence: {case_confidence:.0%}
🎯 Similarity Score: {similarity:.0%}
📅 Analysis Date: {case_date[:10] if case_date != 'Unknown' else 'Unknown'}

📋 Key Medical Values:
"""
                
                if 'medical_data' in case and case['medical_data']:
                    for key, value in case['medical_data'].items():
                        param_name = key.replace('_', ' ').title()
                        unit = self.get_unit_for_parameter(key)
                        cases_text += f"   • {param_name}: {value} {unit}\n"
                else:
                    cases_text += "   • No detailed medical data available\n"
                
                cases_text += "\n"
            
            cases_text += """
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

🤖 AI PATTERN ANALYSIS:
• Cases are matched using advanced semantic similarity
• Higher similarity scores indicate stronger pattern matches
• The system learns from each analysis to improve accuracy
• Database grows with each processed medical report

            """
        else:
            cases_text = """
🔍 SIMILAR CASES DATABASE ANALYSIS

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📊 NO SIMILAR CASES FOUND

This indicates one of the following:

🔸 This is your first analysis with MedAI
🔸 This case represents a unique pattern not seen before
🔸 The case database is still building

🚀 BUILDING YOUR CASE DATABASE:

As you analyze more medical reports, MedAI will:
• Build a comprehensive case history
• Improve pattern recognition accuracy
• Provide better similarity matching
• Enhance diagnostic confidence

Each analysis contributes to the learning database, making future
predictions more accurate and reliable.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

🎯 RECOMMENDATIONS:
• Continue analyzing medical reports to build database
• Review past cases using "View Case Database" button
• Export results for external analysis if needed

            """
        
        self.cases_textbox.delete("0.0", "end")
        self.cases_textbox.insert("0.0", cases_text)
    
    def export_summary(self):
        """Export the summary to a text file."""
        if not self.current_results:
            messagebox.showwarning("No Data", "No analysis results to export.")
            return

        summary = self.current_results.get('summary', '')
        if not summary:
            messagebox.showwarning("No Summary", "No summary available to export.")
            return

        try:
            # Create exports directory if it doesn't exist
            export_dir = Path("exports")
            export_dir.mkdir(exist_ok=True)
            
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            filename = export_dir / f"medai_summary_{timestamp}.txt"
            
            with open(filename, "w", encoding="utf-8") as f:
                f.write(summary)
            
            messagebox.showinfo("Export Successful", f"Summary exported to:\n{filename.absolute()}")
        except Exception as e:
            messagebox.showerror("Export Error", f"Failed to export summary: {e}")

    def export_full_report(self):
        """Export the full analysis results to a JSON file."""
        if not self.current_results:
            messagebox.showwarning("No Data", "No analysis results to export.")
            return

        try:
            # Create exports directory if it doesn't exist
            export_dir = Path("exports")
            export_dir.mkdir(exist_ok=True)
            
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            filename = export_dir / f"medai_report_{timestamp}.json"
            
            # Use a custom encoder to handle numpy arrays if they exist
            class CustomJSONEncoder(json.JSONEncoder):
                def default(self, obj):
                    if isinstance(obj, np.ndarray):
                        return obj.tolist()
                    if isinstance(obj, (np.float32, np.float64)):
                        return float(obj)
                    return json.JSONEncoder.default(self, obj)

            with open(filename, "w", encoding="utf-8") as f:
                json.dump(self.current_results, f, indent=4, cls=CustomJSONEncoder)
            
            messagebox.showinfo("Export Successful", f"Full report exported to:\n{filename.absolute()}")
        except Exception as e:
            messagebox.showerror("Export Error", f"Failed to export full report: {e}")

    def view_cases(self):
        """Show modern case database window"""
        if not self.medai:
            messagebox.showwarning("System Not Ready", "MedAI is still loading.")
            return
        
        # Create new window
        cases_window = ctk.CTkToplevel(self.root)
        cases_window.title("MedAI Case Database")
        cases_window.geometry("1000x700")
        
        # Header
        header_label = ctk.CTkLabel(
            cases_window,
            text=f"📚 Case Database ({len(self.medai.cases_db)} cases)",
            font=ctk.CTkFont(size=24, weight="bold")
        )
        header_label.pack(pady=20)
        
        if not self.medai.cases_db:
            # No cases message
            no_cases_frame = ctk.CTkFrame(cases_window)
            no_cases_frame.pack(fill="both", expand=True, padx=20, pady=20)
            
            no_cases_label = ctk.CTkLabel(
                no_cases_frame,
                text="No cases in database yet.\nStart analyzing medical reports to build your case history!",
                font=ctk.CTkFont(size=16),
                justify="center"
            )
            no_cases_label.pack(expand=True)
            
        else:
            # Cases list in scrollable frame
            cases_frame = ctk.CTkScrollableFrame(cases_window)
            cases_frame.pack(fill="both", expand=True, padx=20, pady=(0, 20))
            
            # Create case cards
            for i, case in enumerate(self.medai.cases_db, 1):
                self.create_case_card(cases_frame, i, case)
        
        # Close button
        close_btn = ctk.CTkButton(
            cases_window,
            text="Close",
            command=cases_window.destroy,
            font=ctk.CTkFont(size=14, weight="bold")
        )
        close_btn.pack(pady=20)
    
    def create_case_card(self, parent, case_num, case):
        """Create a modern card for each case in the database"""
        
        # Card frame
        card = ctk.CTkFrame(parent, corner_radius=10)
        card.pack(fill="x", padx=10, pady=10)
        
        # Configure grid
        card.grid_columnconfigure(1, weight=1)
        
        # Case number and date
        date = case.get('timestamp', 'Unknown')[:10] if case.get('timestamp') != 'Unknown' else 'Unknown'
        header_text = f"Case #{case_num} • {date}"
        
        header_label = ctk.CTkLabel(
            card,
            text=header_text,
            font=ctk.CTkFont(size=14, weight="bold")
        )
        header_label.grid(row=0, column=0, columnspan=3, sticky="w", padx=15, pady=(15, 5))
        
        # Diagnosis
        diagnosis = case.get('diagnosis', 'Unknown').replace('_', ' ').title()
        diagnosis_label = ctk.CTkLabel(
            card,
            text=f"🔬 {diagnosis}",
            font=ctk.CTkFont(size=16, weight="bold"),
            text_color="#2980b9"
        )
        diagnosis_label.grid(row=1, column=0, columnspan=2, sticky="w", padx=15, pady=5)
        
        # Confidence
        confidence = case.get('confidence', 0)
        confidence_label = ctk.CTkLabel(
            card,
            text=f"{confidence:.0%}",
            font=ctk.CTkFont(size=14, weight="bold"),
            text_color="#27ae60" if confidence > 0.7 else "#f39c12"
        )
        confidence_label.grid(row=1, column=2, sticky="e", padx=15, pady=5)
        
        # Medical data summary
        medical_data = case.get('medical_data', {})
        if medical_data:
            summary_items = []
            for key, value in list(medical_data.items())[:4]:  # Show first 4 items
                param_name = key.replace('_', ' ').title()
                summary_items.append(f"{param_name}: {value}")
            
            summary_text = " • ".join(summary_items)
            if len(medical_data) > 4:
                summary_text += f" • +{len(medical_data) - 4} more"
            
            summary_label = ctk.CTkLabel(
                card,
                text=summary_text,
                font=ctk.CTkFont(size=12),
                wraplength=800
            )
            summary_label.grid(row=2, column=0, columnspan=3, sticky="w", padx=15, pady=(5, 15))
    
    def run(self):
        """Start the GUI application"""
        self.root.mainloop()


def main():
    """Main function to run the modern GUI"""
    app = MedAIModernGUI()
    app.run()


if __name__ == "__main__":
    main()