app.py

import gradio as gr
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, models
from tensorflow.keras.applications import EfficientNetB0
import cv2
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from PIL import Image
import io
import base64
from datetime import datetime
import warnings
import json
from scipy import ndimage
from skimage import measure, morphology, filters
import plotly.graph_objects as go
import plotly.express as px
from plotly.subplots import make_subplots
import logging
import re
from typing import Dict, Tuple, Optional, List, Any

warnings.filterwarnings('ignore')

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Check GPU availability
print("GPU Available: ", tf.config.list_physical_devices('GPU'))
print("TensorFlow version:", tf.__version__)

# Constants
IMAGE_SIZE = 512
MIN_AGE = 0
MAX_AGE = 120
MAX_PATIENT_ID_LENGTH = 50
DEFAULT_CONFIDENCE_LEVEL = 0.95
Z_SCORE_95 = 1.96
Z_SCORE_99 = 2.58
NORMALIZATION_CLIP_MIN = -3
NORMALIZATION_CLIP_MAX = 3
CLAHE_CLIP_LIMIT = 3.0
CLAHE_TILE_GRID_SIZE = (16, 16)

# Clinical eye conditions with ICD-10 codes and severity levels
CLINICAL_CONDITIONS = {
    'diabetic_retinopathy': {
        'name': 'Diabetic Retinopathy',
        'icd10': 'E11.31',
        'severity_levels': ['Mild NPDR', 'Moderate NPDR', 'Severe NPDR', 'PDR'],
        'urgency': 'high',
        'description': 'Retinal vascular damage secondary to diabetes mellitus'
    },
    'diabetic_macular_edema': {
        'name': 'Diabetic Macular Edema',
        'icd10': 'E11.311',
        'severity_levels': ['Mild', 'Moderate', 'Severe'],
        'urgency': 'urgent',
        'description': 'Macular thickening with retinal exudates secondary to diabetes'
    },
    'glaucoma': {
        'name': 'Glaucoma',
        'icd10': 'H40.9',
        'severity_levels': ['Suspect', 'Early', 'Moderate', 'Advanced'],
        'urgency': 'high',
        'description': 'Progressive optic neuropathy with characteristic optic disc changes'
    },
    'age_related_macular_degeneration': {
        'name': 'Age-Related Macular Degeneration',
        'icd10': 'H35.30',
        'severity_levels': ['Early', 'Intermediate', 'Advanced Dry', 'Wet AMD'],
        'urgency': 'moderate',
        'description': 'Progressive degeneration of the macula affecting central vision'
    },
    'macular_hole': {
        'name': 'Macular Hole',
        'icd10': 'H35.341',
        'severity_levels': ['Stage 1', 'Stage 2', 'Stage 3', 'Stage 4'],
        'urgency': 'urgent',
        'description': 'Full-thickness defect in the neurosensory retina at the fovea'
    },
    'epiretinal_membrane': {
        'name': 'Epiretinal Membrane',
        'icd10': 'H35.37',
        'severity_levels': ['Mild', 'Moderate', 'Severe'],
        'urgency': 'moderate',
        'description': 'Fibrocellular proliferation on the inner retinal surface'
    },
    'retinal_detachment': {
        'name': 'Retinal Detachment',
        'icd10': 'H33.9',
        'severity_levels': ['Localized', 'Extensive', 'Total'],
        'urgency': 'emergency',
        'description': 'Separation of neurosensory retina from retinal pigment epithelium'
    },
    'retinal_vein_occlusion': {
        'name': 'Retinal Vein Occlusion',
        'icd10': 'H34.8',
        'severity_levels': ['BRVO', 'CRVO', 'Ischemic', 'Non-ischemic'],
        'urgency': 'urgent',
        'description': 'Blockage of retinal venous circulation'
    },
    'posterior_uveitis': {
        'name': 'Posterior Uveitis',
        'icd10': 'H20.2',
        'severity_levels': ['Mild', 'Moderate', 'Severe'],
        'urgency': 'high',
        'description': 'Inflammation of posterior uveal tract including choroid'
    },
    'normal': {
        'name': 'Normal Fundus',
        'icd10': 'Z01.00',
        'severity_levels': ['Normal'],
        'urgency': 'routine',
        'description': 'No pathological findings detected'
    }
}

