Update core/app.py

core/app.py

@@ -1,1054 +1,642 @@
+#!/usr/bin/env python3
 """
-MyAvatar - Complete AI Avatar Video Generation Platform
-========================================================
-Modular version with enhanced organization - REFACTORED ROUTES + PREMIUM FEATURES + BACKGROUNDFX + VIDEO PROCESSING
+BackgroundFX Pro – Main Application Entry Point
+Refactored modular architecture – orchestrates specialised components
 """
-from fastapi import FastAPI, Request, HTTPException, Depends
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.staticfiles import StaticFiles
-from fastapi.templating import Jinja2Templates
-import uvicorn
-from app.database.database import init_database, create_admin_user, update_database_schema
-from app.utils.logging_config import logger, log_info, log_error, log_compatibility_status
-import gradio as gr
-from app.tools.huggingface_app import huggingface_gradio_app
-from dotenv import load_dotenv
+from __future__ import annotations
+# ── Early env/threading hygiene (safe default to silence libgomp) ────────────
 import os
+os.environ["OMP_NUM_THREADS"] = "2"  # Force valid value early
+# If you use early_env in your project, keep this import (harmless if absent)
+try:
+    import early_env # sets OMP/MKL/OPENBLAS + torch threads safely
+except Exception:
+    pass
 import logging
-import traceback
-import uuid
 import threading
-from datetime import datetime
-from typing import Optional
-from pathlib import Path
+import traceback
 import sys
