Update app.py

app.py

@@ -1,685 +1,882 @@
 #!/usr/bin/env python3
+import importlib.util
 import os
 import sys
-import traceback
-from typing import Optional, Tuple, Dict, Any, List
-import warnings
-
-import importlib.util
 import time
 import cv2
 import torch
 import numpy as np
 import gradio as gr
-from PIL import Image, ImageOps
+from PIL import Image
+from torchvision import transforms
 import torch.nn as nn
 import torch.nn.functional as F
+import traceback
+from torchvision.models import vit_b_16
 from transformers import AutoModel, CLIPImageProcessor
 import joblib
+import zipfile
 import json
+from datetime import datetime
+import base64
+import io
 
-# Suppress warnings
-warnings.filterwarnings("ignore", message="Couldn't find the key")
-warnings.filterwarnings("ignore", category=UserWarning)
+# Add current directory to path
+if not os.getcwd() in sys.path:
+    sys.path.append(os.getcwd())
 
-# --------------------------------------------------------------------------------------
-# Environment Setup
-# --------------------------------------------------------------------------------------
+# Check if detectron2 is installed and attempt installation if needed
+if importlib.util.find_spec("detectron") is None:
+    print("🔄 Detectron2 not found. Attempting installation...")
+    print("Installing PyTorch and Detectron2...")
+    os.system("pip install torch torchvision --extra-index-url https://download.pytorch.org/whl/cpu")
+    os.system("pip install git+https://github.com/facebookresearch/detectron2.git")
+    print("Installation complete!")
 
-# Check for Detectron2
+# Optional Detectron2 import
 DETECTRON2_AVAILABLE = False
 try:
+    print("Attempting to import Detectron2...")
     from detectron2.engine import DefaultPredictor
     from detectron2.config import get_cfg
+    from detectron2.utils.visualizer import Visualizer, ColorMode
     from detectron2 import model_zoo
+
     DETECTRON2_AVAILABLE = True
-    print("✅ Detectron2 available")
-except ImportError:
-    print("⚠️ Detectron2 not available - Stage 1 will use simulator")
+    print("✅ Detectron2 imported successfully")
+except ImportError as e:
+    print(f"⚠️ Detectron2 not available: {e}")
+    DETECTRON2_AVAILABLE = False
 
-# Download classifier from HF if available
+# Try to download model from Hugging Face
 huggingface_model_path = None
 try:
     from huggingface_hub import hf_hub_download
-    
-    repo = os.getenv('PRIVATE_REPO', 'fallback')
-    token = os.getenv('key')
-    
-    if repo != 'fallback' and token:
-        huggingface_model_path = hf_hub_download(
-            repo_id=repo,
-            filename="V1.pkl",
-            token=token
-        )
-        print(f"✅ Classifier downloaded: {huggingface_model_path}")
+
+    # Try to download from your repository
+    huggingface_model_path = hf_hub_download(
+        repo_id=os.getenv('PRIVATE_REPO', 'fallback'),
+        filename="V1.pkl",
+        token=os.getenv('key')
+    )
+    print(f"✅ Model downloaded from Hugging Face: {huggingface_model_path}")
 except Exception as e:
-    print(f"⚠️ Could not download classifier: {e}")
+    print(f"⚠️ Could not download model from Hugging Face: {e}")
+    print("🔄 Will use demo mode with simulated results")
+    huggingface_model_path = None
+
+# Define model paths - SEQUENTIAL PIPELINE
+DEFAULT_DAMAGE_MODEL_PATH = "./output/model_final.pth"  # zone detection (Stage 1)
+DEFAULT_AI_DETECTION_MODEL_PATH = "./output/V1.pkl"  # AI detection (Stage 2)
 
-# Device setup
+# Initialize device for model
 if torch.backends.mps.is_available():
-    DEVICE = torch.device("mps")
-    print("🖥️ Using MPS (Metal Performance Shaders)")
+    RADIO_DEVICE = torch.device("mps")
 elif torch.cuda.is_available():
-    DEVICE = torch.device("cuda")
-    print("🖥️ Using CUDA")
+    RADIO_DEVICE = torch.device("cuda")
 else:
-    DEVICE = torch.device("cpu")
-    print("🖥️ Using CPU")
+    RADIO_DEVICE = torch.device("cpu")
 
-# --------------------------------------------------------------------------------------
-# Global Models
-# --------------------------------------------------------------------------------------
-
-image_processor = None
-radio_model = None
+# Global variables for C model
+radio_l_image_processor = None
+radio_l_model = None
 ai_detection_classifier = None
-_preloaded = False
 
-# Default paths
-DEFAULT_AI_DETECTION_MODEL_PATH = "./output/V1.pkl"
-DEFAULT_DAMAGE_MODEL_PATH = "./output/model_final.pth"
+# Maximum number of tries allowed per user per day
+MAX_TRIES = 10
 