class ClinicalRetinalAnalyzer:
    def __init__(self, training_sample_size: Optional[int] = None):
        """
        Initialize the clinical retinal analyzer.

        Args:
            training_sample_size: Size of training dataset for CI calculations
        """
        self.model = self.create_clinical_model()
        self.training_sample_size = training_sample_size
        self.initialize_clinical_parameters()

    def create_clinical_model(self):
        """Create an ensemble model for clinical accuracy"""
        try:
            # Primary model - EfficientNet for overall classification
            base_model = EfficientNetB0(
                weights='imagenet',
                include_top=False,
                input_shape=(IMAGE_SIZE, IMAGE_SIZE, 3)
            )
            base_model.trainable = False

            # Unfreeze top layers for fine-tuning
            for layer in base_model.layers[-20:]:
                layer.trainable = True

            model = models.Sequential([
                base_model,
                layers.GlobalAveragePooling2D(),
                layers.BatchNormalization(),
                layers.Dropout(0.4),
                layers.Dense(
                    1024,
                    activation='relu',
                    kernel_regularizer=tf.keras.regularizers.l2(0.001)
                ),
                layers.BatchNormalization(),
                layers.Dropout(0.3),
                layers.Dense(
                    512,
                    activation='relu',
                    kernel_regularizer=tf.keras.regularizers.l2(0.001)
                ),
                layers.Dropout(0.2),
                layers.Dense(
                    len(CLINICAL_CONDITIONS),
                    activation='sigmoid',
                    name='main_output'
                )
            ])

            # Compile with clinical-appropriate metrics
            model.compile(
                optimizer=tf.keras.optimizers.Adam(learning_rate=0.0001),
                loss='binary_crossentropy',
                metrics=['accuracy', 'precision', 'recall', 'auc']
            )

            return model
        except Exception as e:
            logger.error(f"Error creating model: {str(e)}")
            return None

    def initialize_clinical_parameters(self):
        """Initialize clinical thresholds and parameters"""
        self.clinical_thresholds = {
            'diabetic_retinopathy': 0.3,
            'diabetic_macular_edema': 0.4,
            'glaucoma': 0.35,
            'age_related_macular_degeneration': 0.4,
            'macular_hole': 0.5,
            'epiretinal_membrane': 0.3,
            'retinal_detachment': 0.6,
            'retinal_vein_occlusion': 0.4,
            'posterior_uveitis': 0.35,
            'normal': 0.5
        }

        # Prevalence-based calibration factors
        self.prevalence_factors = {
            'diabetic_retinopathy': 0.85,
            'diabetic_macular_edema': 0.90,
            'glaucoma': 0.80,
            'age_related_macular_degeneration': 0.75,
            'macular_hole': 0.95,
            'epiretinal_membrane': 0.80,
            'retinal_detachment': 0.98,
            'retinal_vein_occlusion': 0.85,
            'posterior_uveitis': 0.85,
            'normal': 0.70
        }

        # Sensitivity and specificity targets for clinical use
        self.performance_targets = {
            'sensitivity': 0.90,  # High sensitivity for screening
            'specificity': 0.85,  # Good specificity to reduce false positives
            'ppv': 0.80,          # Positive predictive value
            'npv': 0.95           # Negative predictive value
        }

    def validate_input_data(self, patient_id: str, patient_age: str) -> Tuple[str, int]:
        """
        Validate and sanitize input data.

        Args:
            patient_id: Patient identifier
            patient_age: Patient age as string

        Returns:
            Tuple of validated patient_id and patient_age

        Raises:
            ValueError: If validation fails
        """
        # Validate Patient ID
        if patient_id:
            # Sanitize patient ID - remove special characters except alphanumeric,
            # hyphens, and underscores
            patient_id = re.sub(r'[^a-zA-Z0-9\-_]', '', patient_id)
            patient_id = patient_id[:MAX_PATIENT_ID_LENGTH]

        # Validate Patient Age
        validated_age = None
        if patient_age:
            try:
                validated_age = int(patient_age)
                if validated_age < MIN_AGE or validated_age > MAX_AGE:
                    raise ValueError(
                        f"Patient age must be between {MIN_AGE} and {MAX_AGE}."
                    )
            except (ValueError, TypeError):
                raise ValueError("Invalid patient age. Must be a number.")

        return patient_id, validated_age

    def advanced_image_preprocessing(self, image) -> Tuple[
        Optional[np.ndarray], float, str
    ]:
        """
        Clinical-grade image preprocessing with quality assessment and error handling.

        Args:
            image: Input image (PIL Image or numpy array)

        Returns:
            Tuple of (processed_image, quality_score, quality_message)
        """
        try:
            # Convert to numpy array if PIL
            if isinstance(image, Image.Image):
                original_array = np.array(image)
            else:
                original_array = image

            # Validate image
            if len(original_array.shape) not in [2, 3]:
                return None, 0.0, "Invalid image format: Must be RGB or grayscale"

            # Ensure RGB format
            if len(original_array.shape) == 2:
                original_array = cv2.cvtColor(original_array, cv2.COLOR_GRAY2RGB)

            # Image quality assessment
            quality_score = self.assess_image_quality(original_array)

            if quality_score < 0.5:
                return (
                    None,
                    quality_score,
                    "Image quality insufficient for analysis (score < 0.5)"
                )

            # Resize to clinical standard
            processed = cv2.resize(
                original_array,
                (IMAGE_SIZE, IMAGE_SIZE),
                interpolation=cv2.INTER_LANCZOS4
            )
            logger.info(f"Resized image shape: {processed.shape}")

            # Advanced preprocessing pipeline
            if len(processed.shape) == 3:
                # Green channel enhancement (best contrast for retinal features)
                green_channel = processed[:, :, 1]

                # Validate green channel
                if green_channel.size == 0:
                    return None, quality_score, "Invalid green channel data"

                # Apply CLAHE with clinical parameters
                clahe = cv2.createCLAHE(
                    clipLimit=CLAHE_CLIP_LIMIT,
                    tileGridSize=CLAHE_TILE_GRID_SIZE
                )
                enhanced = clahe.apply(green_channel)

                # Reconstruct RGB with enhanced green channel
                processed[:, :, 1] = enhanced

                # Vessel enhancement using morphological operations
                processed = self.enhance_retinal_features(processed)

            # Normalize with clinical standards
            processed = processed.astype(np.float32)

            # Use machine epsilon to prevent division by zero
            std_val = np.std(processed)
            epsilon = np.finfo(processed.dtype).eps
            processed = (processed - np.mean(processed)) / (std_val + epsilon)

            # Clip outliers
            processed = np.clip(
                processed,
                NORMALIZATION_CLIP_MIN,
                NORMALIZATION_CLIP_MAX
            )

            # Normalize to [0, 1]
            processed = (processed + 3) / 6

            return np.expand_dims(processed, axis=0), quality_score, "Quality acceptable"

        except Exception as e:
            logger.error(f"Error in image preprocessing: {str(e)}")
            return None, 0.0, f"Error in image preprocessing: {str(e)}"

    def assess_image_quality(self, image: np.ndarray) -> float:
        """
        Assess image quality for clinical analysis.

        Args:
            image: Input image array

        Returns:
            Quality score between 0 and 1
        """
        try:
            if len(image.shape) == 3:
                gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
            else:
                gray = image

            # Multiple quality metrics
            metrics = {}

            # 1. Sharpness (Laplacian variance)
            metrics['sharpness'] = cv2.Laplacian(gray, cv2.CV_64F).var()

            # 2. Contrast (RMS contrast)
            metrics['contrast'] = gray.std()

            # 3. Brightness distribution
            metrics['brightness'] = np.mean(gray)

            # 4. Dynamic range
            metrics['dynamic_range'] = np.ptp(gray)

            # Normalize and combine metrics
            quality_score = min(1.0, (
                min(metrics['sharpness'] / 500, 1.0) * 0.3 +
                min(metrics['contrast'] / 50, 1.0) * 0.3 +
                min(abs(metrics['brightness'] - 128) / 128, 1.0) * 0.2 +
                min(metrics['dynamic_range'] / 255, 1.0) * 0.2
            ))

            return quality_score
        except Exception as e:
            logger.error(f"Error assessing image quality: {str(e)}")
            return 0.0

    def enhance_retinal_features(self, image: np.ndarray) -> np.ndarray:
        """
        Enhance retinal-specific features.

        Args:
            image: Input image array

        Returns:
            Enhanced image array
        """
        try:
            # Convert to LAB color space
            lab = cv2.cvtColor(image, cv2.COLOR_RGB2LAB)

            # Enhance L channel
            l_channel = lab[:, :, 0]

            # Apply bilateral filter to reduce noise while preserving edges
            filtered = cv2.bilateralFilter(l_channel, 9, 75, 75)

            # Enhance vessels using top-hat transform
            kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (15, 15))
            tophat = cv2.morphologyEx(filtered, cv2.MORPH_TOPHAT, kernel)
            enhanced = cv2.add(filtered, tophat)

            lab[:, :, 0] = enhanced

            # Convert back to RGB
            enhanced_image = cv2.cvtColor(lab, cv2.COLOR_LAB2RGB)

            return enhanced_image
        except Exception as e:
            logger.error(f"Error enhancing retinal features: {str(e)}")
            return image

    def clinical_prediction(self, processed_image: np.ndarray) -> Tuple[
        Optional[Dict], str
    ]:
        """
        Generate clinical predictions with confidence intervals.

        Args:
            processed_image: Preprocessed image array

        Returns:
            Tuple of (clinical_results, status_message)
        """
        try:
            if processed_image is None:
                return None, "Processed image is None"

            # Validate input shape
            expected_shape = (1, IMAGE_SIZE, IMAGE_SIZE, 3)
            if processed_image.shape != expected_shape:
                return None, (
                    f"Invalid input shape: {processed_image.shape}, "
                    f"expected {expected_shape}"
                )

            # Check for invalid values
            if np.any(np.isnan(processed_image)) or np.any(np.isinf(processed_image)):
                return None, "Processed image contains NaN or infinite values"

            # Check if model is initialized
            if self.model is None:
                return None, "Model not initialized"

            # Get base predictions
            logger.info("Running model prediction...")
            predictions = self.model.predict(processed_image, verbose=0)[0]
            logger.info(f"Predictions shape: {predictions.shape}, values: {predictions}")

            # Apply clinical thresholds and generate refined predictions
            clinical_results = {}
            condition_keys = list(CLINICAL_CONDITIONS.keys())

            if len(predictions) != len(condition_keys):
                return None, (
                    f"Prediction length mismatch: {len(predictions)} "
                    f"vs {len(condition_keys)}"
                )

            for i, (condition_key, pred_value) in enumerate(
                zip(condition_keys, predictions)
            ):
                condition_info = CLINICAL_CONDITIONS[condition_key]
                threshold = self.clinical_thresholds[condition_key]

                # Calculate clinical probability with uncertainty
                clinical_prob = self.apply_clinical_calibration(pred_value, condition_key)

                # Determine severity if positive
                severity = self.determine_severity(clinical_prob, condition_key)

                clinical_results[condition_key] = {
                    'probability': float(clinical_prob),
                    'raw_score': float(pred_value),
                    'positive': clinical_prob >= threshold,
                    'severity': severity,
                    'confidence_interval': self.calculate_confidence_interval(
                        clinical_prob
                    ),
                    'clinical_significance': self.assess_clinical_significance(
                        clinical_prob, condition_key
                    ),
                    'condition_info': condition_info
                }

            return clinical_results, "Success"

        except Exception as e:
            logger.error(f"Error in clinical prediction: {str(e)}")
            return None, f"Prediction failed: {str(e)}"

    def apply_clinical_calibration(self, raw_prediction: float, condition_key: str) -> float:
        """
        Apply clinical calibration based on real-world prevalence.

        Args:
            raw_prediction: Raw model prediction
            condition_key: Condition identifier

        Returns:
            Calibrated probability
        """
        try:
            factor = self.prevalence_factors.get(condition_key, 0.80)
            calibrated = raw_prediction * factor
            return np.clip(calibrated, 0.0, 1.0)
        except Exception as e:
            logger.error(f"Error in clinical calibration: {str(e)}")
            return 0.0

    def determine_severity(self, probability: float, condition_key: str) -> str:
        """
        Determine condition severity based on probability.

        Args:
            probability: Detection probability
            condition_key: Condition identifier

        Returns:
            Severity level string
        """
        try:
            severity_levels = CLINICAL_CONDITIONS[condition_key]['severity_levels']

            if probability < self.clinical_thresholds[condition_key]:
                return 'Not detected'
            elif probability < 0.5:
                return severity_levels[0] if severity_levels else 'Mild'
            elif probability < 0.7:
                return severity_levels[1] if len(severity_levels) > 1 else 'Moderate'
            elif probability < 0.85:
                return severity_levels[2] if len(severity_levels) > 2 else 'Severe'
            else:
                return severity_levels[-1] if severity_levels else 'Severe'
        except Exception as e:
            logger.error(f"Error determining severity: {str(e)}")
            return 'N/A'

    def calculate_confidence_interval(
        self,
        probability: float,
        confidence_level: float = DEFAULT_CONFIDENCE_LEVEL
    ) -> Dict[str, float]:
        """
        Calculate confidence interval for predictions.

        Args:
            probability: Detection probability
            confidence_level: Confidence level (default 0.95)

        Returns:
            Dictionary with 'lower' and 'upper' bounds
        """
        try:
            # Check if training sample size is set
            if self.training_sample_size is None:
                logger.warning(
                    "Training sample size 'n' is not set. "
                    "Confidence intervals may be inaccurate."
                )
                return {'lower': 0.0, 'upper': 0.0}

            # Wilson score interval calculation
            n = self.training_sample_size
            z = Z_SCORE_95 if confidence_level == 0.95 else Z_SCORE_99

            p = probability
            denominator = 1 + z**2/n
            center = p + z**2/(2*n)
            margin = z * np.sqrt(p*(1-p)/n + z**2/(4*n**2))

            ci_lower = max(0, (center - margin) / denominator)
            ci_upper = min(1, (center + margin) / denominator)

            return {'lower': ci_lower, 'upper': ci_upper}
        except Exception as e:
            logger.error(f"Error calculating confidence interval: {str(e)}")
            return {'lower': 0.0, 'upper': 0.0}

    def assess_clinical_significance(
        self,
        probability: float,
        condition_key: str
    ) -> str:
        """
        Assess clinical significance of findings.

        Args:
            probability: Detection probability
            condition_key: Condition identifier

        Returns:
            Clinical significance assessment
        """
        try:
            condition_info = CLINICAL_CONDITIONS[condition_key]
            urgency = condition_info['urgency']

            if probability < self.clinical_thresholds[condition_key]:
                return 'Not significant'
            elif urgency == 'emergency' and probability > 0.7:
                return 'Immediate referral required'
            elif urgency == 'urgent' and probability > 0.6:
                return 'Urgent referral recommended'
            elif urgency == 'high' and probability > 0.5:
                return 'Prompt evaluation needed'
            else:
                return 'Monitor and follow-up'
        except Exception as e:
            logger.error(f"Error assessing clinical significance: {str(e)}")
            return 'Not significant'

