Update core/app.py

core/app.py

@@ -1,609 +1,1054 @@
-#!/usr/bin/env python3
 """
-BackgroundFX Pro – Main Application Entry Point
-Refactored modular architecture – orchestrates specialised components
+MyAvatar - Complete AI Avatar Video Generation Platform
+========================================================
+Modular version with enhanced organization - REFACTORED ROUTES + PREMIUM FEATURES + BACKGROUNDFX + VIDEO PROCESSING
 """
-from __future__ import annotations
-# ── Early env/threading hygiene (safe default to silence libgomp) ────────────
+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
 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 threading
 import traceback
-import sys
-import time
+import uuid
+import threading
+from datetime import datetime
+from typing import Optional
 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 ──────────────────────────────────────────────────────────────────
+import sys
+
+# Load environment variables
+load_dotenv()
+
+# Define the base directory of the project
+BASE_DIR = Path(__file__).resolve().parent
+
+# Setup logging
 logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+  level=logging.INFO,
+  format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
 )
-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) ───────────────────────────────────────────
+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=["*"],
+)
+
+# 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
+
 try:
     import gradio_client.utils as gc_utils
-    _orig_get_type = gc_utils.get_type
-    def _patched_get_type(schema):
+    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
         if not isinstance(schema, dict):
-            if isinstance(schema, bool): return "boolean"
-            if isinstance(schema, str): return "string"
-            if isinstance(schema, (int, float)): return "number"
+            # 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
             return "string"
-        return _orig_get_type(schema)
-    gc_utils.get_type = _patched_get_type
-    logger.info("Gradio schema patch applied")
-except Exception as e:
-    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
+        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 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",
+  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}")
+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),
 ]
-for import_path in two_stage_paths:
+
+# 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"),
+]
+
+# 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"""
     try:
-        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
+        logger.info("BackgroundFX page accessed")
         
-        # 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)
-        
-        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
+        # 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)
         else:
-            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():
+            # 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"""
     try:
-        logger.info("Starting BackgroundFX Pro")
-        logger.info(f"Device: {processor.device_manager.get_optimal_device()}")
-        logger.info(f"Two-stage available: {TWO_STAGE_AVAILABLE}")
-        
-        # 🔹 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")
-        
-        # Now import UI - this should work since callbacks no longer imports from core.app at module level
-        from ui.ui_components import create_interface
-        
-        # Create and launch the interface
-        demo = create_interface()
-        demo.queue().launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            show_error=True,
-            debug=False,
-        )
+        logger.info("Admin premium page accessed")
         
+        # 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>
+            """)
+            
     except Exception as e:
-        logger.error(f"Fatal error in main: {e}")
-        import traceback
-        traceback.print_exc()
-    finally:
-        processor.cleanup_resources()
+        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__":
-    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.")
+        import traceback
+        traceback.print_exc()
+    except Exception as e:
+        print(f"FATAL: Application failed to start: {e}")
+        import traceback
+        traceback.print_exc()