-
-# Load environment variables
-load_dotenv()
-
-# Define the base directory of the project
-BASE_DIR = Path(__file__).resolve().parent
-
-# Setup logging
+import time
+from pathlib import Path
+from typing import Optional, Tuple, Dict, Any, Callable
+# Mitigate CUDA fragmentation (must be set before importing torch)
+if "PYTORCH_CUDA_ALLOC_CONF" not in os.environ:
+    os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True,max_split_size_mb:128"
+# ── Logging ──────────────────────────────────────────────────────────────────
 logging.basicConfig(
-  level=logging.INFO,
-  format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger("MyAvatar")
-
-# SAFE IMPORTS - wrap in try/catch to prevent startup crashes
-try:
-  from app.services.notifications import send_alert, notify_service_status
-except ImportError as e:
-  logger.warning(f"Notifications service not available: {e}")
-  def notify_service_status(*args, **kwargs): pass
-
-try:
-  # Import compatibility mode checking
-  from app.compatibility import ENABLE_SAFE_MODE, ENABLE_BACKGROUND_REPLACEMENT, log_compatibility_status
-except ImportError as e:
-  logger.warning(f"Compatibility module not available: {e}")
-  ENABLE_SAFE_MODE = True
-  ENABLE_BACKGROUND_REPLACEMENT = False
-  def log_compatibility_status(): return {"safe_mode": True}
-
-try:
-  # Import modular components
-  from app.logger.log_handler import log_handler, log_info, log_error, log_warning
-except ImportError as e:
-  logger.warning(f"Log handler not available: {e}")
-  def log_info(msg, context): logger.info(f"[{context}] {msg}")
-  def log_error(msg, context, exc=None): logger.error(f"[{context}] {msg}")
-  def log_warning(msg, context): logger.warning(f"[{context}] {msg}")
-
-try:
-  from app.db.database import init_database, update_database_schema, get_db_connection
-  from app.db.admin import create_admin_user
-except ImportError as e:
-  logger.error(f"Database modules not available: {e}")
-  def init_database(): pass
-  def update_database_schema(): pass
-  def create_admin_user(): pass
-
-# Import HeyGen API for debug endpoints
-try:
-  from app.api.heygen import get_available_avatars
-except ImportError as e:
-  logger.warning(f"HeyGen API module not available: {e}")
-  def get_available_avatars(*args, **kwargs): 
-      return {"error": "HeyGen API not available"}
-
-# IMPORT VIDEO URL REFRESHER
-try:
-  from video_url_refresher import VideoURLRefresher
-  video_refresher_available = True
-  logger.info("Video URL refresher imported successfully")
-except ImportError as e:
-  logger.warning(f"Video URL refresher not available: {e}")
-  video_refresher_available = False
-
-# FASTAPI APP INITIALIZATION
-app = FastAPI(title="MyAvatar", description="AI Avatar Video Generation Platform - Premium Edition with BackgroundFX + Advanced Video Processing")
-
-# AUTO-RUN DATABASE MIGRATIONS ON STARTUP
-try:
-    logger.info("🔄 Starting database migration process...")
-    logger.info(f"🔍 Current working directory: {os.getcwd()}")
-    logger.info(f"🔍 Python path: {sys.path[:3]}...")  # Show first 3 paths
-    
-    # Try to import migration runner
-    logger.info("📦 Importing migration runner...")
-    from run_migrations import run_migrations
-    logger.info("✅ Migration runner imported successfully")
-    
-    # Run migrations
-    logger.info("🚀 Executing migrations...")
-    migration_success = run_migrations()
-    
-    if migration_success:
-        logger.info("🎉 Database migrations completed successfully")
-    else:
-        logger.error("❌ Database migrations failed - this will cause upload errors")
-        
-except ImportError as e:
-    logger.error(f"❌ Could not import migration runner: {e}")
-    logger.error("📁 This means video processing will fail - missing database tables")
-except Exception as e:
-    logger.error(f"❌ Migration error: {e}")
-    logger.error("📁 This will cause video upload failures")
-    import traceback
-    logger.error(f"🔍 Full traceback: {traceback.format_exc()}")
-
-# CORS middleware
-app.add_middleware(
-  CORSMiddleware,
-  allow_origins=["*"],
-  allow_credentials=True,  
-  allow_methods=["*"],
-  allow_headers=["*"],
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
 )
-
-# Exception handler
-@app.exception_handler(Exception)
-async def global_exception_handler(request: Request, exc: Exception):
-  log_error(f"Uncaught exception: {str(exc)}", "Server", exc)
-  return JSONResponse(
-      status_code=500,
-      content={"detail": "Internal server error", "message": str(exc)}
-  )
-
-# Mount static files safely
-try:
-  app.mount("/static", StaticFiles(directory=BASE_DIR / "static"), name="static")
-except Exception as e:
-  logger.warning(f"Could not mount static files: {e}")
-
-
-# =============================================================================
-# VIDEO URL REFRESHER BACKGROUND SERVICE
-# =============================================================================
-
-def start_video_url_refresher():
-  """Start the video URL refresher in a background thread"""
-  try:
-      if not video_refresher_available:
-          logger.warning("Video URL refresher not available - skipping background service")
-          return
-      
-      logger.info("Starting video URL refresher background service...")
-      refresher = VideoURLRefresher()
-      
-      # Configure intervals from environment variables
-      interval_hours = int(os.getenv('REFRESH_INTERVAL_HOURS', '4'))
-      threshold_hours = int(os.getenv('EXPIRY_THRESHOLD_HOURS', '6'))
-      
-      logger.info(f"Video URL refresher configured:")
-      logger.info(f"  • Refresh interval: {interval_hours} hours")
-      logger.info(f"  • Expiry threshold: {threshold_hours} hours")
-      
-      # Run the refresher continuously
-      refresher.run_continuous(interval_hours=interval_hours, hours_threshold=threshold_hours)
-      
-  except Exception as e:
-      logger.error(f"Error starting video URL refresher: {e}")
-      logger.error(f"Video URL refresher traceback: {traceback.format_exc()}")
-
-# Start the background refresher service
-if video_refresher_available:
-  refresher_thread = threading.Thread(target=start_video_url_refresher, daemon=True)
-  refresher_thread.start()
-  logger.info("✅ Video URL refresher background service started")
-else:
-  logger.warning("⚠️ Video URL refresher background service not started - module not available")
-
-# ============================================================================
-# GRADIO MONKEY PATCH (BUG FIX for gradio>=4.44.0)
-# ============================================================================
-# Addresses a schema validation issue where booleans are not handled correctly.
-# See memory: 6d1e1af9-ea10-4f3d-b9d5-45c2657ebcf6
-
+logger = logging.getLogger("core.app")
+# ── Ensure project root importable ───────────────────────────────────────────
+PROJECT_FILE = Path(__file__).resolve()
+CORE_DIR = PROJECT_FILE.parent
+ROOT = CORE_DIR.parent
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+# Create loader directories if they don't exist
+loaders_dir = ROOT / "models" / "loaders"
+loaders_dir.mkdir(parents=True, exist_ok=True)
+# ── Gradio schema patch (HF quirk) ───────────────────────────────────────────
 try:
     import gradio_client.utils as gc_utils
-    original_get_type = gc_utils.get_type
-
-    def patched_get_type(schema):
-        # The original function fails if schema is not a dict, handle this gracefully
+    _orig_get_type = gc_utils.get_type
+    def _patched_get_type(schema):
         if not isinstance(schema, dict):
-            # if the schema is a boolean, return "boolean" to avoid an iteration error
-            if isinstance(schema, bool):
-                return "boolean"
-            # Fallback for other unexpected schema formats
+            if isinstance(schema, bool): return "boolean"
+            if isinstance(schema, str): return "string"
+            if isinstance(schema, (int, float)): return "number"
             return "string"
-        return original_get_type(schema)
-
-    gc_utils.get_type = patched_get_type
-    logging.info("✅ Applied Gradio schema validation monkey patch.")
-except (ImportError, AttributeError) as e:
-    logging.warning(f"⚠️ Could not apply Gradio monkey patch: {e}")
-
-# ============================================================================
-# APPLICATION STARTUP
-# ============================================================================
-
-# Perform initial setup
-def ensure_directories():
-    # Ensure necessary directories exist
-    directories = ['static', 'templates', 'app/database']
-    for directory in directories:
-        dir_path = BASE_DIR / directory
-        if not dir_path.exists():
-            os.makedirs(dir_path)
-
-def install_system_dependencies():
-    # Install system dependencies
-    # Add your system dependencies installation code here
-    pass
-
-def install_python_requirements():
-    # Install Python requirements
-    # Add your Python requirements installation code here
-    pass
-
-ensure_directories()
-install_system_dependencies()
-install_python_requirements()
-
-# ============================================================================
-# FASTAPI APPLICATION
-# =============================================================================
-
-# Initialize file change tracker
-try:
-  from app.startup.file_tracker_startup import initialize_file_tracker
-  initialize_file_tracker()
-except ImportError as e:
-  logger.warning(f"File change tracker not available: {e}")
+        return _orig_get_type(schema)
+    gc_utils.get_type = _patched_get_type
+    logger.info("Gradio schema patch applied")
 except Exception as e:
-  logger.error(f"Error starting file change tracker: {e}")
-
-# =============================================================================
-# MODULAR ROUTE IMPORTS - REFACTORED STRUCTURE + PREMIUM FEATURES + BACKGROUNDFX + VIDEO PROCESSING
-# =============================================================================
-
-routers_loaded = []
-router_errors = []
-
-# 🔄 NEW MODULAR ROUTES (split from old web_routes.py)
-modular_route_imports = [
-  # Core authentication and user routes (no prefix - root level)
-  ("app.routes.auth_routes", "router", None),
-  
-  # Admin routes with /admin prefix
-  ("app.routes.admin_routes", "router", "/admin"),
-  
-  # API routes with /api prefix - UNCOMMENTED to enable video creation endpoints
-  ("app.routes.api_routes", "router", "/api"),
-  
-  # 🎯 PREMIUM ROUTES - NEW COMPLETE PREMIUM SYSTEM - FIXED IMPORT PATH
-  ("app.routes.premium_routes", "router", None),  # ✅ FIXED - Now uses app.routes.premium_routes
-  
-  # 🎯 BACKGROUNDFX ROUTES - NEW HeyGen WebM + Transparent Video System
-  ("app.routes.backgroundfx_routes", "router", None),  # No prefix since it has its own /api/backgrounds
-  
-  # 🎬 VIDEO PROCESSING ROUTES - NEW Advanced Background Replacement API
-  ("app.routes.video_processing_routes", "router", "/video-processing"),
-  
-  # Video routes with NO prefix - FIXED for template routes
-  ("app.routes.video_routes", "router", None),
-  
-  # Emergency routes with /emergency prefix
-  ("app.routes.emergency_routes", "router", "/emergency"),
-  
-  # File tracker routes with /admin/file-tracker prefix
-  ("app.routes.file_tracker_routes", "router", "/admin/file-tracker"),
-  
-  # Dashboard and main app routes (if you create web_routes.py for remaining routes)
-  ("app.routes.web_routes", "router", None),
-]
-
-# Load modular routes with prefixes
-for module_name, router_name, prefix in modular_route_imports:
-  try:
-      logger.info(f"Attempting to import {module_name}...")
-      module = __import__(module_name, fromlist=[router_name])
-      logger.info(f"Successfully imported {module_name}, getting router...")
-      router = getattr(module, router_name)
-      logger.info(f"Got router from {module_name}, including in app with prefix: {prefix}")
-      
-      if prefix:
-          app.include_router(router, prefix=prefix)
-          logger.info(f"✅ Successfully loaded router: {module_name} (prefix: {prefix})")
-      else:
-          app.include_router(router)
-          logger.info(f"✅ Successfully loaded router: {module_name} (no prefix)")
-          
-      routers_loaded.append(f"{module_name}{' -> ' + prefix if prefix else ''}")
-      
-  except Exception as e:
-      error_details = {
-          "module": module_name,
-          "error": str(e),
-          "traceback": traceback.format_exc()
-      }
-      router_errors.append(error_details)
-      logger.error(f"❌ Could not load router {module_name}: {e}")
-      logger.error(f"Full traceback: {traceback.format_exc()}")
-
-# 🔧 LEGACY/REMAINING ROUTES (keep your existing working routes)
-legacy_route_imports = [
-  # Keep these existing routes that still work
-  ("app.routes.health_routes", "router"),
-  ("app.routes.debug_routes", "router"), 
-  ("app.routes.voice_routes", "router"),
-  ("app.routes.avatar_rebuild_route", "router"),
-  ("app.routes.migration_routes", "router"),
-  ("app.routes.finance_routes", "router"),
+    logger.warning(f"Gradio patch failed: {e}")
+# ── Core config + components ─────────────────────────────────────────────────
+try:
+    from config.app_config import get_config
+except ImportError:
+    # Dummy if missing
+    class DummyConfig:
+        def to_dict(self):
+            return {}
+    get_config = lambda: DummyConfig()
+from utils.hardware.device_manager import DeviceManager
+from utils.system.memory_manager import MemoryManager
+# Try to import the new split loaders first, fall back to old if needed
+try:
+    from models.loaders.model_loader import ModelLoader
+    logger.info("Using split loader architecture")
+except ImportError:
+    logger.warning("Split loaders not found, using legacy loader")
+    # Fall back to old loader if split architecture isn't available yet
+    from models.model_loader import ModelLoader # type: ignore
+from processing.video.video_processor import CoreVideoProcessor
+from processing.audio.audio_processor import AudioProcessor
+from utils.monitoring.progress_tracker import ProgressTracker
+from utils.cv_processing import validate_video_file
+# ── Optional Two-Stage import ────────────────────────────────────────────────
+TWO_STAGE_AVAILABLE = False
+TWO_STAGE_IMPORT_ORIGIN = ""
+TWO_STAGE_IMPORT_ERROR = ""
+CHROMA_PRESETS: Dict[str, Dict[str, Any]] = {"standard": {}}
+TwoStageProcessor = None # type: ignore
+# Try multiple import paths for two-stage processor
+two_stage_paths = [
+    "processors.two_stage", # Your fixed version
+    "processing.two_stage.two_stage_processor",
+    "processing.two_stage",
 ]
-
-# Load legacy routes (no prefixes)
-for module_name, router_name in legacy_route_imports:
-  try:
-      logger.info(f"Attempting to import legacy route {module_name}...")
-      module = __import__(module_name, fromlist=[router_name])
-      logger.info(f"Successfully imported {module_name}, getting router...")
-      router = getattr(module, router_name)
-      logger.info(f"Got router from {module_name}, including in app...")
-      app.include_router(router)
-      routers_loaded.append(f"{module_name} (legacy)")
-      logger.info(f"✅ Successfully loaded legacy router: {module_name}")
-  except Exception as e:
-      error_details = {
-          "module": module_name,
-          "error": str(e),
-          "traceback": traceback.format_exc()
-      }
-      router_errors.append(error_details)
-      logger.error(f"❌ Could not load legacy router {module_name}: {e}")
-      logger.error(f"Full traceback: {traceback.format_exc()}")
-
-# Background routes - conditional and safe
-if ENABLE_BACKGROUND_REPLACEMENT:
-  try:
-      from app.database.background_schema import initialize_backgrounds_schema, add_default_backgrounds
-      from app.routes.background_routes import router as background_router
-      app.include_router(background_router, prefix="/background", tags=["background"])
-      routers_loaded.append("background_routes -> /background")
-      logger.info("Background replacement routes loaded")
-  except Exception as e:
-      logger.warning(f"Could not load background routes: {e}")
-
-# =============================================================================
-# BACKGROUNDFX PAGE ROUTE - Serve the HTML interface
-# =============================================================================
-
-@app.get("/backgroundfx")
-async def backgroundfx_page(request: Request):
-    """BackgroundFX premium feature page - HeyGen WebM + Transparent Videos"""
+for import_path in two_stage_paths:
     try:
-        logger.info("BackgroundFX page accessed")
+        exec(f"from {import_path} import TwoStageProcessor, CHROMA_PRESETS")
+        TWO_STAGE_AVAILABLE = True
+        TWO_STAGE_IMPORT_ORIGIN = import_path
+        logger.info(f"Two-stage import OK ({import_path})")
+        break
+    except Exception as e:
+        TWO_STAGE_IMPORT_ERROR = str(e)
+        continue
+if not TWO_STAGE_AVAILABLE:
+    logger.warning(f"Two-stage import FAILED from all paths: {TWO_STAGE_IMPORT_ERROR}")
+# ── Quiet startup self-check (async by default) ──────────────────────────────
+# Place the helper in tools/startup_selfcheck.py (with tools/__init__.py present)
+try:
+    from tools.startup_selfcheck import schedule_startup_selfcheck
+except Exception:
+    schedule_startup_selfcheck = None # graceful if the helper isn't shipped
+# Dummy exceptions if core.exceptions not available
+class ModelLoadingError(Exception):
+    pass
+class VideoProcessingError(Exception):
+    pass
+# ╔══════════════════════════════════════════════════════════════════════════╗
+# ║ VideoProcessor class ║
+# ╚══════════════════════════════════════════════════════════════════════════╝
+class VideoProcessor:
+    """
+    Main orchestrator – coordinates all specialised components.
+    """
+    def __init__(self):
+        self.config = get_config()
+        self._patch_config_defaults(self.config) # avoid AttributeError on older configs
+        self.device_manager = DeviceManager()
+        self.memory_manager = MemoryManager(self.device_manager.get_optimal_device())
+        self.model_loader = ModelLoader(self.device_manager, self.memory_manager)
+        self.audio_processor = AudioProcessor()
+        self.core_processor: Optional[CoreVideoProcessor] = None
+        self.two_stage_processor: Optional[Any] = None
+        self.models_loaded = False
+        self.loading_lock = threading.Lock()
+        self.cancel_event = threading.Event()
+        self.progress_tracker: Optional[ProgressTracker] = None
+        logger.info(f"VideoProcessor on device: {self.device_manager.get_optimal_device()}")
+    # ── Config hardening: add missing fields safely ───────────────────────────
+    @staticmethod
+    def _patch_config_defaults(cfg: Any) -> None:
+        defaults = {
+            # video / i/o
+            "use_nvenc": False,
+            "prefer_mp4": True,
+            "video_codec": "mp4v",
+            "audio_copy": True,
+            "ffmpeg_path": "ffmpeg",
+            # model/resource guards
+            "max_model_size": 0,
+            "max_model_size_bytes": 0,
+            # housekeeping
+            "output_dir": str((Path(__file__).resolve().parent.parent) / "outputs"),
+            # MatAnyone settings to ensure it's enabled
+            "matanyone_enabled": True,
+            "use_matanyone": True,
+        }
+        for k, v in defaults.items():
+            if not hasattr(cfg, k):
+                setattr(cfg, k, v)
+        Path(cfg.output_dir).mkdir(parents=True, exist_ok=True)
+    # ── Progress helper ───────────────────────────────────────────────────────
+    def _init_progress(self, video_path: str, cb: Optional[Callable] = None):
+        try:
+            import cv2
+            cap = cv2.VideoCapture(video_path)
+            total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+            cap.release()
+            if total <= 0:
+                total = 100
+            self.progress_tracker = ProgressTracker(total, cb)
+        except Exception as e:
+            logger.warning(f"Progress init failed: {e}")
+            self.progress_tracker = ProgressTracker(100, cb)
+    # ── Model loading ─────────────────────────────────────────────────────────
+    def load_models(self, progress_callback: Optional[Callable] = None) -> str:
+        with self.loading_lock:
+            if self.models_loaded:
+                return "Models already loaded and validated"
+            try:
+                self.cancel_event.clear()
+                if progress_callback:
+                    progress_callback(0.0, f"Loading on {self.device_manager.get_optimal_device()}")
+                sam2_loaded, mat_loaded = self.model_loader.load_all_models(
+                    progress_callback=progress_callback, cancel_event=self.cancel_event
+                )
+                if self.cancel_event.is_set():
+                    return "Model loading cancelled"
+                # Get the actual models
+                sam2_predictor = sam2_loaded.model if sam2_loaded else None
+                mat_model = mat_loaded.model if mat_loaded else None # NOTE: in our MatAnyone loader this is a stateful adapter (callable)
+                # Initialize core processor
+                self.core_processor = CoreVideoProcessor(config=self.config, models=self.model_loader)
+                # Initialize two-stage processor if available
+                self.two_stage_processor = None
+                if TWO_STAGE_AVAILABLE and TwoStageProcessor and (sam2_predictor or mat_model):
+                    try:
+                        self.two_stage_processor = TwoStageProcessor(
+                            sam2_predictor=sam2_predictor, matanyone_model=mat_model
+                        )
+                        logger.info("Two-stage processor initialised")
+                    except Exception as e:
+                        logger.warning(f"Two-stage init failed: {e}")
+                        self.two_stage_processor = None
+                self.models_loaded = True
+                msg = self.model_loader.get_load_summary()
+               
+                # Add status about processors
+                if self.two_stage_processor:
+                    msg += "\n✅ Two-stage processor ready"
+                else:
+                    msg += "\n⚠️ Two-stage processor not available"
+                   
+                if mat_model:
+                    msg += "\n✅ MatAnyone refinement active"
+                else:
+                    msg += "\n⚠️ MatAnyone not loaded (edges may be rough)"
+                   
+                logger.info(msg)
+                return msg
+            except (AttributeError, ModelLoadingError) as e:
+                self.models_loaded = False
+                err = f"Model loading failed: {e}"
+                logger.error(err)
+                return err
+            except Exception as e:
+                self.models_loaded = False
+                err = f"Unexpected error during model loading: {e}"
+                logger.error(f"{err}\n{traceback.format_exc()}")
+                return err
+    # ── Public entry – process video ─────────────────────────────────────────
+    def process_video(
+        self,
+        video_path: str,
+        background_choice: str,
+        custom_background_path: Optional[str] = None,
+        progress_callback: Optional[Callable] = None,
+        use_two_stage: bool = False,
+        chroma_preset: str = "standard",
+        key_color_mode: str = "auto",
+        preview_mask: bool = False,
+        preview_greenscreen: bool = False,
+    ) -> Tuple[Optional[str], Optional[str], str]:
+        
+        # ===== BACKGROUND PATH DEBUG & FIX =====
+        logger.info("=" * 60)
+        logger.info("BACKGROUND PATH DEBUGGING")
+        logger.info(f"background_choice: {background_choice}")
+        logger.info(f"custom_background_path type: {type(custom_background_path)}")
+        logger.info(f"custom_background_path value: {custom_background_path}")
+        
+        # Fix 1: Handle if Gradio sends a dict
+        if isinstance(custom_background_path, dict):
+            original = custom_background_path
+            custom_background_path = custom_background_path.get('name') or custom_background_path.get('path')
+            logger.info(f"Extracted path from dict: {original} -> {custom_background_path}")
+        
+        # Fix 2: Handle PIL Image objects
+        try:
+            from PIL import Image
+            if isinstance(custom_background_path, Image.Image):
+                import tempfile
+                with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as tmp:
+                    custom_background_path.save(tmp.name)
+                    custom_background_path = tmp.name
+                    logger.info(f"Saved PIL Image to: {custom_background_path}")
+        except ImportError:
+            pass
+        
+        # Fix 3: Verify file exists when using custom background
+        if background_choice == "custom" or custom_background_path:
+            if custom_background_path:
+                if Path(custom_background_path).exists():
+                    logger.info(f"✅ Background file exists: {custom_background_path}")
+                else:
+                    logger.warning(f"⚠️ Background file does not exist: {custom_background_path}")
+                    # Try to find it in Gradio temp directories
+                    import glob
+                    patterns = [
+                        "/tmp/gradio*/**/*.jpg",
+                        "/tmp/gradio*/**/*.jpeg", 
+                        "/tmp/gradio*/**/*.png",
+                        "/tmp/**/*.jpg",
+                        "/tmp/**/*.jpeg",
+                        "/tmp/**/*.png",
+                    ]
+                    for pattern in patterns:
+                        files = glob.glob(pattern, recursive=True)
+                        if files:
+                            # Get the most recent file
+                            newest = max(files, key=os.path.getmtime)
+                            logger.info(f"Found potential background: {newest}")
+                            # Only use it if it was created in the last 5 minutes
+                            if (time.time() - os.path.getmtime(newest)) < 300:
+                                custom_background_path = newest
+                                logger.info(f"✅ Using recent temp file: {custom_background_path}")
+                                break
+            else:
+                logger.error("❌ Custom background mode but path is None!")
         
-        # First try the enhanced template
-        enhanced_html_file = BASE_DIR / "templates" / "backgroundfx_enhanced.html"
-        if enhanced_html_file.exists():
-            templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
-            return templates.TemplateResponse("backgroundfx_enhanced.html", {"request": request})
+        logger.info(f"Final custom_background_path: {custom_background_path}")
+        logger.info("=" * 60)
         
-        # Fall back to original template
-        html_file = BASE_DIR / "templates" / "backgroundfx.html"
-        if html_file.exists():
-            with open(html_file, 'r', encoding='utf-8') as f:
-                content = f.read()
-            logger.info("✅ BackgroundFX HTML template loaded successfully")
-            return HTMLResponse(content=content)
+        if not self.models_loaded or not self.core_processor:
+            return None, None, "Models not loaded. Please click 'Load Models' first."
+        if self.cancel_event.is_set():
+            return None, None, "Processing cancelled"
+        self._init_progress(video_path, progress_callback)
+        ok, why = validate_video_file(video_path)
+        if not ok:
+            return None, None, f"Invalid video: {why}"
+        try:
+            # Log which mode we're using
+            mode = "two-stage" if use_two_stage else "single-stage"
+            matanyone_status = "enabled" if self.model_loader.get_matanyone() else "disabled"
+            logger.info(f"Processing video in {mode} mode, MatAnyone: {matanyone_status}")
+            # IMPORTANT: start each video with a clean MatAnyone memory
+            self._reset_matanyone_session()
+            if use_two_stage:
+                if not TWO_STAGE_AVAILABLE or self.two_stage_processor is None:
+                    return None, None, "Two-stage processing not available"
+                final, green, msg = self._process_two_stage(
+                    video_path,
+                    background_choice,
+                    custom_background_path,
+                    progress_callback,
+                    chroma_preset,
+                    key_color_mode,
+                )
+                return final, green, msg
+            else:
+                final, green, msg = self._process_single_stage(
+                    video_path,
+                    background_choice,
+                    custom_background_path,
+                    progress_callback,
+                    preview_mask,
+                    preview_greenscreen,
+                )
+                return final, green, msg
+        except VideoProcessingError as e:
+            logger.error(f"Processing failed: {e}")
+            return None, None, f"Processing failed: {e}"
+        except Exception as e:
+            logger.error(f"Unexpected processing error: {e}\n{traceback.format_exc()}")
+            return None, None, f"Unexpected error: {e}"
+    # ── Private – per-video MatAnyone reset ──────────────────────────────────
+    def _reset_matanyone_session(self):
+        """
+        Ensure a fresh MatAnyone memory per video. The MatAnyone loader we use returns a
+        callable *stateful adapter*. If present, reset() clears its InferenceCore memory.
+        """
+        try:
+            mat = self.model_loader.get_matanyone()
+        except Exception:
+            mat = None
+        if mat is not None and hasattr(mat, "reset") and callable(mat.reset):
+            try:
+                mat.reset()
+                logger.info("MatAnyone session reset for new video")
+            except Exception as e:
+                logger.warning(f"MatAnyone session reset failed (continuing): {e}")
+    # ── Private – single-stage ───────────────────────────────────────────────
+    def _process_single_stage(
+        self,
+        video_path: str,
+        background_choice: str,
+        custom_background_path: Optional[str],
+        progress_callback: Optional[Callable],
+        preview_mask: bool,
+        preview_greenscreen: bool,
+    ) -> Tuple[Optional[str], Optional[str], str]:
+        
+        # Additional debug logging for single-stage
+        logger.info(f"[Single-stage] background_choice: {background_choice}")
+        logger.info(f"[Single-stage] custom_background_path: {custom_background_path}")
+        
+        ts = int(time.time())
+        out_dir = Path(self.config.output_dir) / "single_stage"
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path = str(out_dir / f"processed_{ts}.mp4")
+        # Process video via your CoreVideoProcessor
+        result = self.core_processor.process_video(
+            input_path=video_path,
+            output_path=out_path,
+            bg_config={
+                "background_choice": background_choice,
+                "custom_path": custom_background_path,
+            },
+            progress_callback=progress_callback,
+        )
+       
+        if not result:
+            return None, None, "Video processing failed"
+        # Mux audio unless preview-only
+        if not (preview_mask or preview_greenscreen):
+            try:
+                final_path = self.audio_processor.add_audio_to_video(
+                    original_video=video_path, processed_video=out_path
+                )
+            except Exception as e:
+                logger.warning(f"Audio mux failed, returning video without audio: {e}")
+                final_path = out_path
         else:
-            # Fallback to basic page with link to dashboard
-            logger.warning("⚠️ BackgroundFX HTML template not found, using fallback")
-            return HTMLResponse(content="""
-                <!DOCTYPE html>
-                <html>
-                <head>
-                    <title>BackgroundFX - Enhanced Video Processing</title>
-                    <style>
-                        body { font-family: Arial, sans-serif; margin: 40px; text-align: center; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); min-height: 100vh; color: white; }
-                        .container { max-width: 600px; margin: 0 auto; padding: 40px; background: rgba(255,255,255,0.1); border-radius: 20px; }
-                        h1 { font-size: 3em; margin-bottom: 20px; }
-                        .btn { padding: 15px 30px; background: #fff; color: #667eea; text-decoration: none; border-radius: 10px; font-weight: bold; margin: 10px; display: inline-block; }
-                        .status { background: rgba(16, 185, 129, 0.2); padding: 15px; border-radius: 10px; margin: 20px 0; }
-                    </style>
-                </head>
-                <body>
-                    <div class="container">
-                        <h1>BackgroundFX - Enhanced Video Processing</h1>
-                        <div class="status">
-                            <h3>⚠️ Enhanced UI Not Found</h3>
-                            <p>The advanced user interface file is missing.</p>
-                        </div>
-                        <p><strong>Save the Enhanced UI as:</strong> <code>templates/backgroundfx_enhanced.html</code></p>
-                        <a href="/dashboard-direct" class="btn">← Back to Dashboard</a>
-                        <a href="/video-processing/status" class="btn">🔧 Test API</a>
-                    </div>
-                </body>
-                </html>
-            """)
-            
-    except Exception as e:
-        logger.error(f"Error serving BackgroundFX page: {e}")
-        return HTMLResponse(content=f"""
-            <div style="font-family: Arial, sans-serif; margin: 40px; text-align: center;">
-                <h1>BackgroundFX Error</h1>
-                <p>Error: {str(e)}</p>
-                <p><a href="/dashboard-direct">Back to Dashboard</a></p>
-            </div>
-        """, status_code=500)
-
-# =============================================================================
-# ADMIN PREMIUM MANAGEMENT PAGE
-# =============================================================================
-
-@app.get("/admin/premium")
-async def admin_premium_page(request: Request):
-    """Admin premium management interface"""
+            final_path = out_path
+        # Build status message
+        try:
+            mat_loaded = bool(self.model_loader.get_matanyone())
+        except Exception:
+            mat_loaded = False
+        matanyone_status = "✓" if mat_loaded else "✗"
+        msg = (
+            "Processing completed.\n"
+            f"Frames: {result.get('frames', 'unknown')}\n"
+            f"Background: {background_choice}\n"
+            f"Mode: Single-stage\n"
+            f"MatAnyone: {matanyone_status}\n"
+            f"Device: {self.device_manager.get_optimal_device()}"
+        )
+        return final_path, None, msg  # No green in single-stage
+    # ── Private – two-stage ─────────────────────────────────────────────────
+    def _process_two_stage(
+        self,
+        video_path: str,
+        background_choice: str,
+        custom_background_path: Optional[str],
+        progress_callback: Optional[Callable],
+        chroma_preset: str,
+        key_color_mode: str,
+    ) -> Tuple[Optional[str], Optional[str], str]:
+        if self.two_stage_processor is None:
+            return None, None, "Two-stage processor not available"
+        
+        # Additional debug logging for two-stage
+        logger.info(f"[Two-stage] background_choice: {background_choice}")
+        logger.info(f"[Two-stage] custom_background_path: {custom_background_path}")
+        
+        import cv2
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            return None, None, "Could not open input video"
+        w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) or 1280
+        h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) or 720
+        cap.release()
+        # Prepare background
+        try:
+            background = self.core_processor.prepare_background(
+                background_choice, custom_background_path, w, h
+            )
+        except Exception as e:
+            logger.error(f"Background preparation failed: {e}")
+            return None, None, f"Failed to prepare background: {e}"
+        if background is None:
+            return None, None, "Failed to prepare background"
+        ts = int(time.time())
+        out_dir = Path(self.config.output_dir) / "two_stage"
+        out_dir.mkdir(parents=True, exist_ok=True)
+        final_out = str(out_dir / f"final_{ts}.mp4")
+        chroma_cfg = CHROMA_PRESETS.get(chroma_preset, CHROMA_PRESETS.get("standard", {}))
+        logger.info(f"Two-stage with preset: {chroma_preset} | key_color: {key_color_mode}")
+        # (Per-video reset already called in process_video)
+        final_path, green_path, stage2_msg = self.two_stage_processor.process_full_pipeline(
+            video_path,
+            background,
+            final_out,
+            key_color_mode=key_color_mode,
+            chroma_settings=chroma_cfg,
+            progress_callback=progress_callback,
+        )
+        if final_path is None:
+            return None, None, stage2_msg
+        # Mux audio
+        try:
+            final_with_audio = self.audio_processor.add_audio_to_video(
+                original_video=video_path, processed_video=final_path
+            )
+        except Exception as e:
+            logger.warning(f"Audio mux failed: {e}")
+            final_with_audio = final_path
+        try:
+            mat_loaded = bool(self.model_loader.get_matanyone())
+        except Exception:
+            mat_loaded = False
+        matanyone_status = "✓" if mat_loaded else "✗"
+        msg = (
+            "Two-stage processing completed.\n"
+            f"Background: {background_choice}\n"
+            f"Chroma Preset: {chroma_preset}\n"
+            f"MatAnyone: {matanyone_status}\n"
+            f"Device: {self.device_manager.get_optimal_device()}"
+        )
+        return final_with_audio, green_path, msg
+    # ── Status helpers ───────────────────────────────────────────────────────
+    def get_status(self) -> Dict[str, Any]:
+        status = {
+            "models_loaded": self.models_loaded,
+            "two_stage_available": bool(TWO_STAGE_AVAILABLE and self.two_stage_processor),
+            "two_stage_origin": TWO_STAGE_IMPORT_ORIGIN or "",
+            "device": str(self.device_manager.get_optimal_device()),
+            "core_processor_loaded": self.core_processor is not None,
+            "config": self._safe_config_dict(),
+            "memory_usage": self._safe_memory_usage(),
+        }
+       
+        try:
+            status["sam2_loaded"] = self.model_loader.get_sam2() is not None
+            status["matanyone_loaded"] = self.model_loader.get_matanyone() is not None
+            status["model_info"] = self.model_loader.get_model_info()
+        except Exception:
+            status["sam2_loaded"] = False
+            status["matanyone_loaded"] = False
+        if self.progress_tracker:
+            status["progress"] = self.progress_tracker.get_all_progress()
+           
+        return status
+    def _safe_config_dict(self) -> Dict[str, Any]:
+        try:
+            return self.config.to_dict()
+        except Exception:
+            keys = ["use_nvenc", "prefer_mp4", "video_codec", "audio_copy",
+                    "ffmpeg_path", "max_model_size", "max_model_size_bytes",
+                    "output_dir", "matanyone_enabled"]
+            return {k: getattr(self.config, k, None) for k in keys}
+    def _safe_memory_usage(self) -> Dict[str, Any]:
+        try:
+            return self.memory_manager.get_memory_usage()
+        except Exception:
+            return {}
+    def cancel_processing(self):
+        self.cancel_event.set()
+        logger.info("Cancellation requested")
+    def cleanup_resources(self):
+        try:
+            self.memory_manager.cleanup_aggressive()
+        except Exception:
+            pass
+        try:
+            self.model_loader.cleanup()
+        except Exception:
+            pass
+        logger.info("Resources cleaned up")
+# ── Singleton + thin wrappers (used by UI callbacks) ────────────────────────
+processor = VideoProcessor()
+def load_models_with_validation(progress_callback: Optional[Callable] = None) -> str:
+    return processor.load_models(progress_callback)
+def process_video_fixed(
+    video_path: str,
+    background_choice: str,
+    custom_background_path: Optional[str],
+    progress_callback: Optional[Callable] = None,
+    use_two_stage: bool = False,
+    chroma_preset: str = "standard",
+    key_color_mode: str = "auto",
+    preview_mask: bool = False,
+    preview_greenscreen: bool = False,
+) -> Tuple[Optional[str], Optional[str], str]:
+    return processor.process_video(
+        video_path,
+        background_choice,
+        custom_background_path,
+        progress_callback,
+        use_two_stage,
+        chroma_preset,
+        key_color_mode,
+        preview_mask,
+        preview_greenscreen,
+    )
+def get_model_status() -> Dict[str, Any]:
+    return processor.get_status()
+def get_cache_status() -> Dict[str, Any]:
+    return processor.get_status()
+PROCESS_CANCELLED = processor.cancel_event
+# ── CLI entrypoint (must exist; app.py imports main) ─────────────────────────
+def main():
     try:
-        logger.info("Admin premium page accessed")
+        logger.info("Starting BackgroundFX Pro")
+        logger.info(f"Device: {processor.device_manager.get_optimal_device()}")
+        logger.info(f"Two-stage available: {TWO_STAGE_AVAILABLE}")
         
-        # Check if admin premium template exists
-        admin_premium_file = BASE_DIR / "templates" / "admin_premium.html"
-        if admin_premium_file.exists():
-            templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
-            return templates.TemplateResponse("admin_premium.html", {"request": request})
-        else:
-            # Fallback to basic admin premium page
-            logger.warning("⚠️ Admin premium template not found, using fallback")
-            return HTMLResponse(content="""
-                <!DOCTYPE html>
-                <html>
-                <head>
-                    <title>Premium Management - MyAvatar Admin</title>
-                    <style>
-                        body { font-family: Arial, sans-serif; margin: 40px; text-align: center; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); min-height: 100vh; color: white; }
-                        .container { max-width: 800px; margin: 0 auto; padding: 40px; background: rgba(255,255,255,0.1); border-radius: 20px; }
-                        h1 { font-size: 3em; margin-bottom: 20px; }
-                        .btn { padding: 15px 30px; background: #fff; color: #667eea; text-decoration: none; border-radius: 10px; font-weight: bold; margin: 10px; display: inline-block; }
-                        .status { background: rgba(16, 185, 129, 0.2); padding: 15px; border-radius: 10px; margin: 20px 0; }
-                    </style>
-                </head>
-                <body>
-                    <div class="container">
-                        <h1>🎯 Premium Management</h1>
-                        <p>Manage premium subscriptions and user access</p>
-                        
-                        <div class="status">
-                            <h3> Premium System Status: OPERATIONAL</h3>
-                            <p>• Premium routes loaded<br>
-                            # Initialize core processor with loaded models
-                self.core_processor = CoreVideoProcessor(
-                    sam2_predictor=sam2_predictor,
-                    matanyone_model=matanyone_model,
-                    config=self.config,
-                    memory_mgr=self.memory_manager
-                )        <p><strong>Save the Admin Interface as:</strong> <code>templates/admin_premium.html</code></p>
-                        <a href="/admin" class="btn"> Back to Admin</a>
-                        <a href="/admin/premium/users" class="btn"> Test API</a>
-                    </div>
-                </body>
-                </html>
-            """)
+        # 🔹 Quiet model self-check (defaults to async; set SELF_CHECK_MODE=sync to block)
+        if schedule_startup_selfcheck is not None:
+            try:
+                schedule_startup_selfcheck(mode=os.getenv("SELF_CHECK_MODE", "async"))
+            except Exception as e:
+                logger.error(f"Startup self-check skipped: {e}", exc_info=True)
+        
+        # Log model loader type
+        try:
+            from models.loaders.model_loader import ModelLoader
+            logger.info("Using split loader architecture")
+        except Exception:
+            logger.info("Using legacy loader")
+        
+        # FIXED: Move UI import inside main() to avoid circular dependency
+        # and add better error handling
+        try:
+            # Import here to break circular dependency
+            from ui import ui_components
+            
+            # Now get the create_interface function
+            if hasattr(ui_components, 'create_interface'):
+                create_interface = ui_components.create_interface
+            else:
+                logger.error("create_interface not found in ui_components")
+                logger.error(f"Available attributes: {dir(ui_components)}")
+                raise ImportError("create_interface function not found")
+                
+        except ImportError as e:
+            logger.error(f"Failed to import UI components: {e}")
+            import traceback
+            traceback.print_exc()
+            
+            # Try alternate import method
+            try:
+                logger.info("Trying alternate import method...")
+                import importlib
+                ui_components = importlib.import_module('ui.ui_components')
+                create_interface = getattr(ui_components, 'create_interface')
+                logger.info("Alternate import successful")
+            except Exception as e2:
+                logger.error(f"Alternate import also failed: {e2}")
+                logger.info("System initialized but UI unavailable. Exiting.")
+                return
+        
+        # Create and launch the interface
+        try:
+            demo = create_interface()
+            demo.queue().launch(
+                server_name="0.0.0.0",
+                server_port=7860,
+                show_error=True,
+                debug=False,
+            )
+        except Exception as e:
+            logger.error(f"Failed to launch Gradio interface: {e}")
+            import traceback
+            traceback.print_exc()
             
     except Exception as e:
-        logger.error(f"Error serving admin premium page: {e}")
-        return HTMLResponse(content=f"""
-            <div style="font-family: Arial, sans-serif; margin: 40px; text-align: center;">
-                <h1>Admin Premium Error</h1>
-                <p>Error: {str(e)}</p>
-                <p><a href="/admin">Back to Admin</a></p>
-            </div>
-        """, status_code=500)
-
-# Create necessary directories
-directories = [
-  "static/uploads/audio", 
-  "static/uploads/images", 
-  "output", 
-  "processed", 
-  "uploads", 
-  "temp_audio", 
-  "static/backgrounds",  # BackgroundFX storage
-  "temp/background_processing", 
-  "temp/video_processing"
-]
-
-for directory in directories:
-  try:
-      os.makedirs(BASE_DIR / directory, exist_ok=True)
-  except Exception as e:
-      logger.warning(f"Could not create directory {directory}: {e}")
-
-# BULLETPROOF Health check endpoint
-@app.get("/health")
-async def health_check():
-  """Bulletproof health check that never fails"""
-  try:
-      log_info("Health check endpoint accessed", "Health") 
-      return {"status": "ok", "timestamp": datetime.now().isoformat()}
-  except Exception:
-      # Even if logging fails, return basic response
-      return {"status": "ok"}
-
-@app.get("/simple-health") 
-async def simple_health_check():
-  """Ultra-simple health check for deployment platforms"""
-  return {"status": "ok"}
-
-# DEBUG ROUTE - TO DIAGNOSE ROUTE LOADING ISSUES
-@app.get("/debug-routes")
-async def debug_routes():
-  """Debug which routes are loaded and why others failed"""
-  routes = []
-  for route in app.routes:
-      routes.append({
-          "path": getattr(route, 'path', 'unknown'),
-          "methods": getattr(route, 'methods', []),
-          "name": getattr(route, 'name', 'unknown')
-      })
-  
-  # Check for specific route types
-  backgroundfx_routes = [r for r in routes if "/api/backgrounds" in r.get("path", "")]
-  video_processing_routes = [r for r in routes if "/video-processing" in r.get("path", "")]
-  premium_routes = [r for r in routes if "/api/premium" in r.get("path", "") or "/admin/premium" in r.get("path", "")]
-  
-  return {
-      "total_routes": len(app.routes),
-      "routes_loaded_successfully": routers_loaded,
-      "router_import_errors": router_errors,
-      "all_routes": routes,
-      "premium_system_status": {
-          "premium_routes_loaded": len(premium_routes),
-          "premium_routes": premium_routes,
-          "premium_router_in_loaded": any("premium_routes" in r for r in routers_loaded),
-          "admin_premium_page_available": "/admin/premium" in [r.get("path") for r in routes]
-      },
-      "backgroundfx_status": {
-          "backgroundfx_routes_loaded": len(backgroundfx_routes),
-          "backgroundfx_routes": backgroundfx_routes,
-          "backgroundfx_page_available": "/backgroundfx" in [r.get("path") for r in routes],
-          "heygen_api_configured": bool(os.getenv("HEYGEN_API_KEY") and os.getenv("HEYGEN_API_KEY") != "your-heygen-api-key"),
-          "unsplash_api_configured": bool(os.getenv("UNSPLASH_ACCESS_KEY") and os.getenv("UNSPLASH_ACCESS_KEY") != "your-unsplash-key"),
-          "openai_api_configured": bool(os.getenv("OPENAI_API_KEY") and os.getenv("OPENAI_API_KEY") != "your-openai-api-key")
-      },
-      "video_processing_status": {
-          "video_processing_routes_loaded": len(video_processing_routes),
-          "video_processing_routes": video_processing_routes,
-          "api_prefix": "/video-processing",
-          "endpoints_available": [r.get("path") for r in video_processing_routes]
-      },
-      "refactoring_status": {
-          "modular_routes_loaded": len([r for r in routers_loaded if not "legacy" in r]),
-          "legacy_routes_loaded": len([r for r in routers_loaded if "legacy" in r]),
-          "total_errors": len(router_errors)
-      },
-      "video_url_refresher_status": {
-          "available": video_refresher_available,
-          "running": video_refresher_available,
-          "refresh_interval": os.getenv('REFRESH_INTERVAL_HOURS', '4') + " hours",
-          "expiry_threshold": os.getenv('EXPIRY_THRESHOLD_HOURS', '6') + " hours"
-      }
-  }
-
-# TEST ROUTE - Simple route to confirm basic functionality
-@app.get("/test")
-async def test_route():
-  """Test route to confirm FastAPI is working"""
-  return {
-      "message": "FastAPI is working with Premium Features + BackgroundFX + Video Processing!", 
-      "routers_loaded": routers_loaded,
-      "timestamp": datetime.now().isoformat(),
-      "refactoring_complete": True,
-      "premium_features_enabled": True,
-      "backgroundfx_enabled": "app.routes.backgroundfx_routes" in str(routers_loaded),
-      "video_processing_enabled": "app.routes.video_processing_routes" in str(routers_loaded),
-      "premium_system_enabled": "app.routes.premium_routes" in str(routers_loaded),
-      "modular_structure": {
-          "auth_routes": "/login, /register, /logout, /dashboard-direct",
-          "admin_routes": "/admin/*",
-          "api_routes": "/api/* (ENABLED)",
-          "premium_routes": "/api/premium/*, /admin/premium/* (NEW - Complete Premium System)",
-          "backgroundfx_routes": "/api/backgrounds/* (HeyGen WebM + Transparent Videos)",
-          "video_processing_routes": "/video-processing/* (Advanced Background Replacement)",
-          "video_routes": "/voice-recording, /text-to-video (ENABLED)", 
-          "emergency_routes": "/emergency/*"
-      },
-      "premium_endpoints": {
-          "admin_users": "/admin/premium/users",
-          "admin_set_premium": "/admin/premium/set-user-premium",
-          "admin_remove_premium": "/admin/premium/remove-user-premium",
-          "user_status": "/api/premium/status",
-          "user_start_trial": "/api/premium/start-trial",
-          "user_upgrade": "/api/premium/upgrade",
-          "check_feature_access": "/api/premium/check-feature-access/{feature}",
-          "admin_premium_page": "/admin/premium"
-      },
-      "backgroundfx_endpoints": {
-          "page": "/backgroundfx",
-          "status": "/api/backgrounds/status",
-          "get_videos": "/api/videos",
-          "transparent_video": "/api/backgrounds/get-transparent-video",
-          "green_screen": "/api/backgrounds/create-green-screen",
-          "backgrounds": "/api/backgrounds",
-          "upload_background": "/api/backgrounds/upload",
-          "search_images": "/api/backgrounds/search-images",
-          "ai_generate": "/api/backgrounds/generate-ai-image",
-          "add_from_url": "/api/backgrounds/add-from-url"
-      },
-      "video_processing_endpoints": {
-          "status": "/video-processing/status",
-          "upload_video": "/video-processing/upload-video",
-          "upload_background": "/video-processing/upload-background", 
-          "replace_background": "/video-processing/replace-background",
-          "job_status": "/video-processing/job/{job_id}/status",
-          "download": "/video-processing/job/{job_id}/download",
-          "list_jobs": "/video-processing/jobs"
-      },
-      "video_url_refresher": {
-          "status": "running" if video_refresher_available else "not_available",
-          "interval": os.getenv('REFRESH_INTERVAL_HOURS', '4') + " hours"
-      }
-  }
-
-# =============================================================================
-# BACKGROUNDFX INTEGRATION STATUS
-# =============================================================================
-
-@app.get("/admin/backgroundfx-status")
-async def backgroundfx_system_status():
-  """Check BackgroundFX system status for admin"""
-  try:
-      # Check environment variables
-      heygen_configured = heygen_api_configured
-      unsplash_configured = unsplash_api_configured
-      openai_configured = openai_api_configured
-      
-      # Check if routers are loaded
-      backgroundfx_router_loaded = "app.routes.backgroundfx_routes" in str(routers_loaded)
-      video_processing_router_loaded = "app.routes.video_processing_routes" in str(routers_loaded)
-      premium_router_loaded = "app.routes.premium_routes" in str(routers_loaded)
-      
-      # Check static directory
-      backgrounds_dir = Path("static/backgrounds")
-      backgrounds_dir_exists = backgrounds_dir.exists()
-      
-      return {
-          "backgroundfx_system_status": "operational" if backgroundfx_router_loaded else "error",
-          "premium_system_status": "operational" if premium_router_loaded else "error",
-          "router_loaded": backgroundfx_router_loaded,
-          "video_processing_router_loaded": video_processing_router_loaded,
-          "premium_router_loaded": premium_router_loaded,
-          "api_integrations": {
-              "heygen_webm_api": heygen_configured,
-              "unsplash_search": unsplash_configured,
-              "openai_dalle": openai_configured
-          },
-          "features_available": {
-              "transparent_videos": heygen_configured and premium_router_loaded,
-              "green_screen_videos": heygen_configured and premium_router_loaded,
-              "image_search": unsplash_configured and premium_router_loaded,
-              "ai_image_generation": openai_configured and premium_router_loaded,
-              "background_library": premium_router_loaded,
-              "file_upload": backgrounds_dir_exists and premium_router_loaded,
-              "advanced_video_processing": video_processing_router_loaded and premium_router_loaded,
-              "premium_user_management": premium_router_loaded,
-              "trial_system": premium_router_loaded
-          },
-          "storage": {
-              "backgrounds_directory": str(backgrounds_dir),
-              "directory_exists": backgrounds_dir_exists,
-              "writable": backgrounds_dir.exists() and os.access(backgrounds_dir, os.W_OK)
-          },
-          "database_tables": {
-              "background_videos": "auto-initialized",
-              "user_backgrounds": "auto-initialized",
-              "video_processing_jobs": "created",
-              "uploaded_videos": "created",
-              "background_images": "created",
-              "premium_subscriptions": "created" if premium_router_loaded else "missing",
-              "premium_features": "created" if premium_router_loaded else "missing"
-          },
-          "endpoints": {
-              "frontend_page": "/backgroundfx",
-              "admin_premium_page": "/admin/premium",
-              "api_base": "/api/backgrounds",
-              "video_processing_base": "/video-processing",
-              "premium_api_base": "/api/premium",
-              "status_check": "/api/backgrounds/status",
-              "video_processing_status": "/video-processing/status",
-              "premium_status": "/api/premium/status"
-          },
-          "timestamp": datetime.now().isoformat()
-      }
-  except Exception as e:
-      return {
-          "backgroundfx_system_status": "error",
-          "premium_system_status": "error",
-          "error": str(e),
-          "timestamp": datetime.now().isoformat()
-      }
-
-# =============================================================================
-# MANUAL VIDEO REFRESH ENDPOINTS
-# =============================================================================
-
-@app.get("/admin/refresh-videos")
-async def manual_refresh_videos():
-  """Manually trigger video URL refresh"""
-  try:
-      if not video_refresher_available:
-          return {"error": "Video URL refresher not available"}
-      
-      logger.info("Manual video refresh triggered")
-      refresher = VideoURLRefresher()
-      refresher.run_refresh_cycle()
-      
-      return {
-          "status": "success",
-          "message": "Video URL refresh completed",
-          "timestamp": datetime.now().isoformat()
-      }
-  except Exception as e:
-      logger.error(f"Manual refresh failed: {e}")
-      return {
-          "status": "error",
-          "message": str(e),
-          "timestamp": datetime.now().isoformat()
-      }
-
-@app.get("/admin/refresh-status")
-async def refresh_status():
-  """Check video URL refresh service status"""
-  return {
-      "video_url_refresher": {
-          "available": video_refresher_available,
-          "running": video_refresher_available,
-          "refresh_interval": os.getenv('REFRESH_INTERVAL_HOURS', '4') + " hours",
-          "expiry_threshold": os.getenv('EXPIRY_THRESHOLD_HOURS', '6') + " hours"
-      },
-      "environment": {
-          "REFRESH_INTERVAL_HOURS": os.getenv('REFRESH_INTERVAL_HOURS', '4'),
-          "EXPIRY_THRESHOLD_HOURS": os.getenv('EXPIRY_THRESHOLD_HOURS', '6'),
-          "REFRESHER_MODE": os.getenv('REFRESHER_MODE', 'continuous')
-      },
-      "timestamp": datetime.now().isoformat()
-  }
-
-# =============================================================================
-# HEYGEN AVATAR DEBUG ENDPOINTS
-# =============================================================================
-
-@app.get("/debug-avatars")
-async def debug_avatars():
-  """
-  Temporary debug endpoint to inspect HeyGen API response structure.
-  Access this at: https://app.myavatar.dk/debug-avatars
-  """
-  try:
-      log_info("Debug avatars endpoint accessed", "Debug")
-
-      api_key = os.getenv("HEYGEN_API_KEY")
-      if not api_key:
-          logger.error("HEYGEN_API_KEY not found in environment")
-          raise HTTPException(status_code=500, detail="HEYGEN_API_KEY not configured")
-      
-      logger.info("Fetching avatars from HeyGen API...")
-      result = get_available_avatars(api_key)
-      
-      if not result:
-          raise HTTPException(status_code=500, detail="No response from HeyGen API")
-      
-      # Analyze the response structure for better debugging
-      if isinstance(result, dict) and 'data' in result:
-          avatars = result['data']
-          logger.info(f"Successfully fetched {len(avatars)} avatars from HeyGen")
-          
-          # Create analysis for easier debugging
-          analysis = {
-              "success": True,
-              "total_avatars": len(avatars),
-              "api_response_keys": list(result.keys()),
-              "sample_avatar_keys": list(avatars[0].keys()) if avatars else [],
-              "sample_avatars": avatars[:3] if len(avatars) > 3 else avatars,
-              "timestamp": datetime.now().isoformat()
-          }
-          
-          # Extract all unique fields across all avatars
-          all_fields = set()
-          field_samples = {}
-          
-          for avatar in avatars:
-              for key, value in avatar.items():
-                  all_fields.add(key)
-                  if key not in field_samples and value:
-                      field_samples[key] = str(value)[:100]  # First 100 chars as sample
-          
-          analysis["all_available_fields"] = sorted(list(all_fields))
-          analysis["field_samples"] = field_samples
-          
-          # Look for potential naming fields
-          naming_fields = []
-          for field in all_fields:
-              field_lower = field.lower()
-              if any(keyword in field_lower for keyword in ['name', 'title', 'display', 'label', 'desc']):
-                  naming_fields.append(field)
-          
-          analysis["potential_naming_fields"] = naming_fields
-          
-          log_info(f"Avatar debug analysis completed: {len(avatars)} avatars, {len(all_fields)} unique fields", "Debug")
-          return analysis
-      else:
-          logger.warning(f"Unexpected HeyGen API response structure: {type(result)}")
-          return {
-              "success": False,
-              "raw_response": result,
-              "message": "Unexpected response structure from HeyGen API"
-          }
-      
-  except HTTPException:
-      raise  # Re-raise HTTP exceptions
-  except Exception as e:
-      log_error(f"Error in debug-avatars endpoint: {str(e)}", "Debug", e)
-      logger.error(f"Debug avatars error traceback: {traceback.format_exc()}")
-      raise HTTPException(status_code=500, detail=f"Debug endpoint error: {str(e)}")
-
-@app.get("/debug-env")
-async def debug_environment():
-  """
-  Debug endpoint to check environment variables (safely).
-  Shows which keys exist without exposing values.
-  """
-  try:
-      env_status = {
-          "HEYGEN_API_KEY": "✓ Set" if os.getenv("HEYGEN_API_KEY") else "✗ Missing",
-          "DATABASE_URL": "✓ Set" if os.getenv("DATABASE_URL") else "✗ Missing",
-          "CLOUDINARY_CLOUD_NAME": "✓ Set" if os.getenv("CLOUDINARY_CLOUD_NAME") else "✗ Missing",
-          "CLOUDINARY_API_KEY": "✓ Set" if os.getenv("CLOUDINARY_API_KEY") else "✗ Missing", 
-          "CLOUDINARY_API_SECRET": "✓ Set" if os.getenv("CLOUDINARY_API_SECRET") else "✗ Missing",
-          "SECRET_KEY": "✓ Set" if os.getenv("SECRET_KEY") else "✗ Missing",
-          "UNSPLASH_ACCESS_KEY": "✓ Set" if os.getenv("UNSPLASH_ACCESS_KEY") else "✗ Missing",
-          "OPENAI_API_KEY": "✓ Set" if os.getenv("OPENAI_API_KEY") else "✗ Missing",
-          "RAILWAY_ENVIRONMENT": os.getenv("RAILWAY_ENVIRONMENT", "not_railway"),
-          "PORT": os.getenv("PORT", "not_set"),
-          "REFRESH_INTERVAL_HOURS": os.getenv("REFRESH_INTERVAL_HOURS", "4"),
-          "EXPIRY_THRESHOLD_HOURS": os.getenv("EXPIRY_THRESHOLD_HOURS", "6"),
-          "REFRESHER_MODE": os.getenv("REFRESHER_MODE", "continuous"),
-          "timestamp": datetime.now().isoformat()
-      }
-      
-      # Check if we can import modules
-      try:
-          from app.api.heygen import get_available_avatars
-          env_status["heygen_module"] = "✓ Available"
-      except ImportError as e:
-          env_status["heygen_module"] = f"✗ Import Error: {str(e)}"
-      
-      # Check video refresher status
-      env_status["video_refresher_module"] = "✓ Available" if video_refresher_available else "✗ Not Available"
-      
-      # Check premium system
-      try:
-          from app.routes.premium_routes import check_premium_access
-          env_status["premium_system"] = "✓ Available"
-      except ImportError as e:
-          env_status["premium_system"] = f"✗ Import Error: {str(e)}"
-      
-      # Check BackgroundFX system
-      try:
-          from app.routes.backgroundfx_routes import router
-          env_status["backgroundfx_system"] = "✓ Available"
-      except ImportError as e:
-          env_status["backgroundfx_system"] = f"✗ Import Error: {str(e)}"
-      
-      # Check Video Processing system
-      try:
-          from app.routes.video_processing_routes import router
-          env_status["video_processing_system"] = "✓ Available"
-      except ImportError as e:
-          env_status["video_processing_system"] = f"✗ Import Error: {str(e)}"
-      
-      return env_status
-      
-  except Exception as e:
-      return {"error": str(e), "timestamp": datetime.now().isoformat()}
-
-# Startup event with safe initialization
-@app.on_event("startup")
-async def startup_event():
-  """Safe startup with comprehensive error handling"""
-  
-  # Initialize the notification system safely
-  try:
-      notify_service_status("MyAvatar", "up", "Application started successfully")
-      logger.info("Notification system initialized successfully")
-  except Exception as e:
-      logger.warning(f"Notification system unavailable: {str(e)}")
-
-  # Log compatibility status safely
-  try:
-      status = log_compatibility_status()
-      log_info(f"Starting MyAvatar application (Safe Mode: {status.get('safe_mode', 'unknown')})", "Server")
-  except Exception as e:
-      logger.warning(f"Could not determine compatibility status: {e}")
-      log_info("Starting MyAvatar application", "Server")
-  
-  # Database initialization with error handling
-  try:
-      init_database()
-      update_database_schema()
-      create_admin_user()
-      logger.info("Database initialization completed")
-  except Exception as e:
-      log_error(f"Database initialization failed: {str(e)}", "Server", e)
-      logger.warning("Application may have limited functionality due to database issues")
-  
-  # GDPR schema initialization
-  try:
-      from app.database.gdpr_schema import initialize_gdpr_schema
-      initialize_gdpr_schema()
-      logger.info("GDPR schema initialized")
-  except Exception as gdpr_error:
-      logger.warning(f"GDPR schema initialization failed: {str(gdpr_error)}")
-  
-  # Background replacement initialization
-  if ENABLE_BACKGROUND_REPLACEMENT:
-      try:
-          logger.info("Background replacement functionality enabled via BackgroundFX microservice")
-      except Exception as e:
-          logger.warning(f"Background replacement initialization warning: {e}")
-  
-  # Premium system initialization
-  try:
-      if "app.routes.premium_routes" in str(routers_loaded):
-          logger.info("✅ Premium system loaded successfully")
-          logger.info("🎯 Premium user management ready")
-          logger.info("🎁 14-day trial system ready")
-          logger.info("⭐ Premium feature access control ready")
-      else:
-          logger.warning("⚠️ Premium system not loaded")
-  except Exception as e:
-      logger.warning(f"Premium system initialization warning: {e}")
-  
-  # BackgroundFX system initialization
-  try:
-      if "app.routes.backgroundfx_routes" in str(routers_loaded):
-          logger.info("✅ BackgroundFX system loaded successfully")
-          logger.info("🎬 HeyGen WebM API integration ready")
-          logger.info("🖼️ Unsplash image search ready")
-          logger.info("🤖 OpenAI DALL-E integration ready")
-      else:
-          logger.warning("⚠️ BackgroundFX system not loaded")
-  except Exception as e:
-      logger.warning(f"BackgroundFX system check warning: {e}")
-      
-  # Video Processing system initialization
-  try:
-      if "app.routes.video_processing_routes" in str(routers_loaded):
-          logger.info("✅ Video Processing system loaded successfully")
-          logger.info("🎥 Advanced background replacement API ready")
-          logger.info("📊 Real-time job tracking ready")
-          logger.info("🔄 File upload and processing ready")
-      else:
-          logger.warning("⚠️ Video Processing system not loaded")
-  except Exception as e:
-      logger.warning(f"Video Processing system check warning: {e}")
-  
-  # Report successful startup
-  edition_name = "Premium Edition with BackgroundFX + Video Processing + Complete Premium System"
-  log_info(f"MyAvatar {edition_name} is running with MODULAR ROUTE STRUCTURE", "Server")
-  logger.info(f"✅ Successfully loaded {len(routers_loaded)} route modules: {', '.join(routers_loaded)}")
-  
-  if router_errors:
-      logger.error(f"❌ Failed to load {len(router_errors)} route modules")
-      for error in router_errors:
-          logger.error(f"   - {error['module']}: {error['error']}")
-  
-  # Log system status
-  modular_count = len([r for r in routers_loaded if not "legacy" in r])
-  legacy_count = len([r for r in routers_loaded if "legacy" in r])
-  logger.info(f"🏗️ REFACTORING COMPLETE: {modular_count} modular routes, {legacy_count} legacy routes")
-
-  # Mount the Gradio app for the background removal tool
-  # This is done at the end of startup to ensure all other initializations are complete
-  try:
-      logger.info("🔧 Mounting Gradio app for background removal tool...")
-      gr.mount_gradio_app(app, huggingface_gradio_app, path="/tools/background_remover")
-      logger.info("✅ Gradio app mounted successfully at /tools/background_remover")
-  except Exception as e:
-      logger.error(f"❌ Failed to mount Gradio app: {e}")
-      logger.error(f"Full traceback: {traceback.format_exc()}")
-  
-  # Check feature status
-  premium_loaded = any("premium_routes" in r for r in routers_loaded)
-  backgroundfx_loaded = any("backgroundfx_routes" in r for r in routers_loaded)
-  video_processing_loaded = any("video_processing_routes" in r for r in routers_loaded)
-  
-  if premium_loaded:
-      logger.info("🎯 PREMIUM SYSTEM ACTIVE: Complete user management and access control")
-  else:
-      logger.warning("⚠️ Premium system not loaded - BackgroundFX and Video Processing will fail")
-  
-  if backgroundfx_loaded:
-      logger.info("🎬 BACKGROUNDFX FEATURES ACTIVE: HeyGen WebM + Transparent Videos ready")
-  else:
-      logger.warning("⚠️ BackgroundFX features not loaded")
-      
-  if video_processing_loaded:
-      logger.info("🎥 VIDEO PROCESSING FEATURES ACTIVE: Advanced Background Replacement ready")
-  else:
-      logger.warning("⚠️ Video Processing features not loaded")
-  
-  # Log video refresher status
-  if video_refresher_available:
-      logger.info("🔄 Video URL refresher background service is running")
-  else:
-      logger.warning("⚠️ Video URL refresher background service is not available")
-  
-  # Final system status
-  if premium_loaded and backgroundfx_loaded and video_processing_loaded:
-      logger.info("🎉 ALL SYSTEMS OPERATIONAL: Premium + BackgroundFX + Video Processing")
-  else:
-      logger.warning("⚠️ Some systems not operational - check router loading errors")
-
-# Entry point
-# Main application entry point
-if __name__ == "__main__":
-    try:
-        logger.info("Starting application server...")
-        # Note: Database initialization is now handled by the startup event.
-        # Start the FastAPI application using uvicorn
-        uvicorn.run("app:app", host="0.0.0.0", port=int(os.getenv("PORT", 7860)), reload=True)
-
-    except ImportError as e:
-        print(f"FATAL: Missing essential dependency: {e}")
-        print("Please run 'pip install -r requirements.txt' to install required packages.")
+        logger.error(f"Fatal error in main: {e}")
         import traceback
         traceback.print_exc()
-    except Exception as e:
-        print(f"FATAL: Application failed to start: {e}")
-        import traceback
-        traceback.print_exc()
+    finally:
+        processor.cleanup_resources()
+
+if __name__ == "__main__":
+    main()