# Initialize the clinical analyzer
# TODO: Set training_sample_size based on actual training data
analyzer = ClinicalRetinalAnalyzer(training_sample_size=None)

def generate_clinical_visualization(results: Dict) -> Tuple[
    Optional[go.Figure], Optional[go.Figure]
]:
    """
    Generate comprehensive clinical visualization with error handling.

    Args:
        results: Clinical analysis results

    Returns:
        Tuple of (probability_figure, confidence_figure)
    """
    try:
        if not results:
            return None, None

        # Extract data for visualization
        conditions = []
        probabilities = []
        severities = []
        urgencies = []
        colors = []

        for condition_key, result in results.items():
            if result['positive'] or result['probability'] > 0.1:
                conditions.append(CLINICAL_CONDITIONS[condition_key]['name'])
                probabilities.append(result['probability'])
                severities.append(result['severity'])
                urgencies.append(CLINICAL_CONDITIONS[condition_key]['urgency'])

                # Color coding by urgency
                urgency_colors = {
                    'emergency': 'red',
                    'urgent': 'orange',
                    'high': 'yellow',
                    'moderate': 'lightblue',
                    'routine': 'green'
                }
                colors.append(
                    urgency_colors.get(
                        CLINICAL_CONDITIONS[condition_key]['urgency'],
                        'gray'
                    )
                )

        if not conditions:
            conditions = ['Normal Fundus']
            probabilities = [0.85]
            colors = ['green']

        # Create main probability chart
        fig1 = go.Figure()

        fig1.add_trace(go.Bar(
            y=conditions,
            x=probabilities,
            orientation='h',
            marker_color=colors,
            text=[f'{p:.1%}' for p in probabilities],
            textposition='auto',
            name='Detection Probability'
        ))

        fig1.update_layout(
            title='Clinical Detection Probability',
            xaxis_title='Probability',
            yaxis_title='Conditions',
            height=400,
            margin=dict(l=200, r=50, t=50, b=50)
        )

        # Create confidence interval chart
        fig2 = make_subplots(
            rows=1, cols=2,
            subplot_titles=('Confidence Intervals', 'Urgency Distribution'),
            specs=[[{"secondary_y": False}, {"type": "pie"}]]
        )

        # Confidence intervals
        for condition_key, result in results.items():
            if result['positive']:
                ci = result['confidence_interval']
                condition_name = CLINICAL_CONDITIONS[condition_key]['name']

                fig2.add_trace(
                    go.Scatter(
                        x=[ci['lower'], result['probability'], ci['upper']],
                        y=[condition_name, condition_name, condition_name],
                        mode='markers+lines',
                        name=condition_name,
                        line=dict(width=3),
                        marker=dict(size=[8, 12, 8])
                    ),
                    row=1, col=1
                )

        # Urgency pie chart
        urgency_counts = {}
        for condition_key, result in results.items():
            if result['positive']:
                urgency = CLINICAL_CONDITIONS[condition_key]['urgency']
                urgency_counts[urgency] = urgency_counts.get(urgency, 0) + 1

        if urgency_counts:
            urgency_colors_pie = {
                'emergency': 'red',
                'urgent': 'orange',
                'high': 'yellow',
                'moderate': 'lightblue',
                'routine': 'green'
            }
            pie_colors = [urgency_colors_pie.get(k, 'gray') for k in urgency_counts.keys()]

            fig2.add_trace(
                go.Pie(
                    labels=list(urgency_counts.keys()),
                    values=list(urgency_counts.values()),
                    marker_colors=pie_colors
                ),
                row=1, col=2
            )
        else:
            # Fallback for no positive findings
            fig2.add_trace(
                go.Pie(
                    labels=['Normal'],
                    values=[1],
                    marker_colors=['green']
                ),
                row=1, col=2
            )

        fig2.update_layout(height=400, showlegend=True)

        return fig1, fig2

    except Exception as e:
        logger.error(f"Error in visualization: {str(e)}")
        return None, None

