Update app.py

app.py

@@ -13,8 +13,6 @@ import torch.nn as nn
 import traceback
 from huggingface_hub import hf_hub_download
 from torchvision.models import vit_b_16
-import uuid
-import json
 
 # Email functionality imports
 import smtplib
@@ -27,8 +25,6 @@ import base64
 import io
 from datetime import datetime
 
-print("🚀 Démarrage de l'application Car Damage Detector...")
-
 # Add current directory to path
 if not os.getcwd() in sys.path:
     sys.path.append(os.getcwd())
@@ -36,12 +32,9 @@ if not os.getcwd() in sys.path:
 # Check if detectron2 is installed
 if importlib.util.find_spec("detectron2") is None:
     print("Installing PyTorch and Detectron2...")
-    try:
-        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!")
-    except Exception as e:
-        print(f"Warning: Could not install detectron2: {e}")
+    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
 try:
@@ -50,9 +43,8 @@ try:
     from detectron2.utils.visualizer import Visualizer, ColorMode
     from detectron2 import model_zoo
     DETECTRON2_AVAILABLE = True
-    print("✅ Detectron2 disponible")
 except ImportError:
-    print("⚠️ Warning: Detectron2 is not installed. Damage detection will not be available.")
+    print("Warning: Detectron2 is not installed. Damage detection will not be available.")
     DETECTRON2_AVAILABLE = False
 
 # Define model paths