-# --------------------------------------------------------------------------------------
-# C-RADIOv3-g Model Loading (matching your working implementation)
-# --------------------------------------------------------------------------------------
+# JavaScript for cookie management - Version corrigée
+COOKIE_JAVASCRIPT = """
+<script>
+// Cookie management functions for HEDI
+function setCookie(name, value, days = 1) {
+    try {
+        const expires = new Date();
+        expires.setTime(expires.getTime() + (days * 24 * 60 * 60 * 1000));
+        document.cookie = name + '=' + value + ';expires=' + expires.toUTCString() + ';path=/;SameSite=Lax';
+        console.log('✅ Cookie set:', name, '=', value);
+        return true;
+    } catch (e) {
+        console.error('❌ Error setting cookie:', e);
+        return false;
+    }
+}
+function getCookie(name) {
+    try {
+        const nameEQ = name + '=';
+        const ca = document.cookie.split(';');
+        for(let i = 0; i < ca.length; i++) {
+            let c = ca[i];
+            while (c.charAt(0) == ' ') c = c.substring(1, c.length);
+            if (c.indexOf(nameEQ) == 0) {
+                const value = c.substring(nameEQ.length, c.length);
+                console.log('📖 Cookie read:', name, '=', value);
+                return value;
+            }
+        }
+        console.log('📖 Cookie not found:', name);
+        return null;
+    } catch (e) {
+        console.error('❌ Error reading cookie:', e);
+        return null;
+    }
+}
+function getHediUsage() {
+    try {
+        console.log('🔍 Getting HEDI usage...');
+        const today = new Date().toISOString().split('T')[0]; // YYYY-MM-DD
+        const lastDate = getCookie('hedi_last_date');
 
-def preload_radio_model():
-    """Load C-RADIOv3-g model for feature extraction"""
-    global image_processor, radio_model, _preloaded
-    
-    if _preloaded:
-        print("✅ Models already loaded")
-        return True
-    
+        // Daily reset
+        if (lastDate !== today) {
+            console.log('🔄 Daily reset detected: ' + lastDate + ' → ' + today);
+            setCookie('hedi_usage_count', '0', 1);
+            setCookie('hedi_last_date', today, 1);
+            console.log('✅ Usage reset to 0');
+            return 0;
+        }
+
+        const usage = parseInt(getCookie('hedi_usage_count') || '0');
+        console.log('🍪 Current usage from cookies: ' + usage + '/10');
+        return usage;
+    } catch (e) {
+        console.error('❌ Error getting usage from cookies:', e);
+        return 0;
+    }
+}
+function saveHediUsage(count) {
+    try {
+        console.log('💾 Saving usage to cookies:', count);
+        const today = new Date().toISOString().split('T')[0];
+        const success1 = setCookie('hedi_usage_count', count.toString(), 1);
+        const success2 = setCookie('hedi_last_date', today, 1);
+
+        if (success1 && success2) {
+            console.log('✅ Usage saved successfully: ' + count + '/10');
+            return true;
+        } else {
+            console.error('❌ Failed to save usage');
+            return false;
+        }
+    } catch (e) {
+        console.error('❌ Error saving usage to cookies:', e);
+        return false;
+    }
+}
+// Expose functions globally
+window.hediCookies = {
+    getUsage: function() {
+        try {
+            return getHediUsage();
+        } catch (e) {
+            console.error('Fallback: Error in getUsage', e);
+            return 0;
+        }
+    },
+    saveUsage: function(count) {
+        try {
+            return saveHediUsage(count);
+        } catch (e) {
+            console.error('Fallback: Error in saveUsage', e);
+            return false;
+        }
+    }
+};
+// Initialize immediately
+console.log('🍪 HEDI Cookies loading...');
+try {
+    const initialUsage = getHediUsage();
+    console.log('🍪 HEDI Cookies initialized with usage:', initialUsage);
+} catch (e) {
+    console.error('❌ Error during initialization:', e);
+}
+</script>
+"""
+
+
+def get_usage_display_html(usage_count):
+    """Generate usage display HTML with cookies info"""
+    usage_percent = (usage_count / MAX_TRIES) * 100
+    color = "#dc2626" if usage_count >= MAX_TRIES else "#2563eb" if usage_count < 7 else "#f59e0b"
+
+    return f"""
+    <div id="usage-display" style="background: white; border: 1px solid #e5e7eb; padding: 15px; border-radius: 8px;">
+        <div style="display: flex; justify-content: space-between; margin-bottom: 10px;">
+            <span>Daily Usage:</span>
+            <span style="background: #dbeafe; color: #1e40af; padding: 2px 8px; border-radius: 12px;">{usage_count}/{MAX_TRIES}</span>
+        </div>
+        <div style="background: #e5e7eb; height: 6px; border-radius: 3px;">
+            <div style="background: {color}; height: 6px; border-radius: 3px; width: {usage_percent}%; transition: width 0.3s;"></div>
+        </div>
+        <div style="font-size: 12px; color: #6b7280; margin-top: 5px; text-align: center;">
+            {'⚠️ Daily limit reached!' if usage_count >= MAX_TRIES else f'✅ {MAX_TRIES - usage_count} remaining' if usage_count < MAX_TRIES else ''}
+        </div>
+    </div>
+    """
+
+
+def preload_models():
+    """Preload models at startup to improve response time"""
+    global radio_l_image_processor, radio_l_model
+
+    print("🔄 Preloading C model...")
     try:
-        # Use C-RADIOv3-g (not v3-B!)
-        hf_repo = os.getenv('MODEL_REPO', 'nvidia/C-RADIOv3-g')
-        if hf_repo == 'fallback':
-            hf_repo = 'nvidia/C-RADIOv3-g'
-        
-        print(f"���� Loading {hf_repo}...")
-        
-        # Load image processor
-        image_processor = CLIPImageProcessor.from_pretrained(hf_repo)
-        
-        # Load model with trust_remote_code
-        radio_model = AutoModel.from_pretrained(hf_repo, trust_remote_code=True)
-        radio_model = radio_model.to(DEVICE)
-        radio_model.eval()
-        
-        print(f"✅ {hf_repo} loaded successfully")
-        _preloaded = True
-        return True
-        
-    except KeyError as ke:
-        if "ls1.gamma" in str(ke) or "ls1.grandma" in str(ke):
-            print(f"⚠️ Known layer scaling issue, trying workaround...")
-            
-            # Try with low_cpu_mem_usage=False
-            try:
-                radio_model = AutoModel.from_pretrained(
-                    hf_repo, 
-                    trust_remote_code=True,
-                    low_cpu_mem_usage=False
-                )
-                radio_model = radio_model.to(DEVICE)
-                radio_model.eval()
-                _preloaded = True
-                print("✅ Loaded with workaround")
-                return True
-            except:
-                pass
-                
+        hf_repo = os.getenv('MODEL_REPO', 'fallback')
+        if hf_repo and hf_repo != 'fallback':
+            from transformers import AutoModel, CLIPImageProcessor
+            radio_l_image_processor = CLIPImageProcessor.from_pretrained(hf_repo)
+            radio_l_model = AutoModel.from_pretrained(hf_repo, trust_remote_code=True)
+            radio_l_model = radio_l_model.to(RADIO_DEVICE)
+            radio_l_model.eval()
+            print("✅ C model preloaded successfully!")
+            return True
     except Exception as e:
-        print(f"❌ Failed to load RADIO model: {e}")
-    
-    # Fallback to CLIP if needed
+        print(f"⚠️ Could not preload C model: {e}")
+    return False
+
+
+def setup_device(device_str):
+    """Set up computation device"""
+    if device_str == 'auto':
+        if torch.cuda.is_available():
+            return torch.device('cuda:0')
+        elif hasattr(torch, 'backends') and hasattr(torch.backends, 'mps') and torch.backends.mps.is_available():
+            return torch.device('mps')
+        else:
+            return torch.device('cpu')
+    elif device_str == 'cuda' and torch.cuda.is_available():
+        return torch.device('cuda:0')
+    elif device_str == 'mps' and hasattr(torch, 'backends') and hasattr(torch.backends,
+                                                                        'mps') and torch.backends.mps.is_available():
+        return torch.device('mps')
+    else:
+        return torch.device('cpu')
+
+
+def load_detectron2_damage_model(model_path, device):
+    """Load fine-tuned Detectron2 model for damage detection (Stage 1)"""
+    if not DETECTRON2_AVAILABLE:
+        print("❌ Detectron2 not available")
+        return None
+
+    if model_path is None or not os.path.exists(model_path):
+        print(f"❌ Damage model not found at: {model_path}")
+        return None
+
     try:
-        print("📦 Trying fallback CLIP model...")
-        from transformers import CLIPModel, CLIPProcessor
-        
-        clip_model = "openai/clip-vit-base-patch32"
-        image_processor = CLIPProcessor.from_pretrained(clip_model)
-        radio_model = CLIPModel.from_pretrained(clip_model)
-        radio_model = radio_model.to(DEVICE)
-        radio_model.eval()
-        
-        print("✅ Using CLIP fallback (Note: results may differ)")
-        _preloaded = True
+        cfg = get_cfg()
+        cfg.merge_from_file(model_zoo.get_config_file("COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"))
+        cfg.MODEL.WEIGHTS = model_path
+        cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5
+        cfg.MODEL.DEVICE = str(device)
+
+        # Adjust number of classes if needed (update based on your fine-tuned model)
+        cfg.MODEL.ROI_HEADS.NUM_CLASSES = 1  # Assuming binary damage detection
+
+        predictor = DefaultPredictor(cfg)
+        print("✅ Detectron2 damage detection model loaded successfully")
+        return predictor
+    except Exception as e:
+        print(f"❌ Error loading Detectron2 model: {e}")
+        return None
+
+
+def initialize_radiov3_model():
+    """Initialize the model for feature extraction"""
+    global radio_l_image_processor, radio_l_model
+
+    # Check if already loaded
+    if radio_l_image_processor is not None and radio_l_model is not None:
+        print("✅ C model already loaded, reusing...")
+        return True
+
+    try:
+        print("🔄 Loading model C...")
+        hf_repo = os.getenv('MODEL_REPO', 'fallback')
+        radio_l_image_processor = CLIPImageProcessor.from_pretrained(hf_repo)
+        radio_l_model = AutoModel.from_pretrained(hf_repo, trust_remote_code=True)
+        radio_l_model = radio_l_model.to(RADIO_DEVICE)
+        radio_l_model.eval()
+        print("✅ C model loaded successfully")
         return True
-        
     except Exception as e:
-        print(f"❌ All model loading attempts failed: {e}")
+        print(f"❌ Error loading model: {e}")
         return False
 
-# --------------------------------------------------------------------------------------
-# Feature Extraction (matching your working implementation)
-# --------------------------------------------------------------------------------------
 
-def extract_radio_features(image):
-    """
-    Extract RADIO features from image - matching your working implementation
-    CRITICAL: This must output 1,119,744 features to match the classifier
-    """
-    global image_processor, radio_model
-    
-    if image_processor is None or radio_model is None:
-        raise Exception("RADIO model not initialized")
-    
-    # Convert to PIL if needed
-    if not isinstance(image, Image.Image):
-        if isinstance(image, np.ndarray):
-            image = Image.fromarray(image.astype('uint8'))
-        else:
-            raise ValueError(f"Unsupported image type: {type(image)}")
-    
-    # CRITICAL: Resize to 512x512 (not 224x224!)
-    # This matches your working implementation
-    image = image.convert("RGB").resize((512, 512))
-    
-    # Process image with CLIP processor
-    pixel_values = image_processor(
-        images=image,
-        return_tensors='pt',
-        do_resize=True
-    ).pixel_values
-    pixel_values = pixel_values.to(DEVICE)
-    
-    # Extract features
+def extract_radio_l_features(image):
+    """Extract C features from a PIL image with 224x224 resize"""
+    global radio_l_image_processor, radio_l_model
+
+    if radio_l_image_processor is None or radio_l_model is None:
+        raise Exception("C model not initialized")
+
+    # Resize to 224x224 as required
+    if isinstance(image, np.ndarray):
+        image = Image.fromarray(image.astype('uint8'))
+
+    image = image.resize((224, 224))
+
+    pixel_values = radio_l_image_processor(images=image, return_tensors='pt', do_resize=True).pixel_values
+    pixel_values = pixel_values.to(RADIO_DEVICE)
+
     with torch.no_grad():
-        # Check if using CLIP fallback
-        if hasattr(radio_model, 'get_image_features'):
-            # CLIP model - different output format
-            features = radio_model.get_image_features(pixel_values)
-            # CLIP features are much smaller, need to handle this
-            features = features.detach().flatten()
-        else:
-            # C-RADIOv3 returns tuple: (summary, features)
-            outputs = radio_model(pixel_values)
-            
-            if isinstance(outputs, tuple):
-                summary, features = outputs
-            else:
-                # Handle other possible formats
-                features = outputs
-            
-            # Flatten ALL dimensions - no pooling or reduction!
-            features = features.detach().flatten()
-        
-        # L2 normalize (matching your working code)
+        summary, features = radio_l_model(pixel_values)
+        features = features.detach().flatten()
         features = F.normalize(features, p=2, dim=-1).cpu().flatten()
-    
-    features_np = features.numpy()
-    
-    print(f"  ✓ Extracted features shape: {features_np.shape}")
-    
-    # Check if dimensions match expected
-    if features_np.shape[0] != 1119744 and features_np.shape[0] > 1000:
-        print(f"  ⚠️ Warning: Expected 1,119,744 features but got {features_np.shape[0]}")
-    
-    return features_np
 
-# --------------------------------------------------------------------------------------
-# Classifier Loading
-# --------------------------------------------------------------------------------------
+    return features.numpy()
+
 
 def load_ai_detection_classifier(model_path):
-    """Load the PassiveAggressiveClassifier"""
+    """Load the AI detection (Stage 2)"""
     global ai_detection_classifier
-    
-    if ai_detection_classifier is not None:
-        print("✅ Classifier already loaded")
-        return ai_detection_classifier
-    
-    if not os.path.exists(model_path):
-        print(f"❌ Classifier not found at: {model_path}")
+
+    if model_path is None or not os.path.exists(model_path):
+        print(f"❌ AI detection model not found at: {model_path}")
         return None
-    
+
     try:
         ai_detection_classifier = joblib.load(model_path)
-        
-        # Check expected features
-        if hasattr(ai_detection_classifier, 'n_features_in_'):
-            expected = ai_detection_classifier.n_features_in_
-            print(f"✅ Classifier loaded - expects {expected:,} features")
-        else:
-            print(f"✅ Classifier loaded: {type(ai_detection_classifier).__name__}")
-        
+        print("✅ V1.pkl AI detection classifier loaded successfully")
         return ai_detection_classifier
-        
     except Exception as e:
-        print(f"❌ Error loading classifier: {e}")
+        print(f"❌ Error loading V1.pkl classifier: {e}")
         return None
 
-# --------------------------------------------------------------------------------------
-# Prediction
-# --------------------------------------------------------------------------------------
 