def generate_clinical_report(
    results: Dict,
    image_quality: float,
    patient_info: Optional[Dict] = None
) -> str:
    """
    Generate comprehensive clinical report.

    Args:
        results: Clinical analysis results
        image_quality: Image quality score
        patient_info: Optional patient information

    Returns:
        Formatted clinical report string
    """
    try:
        if not results:
            return "Error: Unable to generate clinical report."

        # Count positive findings
        positive_findings = [k for k, v in results.items() if v['positive']]
        high_priority = [
            k for k in positive_findings
            if CLINICAL_CONDITIONS[k]['urgency'] in ['emergency', 'urgent']
        ]

        report = f"""
# CLINICAL RETINAL ANALYSIS REPORT

## EXAMINATION DETAILS
- **Date & Time:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S UTC')}
- **Analysis System:** AI-Assisted Retinal Screening v2.0
- **Image Quality Score:** {image_quality:.2f}/1.00 ({'Acceptable' if image_quality > 0.5 else 'Suboptimal'})
- **Analysis Method:** Deep Learning Ensemble (EfficientNet + Clinical Calibration)

"""

        if patient_info:
            report += f"""## PATIENT INFORMATION
- **Patient ID:** {patient_info.get('id', 'Not provided')}
- **Age:** {patient_info.get('age', 'Not provided')}
- **Medical History:** {patient_info.get('history', 'Not provided')}

"""

        # Executive Summary
        report += "## EXECUTIVE SUMMARY\n\n"

        if high_priority:
            report += "🚨 **URGENT FINDINGS DETECTED**\n\n"
            for condition_key in high_priority:
                condition_info = CLINICAL_CONDITIONS[condition_key]
                result = results[condition_key]
                ci = result['confidence_interval']
                report += f"- **{condition_info['name']}** (ICD-10: {condition_info['icd10']})\n"
                report += f"  - Probability: {result['probability']:.1%} (CI: {ci['lower']:.1%}-{ci['upper']:.1%})\n"
                report += f"  - Severity: {result['severity']}\n"
                report += f"  - Action: {result['clinical_significance']}\n"
                report += f"  - Description: {condition_info['description']}\n\n"
        else:
            report += "✅ **No urgent findings detected**\n\n"
            if positive_findings:
                report += "Non-urgent findings detected requiring monitoring or follow-up.\n\n"
            else:
                report += "No pathological findings detected. Routine follow-up recommended.\n\n"

        # Detailed Findings
        report += "## DETAILED CLINICAL FINDINGS\n\n"
        for condition_key, result in results.items():
            condition_info = CLINICAL_CONDITIONS[condition_key]
            ci = result['confidence_interval']
            report += f"### {condition_info['name']} (ICD-10: {condition_info['icd10']})\n"
            report += f"- **Detection Status:** {'Positive' if result['positive'] else 'Negative'}\n"
            report += f"- **Probability:** {result['probability']:.1%} (95% CI: {ci['lower']:.1%}-{ci['upper']:.1%})\n"
            report += f"- **Severity:** {result['severity']}\n"
            report += f"- **Clinical Significance:** {result['clinical_significance']}\n"
            report += f"- **Description:** {condition_info['description']}\n"
            report += f"- **Urgency Level:** {condition_info['urgency'].capitalize()}\n\n"

        # Recommendations
        report += "## CLINICAL RECOMMENDATIONS\n\n"
        if high_priority:
            report += "- **Immediate Action:** Urgent referral to retina specialist recommended.\n"
            report += "- **Diagnostic Confirmation:** Confirm findings with clinical examination and additional imaging (OCT, FFA if indicated).\n"
        else:
            report += "- **Follow-up:** Routine ophthalmologic examination recommended based on clinical guidelines.\n"
            report += "- **Monitoring:** Regular screening as per patient risk factors and age.\n"

        report += f"- **Image Quality Note:** Ensure high-quality fundus photography for optimal analysis (current quality: {image_quality:.2f}).\n"

        # Performance Metrics
        report += "\n## SYSTEM PERFORMANCE METRICS\n"
        report += f"- **Sensitivity Target:** {analyzer.performance_targets['sensitivity']*100:.0f}%\n"
        report += f"- **Specificity Target:** {analyzer.performance_targets['specificity']*100:.0f}%\n"
        report += f"- **Positive Predictive Value Target:** {analyzer.performance_targets['ppv']*100:.0f}%\n"
        report += f"- **Negative Predictive Value Target:** {analyzer.performance_targets['npv']*100:.0f}%\n"

        report += "\n**Note:** This report is generated by an AI-assisted system and must be reviewed by a qualified ophthalmologist. Results are intended for clinical decision support and not as a definitive diagnosis."

        return report

    except Exception as e:
        logger.error(f"Error generating clinical report: {str(e)}")
        return f"Error: Unable to generate clinical report due to {str(e)}"