@@ -68,67 +60,32 @@ SAMPLE_IMAGES = [
 # Maximum number of tries allowed
 MAX_TRIES = 5
 
-# Email configuration using environment variables (plus sécurisé)
+# Email configuration using environment variables
 EMAIL_CONFIG = {
     'SMTP_SERVER': 'smtp.mail.ovh.net',
     'EMAIL': os.getenv('login_email', 'sales@askhedi.fr'),
-    'PASSWORD': os.getenv('password_email', '@Esperance92'),  # À déplacer vers les secrets HF
-    'SMTP_PORT': int('465')
+    'PASSWORD': '@Esperance92',
+    'SMTP_PORT': 465
 }
 
-print(f"📧 Configuration email: {EMAIL_CONFIG['EMAIL']} sur {EMAIL_CONFIG['SMTP_SERVER']}")
-
-# Simple in-memory storage for user tries (in production, use a proper database)
-user_tries = {}
-
 # Télécharger le modèle deepfake depuis Hugging Face
-huggingface_model_path = None
 try:
     huggingface_model_path = hf_hub_download(
         repo_id="Askhedi/Car_damage_fraud_detector",
         filename="vit_deepfake_final.pth",
         token=os.getenv('key')
     )
-    print(f"✅ Modèle téléchargé depuis Hugging Face: {huggingface_model_path}")
+    print(f"Modèle téléchargé depuis Hugging Face: {huggingface_model_path}")
 except Exception as e:
-    print(f"⚠️ Erreur lors du téléchargement du modèle depuis Hugging Face: {e}")
+    print(f"Erreur lors du téléchargement du modèle depuis Hugging Face: {e}")
     huggingface_model_path = None
 
-def get_or_create_user_id():
-    """Generate a unique user ID for session tracking"""
-    user_id = f"user_{uuid.uuid4().hex[:8]}_{int(time.time())}"
-    print(f"🆔 Nouvel User ID créé: {user_id}")
-    return user_id
-
-def get_user_tries(user_id):
-    """Get the number of tries for a user"""
-    if not user_id:
-        return 0
-    tries = user_tries.get(user_id, 0)
-    print(f"📊 User {user_id}: {tries}/{MAX_TRIES} essais")
-    return tries
-
-def increment_user_tries(user_id):
-    """Increment the number of tries for a user"""
-    if not user_id:
-        user_id = get_or_create_user_id()
-    
-    current_tries = user_tries.get(user_id, 0)
-    user_tries[user_id] = current_tries + 1
-    new_count = user_tries[user_id]
-    print(f"📈 User {user_id}: {new_count}/{MAX_TRIES} essais (incrémenté)")
-    return new_count
-
-def send_results_by_email(recipient_email, analysis_text, result_image=None, original_filename="car_image"):
+def send_results_by_email(recipient_email, analysis_text, result_image, original_filename="car_image"):
     """Send analysis results by email"""
-    print(f"📧 Tentative d'envoi email vers: {recipient_email}")
-    
     if not EMAIL_CONFIG['PASSWORD']:
-        print("❌ Configuration email manquante")
         return False, "❌ Email configuration not available. Please contact support."
     
     if not recipient_email or "@" not in recipient_email:
-        print("❌ Email invalide")
         return False, "❌ Please provide a valid email address"
     
     try:
@@ -148,8 +105,6 @@ def send_results_by_email(recipient_email, analysis_text, result_image=None, ori
                 .header {{ background-color: #f0f0f0; padding: 15px; border-radius: 5px; }}
                 .results {{ margin: 20px 0; white-space: pre-wrap; }}
                 .footer {{ color: #666; font-size: 12px; margin-top: 30px; }}
-                .verdict-real {{ color: #28a745; font-weight: bold; }}
-                .verdict-fake {{ color: #dc3545; font-weight: bold; }}
             </style>
         </head>
         <body>
@@ -166,7 +121,6 @@ def send_results_by_email(recipient_email, analysis_text, result_image=None, ori
             <div class="footer">
                 <p><em>This analysis was generated by the Car Damage Fraud Detector AI system.</em></p>
                 <p>Powered by Askhedi - Advanced AI Detection Services</p>
-                <p><strong>Important:</strong> This AI analysis should be verified by professional inspection.</p>
             </div>
         </body>
         </html>
@@ -176,79 +130,88 @@ def send_results_by_email(recipient_email, analysis_text, result_image=None, ori
         
         # Attach result image if available
         if result_image is not None:
-            try:
-                # Convert numpy array to image bytes
-                if isinstance(result_image, np.ndarray):
-                    # Convert from RGB to PIL Image
-                    pil_image = Image.fromarray(result_image.astype('uint8'))
-                    img_buffer = io.BytesIO()
-                    pil_image.save(img_buffer, format='PNG')
-                    img_data = img_buffer.getvalue()
-                    
-                    # Attach image
-                    img_part = MIMEBase('application', 'octet-stream')
-                    img_part.set_payload(img_data)
-                    encoders.encode_base64(img_part)
-                    img_part.add_header(
-                        'Content-Disposition',
-                        f'attachment; filename="analysis_result_{original_filename}.png"'
-                    )
-                    msg.attach(img_part)
-                    print("✅ Image attachée à l'email")
-            except Exception as img_error:
-                print(f"⚠️ Erreur attachement image: {img_error}")
+            # Convert numpy array to image bytes
+            if isinstance(result_image, np.ndarray):
+                # Convert from RGB to PIL Image
+                pil_image = Image.fromarray(result_image.astype('uint8'))
+                img_buffer = io.BytesIO()
+                pil_image.save(img_buffer, format='PNG')
+                img_data = img_buffer.getvalue()
+                
+                # Attach image
+                img_part = MIMEBase('application', 'octet-stream')
+                img_part.set_payload(img_data)
+                encoders.encode_base64(img_part)
+                img_part.add_header(
+                    'Content-Disposition',
+                    f'attachment; filename="analysis_result_{original_filename}.png"'
+                )
+                msg.attach(img_part)
         
         # Send email
-        print("📤 Connexion au serveur SMTP...")
         server = smtplib.SMTP_SSL(EMAIL_CONFIG['SMTP_SERVER'], EMAIL_CONFIG['SMTP_PORT'])
         server.login(EMAIL_CONFIG['EMAIL'], EMAIL_CONFIG['PASSWORD'])
         server.send_message(msg)
         server.quit()
         
-        print(f"✅ Email envoyé avec succès à {recipient_email}")
         return True, f"✅ Results sent successfully to {recipient_email}"
         
     except Exception as e:
-        error_msg = f"❌ Error sending email: {str(e)}"
-        print(error_msg)
-        print(f"📋 Détails erreur: {traceback.format_exc()}")
-        return False, error_msg
+        return False, f"❌ Error sending email: {str(e)}"
 
 def setup_device(device_str):
     """Set up the computation device"""
-    print(f"⚙️ Configuration device: {device_str}")
-    
     if device_str == 'auto':
         if torch.cuda.is_available():
-            device = torch.device('cuda:0')
-            print("🚀 CUDA détecté et utilisé")
+            return torch.device('cuda:0')
         elif hasattr(torch, 'backends') and hasattr(torch.backends, 'mps') and torch.backends.mps.is_available():
-            device = torch.device('mps')
-            print("🍎 MPS (Mac) détecté et utilisé")
+            return torch.device('mps')
         else:
-            device = torch.device('cpu')
-            print("💻 CPU utilisé")
-        return device
+            return torch.device('cpu')
     elif device_str == 'cuda' and torch.cuda.is_available():
-        print("🚀 CUDA forcé")
         return torch.device('cuda:0')
     elif device_str == 'mps' and hasattr(torch, 'backends') and hasattr(torch.backends, 'mps') and torch.backends.mps.is_available():
-        print("🍎 MPS forcé")
         return torch.device('mps')
     else:
-        print(f"⚠️ Warning: Device {device_str} not available, using CPU instead.")
+        print(f"Warning: Device {device_str} not available, using CPU instead.")
         return torch.device('cpu')
 
+def setup_damage_detector(model_path, threshold=0.7):
+    """Set up the damage detection model"""
+    if not DETECTRON2_AVAILABLE:
+        print("Detectron2 is not installed. Cannot set up damage detector.")
+        return None, None
+    
+    try:
+        print(f"Checking model path: {model_path}")
+        print(f"Model exists: {os.path.exists(model_path)}")
+        
+        if model_path is None or not os.path.exists(model_path):
+            print(f"Error: Damage model file not found at {model_path}")
+            return None, None
+        
+        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.NUM_CLASSES = 1  # Only one class (damage)
+        cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = threshold
+        
+        # Use CPU if on Mac (MPS)
+        cfg.MODEL.DEVICE = "cpu"
+        print("Forcing Detectron2 to use CPU")        
+        
+        predictor = DefaultPredictor(cfg)
+        return predictor, cfg
+    except Exception as e:
+        print(f"Detailed error: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return None, None
+
 def load_vit_deepfake_model(model_path, device):
     """Load the Vision Transformer (ViT) model for deepfake detection"""
-    print(f"🤖 Chargement modèle ViT depuis: {model_path}")
-    
     if model_path is None:
-        print("⚠️ No deepfake model specified. Skipping deepfake detection.")
-        return None
-        
-    if not os.path.exists(model_path):
-        print(f"❌ Modèle non trouvé: {model_path}")
+        print("No deepfake model specified. Skipping deepfake detection.")
         return None
         
     try:
@@ -260,7 +223,7 @@ def load_vit_deepfake_model(model_path, device):
         model.heads.head = nn.Linear(in_features, 2)
         
         # Load weights
-        print(f"📥 Loading ViT deepfake model from: {model_path}")
+        print(f"Loading ViT deepfake model from: {model_path}")
         checkpoint = torch.load(model_path, map_location='cpu')
         
         if isinstance(checkpoint, dict) and 'model_state_dict' in checkpoint:
@@ -274,109 +237,339 @@ def load_vit_deepfake_model(model_path, device):
         model = model.to(device)
         model.eval()
         
-        print("✅ Modèle ViT chargé avec succès")
         return model
     except Exception as e:
-        print(f"❌ Error loading ViT deepfake model: {e}")
-        print(f"📋 Détails: {traceback.format_exc()}")
+        print(f"Error loading ViT deepfake model: {e}")
+        import traceback
+        traceback.print_exc()
         return None
 
-def create_simple_analysis(image, recipient_email, user_id):
-    """Version simplifiée pour tester le pipeline de base"""
-    print("🔄 Démarrage analyse simplifiée...")
-    
+def preprocess_for_vit(image, device):
+    """Prétraite une image pour le modèle ViT de torchvision"""
     try:
-        # Analyse basique de l'image
-        if image is None:
-            return "❌ Aucune image fournie"
+        print("Début du prétraitement de l'image...")
+        import torch
+        from torchvision import transforms
+        from PIL import Image
+        import numpy as np
+        import cv2
+        
+        # Transformation standard pour ViT (similaire à celle utilisée lors de l'entraînement)
+        transform = transforms.Compose([
+            transforms.Resize((224, 224)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        ])
+        
+        # Convertir l'image en RGB si nécessaire
+        if len(image.shape) == 3 and image.shape[2] == 3:
+            if image.dtype != np.uint8:
+                image = (image * 255).astype(np.uint8)
+            rgb_img = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        else:
+            rgb_img = image
+        print("Image convertie en RGB")
         
-        height, width = image.shape[:2]
+        # Convertir en PIL Image et appliquer les transformations
+        pil_img = Image.fromarray(rgb_img)
+        img_tensor = transform(pil_img).unsqueeze(0).to(device)  # Ajouter la dimension batch et envoyer au device
+        print("Image prétraitée avec succès")
         
-        analysis_text = f"""
-🚗 ANALYSE SIMPLIFIÉE DE DOMMAGES AUTOMOBILE
-==========================================
-
-📧 Email: {recipient_email}
-👤 User ID: {user_id}
-🖼️ Image: {width}x{height} pixels
-⏰ Analyse: {datetime.now().strftime('%d/%m/%Y à %H:%M:%S')}
-
-🔍 DÉTECTION DE DOMMAGES:
-• Analyse automatique de l'image
-• Recherche de zones endommagées
-• Vérification de l'authenticité
-
-📊 RÉSULTATS:
-• Status: ANALYSE BASIQUE RÉUSSIE ✅
-• Recommandation: Vérification manuelle recommandée
-• Confiance: 75% (mode test)
+        return img_tensor
+    except Exception as e:
+        print(f"ERREUR lors du prétraitement de l'image: {e}")
+        traceback.print_exc()
+        return None
 
-⚠️ NOTE: Ceci est une version de test simplifiée.
-L'analyse complète avec IA sera disponible prochainement.
+def detect_damage(img, damage_detector):
+    """Detect damage in an image"""
+    try:
+        if img is None:
+            raise ValueError("Invalid image")
+            
+        # If no detector, use whole image
+        if damage_detector is None:
+            h, w = img.shape[:2]
+            damage_regions = [{
+                "box": (0, 0, w, h),
+                "score": 1.0,
+                "mask": None
+            }]
+            return img, None, damage_regions
+            
+        # Run inference
+        outputs = damage_detector(img)
+        
+        # Get regions
+        instances = outputs["instances"].to("cpu")
+        boxes = instances.pred_boxes.tensor.numpy() if instances.has("pred_boxes") else []
+        scores = instances.scores.numpy() if instances.has("scores") else []
+        masks = instances.pred_masks.numpy() if instances.has("pred_masks") else []
+        
+        damage_regions = []
+        for i in range(len(boxes)):
+            x1, y1, x2, y2 = map(int, boxes[i])
+            damage_regions.append({
+                "box": (x1, y1, x2, y2),
+                "score": float(scores[i]),
+                "mask": masks[i] if len(masks) > i else None
+            })
+        
+        # If no regions found, use whole image
+        if not damage_regions:
+            h, w = img.shape[:2]
+            damage_regions = [{
+                "box": (0, 0, w, h),
+                "score": 1.0,
+                "mask": None
+            }]
+            
+        return img, outputs, damage_regions
+    except Exception as e:
+        print(f"Error detecting damage: {e}")
+        traceback.print_exc()
+        
+        # Return whole image if error
+        if 'img' in locals() and img is not None:
+            h, w = img.shape[:2]
+            damage_regions = [{
+                "box": (0, 0, w, h),
+                "score": 1.0,
+                "mask": None
+            }]
+            return img, None, damage_regions
+        return None, None, []
 
-💡 PROCHAINES ÉTAPES:
-1. Vérification par expert recommandée
-2. Documentation des dommages
-3. Contact avec votre assurance si nécessaire
+def check_deepfake_vit(image, damage_regions, deepfake_model, device, threshold=0.5):
+    """Vérifie si les régions endommagées sont des deepfakes en utilisant un modèle ViT de torchvision"""
+    results = []
+    
+    if deepfake_model is None:
+        print("Le modèle deepfake est None, ignorant la détection")
+        return []
+    
+    print(f"Début de la détection de deepfake avec {len(damage_regions)} régions")
+    detailed_info = []
+    
+    try:
+        # Si pas de régions endommagées, vérifier l'image entière
+        if not damage_regions:
+            print("Pas de régions endommagées, vérification de l'image entière")
+            img_tensor = preprocess_for_vit(image, device)
+            if img_tensor is None:
+                print("Échec du prétraitement de l'image")
+                return []
+                
+            # Exécuter l'inférence - Passer directement le tensor
+            print("Exécution de l'inférence sur l'image entière")
+            with torch.no_grad():
+                outputs = deepfake_model(img_tensor)  # Modèle torchvision attend directement le tensor
+                
+                # Obtenir les prédictions
+                logits = outputs
+                probabilities = torch.nn.functional.softmax(logits, dim=1)
+                
+                # Obtenir les probabilités de classe
+                for i in range(probabilities.shape[1]):
+                    prob = probabilities[0, i].item()
+                    print(f"Probabilité classe {i}: {prob*100:.2f}%")
+                
+                fake_prob = probabilities[0, 1].item()  # Probabilité d'être faux (classe 1)
+                real_prob = probabilities[0, 0].item()  # Probabilité d'être réel (classe 0)
+                is_fake = fake_prob > threshold
+                
+                detailed_info.append(f"Image entière: RÉEL={real_prob*100:.2f}%, FAUX={fake_prob*100:.2f}%")
+                
+                results.append({
+                    "region": "full_image",
+                    "deepfake_prob": float(fake_prob),
+                    "real_prob": float(real_prob),
+                    "is_fake": bool(is_fake),
+                    "detailed_info": detailed_info[-1]
+                })
+            
+            return results
+        
+        # Traiter chaque région endommagée
+        for i, region in enumerate(damage_regions):
+            print(f"Traitement de la région {i}...")
+            x1, y1, x2, y2 = region["box"]
+            x1, y1 = max(0, x1), max(0, y1)
+            x2, y2 = min(image.shape[1], x2), min(image.shape[0], y2)
+            
+            # Ne traiter que les régions valides
+            if x2 > x1 and y2 > y1:
+                # Extraire la région
+                roi = image[y1:y2, x1:x2]
+                print(f"Taille de la région {i}: {roi.shape}")
+                
+                # Prétraiter
+                img_tensor = preprocess_for_vit(roi, device)
+                if img_tensor is None:
+                    print(f"Échec du prétraitement de la région {i}")
+                    continue
+                
+                # Inférence - Passer directement le tensor
+                print(f"Exécution de l'inférence sur la région {i}")
+                with torch.no_grad():
+                    outputs = deepfake_model(img_tensor)  # Modèle torchvision attend directement le tensor
+                    
+                    # Obtenir les prédictions
+                    logits = outputs
+                    probabilities = torch.nn.functional.softmax(logits, dim=1)
+                    
+                    # Obtenir les probabilités de classe
+                    for j in range(probabilities.shape[1]):
+                        prob = probabilities[0, j].item()
+                        print(f"Région {i} - Probabilité classe {j}: {prob*100:.2f}%")
+                    
+                    fake_prob = probabilities[0, 1].item()  # Probabilité d'être faux (classe 1)
+                    real_prob = probabilities[0, 0].item()  # Probabilité d'être réel (classe 0)
+                    is_fake = fake_prob > threshold
+                    
+                    region_info = f"Région {i}: RÉEL={real_prob*100:.2f}%, FAUX={fake_prob*100:.2f}%"
+                    detailed_info.append(region_info)
+                    
+                    results.append({
+                        "region_id": i,
+                        "box": (x1, y1, x2, y2),
+                        "deepfake_prob": float(fake_prob),
+                        "real_prob": float(real_prob),
+                        "is_fake": bool(is_fake),
+                        "detailed_info": region_info
+                    })
+        
+        # Afficher un résumé global
+        if results:
+            print("===== RÉSUMÉ DE LA DÉTECTION DE DEEPFAKE =====")
+            for info in detailed_info:
+                print(info)
+            
+            fake_regions = sum(1 for r in results if r.get("is_fake", False))
+            print(f"Total des régions analysées: {len(results)}")
+            print(f"Régions fausses détectées: {fake_regions}")
+            print(f"Régions réelles détectées: {len(results) - fake_regions}")
+        else:
+            print("Aucune région n'a été analysée avec succès pour les deepfakes")
+            
+        return results
+    except Exception as e:
+        print(f"Erreur dans la détection de deepfake: {e}")
+        traceback.print_exc()
+        return []     
 
----
-Généré par Askhedi Car Damage Detector v1.0
-"""
+def visualize_results(image, damage_outputs, deepfake_results, damage_threshold):
+    """Create visualization of results"""
+    try:
+        img_copy = image.copy()
         
-        # Créer une image de test annotée
-        test_image = image.copy()
-        cv2.putText(test_image, "ANALYSE TEST", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
-        cv2.putText(test_image, f"{width}x{height}", (50, 100), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 0, 0), 2)
+        # Draw damage detection
+        if damage_outputs is not None and DETECTRON2_AVAILABLE:
+            try:
+                v = Visualizer(img_copy[:, :, ::-1], scale=1.0, instance_mode=ColorMode.IMAGE_BW)
+                v = v.draw_instance_predictions(damage_outputs["instances"].to("cpu"))
+                result_img = v.get_image()[:, :, ::-1]
+                result_img = np.array(result_img, dtype=np.uint8)
+            except Exception as e:
+                print(f"Error visualizing damage: {e}")
+                result_img = img_copy
+        else:
+            result_img = img_copy
         
-        # Envoyer l'email
-        success, email_msg = send_results_by_email(recipient_email, analysis_text, test_image, "test_analysis")
+        # Add deepfake results with enhanced information
+        for result in deepfake_results:
+            try:
+                if "box" in result:
+                    x1, y1, x2, y2 = result["box"]
+                    fake_prob = result["deepfake_prob"]
+                    real_prob = result.get("real_prob", 1.0 - fake_prob)  # Calculate real_prob if not present
+                    is_fake = result["is_fake"]
+                    region_id = result.get("region_id", 0)
+                    
+                    # Enhanced status text with both probabilities
+                    text = f"R{region_id}: {'FAKE' if is_fake else 'REAL'}"
+                    prob_text = f"F:{fake_prob*100:.1f}% R:{real_prob*100:.1f}%"
+                    
+                    # Red for fake, green for real
+                    color = (0, 0, 255) if is_fake else (0, 255, 0)
+                    
+                    # Ensure standard numpy array
+                    if not isinstance(result_img, np.ndarray):
+                        result_img = np.array(result_img, dtype=np.uint8)
+                    
+                    # Draw rectangle and text
+                    cv2.rectangle(result_img, (x1, y1), (x2, y2), color, 2)
+                    cv2.putText(result_img, text, (x1, y1-10), cv2.FONT_HERSHEY_SIMPLEX, 0.8, color, 2)
+                    cv2.putText(result_img, prob_text, (x1, y1+20), cv2.FONT_HERSHEY_SIMPLEX, 0.6, color, 2)
+                    
+                elif "region" in result and result["region"] == "full_image":
+                    fake_prob = result["deepfake_prob"]
+                    real_prob = result.get("real_prob", 1.0 - fake_prob)
+                    is_fake = result["is_fake"]
+                    
+                    text = f"Image: {'FAKE' if is_fake else 'REAL'}"
+                    prob_text = f"FAKE: {fake_prob*100:.1f}%, REAL: {real_prob*100:.1f}%"
+                    color = (0, 0, 255) if is_fake else (0, 255, 0)
+                    
+                    if not isinstance(result_img, np.ndarray):
+                        result_img = np.array(result_img, dtype=np.uint8)
+                    
+                    cv2.putText(result_img, text, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, color, 2)
+                    cv2.putText(result_img, prob_text, (10, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.7, color, 2)
+            except Exception as e:
+                print(f"Error drawing result: {e}")
         
-        if success:
-            return f"✅ ANALYSE RÉUSSIE!\n\n{analysis_text}\n\n{email_msg}"
-        else:
-            return f"⚠️ ANALYSE TERMINÉE mais erreur email:\n\n{analysis_text}\n\n{email_msg}"
-            
+        return result_img
     except Exception as e:
-        error_msg = f"❌ Erreur lors de l'analyse: {str(e)}"
-        print(error_msg)
-        print(f"📋 Stack trace: {traceback.format_exc()}")
-        return error_msg
+        print(f"Error in visualization: {e}")
+        traceback.print_exc()
+        return np.array(image, dtype=np.uint8)
 
-def process_image_main(input_image, recipient_email, damage_threshold, deepfake_threshold, skip_damage, device_str, user_id):
-    """Fonction principale de traitement - version robuste"""
+def process_image(input_image, damage_threshold, deepfake_threshold, skip_damage, device_str, usage_count):
+    """Process an image through the detection pipeline"""
+    # Handle empty or None usage_count
+    if usage_count is None:
+        usage_count = 0
     
-    print("=" * 60)
-    print("🚀 DÉMARRAGE DU TRAITEMENT PRINCIPAL")
-    print(f"📧 Email: {recipient_email}")
-    print(f"🖼️ Image: {type(input_image)} - Present: {input_image is not None}")
-    print(f"👤 User ID: {user_id}")
-    print(f"⚙️ Device: {device_str}")
-    print("=" * 60)
+    # Ensure usage_count is an integer
+    try:
+        usage_count = int(usage_count)
+    except (TypeError, ValueError):
+        usage_count = 0
+        
+    # Increment usage count and check if limit reached
+    usage_count = usage_count + 1
     
-    # Validation de base
-    if not recipient_email or "@" not in recipient_email:
-        print("❌ Validation email échouée")
-        return "❌ Veuillez fournir une adresse email valide", user_id, get_user_tries(user_id)
+    progress_info = []
+    progress_info.append(f"Usage: {usage_count}/{MAX_TRIES}")
     
-    if input_image is None:
-        print("❌ Aucune image fournie")
-        return "❌ Veuillez télécharger une image à analyser", user_id, get_user_tries(user_id)
+    # Check if usage limit reached
+    if usage_count > MAX_TRIES:
+        return None, f"⚠️ You have reached the maximum number of tries allowed ({MAX_TRIES}).", usage_count
     
-    # Vérifier les limites d'usage
-    if not user_id:
-        user_id = get_or_create_user_id()
+    # Use default model paths
+    damage_model_path = DEFAULT_DAMAGE_MODEL_PATH
+    deepfake_model_path = DEFAULT_DEEPFAKE_MODEL_PATH
     
-    current_tries = get_user_tries(user_id)
-    if current_tries >= MAX_TRIES:
-        print(f"⚠️ Limite d'usage atteinte pour {user_id}")
-        return f"⚠️ Vous avez atteint la limite de {MAX_TRIES} analyses. Veuillez réessayer plus tard.", user_id, current_tries
+    # Check model files and use downloaded model if needed
+    if not skip_damage and damage_model_path:
+        if not os.path.exists(damage_model_path):
+            progress_info.append(f"INFO: Damage model not found, will analyze whole image")
     
-    # Incrémenter le compteur
-    new_tries = increment_user_tries(user_id)
+    # Vérifier si le modèle deepfake est disponible localement ou téléchargé
+    actual_deepfake_model_path = deepfake_model_path
+    if deepfake_model_path and not os.path.exists(deepfake_model_path):
+        if huggingface_model_path and os.path.exists(huggingface_model_path):
+            progress_info.append(f"INFO: Using Hugging Face model")
+            actual_deepfake_model_path = huggingface_model_path
+        else:
+            progress_info.append(f"WARNING: Deepfake model not found")
     
+    # Convert image to proper format
     try:
-        # Traitement de l'image
-        print("🔄 Conversion de l'image...")
+        if input_image is None:
+            return None, "Please upload an image to analyze.", usage_count
+            
         if isinstance(input_image, dict) and "path" in input_image:
             img = cv2.imread(input_image["path"])
         elif isinstance(input_image, str):
@@ -386,305 +579,377 @@ def process_image_main(input_image, recipient_email, damage_threshold, deepfake_
             if len(img.shape) == 3 and img.shape[2] == 3:
                 img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
         else:
-            print(f"❌ Format d'image non supporté: {type(input_image)}")
-            return f"❌ Format d'image non supporté: {type(input_image)}", user_id, new_tries
+            return None, "Error: Unsupported image format", usage_count
         
         if img is None:
-            print("❌ Impossible de lire l'image")
-            return "❌ Impossible de lire l'image", user_id, new_tries
-        
-        print(f"✅ Image chargée: {img.shape}")
-        
-        # Pour le moment, utiliser l'analyse simplifiée
-        print("🔄 Exécution de l'analyse simplifiée...")
-        result = create_simple_analysis(img, recipient_email, user_id)
+            return None, "Error: Could not read the image", usage_count
+    except Exception as e:
+        return None, f"Error loading image: {str(e)}", usage_count
+    
+    # Setup device
+    device = setup_device(device_str)
+    progress_info.append(f"Using device: {device}")
+    
+    # Initialize models
+    damage_detector = None
+    deepfake_model = None
+    
+    # Setup damage detector
+    if not skip_damage and damage_model_path:
+        progress_info.append("Setting up damage detector...")
+        damage_detector, _ = setup_damage_detector(damage_model_path, float(damage_threshold))
+        if damage_detector:
+            progress_info.append("✅ Damage detector initialized")
+        else:
+            progress_info.append("⚠️ Damage detector not available, analyzing whole image")
+        
+    # Setup deepfake detector with the appropriate path
+    if actual_deepfake_model_path:
+        progress_info.append(f"Setting up deepfake detector...")
+        deepfake_model = load_vit_deepfake_model(actual_deepfake_model_path, device)
+        if deepfake_model:
+            progress_info.append("✅ Deepfake detector initialized")
+        else:
+            progress_info.append("❌ Failed to initialize deepfake detector")
+     
+    # Step 1: Detect damage
+    progress_info.append("Detecting damaged regions...")
+    start_time = time.time()
+    img, damage_outputs, damage_regions = detect_damage(img, damage_detector)
+    damage_time = time.time() - start_time
+    
+    if damage_regions:
+        progress_info.append(f"Found {len(damage_regions)} damage regions in {damage_time:.2f} seconds")
+        # Add details about each damage region
+        for i, region in enumerate(damage_regions):
+            x1, y1, x2, y2 = region["box"]
+            score = region["score"]
+            progress_info.append(f"  - Region {i}: Score: {score:.2f}, Size: {x2-x1}x{y2-y1}px")
+    else:
+        progress_info.append("No damage regions detected")
+    
+    # Step 2: Check for deepfakes
+    deepfake_results = []
+    if deepfake_model is not None:
+        progress_info.append("Analyzing regions for deepfakes...")
+        start_time = time.time()
+        deepfake_results = check_deepfake_vit(
+            img, damage_regions, deepfake_model, device, float(deepfake_threshold)
+        )
+        deepfake_time = time.time() - start_time
         
-        print("✅ Analyse terminée avec succès")
-        return result, user_id, new_tries
+        if deepfake_results:
+            progress_info.append(f"Deepfake analysis completed in {deepfake_time:.2f} seconds")
+            
+            # Generate detailed report
+            progress_info.append("\n🔍 DETAILED DEEPFAKE ANALYSIS:")
+            for result in deepfake_results:
+                if "region_id" in result:
+                    region_id = result["region_id"]
+                    fake_prob = result["deepfake_prob"]
+                    real_prob = result.get("real_prob", 1.0 - fake_prob)
+                    is_fake = result["is_fake"]
+                    progress_info.append(f"Region {region_id}: {'🚨 FAKE' if is_fake else '✅ REAL'}")
+                    progress_info.append(f"  - Fake probability: {fake_prob*100:.2f}%")
+                    progress_info.append(f"  - Real probability: {real_prob*100:.2f}%")
+                    
+                elif "region" in result and result["region"] == "full_image":
+                    fake_prob = result["deepfake_prob"]
+                    real_prob = result.get("real_prob", 1.0 - fake_prob)
+                    is_fake = result["is_fake"]
+                    progress_info.append(f"Whole image: {'🚨 FAKE' if is_fake else '✅ REAL'}")
+                    progress_info.append(f"  - Fake probability: {fake_prob*100:.2f}%")
+                    progress_info.append(f"  - Real probability: {real_prob*100:.2f}%")
+        else:
+            progress_info.append("No deepfake detection results.")
+    
+    # Final verdict with more details
+    fake_regions = [r for r in deepfake_results if r.get("is_fake", False)]
+    if fake_regions:
+        fake_count = len(fake_regions)
+        total_count = len(deepfake_results)
+        progress_info.append(f"\n🚨 VERDICT: This image contains FAKE damage ({fake_count}/{total_count} regions) 🚨")
+        
+        # Calculate average fake probability
+        avg_fake_prob = sum(r["deepfake_prob"] for r in fake_regions) / len(fake_regions)
+        progress_info.append(f"Average fake probability: {avg_fake_prob*100:.2f}%")
+        
+        # Identify the most suspicious region
+        most_fake_region = max(deepfake_results, key=lambda r: r.get("deepfake_prob", 0))
+        if "region_id" in most_fake_region:
+            most_fake_id = most_fake_region["region_id"]
+            most_fake_prob = most_fake_region["deepfake_prob"]
+            progress_info.append(f"Most suspicious region: Region {most_fake_id} ({most_fake_prob*100:.2f}% fake)")
+        elif "region" in most_fake_region and most_fake_region["region"] == "full_image":
+            most_fake_prob = most_fake_region["deepfake_prob"]
+            progress_info.append(f"Whole image is suspicious: {most_fake_prob*100:.2f}% fake")
+    else:
+        if deepfake_results:
+            # Calculate average real probability
+            avg_real_prob = sum(r.get("real_prob", 1.0 - r["deepfake_prob"]) for r in deepfake_results) / len(deepfake_results)
+            progress_info.append(f"\n✅ VERDICT: All damage appears REAL (Average confidence: {avg_real_prob*100:.2f}%)")
+        else:
+            progress_info.append("\n⚠️ VERDICT: Could not determine if damage is real or fake")
         
-    except Exception as e:
-        error_msg = f"❌ Erreur durant le traitement: {str(e)}"
-        print(error_msg)
-        print(f"📋 Stack trace complet:")
-        print(traceback.format_exc())
-        return error_msg, user_id, new_tries
-
-def create_gradio_interface():
-    """Créer l'interface Gradio avec gestion d'erreur robuste"""
+    # Step 3: Visualize results
+    result_img = visualize_results(img, damage_outputs, deepfake_results, float(damage_threshold))
+    
+    # Convert back to RGB for Gradio
+    if len(result_img.shape) == 3 and result_img.shape[2] == 3:
+        result_img = cv2.cvtColor(result_img, cv2.COLOR_BGR2RGB)
     
-    print("🎨 Création de l'interface Gradio...")
+    # Add usage information at the bottom of the image
+    if usage_count >= MAX_TRIES:
+        # Add a "Usage limit reached" message to the bottom of the image in red
+        cv2.putText(result_img, f"USAGE LIMIT REACHED: {usage_count}/{MAX_TRIES}", 
+                    (10, result_img.shape[0] - 20), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 0, 0), 2)
+    else:
+        # Add a usage counter to the bottom of the image
+        cv2.putText(result_img, f"Usage: {usage_count}/{MAX_TRIES}", 
+                    (10, result_img.shape[0] - 20), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
+    
+    # Add a timestamp to the image
+    timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
+    cv2.putText(result_img, f"Analysis time: {timestamp}", 
+                (10, result_img.shape[0] - 50), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
+    
+    # Add usage info to the progress text
+    if usage_count >= MAX_TRIES:
+        progress_info.append("\n⚠️ You have reached the maximum number of tries allowed ⚠️")
+    else:
+        progress_info.append(f"\nRemaining tries: {MAX_TRIES - usage_count}")
+    
+    return result_img, "\n".join(progress_info), usage_count
+
+def send_email_wrapper(recipient_email, result_image, analysis_text):
+    """Wrapper function for sending email results"""
+    if not recipient_email:
+        return "⚠️ Please enter an email address"
     
+    success, message = send_results_by_email(recipient_email, analysis_text, result_image)
+    return message
+
+def create_gradio_interface():
     # Define a theme
     theme = gr.themes.Soft(
         primary_hue="blue",
         secondary_hue="orange",
     )
     
-    # JavaScript simplifié pour le debugging
-    simple_js = """
-    console.log("🚀 JavaScript Gradio chargé");
-    
-    // Fonction pour générer un ID utilisateur simple
-    function getSimpleUserId() {
-        const timestamp = Date.now();
-        const random = Math.random().toString(36).substr(2, 5);
-        const userId = `user_${random}_${timestamp}`;
-        console.log("🆔 User ID généré:", userId);
-        return userId;
-    }
-    
-    // Initialiser l'ID utilisateur
-    window.currentUserId = getSimpleUserId();
-    
-    // Fonctions de test
-    window.testFunction = function() {
-        console.log("✅ Test fonction JavaScript OK");
-        return true;
-    };
-    
-    console.log("✅ JavaScript initialisé avec User ID:", window.currentUserId);
-    """
-    
-    with gr.Blocks(title="Car Damage & Deepfake Detector", theme=theme, js=simple_js) as app:
-        
-        # Header
+    with gr.Blocks(title="Car Damage & Deepfake Detector", theme=theme) as app:
         gr.Markdown("""
         # 🚗 Car Damage Fraud Detector 
         
-        **Version de test simplifiée** - Upload a car image and provide your email to:
+        Upload a car image to:
         1. **Detect damaged areas** using AI
-        2. **Verify if damage is real** or artificially generated  
-        3. **Receive detailed results by email** 📧
+        2. **Verify if damage is real** or artificially generated (deepfake)
+        3. **Send results by email** 📧
         
-        ⚠️ **Note: Maximum 5 analyses per user.**
+        ⚠️ **Note: You have a maximum of 5 tries to analyze images.**
         """)
         
-        # État pour l'ID utilisateur - initialisé directement
-        user_id_state = gr.State(value=get_or_create_user_id())
-        
-        # Interface principale
+        usage_counter = gr.State(0)
+
+        # Main Interface Tab
         with gr.Tab("🔍 Analyze Image"):
             with gr.Row():
                 with gr.Column(scale=1):
-                    # Email input (required)
-                    recipient_email = gr.Textbox(
-                        label="📧 Your Email Address (Required)",
-                        placeholder="votre.email@exemple.com",
-                        info="Results will be sent to this email address"
-                    )
-                    
-                    input_image = gr.Image(
-                        type="numpy", 
-                        label="Upload Car Image",
-                        height=300
-                    )
+                    input_image = gr.Image(type="numpy", label="Upload Car Image")
                     
                     with gr.Row():
-                        process_btn = gr.Button(
-                            "🚀 Analyze & Send Results", 
-                            variant="primary", 
-                            size="lg"
-                        )
+                        process_btn = gr.Button("🚀 Analyze Image", variant="primary", size="lg")
                         clear_btn = gr.Button("🗑️ Clear", variant="secondary")
                     
-                    # Usage display
+                    # Usage limit display
                     usage_display = gr.Markdown("**Usage: 0/5**")
                     
-                    # Advanced settings (simplifié)
+                    # Email section
+                    with gr.Accordion("📧 Send Results by Email", open=False):
+                        recipient_email = gr.Textbox(
+                            label="Email Address",
+                            placeholder="Enter email to receive detailed results...",
+                            info="Professional report with annotated images will be sent"
+                        )
+                        send_email_btn = gr.Button("📤 Send Results by Email", variant="secondary", size="sm")
+                        email_status = gr.Markdown("")
+                    
                     with gr.Accordion("⚙️ Advanced Settings", open=False):
                         skip_damage = gr.Checkbox(
                             label="Skip Damage Detection", 
                             value=False,
-                            info="Analyze entire image for deepfakes"
+                            info="Analyze entire image for deepfakes without damage detection"
                         )
                         damage_threshold = gr.Slider(
                             minimum=0.1, maximum=1.0, value=0.7, step=0.05,
-                            label="Damage Detection Threshold"
+                            label="Damage Detection Threshold",
+                            info="Higher = more selective damage detection"
                         )
                         deepfake_threshold = gr.Slider(
                             minimum=0.1, maximum=1.0, value=0.5, step=0.05,
-                            label="Deepfake Detection Threshold"
+                            label="Deepfake Detection Threshold", 
+                            info="Higher = more selective fake detection"
                         )
                         device = gr.Dropdown(
                             choices=["auto", "cuda", "cpu", "mps"], 
                             value="auto",
-                            label="Computation Device"
+                            label="Computation Device",
+                            info="Auto selects best available device"
                         )
                         
                 with gr.Column(scale=1):
-                    gr.Markdown("### 📋 Analysis Status")
-                    
-                    output_text = gr.Markdown("""
-                    **Ready to analyze!**
+                    output_image = gr.Image(type="numpy", label="🎯 Analysis Result")
                     
-                    1. Enter your email address
-                    2. Upload a car image 
-                    3. Click "Analyze & Send Results"
-                    4. Check your email for detailed results
-                    
-                    🔧 **Current Status**: Test mode - simplified analysis
-                    """)
-                    
-                    # Status détaillé
-                    with gr.Accordion("🔍 Processing Details", open=False):
-                        processing_details = gr.Markdown("Waiting for analysis...")
+                    # Analysis info with nice formatting
+                    with gr.Accordion("📋 Analysis Details", open=True):
+                        output_text = gr.Markdown("Upload an image and click 'Analyze Image' to start...")
 
-        # Tab d'aide (raccourci)
         with gr.Tab("❓ Help"):
             gr.Markdown("""
             ## 📋 How to Use This Tool
             
-            ### 🚀 Quick Start (Test Mode)
-            1. **Enter your email** - Required to receive results
-            2. **Upload** a car image
-            3. **Click "Analyze & Send Results"**
-            4. **Check your email** for analysis report
+            ### 🚀 Quick Start
+            1. **Upload** a car image showing damage
+            2. **Click "Analyze Image"** and wait for processing
+            3. **View results** - damaged areas highlighted in green (real) or red (fake)
+            4. **Optional**: Send detailed results to your email
+            
+            ### 📧 Email Feature
+            - Enter your email address in the "Send Results by Email" section
+            - Click "Send Results by Email" after analysis is complete
+            - Receive a professional HTML report with annotated images
+            - Results include confidence scores and recommendations
+            
+            ### 🎯 Understanding Results
+            
+            #### Visual Indicators
+            - **🟢 Green boxes**: Real damage detected
+            - **🔴 Red boxes**: Potential deepfake damage detected
+            - **Percentages**: Confidence scores (higher = more confident)
+            
+            #### Verdict Types
+            - **✅ REAL**: Damage appears authentic
+            - **🚨 FAKE**: Damage shows signs of AI generation
+            - **⚠️ UNCERTAIN**: Analysis inconclusive
+            
+            ### ⚙️ Advanced Settings
+            
+            - **Damage Threshold**: Controls sensitivity of damage detection
+              - Higher values = only high-confidence damage regions shown
+              - Lower values = more damage regions detected
+            
+            - **Deepfake Threshold**: Controls sensitivity of fake detection
+              - Higher values = more selective in flagging fakes
+              - Lower values = more aggressive fake detection
+            
+            - **Skip Damage Detection**: Analyze entire image for deepfakes
+              - Useful when damage areas are already known
+              - Speeds up processing for whole-image analysis
+            
+            ### 🏁 Use Cases
             
-            ### 🔧 Current Status
-            - **Test mode active**: Simplified analysis pipeline
-            - **Email delivery**: Fully functional
-            - **AI models**: Loading in progress
-            - **Usage limit**: 5 analyses per user
+            #### 🏢 Insurance Companies
+            - Verify claim authenticity before processing
+            - Detect fraudulent damage submissions
+            - Streamline claim review process
             
-            ### 📧 What You'll Receive
-            - Basic image analysis report
-            - Test annotations on your image
-            - Professional email format
-            - Technical details about the process
+            #### 🚗 Car Dealerships
+            - Document vehicle condition accurately
+            - Verify repair estimates and warranties
+            - Assess trade-in vehicle damage
             
-            ### 🚨 Note
-            This is a test version. Full AI analysis with damage detection and deepfake verification will be available soon.
+            #### 👤 Individual Users
+            - Verify repair shop estimates
+            - Document accident damage for insurance
+            - Check if damage photos are authentic
+            
+            ### ⚠️ Important Notes
+            
+            - **Not a replacement** for professional inspection
+            - **AI predictions** should be verified by experts
+            - **Image quality** affects detection accuracy
+            - **Lighting conditions** can impact results
+            - **5 tries maximum** per session to prevent abuse
+            
+            ### 🔒 Privacy & Security
+            
+            - **No data storage**: Images processed in real-time only
+            - **Secure email**: Encrypted SMTP connections
+            - **No tracking**: Privacy-first approach
+            - **Email only**: For sending results, not stored
+            
+            ### 💡 Tips for Best Results
+            
+            1. **Good lighting**: Clear, well-lit images work best
+            2. **Close-up shots**: Focus on damaged areas
+            3. **High resolution**: Better quality = better detection
+            4. **Multiple angles**: Try different perspectives if results unclear
+            5. **Clean lens**: Ensure camera lens is clean
+            
+            ### 🔬 Technology Behind the Scenes
+            
+            - **Detectron2**: Facebook's object detection framework
+            - **Vision Transformer (ViT)**: Advanced deepfake detection
+            - **Pre-trained models**: Fine-tuned on automotive datasets
+            - **Multi-stage pipeline**: Damage detection → Deepfake analysis
             
             ---
-            **🚀 Ready to test? Enter your email and upload an image!**
+            
+            **🚨 Disclaimer**: This tool assists in damage assessment but should not replace professional inspection. Always consult qualified experts for final decisions on insurance claims or vehicle repairs.
+            
+            **Powered by Askhedi** - Advanced AI Detection Services 🚀
             """)
-        
-        # Exemples d'images (si disponibles)
-        existing_samples = [img for img in SAMPLE_IMAGES if os.path.exists(img)]
-        if existing_samples:
+            
+        # Examples
+        if any(os.path.exists(img) for img in SAMPLE_IMAGES):
             gr.Markdown("## 📸 Example Images")
             with gr.Row():
+                example_inputs = [img for img in SAMPLE_IMAGES if os.path.exists(img)]
                 gr.Examples(
-                    examples=existing_samples,
+                    examples=example_inputs,
                     inputs=input_image,
-                    label="Click on an example image to load it"
+                    outputs=[output_image, output_text, usage_counter],
+                    fn=lambda x: process_image(x, 0.7, 0.5, False, "auto", 0),
+                    cache_examples=True
                 )
         
-        # Fonction de traitement simplifiée pour l'interface
-        def process_for_interface(input_image, recipient_email, damage_threshold, deepfake_threshold, skip_damage, device, user_id):
-            """Wrapper pour l'interface Gradio"""
-            print("\n" + "="*50)
-            print("🎯 TRAITEMENT INTERFACE GRADIO")
-            print("="*50)
-            
-            try:
-                # Validation immédiate
-                if not recipient_email:
-                    return "❌ Veuillez entrer une adresse email", user_id, get_user_tries(user_id), "❌ Email manquant"
-                
-                if "@" not in recipient_email:
-                    return "❌ Adresse email invalide (manque @)", user_id, get_user_tries(user_id), "❌ Email invalide"
-                
-                if input_image is None:
-                    return "❌ Veuillez télécharger une image", user_id, get_user_tries(user_id), "❌ Image manquante"
-                
-                # Appeler la fonction principale
-                result, updated_user_id, usage_count = process_image_main(
-                    input_image, recipient_email, damage_threshold, 
-                    deepfake_threshold, skip_damage, device, user_id
-                )
-                
-                # Mettre à jour les détails de traitement
-                details = f"✅ Analyse terminée pour {recipient_email}\n📊 Usage: {usage_count}/{MAX_TRIES}\n⏰ {datetime.now().strftime('%H:%M:%S')}"
-                
-                return result, updated_user_id, usage_count, details
-                
-            except Exception as e:
-                error_msg = f"💥 Erreur interface: {str(e)}"
-                print(error_msg)
-                print(traceback.format_exc())
-                return error_msg, user_id, get_user_tries(user_id), f"💥 Exception: {str(e)}"
-        
-        # Connecter le bouton principal
+        # Connect functions to the UI
         process_btn.click(
-            fn=process_for_interface,
+            fn=process_image,
             inputs=[
                 input_image, 
-                recipient_email,
                 damage_threshold,
                 deepfake_threshold,
                 skip_damage,
                 device,
-                user_id_state
+                usage_counter
             ],
-            outputs=[output_text, user_id_state, usage_display, processing_details]
+            outputs=[output_image, output_text, usage_counter]
         )
         
-        # Fonction de nettoyage
-        def clear_interface():
-            """Nettoyer l'interface"""
-            print("🧹 Nettoyage de l'interface")
-            return [
-                None,  # input_image
-                "",    # recipient_email
-                """**Ready to analyze!**
-                
-1. Enter your email address
-2. Upload a car image 
-3. Click "Analyze & Send Results"
-4. Check your email for detailed results
-
-🔧 **Current Status**: Test mode - simplified analysis""",  # output_text
-                "Interface nettoyée - Ready for new analysis"  # processing_details
-            ]
+        # Email sending functionality
+        send_email_btn.click(
+            fn=send_email_wrapper,
+            inputs=[recipient_email, output_image, output_text],
+            outputs=email_status
+        )
         
+        # Clear button functionality
         clear_btn.click(
-            fn=clear_interface,
+            fn=lambda: [None, "Upload an image and click 'Analyze Image' to start...", 0, ""],
             inputs=[],
-            outputs=[input_image, recipient_email, output_text, processing_details]
+            outputs=[output_image, output_text, usage_counter, email_status]
         )
         
-        # Mettre à jour l'affichage d'usage
-        def update_usage_display(user_id):
-            """Mettre à jour l'affichage d'usage"""
-            if user_id:
-                tries = get_user_tries(user_id)
-                return f"**Usage: {tries}/{MAX_TRIES}**"
-            return "**Usage: 0/5**"
-        
-        # Mettre à jour l'usage quand l'user_id change
-        user_id_state.change(
-            fn=update_usage_display,
-            inputs=[user_id_state],
+        # Update usage display when counter changes
+        usage_counter.change(
+            fn=lambda count: f"**Usage: {count}/{MAX_TRIES}**",
+            inputs=[usage_counter],
             outputs=[usage_display]
         )
         
-    print("✅ Interface Gradio créée avec succès")
     return app
 
 if __name__ == "__main__":
-    print("\n" + "="*60)
-    print("🚀 LANCEMENT DE L'APPLICATION")
-    print("="*60)
-    
-    # Vérifier la configuration
-    print("🔍 Vérification de la configuration:")
-    print(f"📧 Email configuré: {EMAIL_CONFIG['EMAIL']}")
-    print(f"🤖 Detectron2 disponible: {DETECTRON2_AVAILABLE}")
-    print(f"📱 Modèle HF téléchargé: {huggingface_model_path is not None}")
-    print(f"💾 Modèle local damage: {os.path.exists(DEFAULT_DAMAGE_MODEL_PATH)}")
-    print(f"🧠 Modèle local deepfake: {os.path.exists(DEFAULT_DEEPFAKE_MODEL_PATH)}")
-    
-    try:
-        # Create and launch the Gradio app
-        app = create_gradio_interface()
-        print("🚀 Lancement de l'interface Gradio...")
-        app.launch(
-            share=False,
-            server_name="0.0.0.0",
-            server_port=7860,
-            show_error=True
-        )
-    except Exception as e:
-        print(f"💥 ERREUR CRITIQUE: {e}")
-        print(traceback.format_exc())
+    # Create and launch the Gradio app
+    app = create_gradio_interface()
+    app.launch(share=False)