-def predict_with_classifier(features):
-    """Make prediction with loaded classifier"""
-    global ai_detection_classifier
-    
-    if ai_detection_classifier is None:
-        return None
-    
-    # Reshape for sklearn
-    features = features.reshape(1, -1)
-    
-    # Check dimensions
-    if hasattr(ai_detection_classifier, 'n_features_in_'):
-        expected = ai_detection_classifier.n_features_in_
-        actual = features.shape[1]
-        
-        if expected != actual:
-            print(f"❌ Dimension mismatch: classifier expects {expected:,} but got {actual:,} features")
-            
-            # If using CLIP fallback with wrong dimensions
-            if actual < 10000:  # CLIP features are much smaller
-                print("  Note: Using CLIP fallback - results will be unreliable")
-                # Pad with zeros to match expected size (not ideal but allows demo)
-                features = np.pad(features, ((0, 0), (0, expected - actual)), 'constant')
-                print(f"  Padded features to {features.shape[1]:,} dimensions")
-    
-    # Make prediction
-    try:
-        pred = ai_detection_classifier.predict(features)[0]
-        
-        # Get confidence
-        confidence = None
-        if hasattr(ai_detection_classifier, 'decision_function'):
-            confidence = float(ai_detection_classifier.decision_function(features)[0])
-        elif hasattr(ai_detection_classifier, 'predict_proba'):
-            proba = ai_detection_classifier.predict_proba(features)[0]
-            confidence = float(max(proba))
-        
-        # Convert decision function to probability using sigmoid
-        if confidence is not None:
-            probability = 1 / (1 + np.exp(-confidence))
-        else:
-            probability = float(pred)
-        
+def simulate_damage_detection(image):
+    """Simulate damage detection when Zone model is not available"""
+    import random
+    import hashlib
+
+    # Create deterministic "analysis" based on image content
+    if isinstance(image, np.ndarray):
+        # Use image hash to create consistent results
+        img_hash = hashlib.md5(image.tobytes()).hexdigest()
+        seed = int(img_hash[:8], 16) % 1000
+        random.seed(seed)
+
+        h, w = image.shape[:2]
+        num_damages = random.randint(1, 3)
+
+        damages = []
+        for i in range(num_damages):
+            # Generate realistic damage regions
+            x1 = random.randint(0, w // 2)
+            y1 = random.randint(0, h // 2)
+            x2 = x1 + random.randint(w // 6, w // 3)
+            y2 = y1 + random.randint(h // 6, h // 3)
+
+            # Ensure bounds
+            x2 = min(x2, w - 1)
+            y2 = min(y2, h - 1)
+
+            confidence = random.uniform(0.6, 0.95)
+            damage_type = random.choice(["Scratch", "Dent", "Crack", "Paint Damage"])
+
+            damages.append({
+                "bbox": [x1, y1, x2, y2],
+                "confidence": confidence,
+                "type": damage_type,
+                "area": (x2 - x1) * (y2 - y1)
+            })
+
         return {
-            "prediction": int(pred),
-            "label": "AI-Generated" if pred == 1 else "Real",
-            "probability": probability,
-            "confidence": confidence,
-            "confidence_score": abs(confidence) if confidence else 0
+            "damages": damages,
+            "total_damages": len(damages),
+            "demo_mode": True
+        }
+    else:
+        # Default demo result
+        return {
+            "damages": [{"bbox": [100, 100, 200, 200], "confidence": 0.85, "type": "Dent", "area": 10000}],
+            "total_damages": 1,
+            "demo_mode": True
         }
-        
-    except Exception as e:
-        print(f"❌ Prediction error: {e}")
-        traceback.print_exc()
-        return None
 
-# --------------------------------------------------------------------------------------
-# Damage Detection (Stage 1) - Optional
-# --------------------------------------------------------------------------------------
 
-_damage_predictor = None
+def simulate_ai_detection(image, threshold=0.5):
+    """Simulate AI detection analysis when real model is not available"""
+    import random
+    import hashlib
 
-def load_damage_model(model_path):
-    """Load Detectron2 damage detection model"""
-    global _damage_predictor
-    
-    if _damage_predictor is not None:
-        return _damage_predictor
+    # Create deterministic "analysis" based on image content
+    if isinstance(image, np.ndarray):
+        # Use image hash to create consistent results
+        img_hash = hashlib.md5(image.tobytes()).hexdigest()
+        seed = int(img_hash[:8], 16) % 1000
+        random.seed(seed)
+
+        # Generate "realistic" probabilities
+        ai_prob = random.uniform(0.1, 0.9)
+        real_prob = 1.0 - ai_prob
+        is_ai = ai_prob > threshold
+
+        return {
+            "ai_prob": ai_prob,
+            "real_prob": real_prob,
+            "is_ai": is_ai,
+            "prediction": 1 if is_ai else 0,
+            "confidence": "HIGH" if abs(ai_prob - 0.5) > 0.3 else "MEDIUM" if abs(ai_prob - 0.5) > 0.15 else "LOW",
+            "demo_mode": True
+        }
+    else:
+        # Default demo result
+        return {
+            "ai_prob": 0.3,
+            "real_prob": 0.7,
+            "is_ai": False,
+            "prediction": 0,
+            "confidence": "MEDIUM",
+            "demo_mode": True
+        }
+
+
+def analyze_with_status(input_image, damage_threshold=0.7, ai_detection_threshold=0.5, device_str="cpu"):
+    """Main API function for analysis - returns results directly"""
     
-    if not DETECTRON2_AVAILABLE or not os.path.exists(model_path):
-        print("ℹ️ Damage detection not available")
-        return None
+    print(f"🚀 analyze_with_status called!")
+    print(f"📊 Parameters: image={input_image is not None}, threshold_damage={damage_threshold}, ai_detection_threshold={ai_detection_threshold}")
     
+    # Basic image validation
     try:
-        cfg = get_cfg()
-        cfg.merge_from_file(model_zoo.get_config_file("COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"))
-        cfg.MODEL.WEIGHTS = model_path
-        cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5
-        cfg.MODEL.ROI_HEADS.NUM_CLASSES = 1
-        cfg.MODEL.DEVICE = str(DEVICE)
-        
-        _damage_predictor = DefaultPredictor(cfg)
-        print("✅ Damage detection model loaded")
-        return _damage_predictor
-        
+        if input_image is None:
+            return {
+                "success": False,
+                "error": "No image provided",
+                "analysis_text": "❌ Please upload an image to analyze.",
+                "result_image": None
+            }
+
+        # Convert image to proper format
+        if isinstance(input_image, dict) and "path" in input_image:
+            img = cv2.imread(input_image["path"])
+            original_filename = os.path.basename(input_image["path"])
+        elif isinstance(input_image, str):
+            img = cv2.imread(input_image)
+            original_filename = os.path.basename(input_image)
+        elif isinstance(input_image, np.ndarray):
+            img = input_image.copy()
+            if len(img.shape) == 3 and img.shape[2] == 3:
+                img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+            original_filename = "uploaded_image"
+        else:
+            return {
+                "success": False,
+                "error": "Unsupported image format",
+                "analysis_text": "❌ Unsupported image format",
+                "result_image": None
+            }
+
+        if img is None:
+            return {
+                "success": False,
+                "error": "Could not read image",
+                "analysis_text": "❌ Could not read the image",
+                "result_image": None
+            }
+
     except Exception as e:
-        print(f"❌ Could not load damage model: {e}")
-        return None
+        return {
+            "success": False,
+            "error": str(e),
+            "analysis_text": f"❌ Error loading image: {str(e)}",
+            "result_image": None
+        }
 
-def simulate_damage_detection(image):
-    """Simulate damage detection for demo"""
-    import hashlib, random
-    
-    if isinstance(image, Image.Image):
-        arr = np.array(image)
+    # Setup processing
+    device = setup_device(device_str)
+
+    # Convert to RGB for consistent processing
+    if len(img.shape) == 3 and img.shape[2] == 3:
+        rgb_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
     else:
-        arr = image
-    
-    h, w = arr.shape[:2] if arr.ndim >= 2 else (100, 100)
-    
-    # Deterministic random based on image
-    seed = int(hashlib.md5(arr.tobytes()).hexdigest()[:8], 16) % 10000
-    random.seed(seed)
-    
-    n_damages = random.randint(0, 3)
-    damages = []
-    
-    for i in range(n_damages):
-        x1 = random.randint(0, max(1, w - 100))
-        y1 = random.randint(0, max(1, h - 100))
-        x2 = min(w, x1 + random.randint(50, 150))
-        y2 = min(h, y1 + random.randint(50, 150))
-        
-        damages.append({
-            "bbox": [x1, y1, x2, y2],
-            "score": random.uniform(0.6, 0.95),
-            "label": f"damage_{i+1}"
-        })
-    
-    return damages
+        rgb_img = img
 
-# --------------------------------------------------------------------------------------
-# Main Analysis Function
-# --------------------------------------------------------------------------------------
+    # Initialize models
+    damage_model_path = DEFAULT_DAMAGE_MODEL_PATH
+    ai_detection_model_path = huggingface_model_path or DEFAULT_AI_DETECTION_MODEL_PATH
 
-def analyze_image(image, enable_damage=False, damage_threshold=0.5):
-    """Main analysis pipeline"""
-    
-    if image is None:
-        return "No image provided", {}, None
+    damage_model = None
+    ai_classifier = None
+    demo_mode = False
+
+    # Stage 1: Load Damage Detection Model (Detectron2)
+    if damage_model_path and os.path.exists(damage_model_path):
+        damage_model = load_detectron2_damage_model(damage_model_path, device)
+        if not damage_model:
+            demo_mode = True
+    else:
+        demo_mode = True
+
+    # Stage 2: Initialize C-RADIOv3-g model
+    radiov3_initialized = initialize_radiov3_model()
+    if not radiov3_initialized:
+        demo_mode = True
+
+    # Stage 2b: Load AI Detection Classifier (V1.pkl)
+    if ai_detection_model_path and os.path.exists(ai_detection_model_path):
+        ai_classifier = load_ai_detection_classifier(ai_detection_model_path)
+        if not ai_classifier:
+            demo_mode = True
+    else:
+        demo_mode = True
+
+    # Set demo mode if any model failed
+    if damage_model is None or not radiov3_initialized or ai_classifier is None:
+        demo_mode = True
+
+    progress_info = []
+    progress_info.append("🔄 SEQUENTIAL ANALYSIS PIPELINE")
     
+    # STAGE 1: DAMAGE DETECTION
     try:
-        # Convert numpy to PIL if needed
-        if isinstance(image, np.ndarray):
-            image = Image.fromarray(image.astype('uint8'))
-        
-        # Stage 2: AI Detection (Main functionality)
-        ai_result = None
-        
-        # Ensure models are loaded
-        if not _preloaded:
-            if not preload_radio_model():
-                return "Failed to load feature extractor", {"error": "Model loading failed"}, None
-        
-        # Load classifier
-        classifier_path = huggingface_model_path or DEFAULT_AI_DETECTION_MODEL_PATH
-        if ai_detection_classifier is None:
-            load_ai_detection_classifier(classifier_path)
-        
-        if ai_detection_classifier is None:
-            return "Classifier not available", {"error": "Classifier not loaded"}, None
-        
-        # Extract features (512x512, full dimensions)
-        try:
-            features = extract_radio_features(image)
-            
-            # Make prediction
-            ai_result = predict_with_classifier(features)
-            
-            if ai_result:
-                result_text = f"{ai_result['label']} (Confidence: {ai_result['probability']:.2%})"
-            else:
-                result_text = "Prediction failed"
-                
-        except Exception as e:
-            print(f"❌ AI detection error: {e}")
-            traceback.print_exc()
-            result_text = f"Error: {str(e)}"
-            ai_result = {"error": str(e)}
-        
-        # Stage 1: Damage Detection (Optional)
-        damages = []
-        annotated = None
-        
-        if enable_damage:
+        if damage_model and not demo_mode:
+            # Use real model
+            outputs = damage_model(rgb_img)
+            instances = outputs["instances"].to("cpu")
+
+            damages = []
+            boxes = instances.pred_boxes.tensor.numpy() if len(instances) > 0 else []
+            scores = instances.scores.numpy() if len(instances) > 0 else []
+
+            for i, (box, score) in enumerate(zip(boxes, scores)):
+                if score > float(damage_threshold):
+                    x1, y1, x2, y2 = box
+                    damages.append({
+                        "bbox": [int(x1), int(y1), int(x2), int(y2)],
+                        "confidence": float(score),
+                        "type": f"Damage_{i + 1}",
+                        "area": int((x2 - x1) * (y2 - y1))
+                    })
+
+            damage_result = {
+                "damages": damages,
+                "total_damages": len(damages),
+                "demo_mode": False
+            }
+        else:
+            # Use simulation
+            damage_result = simulate_damage_detection(rgb_img)
+
+        # Get results
+        damages = damage_result["damages"]
+        total_damages = damage_result["total_damages"]
+
+    except Exception as e:
+        damage_result = simulate_damage_detection(rgb_img)
+        damages = damage_result["damages"]
+        total_damages = damage_result["total_damages"]
+
+    # STAGE 2: AI DETECTION
+    try:
+        if radiov3_initialized and ai_classifier and not demo_mode:
+            # Extract features using C with 224x224 resize
+            features = extract_radio_l_features(rgb_img)
+            features = features.reshape(1, -1)  # Reshape for single sample
+
+            # Predict using V1.pkl classifier
+            prediction = ai_classifier.predict(features)[0]
+
+            # Get confidence/probability
             try:
-                predictor = load_damage_model(DEFAULT_DAMAGE_MODEL_PATH)
-                
-                if predictor:
-                    # Real detection
-                    outputs = predictor(np.array(image))
-                    instances = outputs["instances"].to("cpu")
-                    
-                    if len(instances) > 0:
-                        boxes = instances.pred_boxes.tensor.numpy()
-                        scores = instances.scores.numpy()
-                        
-                        for box, score in zip(boxes, scores):
-                            if score > damage_threshold:
-                                x1, y1, x2, y2 = map(int, box)
-                                damages.append({
-                                    "bbox": [x1, y1, x2, y2],
-                                    "score": float(score),
-                                    "label": "damage"
-                                })
+                if hasattr(ai_classifier, 'predict_proba'):
+                    probabilities = ai_classifier.predict_proba(features)[0]
+                    prob_real = float(probabilities[0]) if len(probabilities) > 1 else 1 - prediction
+                    prob_ai = float(probabilities[1]) if len(probabilities) > 1 else prediction
                 else:
-                    # Use simulator
-                    damages = simulate_damage_detection(image)
-                
-                # Create annotated image
-                annotated = np.array(image.convert("RGB"))
-                for dmg in damages:
-                    x1, y1, x2, y2 = dmg["bbox"]
-                    cv2.rectangle(annotated, (x1, y1), (x2, y2), (255, 255, 0), 2)
-                    label = f"{dmg['score']:.2%}"
-                    cv2.putText(annotated, label, (x1, y1-5), 
-                              cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 0), 2)
-                
-                # Add AI verdict overlay
-                if ai_result and 'label' in ai_result:
-                    color = (0, 255, 0) if ai_result['label'] == "Real" else (0, 0, 255)
-                    cv2.putText(annotated, ai_result['label'], (30, 50),
-                              cv2.FONT_HERSHEY_SIMPLEX, 1.0, color, 3)
-                    
-                    if 'probability' in ai_result:
-                        conf_text = f"Conf: {ai_result['probability']:.1%}"
-                        cv2.putText(annotated, conf_text, (30, 90),
-                                  cv2.FONT_HERSHEY_SIMPLEX, 0.8, color, 2)
-                    
-            except Exception as e:
-                print(f"⚠️ Damage detection error: {e}")
-        
-        # Prepare detailed results
-        detailed_results = {
-            "ai_detection": ai_result or {},
-            "damage_detection": {
-                "enabled": enable_damage,
-                "damages_found": len(damages),
-                "damages": damages
-            } if enable_damage else None
-        }
-        
-        return result_text, detailed_results, annotated
-        
+                    # For models with decision_function
+                    decision_score = ai_classifier.decision_function(features)[0]
+                    prob_real = 0.5 + decision_score / 2 if decision_score < 0 else 0.5 - decision_score / 2
+                    prob_ai = 1 - prob_real
+            except Exception:
+                prob_real = 0.5
+                prob_ai = 0.5
+
+            is_ai = prediction == 1
+
+            ai_detection_result = {
+                "ai_prob": prob_ai,
+                "real_prob": prob_real,
+                "is_ai": is_ai,
+                "prediction": int(prediction),
+                "confidence": "HIGH" if abs(prob_ai - 0.5) > 0.3 else "MEDIUM" if abs(prob_ai - 0.5) > 0.15 else "LOW",
+                "demo_mode": False
+            }
+        else:
+            # Use simulation
+            ai_detection_result = simulate_ai_detection(rgb_img, float(ai_detection_threshold))
+
+        # Get results
+        ai_prob = ai_detection_result["ai_prob"]
+        real_prob = ai_detection_result["real_prob"]
+        is_ai = ai_detection_result["is_ai"]
+        ai_confidence = ai_detection_result["confidence"]
+
     except Exception as e:
-        print(f"❌ Analysis error: {e}")
-        traceback.print_exc()
-        return f"Error: {str(e)}", {"error": str(e)}, None
+        ai_detection_result = simulate_ai_detection(rgb_img, float(ai_detection_threshold))
+        ai_prob = ai_detection_result["ai_prob"]
+        real_prob = ai_detection_result["real_prob"]
+        is_ai = ai_detection_result["is_ai"]
+        ai_confidence = ai_detection_result["confidence"]
+
+    # SEQUENTIAL ANALYSIS SYNTHESIS
+    progress_info.append("\n🔄 ANALYSIS RESULTS:")
+
+    if demo_mode:
+        progress_info.append("⚠️ Note: Using demo simulation (models not fully available)")
+
+    # Determine final verdict based on both stages
+    if total_damages > 0 and not is_ai:
+        final_verdict = "✅ LEGITIMATE DAMAGE CLAIM"
+        verdict_explanation = "Genuine vehicle damage detected in authentic image"
+        recommendation = "✅ Proceed with claim processing"
+        risk_level = "LOW"
+    elif total_damages > 0 and is_ai:
+        final_verdict = "⚠️ POTENTIAL FRAUD - AI-GENERATED IMAGE"
+        verdict_explanation = "Damage detected but image appears to be AI-generated"
+        recommendation = "🔍 Flag for manual review and investigation"
+        risk_level = "HIGH"
+    elif total_damages == 0 and is_ai:
+        final_verdict = "🚨 FRAUD DETECTED"
+        verdict_explanation = "No significant damage found and image appears to be AI-generated"
+        recommendation = "❌ Reject claim - likely fraudulent"
+        risk_level = "VERY HIGH"
+    else:  # No damage, authentic image
+        final_verdict = "⚠️ NO DAMAGE DETECTED"
+        verdict_explanation = "Authentic image but no significant damage found"
+        recommendation = "🔍 Verify claim details and request additional evidence"
+        risk_level = "MEDIUM"
+
+    progress_info.append(f"\n📊 DAMAGE DETECTION:")
+    progress_info.append(f"├─ Total Damages Found: {total_damages}")
+    for i, damage in enumerate(damages):
+        progress_info.append(f"├─ Damage {i+1}: {damage['type']} (Confidence: {damage['confidence']*100:.1f}%)")
+    
+    progress_info.append(f"\n🤖 AI DETECTION:")
+    progress_info.append(f"├─ AI Probability: {ai_prob*100:.1f}%")
+    progress_info.append(f"├─ Real Probability: {real_prob*100:.1f}%")
+    progress_info.append(f"├─ Classification: {'AI-GENERATED' if is_ai else 'AUTHENTIC'}")
+    progress_info.append(f"└─ Confidence Level: {ai_confidence}")
+    
+    progress_info.append(f"\n🎯 FINAL VERDICT:")
+    progress_info.append(f"├─ Verdict: {final_verdict}")
+    progress_info.append(f"├─ Explanation: {verdict_explanation}")
+    progress_info.append(f"├─ Risk Level: {risk_level}")
+    progress_info.append(f"└─ Recommendation: {recommendation}")
+
+    # Create comprehensive visualization
+    result_img = rgb_img.copy()
+
+    # Draw damage detection results (Stage 1)
+    for i, damage in enumerate(damages):
+        bbox = damage["bbox"]
+        conf = damage["confidence"]
+        x1, y1, x2, y2 = bbox
+
+        # Draw bounding box for damage
+        cv2.rectangle(result_img, (x1, y1), (x2, y2), (0, 255, 255), 2)  # Yellow for damage
+        cv2.putText(result_img, f"Damage {i + 1}: {conf * 100:.1f}%",
+                    (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 255), 2)
+
+    # Add AI detection results (Stage 2)
+    ai_color = (255, 0, 0) if is_ai else (0, 255, 0)  # Red for AI, green for real
+    ai_text = f"{'AI-GENERATED' if is_ai else 'AUTHENTIC'}"
+    ai_prob_text = f"Confidence: {(ai_prob if is_ai else real_prob) * 100:.1f}%"
+
+    # Add text overlays
+    cv2.putText(result_img, final_verdict, (30, 50), cv2.FONT_HERSHEY_SIMPLEX, 1.0, ai_color, 3)
+    cv2.putText(result_img, f"Damage Count: {total_damages}", (30, 90), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 255), 2)
+    cv2.putText(result_img, f"AI Detection: {ai_text}", (30, 130), cv2.FONT_HERSHEY_SIMPLEX, 0.8, ai_color, 2)
+    cv2.putText(result_img, ai_prob_text, (30, 170), cv2.FONT_HERSHEY_SIMPLEX, 0.6, ai_color, 2)
+    cv2.putText(result_img, f"Risk Level: {risk_level}", (30, 210), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 0), 2)
+
+    # Add pipeline info
+    analysis_text = "Advanced Detection System"
+    mode_text = "DEMO MODE" if demo_mode else "FULL ANALYSIS"
+    cv2.putText(result_img, analysis_text, (30, 250), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (128, 128, 128), 2)
+    cv2.putText(result_img, mode_text, (30, 280), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (128, 128, 128), 2)
+
+    # Add timestamp
+    timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
+    cv2.putText(result_img, f"Analysis: {timestamp}",
+                (30, result_img.shape[0] - 30), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (128, 128, 128), 1)
+
+    analysis_text = "\n".join(progress_info)
+
+    # Return results as dictionary for API
+    return {
+        "success": True,
+        "analysis_text": analysis_text,
+        "result_image": result_img,
+        "verdict": final_verdict,
+        "risk_level": risk_level,
+        "damage_count": total_damages,
+        "damages": damages,
+        "ai_probability": ai_prob,
+        "real_probability": real_prob,
+        "is_ai_generated": is_ai,
+        "ai_confidence": ai_confidence,
+        "recommendation": recommendation,
+        "demo_mode": demo_mode,
+        "timestamp": timestamp
+    }
 
-# --------------------------------------------------------------------------------------
-# Gradio Interface
-# --------------------------------------------------------------------------------------
 
 def create_gradio_interface():
-    """Create Gradio interface"""
+    """Interface Gradio for API access"""
+    
+    # CSS with JavaScript for cookies
+    custom_css = """
+    :root {
+        --background-fill-primary: #ffffff !important;
+        --background-fill-secondary: #f8f9fa !important;
+        --border-color-primary: #e5e7eb !important;
+        --body-text-color: #000000 !important;
+    }
     
-    with gr.Blocks(title="AI Image Detection - C-RADIOv3-g") as app:
+    .gradio-container {
+        background-color: #ffffff !important;
+        color: #000000 !important;
+    }
+    """ + COOKIE_JAVASCRIPT
+
+    with gr.Blocks(
+            title="HEDI - AI Fraud Detection API",
+            theme=gr.themes.Soft(
+                primary_hue="blue",
+                secondary_hue="slate",
+                neutral_hue="zinc"
+            ),
+            css=custom_css
+    ) as app:
+
+        # Header
         gr.HTML("""
-        <div style="text-align: center; padding: 20px; background: linear-gradient(90deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px;">
-            <h1>🤖 AI Image Detection</h1>
-            <p>C-RADIOv3-g (512×512) + PassiveAggressiveClassifier</p>
-        </div>
+        <div style="background: linear-gradient(90deg, #1e40af, #2563eb); color: white; padding: 20px; border-radius: 10px; margin-bottom: 20px; text-align: center;">
+            <h1 style="margin: 0; color: white;">🛡️ HEDI - AI Fraud Detection API</h1>
+            <p style="margin: 5px 0 0 0; color: white; opacity: 0.9;">Two-Stage Sequential Pipeline Analysis</p>
+        </div> 
         """)
-        
+
         with gr.Row():
-            with gr.Column():
-                input_image = gr.Image(type="numpy", label="Upload Image", height=400)
+            with gr.Column(scale=2):
+                input_image = gr.Image(
+                    type="numpy",
+                    label="Upload Image for Analysis"
+                )
                 
                 with gr.Row():
-                    analyze_btn = gr.Button("🔍 Analyze", variant="primary", size="lg")
-                    clear_btn = gr.Button("🗑️ Clear", variant="secondary", size="lg")
+                    damage_threshold = gr.Slider(
+                        minimum=0.1, maximum=0.95, value=0.7, step=0.05,
+                        label="🔍 Damage Detection Sensitivity"
+                    )
+                    ai_detection_threshold = gr.Slider(
+                        minimum=0.1, maximum=0.9, value=0.5, step=0.05,
+                        label="🤖 AI Detection Sensitivity"
+                    )
                 
-                enable_damage = gr.Checkbox(
-                    value=False, 
-                    label="Enable Damage Detection (Stage 1)",
-                    info="Optional: Detect physical damage in images"
+                analyze_btn = gr.Button(
+                    "🚀 Analyze Image",
+                    variant="primary",
+                    size="lg"
                 )
-                damage_thresh = gr.Slider(
-                    0.1, 0.95, value=0.5, step=0.05,
-                    label="Damage Score Threshold",
-                    visible=False
+            
+            with gr.Column(scale=3):
+                # Analysis Results Display
+                result_text = gr.Textbox(
+                    label="📊 Analysis Results",
+                    lines=20,
+                    max_lines=30,
+                    show_copy_button=True
                 )
                 
-            with gr.Column():
-                output_text = gr.Textbox(
-                    label="AI Detection Result",
-                    placeholder="Upload an image and click Analyze",
-                    lines=2
+                result_image = gr.Image(
+                    label="📸 Annotated Result",
+                    type="numpy"
                 )
-                output_json = gr.JSON(label="Detailed Analysis")
-                annotated_image = gr.Image(label="Annotated Output", visible=False)
-        
-        # Show/hide damage threshold based on checkbox
-        enable_damage.change(
-            fn=lambda x: gr.update(visible=x),
-            inputs=[enable_damage],
-            outputs=[damage_thresh]
-        )
         
-        enable_damage.change(
-            fn=lambda x: gr.update(visible=x),
-            inputs=[enable_damage],
-            outputs=[annotated_image]
-        )
-        
-        # Analysis function
-        def run_analysis(img, dmg_enabled, dmg_thresh):
-            if img is None:
-                return "No image provided", {}, None
+        # Usage display
+        usage_display = gr.HTML(get_usage_display_html(0))
+        
+        # JSON Output for API
+        with gr.Accordion("📄 JSON API Response", open=False):
+            json_output = gr.JSON(label="API Response Data")
+        
+        # Event handler for analysis
+        def process_and_display(image, damage_thresh, ai_thresh):
+            """Process image and display results"""
+            if image is None:
+                return (
+                    "❌ Please upload an image",
+                    None,
+                    {"error": "No image provided"},
+                    get_usage_display_html(0)
+                )
             
-            text, details, annotated = analyze_image(img, dmg_enabled, dmg_thresh)
+            # Get analysis results
+            results = analyze_with_status(image, damage_thresh, ai_thresh)
             
-            # Only show annotated if damage detection is enabled
-            if dmg_enabled and annotated is not None:
-                return text, details, gr.update(value=annotated, visible=True)
+            # Extract visualization and text
+            if results["success"]:
+                # Update usage (in real implementation, integrate with cookies)
+                usage_count = 1  # This would come from cookies in production
+                
+                return (
+                    results["analysis_text"],
+                    results["result_image"],
+                    {
+                        "verdict": results["verdict"],
+                        "risk_level": results["risk_level"],
+                        "damage_count": results["damage_count"],
+                        "damages": results["damages"],
+                        "ai_probability": results["ai_probability"],
+                        "is_ai_generated": results["is_ai_generated"],
+                        "recommendation": results["recommendation"],
+                        "timestamp": results["timestamp"]
+                    },
+                    get_usage_display_html(usage_count)
+                )
             else:
-                return text, details, gr.update(visible=False)
+                return (
+                    results["analysis_text"],
+                    None,
+                    {"error": results.get("error", "Analysis failed")},
+                    get_usage_display_html(0)
+                )
         
-        # Wire up buttons
         analyze_btn.click(
-            fn=run_analysis,
-            inputs=[input_image, enable_damage, damage_thresh],
-            outputs=[output_text, output_json, annotated_image]
+            fn=process_and_display,
+            inputs=[input_image, damage_threshold, ai_detection_threshold],
+            outputs=[result_text, result_image, json_output, usage_display],
+            api_name="analyze_with_status"  # This makes it accessible via API
         )
         
+        # Clear button
+        clear_btn = gr.Button("🗑️ Clear", variant="secondary")
         clear_btn.click(
-            fn=lambda: (None, "", {}, gr.update(visible=False)),
-            outputs=[input_image, output_text, output_json, annotated_image]
-        )
-        
-        # Auto-analyze on image upload
-        input_image.change(
-            fn=run_analysis,
-            inputs=[input_image, enable_damage, damage_thresh],
-            outputs=[output_text, output_json, annotated_image]
+            fn=lambda: (None, None, "", None, {}, get_usage_display_html(0)),
+            outputs=[input_image, result_image, result_text, json_output, usage_display]
         )
-        
-        # Info section
-        with gr.Accordion("ℹ️ Model Information", open=False):
-            gr.Markdown("""
-            ### Technical Details
-            - **Feature Extractor**: nvidia/C-RADIOv3-g
-            - **Input Size**: 512×512 pixels  
-            - **Feature Dimensions**: 1,119,744
-            - **Classifier**: PassiveAggressiveClassifier (V1.pkl)
-            - **Device**: Automatically selected (MPS > CUDA > CPU)
-            
-            ### How It Works
-            1. Image is resized to 512×512
-            2. C-RADIOv3-g extracts visual features
-            3. Features are L2-normalized
-            4. PassiveAggressiveClassifier predicts Real vs AI-Generated
-            
-            ### Optional Stage 1
-            - Damage detection using Detectron2 (if available)
-            - Falls back to simulation if not available
-            """)
-    
-    return app
-
-# --------------------------------------------------------------------------------------
-# Test Function
-# --------------------------------------------------------------------------------------
 
-def test_system():
-    """Test the AI detection system"""
-    print("\n" + "="*60)
-    print("🧪 System Test")
-    print("="*60)
-    
-    test_results = {
-        "device": str(DEVICE),
-        "detectron2_available": DETECTRON2_AVAILABLE,
-        "model_loaded": radio_model is not None,
-        "processor_loaded": image_processor is not None,
-        "classifier_loaded": ai_detection_classifier is not None,
-        "classifier_path": huggingface_model_path or DEFAULT_AI_DETECTION_MODEL_PATH
-    }
-    
-    for key, value in test_results.items():
-        status = "✅" if value not in [None, False, ""] else "❌"
-        print(f"{status} {key}: {value}")
-    
-    # Test feature extraction with dummy image
-    if radio_model and image_processor:
-        try:
-            test_img = Image.new('RGB', (512, 512), color='white')
-            features = extract_radio_features(test_img)
-            print(f"✅ Feature extraction test: {features.shape}")
-            
-            if ai_detection_classifier and hasattr(ai_detection_classifier, 'n_features_in_'):
-                expected = ai_detection_classifier.n_features_in_
-                actual = features.shape[0]
-                if expected == actual:
-                    print(f"✅ Dimension match: {actual:,} features")
-                else:
-                    print(f"⚠️ Dimension mismatch: expected {expected:,}, got {actual:,}")
-                    
-        except Exception as e:
-            print(f"❌ Feature extraction test failed: {e}")
-    
-    print("="*60 + "\n")
+    return app
 
-# --------------------------------------------------------------------------------------
-# Main
-# --------------------------------------------------------------------------------------
 
 if __name__ == "__main__":
-    print("="*60)
-    print("🚀 Starting AI Image Detection Service")
-    print("="*60)
-    print(f"📍 Device: {DEVICE}")
-    print(f"📦 Classifier: {huggingface_model_path or DEFAULT_AI_DETECTION_MODEL_PATH}")
-    
-    # Load models
-    if preload_radio_model():
-        print("✅ Feature extractor loaded")
-    else:
-        print("⚠️ Running without feature extractor")
+    print("🚀 Starting HEDI AI Fraud Detector - API Version...")
+    print(f"✅ Damage model: {'Available' if os.path.exists(DEFAULT_DAMAGE_MODEL_PATH) else 'Demo mode'}")
+    print(f"✅ AI Detection Model: {'Available' if huggingface_model_path or os.path.exists(DEFAULT_AI_DETECTION_MODEL_PATH) else 'Demo mode'}")
+    print("🔌 API Endpoint: /analyze_with_status")
+    print("📊 Returns: JSON response with verdict, risk level, and detailed analysis")
     
-    # Load classifier
-    classifier_path = huggingface_model_path or DEFAULT_AI_DETECTION_MODEL_PATH
-    if load_ai_detection_classifier(classifier_path):
-        print("✅ Classifier loaded")
-    else:
-        print("⚠️ Running without classifier")
-    
-    # Run system test
-    test_system()
+    # Preload models at startup
+    preload_models()
     
-    # Launch app
     app = create_gradio_interface()
     app.launch(
+        share=False,
         server_name="0.0.0.0",
         server_port=7860,
-        share=False,
         show_error=True
     )