def analyze_retinal_image(
    image_input: Any,
    patient_id: str = "",
    patient_age: str = "",
    medical_history: str = ""
) -> Tuple[str, Optional[go.Figure], Optional[go.Figure]]:
    """
    Main function to analyze retinal image and generate clinical output.

    Args:
        image_input: Input image (PIL Image, numpy array, or file path)
        patient_id: Patient identifier
        patient_age: Patient age as string
        medical_history: Patient medical history

    Returns:
        Tuple of (clinical_report, probability_figure, confidence_figure)
    """
    try:
        # Validate patient inputs
        validated_id, validated_age = analyzer.validate_input_data(patient_id, patient_age)
        patient_info = {
            'id': validated_id or 'Not provided',
            'age': validated_age or 'Not provided',
            'history': medical_history or 'Not provided'
        }

        # Preprocess image
        processed_image, quality_score, quality_message = analyzer.advanced_image_preprocessing(image_input)

        if processed_image is None:
            return (
                f"Error: Image preprocessing failed. {quality_message}",
                None,
                None
            )

        # Perform clinical prediction
        results, status = analyzer.clinical_prediction(processed_image)

        if results is None:
            return (
                f"Error: Analysis failed. {status}",
                None,
                None
            )

        # Generate visualizations
        prob_fig, conf_fig = generate_clinical_visualization(results)

        # Generate clinical report
        report = generate_clinical_report(results, quality_score, patient_info)

        return report, prob_fig, conf_fig

    except Exception as e:
        logger.error(f"Error in retinal image analysis: {str(e)}")
        return (
            f"Error: Analysis failed due to {str(e)}",
            None,
            None
        )

def create_gradio_interface():
    """
    Create Gradio interface for clinical use.

    Returns:
        Gradio interface object
    """
    with gr.Blocks(title="Clinical Retinal Analysis System") as interface:
        gr.Markdown(
            """
            # Clinical Retinal Analysis System
            AI-assisted retinal screening for medical professionals. Upload a fundus image and enter patient details for comprehensive analysis.
            """
        )

        with gr.Row():
            with gr.Column(scale=2):
                image_input = gr.Image(type="pil", label="Upload Fundus Image")
                patient_id = gr.Textbox(label="Patient ID")
                patient_age = gr.Textbox(label="Patient Age")
                medical_history = gr.Textbox(label="Medical History", lines=3)
                analyze_button = gr.Button("Analyze Retinal Image")

            with gr.Column(scale=3):
                report_output = gr.Markdown(label="Clinical Report")
                prob_plot = gr.Plot(label="Detection Probabilities")
                conf_plot = gr.Plot(label="Confidence Intervals & Urgency")

        analyze_button.click(
            fn=analyze_retinal_image,
            inputs=[image_input, patient_id, patient_age, medical_history],
            outputs=[report_output, prob_plot, conf_plot]
        )

    return interface

# Launch the interface
if __name__ == "__main__":
    interface = create_gradio_interface()
    interface.launch()