Update app/main.py

app/main.py

@@ -1,226 +1,439 @@
-
-# --- Standard Library Imports ---
-import os
 import logging
+import os
+import asyncio
 from pathlib import Path
 from contextlib import asynccontextmanager
 
-# --- FastAPI and Related Imports ---
-from fastapi import FastAPI, HTTPException, Depends, Request
+from fastapi import FastAPI, HTTPException, Request
 from fastapi.staticfiles import StaticFiles
 from fastapi.responses import HTMLResponse, FileResponse
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.middleware.gzip import GZipMiddleware
-
-# --- Application-Specific Imports ---
-# API Routers
-from .api import (
-    auth,
-    reports,
-    documents,
-    ocr,
-    dashboard,
-    scraping,
-    analytics,
-    enhanced_analytics
-)
-
-# Services
-from .services.database_service import DatabaseManager
-from .services.ocr_service import OCRPipeline
-from .services.ai_service import AIScoringEngine
-# Note: notification_service and cache_service were imported but not used in the lifespan.
-# They can be initialized here if needed.
-
-# --- Logging Configuration ---
+from fastapi.middleware.trustedhost import TrustedHostMiddleware
+
+# Import API routers
+from app.api import auth, documents, analytics, reports, ocr, scraping, dashboard, enhanced_analytics
+
+# Import services - with error handling
+try:
+    from app.services.database_service import DatabaseService
+except ImportError as e:
+    logging.warning(f"Could not import DatabaseService: {e}")
+    DatabaseService = None
+
+try:
+    from app.services.ocr_service import OCRService
+except ImportError as e:
+    logging.warning(f"Could not import OCRService: {e}")
+    OCRService = None
+
+try:
+    from app.services.ai_service import AIService
+except ImportError as e:
+    logging.warning(f"Could not import AIService: {e}")
+    AIService = None
+
+# Configure logging
+os.makedirs('/app/logs', exist_ok=True)
 logging.basicConfig(
     level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('/app/logs/app.log', mode='a'),
+        logging.StreamHandler()
+    ]
 )
 logger = logging.getLogger(__name__)
 
+# Initialize global services
+database_service = None
+ocr_service = None
+ai_service = None
+
+# Application startup flag
+app_ready = False
 
-# --- Lifespan Management ---
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    """
-    Manages the application's lifespan. Initializes services on startup
-    and cleans up on shutdown. Services are stored in app.state.
-    """
-    logger.info("🚀 Starting Legal Dashboard...")
-
+    """Application lifespan manager with optimized startup"""
+    global database_service, ocr_service, ai_service, app_ready
+    
     try:
-        # Initialize services and store them in the application state
-        logger.info("📦 Initializing services...")
-        app.state.db_manager = DatabaseManager()
-        app.state.db_manager.initialize()
-        logger.info("✅ Database initialized")
-
-        app.state.ocr_pipeline = OCRPipeline()
-        app.state.ocr_pipeline.initialize()
-        logger.info("✅ OCR Pipeline initialized")
-
-        app.state.ai_engine = AIScoringEngine()
-        logger.info("✅ AI Engine initialized")
-
-        # Create required temporary directories
-        Path("/tmp/uploads").mkdir(exist_ok=True)
-        Path("/tmp/data").mkdir(exist_ok=True)
-
-        logger.info("🎉 All services initialized successfully!")
-
-        yield  # Application runs here
-
+        logger.info("🚀 Starting Legal Dashboard...")
+        logger.info("📦 Initializing core services...")
+        
+        # Create necessary directories
+        directories = ["/app/data", "/app/logs", "/app/uploads", "/app/cache", "/app/backups"]
+        for directory in directories:
+            os.makedirs(directory, exist_ok=True)
+        
+        # Initialize Database Service (Priority 1 - Required)
+        if DatabaseService:
+            try:
+                database_service = DatabaseService()
+                await database_service.initialize()
+                logger.info("✅ Database initialized")
+            except Exception as e:
+                logger.error(f"❌ Database initialization failed: {e}")
+                # Continue with limited functionality
+        else:
+            logger.warning("⚠️ DatabaseService not available")
+        
+        # Initialize AI Service (Priority 2)
+        if AIService:
+            try:
+                ai_service = AIService()
+                logger.info("✅ AI Engine initialized")
+            except Exception as e:
+                logger.warning(f"⚠️ AI initialization failed: {e}")
+        else:
+            logger.warning("⚠️ AIService not available")
+        
+        # Set app as ready (before OCR to avoid timeout)
+        app_ready = True
+        logger.info("🎉 Core services initialized! App is ready to serve requests.")
+        
+        # Initialize OCR Service (Priority 3 - Can be loaded in background)
+        if OCRService:
+            try:
+                logger.info("🔄 Starting OCR service initialization in background...")
+                # Use asyncio to initialize OCR in background
+                asyncio.create_task(initialize_ocr_background())
+            except Exception as e:
+                logger.warning(f"⚠️ OCR background initialization failed: {e}")
+        else:
+            logger.warning("⚠️ OCRService not available")
+        
+        yield
+        
     except Exception as e:
-        logger.critical(f"❌ Initialization failed: {e}", exc_info=True)
-        # In a real-world scenario, you might want to handle this more gracefully
-        # or prevent the app from starting if critical services fail.
+        logger.error(f"❌ Application startup failed: {e}")
+        app_ready = True  # Set ready anyway to avoid timeout
+        yield
     finally:
-        # Cleanup can be added here if needed (e.g., closing connections)
-        logger.info("🔄 Shutting down Legal Dashboard...")
+        logger.info("🔄 Shutting down services...")
 
+async def initialize_ocr_background():
+    """Initialize OCR service in background to avoid startup timeout"""
+    global ocr_service
+    try:
+        logger.info("🔄 Loading OCR models in background...")
+        ocr_service = OCRService()
+        logger.info("✅ OCR Pipeline initialized in background")
+    except Exception as e:
+        logger.warning(f"⚠️ Background OCR initialization failed: {e}")
 
-# --- FastAPI Application Instance ---
+# Create FastAPI application
 app = FastAPI(
     title="Legal Dashboard API",
-    description="AI-powered Persian legal document processing system",
-    version="1.0.0",
+    description="Advanced Legal Document Management System",
+    version="2.0.0",
     docs_url="/api/docs",
     redoc_url="/api/redoc",
     lifespan=lifespan
 )
 
-# --- Middlewares ---
-app.add_middleware(GZipMiddleware, minimum_size=1000)
+# Add security middleware
+app.add_middleware(
+    TrustedHostMiddleware, 
+    allowed_hosts=["*"]  # Configure appropriately for production
+)
+
+# Add CORS middleware
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # WARNING: Configure this properly for production
+    allow_origins=["*"],  # Configure appropriately for production
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
-
-# --- Dependency Injection Providers ---
-def get_db_manager(request: Request) -> DatabaseManager:
-    return request.app.state.db_manager
-
-def get_ocr_pipeline(request: Request) -> OCRPipeline:
-    return request.app.state.ocr_pipeline
-
-def get_ai_engine(request: Request) -> AIScoringEngine:
-    return request.app.state.ai_engine
-
-
-# --- API Routers ---
-app.include_router(
-    documents.router, prefix="/api/documents", tags=["Documents"])
-app.include_router(ocr.router, prefix="/api/ocr", tags=["OCR"])
-app.include_router(
-    dashboard.router, prefix="/api/dashboard", tags=["Dashboard"])
-app.include_router(scraping.router, prefix="/api/scraping", tags=["Scraping"])
-app.include_router(
-    analytics.router, prefix="/api/analytics", tags=["Analytics"])
-app.include_router(
-    enhanced_analytics.router, prefix="/api/enhanced-analytics", tags=["Enhanced Analytics"])
-app.include_router(auth.router, prefix="/api/auth", tags=["Authentication"])
-app.include_router(reports.router, prefix="/api/reports",
-                   tags=["Reports & Analytics"])
-
-
-# --- Static Files and Frontend Serving ---
-frontend_dir = Path(__file__).resolve().parent.parent / "frontend"
-if frontend_dir.is_dir():
-    app.mount(
-        "/static", StaticFiles(directory=frontend_dir), name="static")
-    logger.info(f"📁 Static files mounted from: {frontend_dir}")
+# Mount static files
+frontend_path = Path("/app/frontend")
+if frontend_path.exists():
+    app.mount("/static", StaticFiles(directory=str(frontend_path)), name="static")
+    logger.info(f"📁 Static files mounted from: {frontend_path}")
 else:
-    logger.warning(
-        f"⚠️ Frontend directory not found at {frontend_dir}. The frontend will not be served.")
-
+    logger.warning(f"⚠️ Frontend directory not found: {frontend_path}")
+
+# Include API routers with error handling
+try:
+    app.include_router(auth.router, prefix="/api/auth", tags=["Authentication"])
+    app.include_router(documents.router, prefix="/api/documents", tags=["Documents"])
+    app.include_router(analytics.router, prefix="/api/analytics", tags=["Analytics"])
+    app.include_router(enhanced_analytics.router, prefix="/api/enhanced-analytics", tags=["Enhanced Analytics"])
+    app.include_router(reports.router, prefix="/api/reports", tags=["Reports"])
+    app.include_router(ocr.router, prefix="/api/ocr", tags=["OCR"])
+    app.include_router(scraping.router, prefix="/api/scraping", tags=["Scraping"])
+    app.include_router(dashboard.router, prefix="/api/dashboard", tags=["Dashboard"])
+except Exception as e:
+    logger.error(f"Error including routers: {e}")
+
+# Health check endpoint - Optimized for quick response
+@app.get("/health")
+async def health_check():
+    """Quick health check endpoint for Docker healthcheck"""
+    return {
+        "status": "healthy" if app_ready else "starting",
+        "message": "Legal Dashboard is running" if app_ready else "Legal Dashboard is starting up",
+        "app_ready": app_ready,
+        "services": {
+            "database": database_service is not None,
+            "ocr": ocr_service is not None,
+            "ai": ai_service is not None
+        }
+    }
 
-@app.get("/", response_class=HTMLResponse, include_in_schema=False)
-async def read_root():
-    """Serves the main frontend application or a fallback page."""
-    html_file = frontend_dir / "index.html"
-    if html_file.is_file():
-        return FileResponse(html_file, media_type="text/html")
+# Detailed health check
+@app.get("/health/detailed")
+async def detailed_health_check():
+    """Detailed health check with service status"""
+    services_status = {}
+    
+    # Check database
+    if database_service:
+        try:
+            # Quick database test
+            services_status["database"] = {"status": "healthy", "message": "Connected"}
+        except Exception as e:
+            services_status["database"] = {"status": "unhealthy", "message": str(e)}
     else:
-        return HTMLResponse("""
-        <html>
-            <head><title>Legal Dashboard</title></head>
-            <body>
-                <h1>🏛️ Legal Dashboard API</h1>
-                <p>Backend is running, but the frontend file (index.html) was not found.</p>
-                <p>Check the 'frontend' directory or <a href="/api/docs">📖 see the API Documentation</a>.</p>
-            </body>
-        </html>
-        """)
-
-
-# --- Core API Endpoints ---
-@app.get("/api/health")
-async def health_check(
-    db: DatabaseManager = Depends(get_db_manager),
-    ocr: OCRPipeline = Depends(get_ocr_pipeline),
-    ai: AIScoringEngine = Depends(get_ai_engine)
-):
-    """Checks the health of all critical services."""
-    db_healthy = db.is_connected()
-    ocr_healthy = ocr.initialized
-    ai_healthy = ai is not None  # Basic check, can be improved if AI engine has a health method
-
-    if db_healthy and ocr_healthy and ai_healthy:
-        status = "healthy"
+        services_status["database"] = {"status": "unavailable", "message": "Service not loaded"}
+    
+    # Check OCR
+    if ocr_service:
+        services_status["ocr"] = {"status": "healthy", "message": "Models loaded"}
     else:
-        status = "unhealthy"
-
+        services_status["ocr"] = {"status": "loading" if not app_ready else "degraded", "message": "Models still loading or failed"}
+    
+    # Check AI
+    if ai_service:
+        services_status["ai"] = {"status": "healthy", "message": "Service available"}
+    else:
+        services_status["ai"] = {"status": "unavailable", "message": "Service not loaded"}
+    
     return {
-        "status": status,
-        "services": {
-            "database": "healthy" if db_healthy else "unhealthy",
-            "ocr": "healthy" if ocr_healthy else "unhealthy",
-            "ai": "healthy" if ai_healthy else "unhealthy"
-        },
-        "version": app.version
+        "status": "healthy",
+        "app_ready": app_ready,
+        "services": services_status,
+        "uptime": "Running"
     }
 
-
-# --- Custom Exception Handlers ---
-@app.exception_handler(404)
-async def not_found_handler(request: Request, exc: HTTPException):
-    """Custom handler for 404 Not Found errors."""
-    return HTMLResponse(content="""
-    <html>
-        <head><title>404 - صفحه یافت نشد</title></head>
-        <body style="font-family: 'Tahoma', sans-serif; text-align: center; padding: 50px;">
-            <h1>🔍 صفحه یافت نشد</h1>
-            <p>متأسفانه، آدرس درخواستی شما در این سرور وجود ندارد.</p>
-            <a href="/">🏠 بازگشت به صفحه اصلی</a>
-        </body>
-    </html>
-    """, status_code=404)
-
-
-@app.exception_handler(500)
-async def internal_error_handler(request: Request, exc: Exception):
-    """Custom handler for 500 Internal Server Errors."""
-    logger.error(f"Internal server error on request {request.method} {request.url}: {exc}", exc_info=True)
-    return HTMLResponse(content="""
-    <html>
-        <head><title>500 - خطای داخلی سرور</title></head>
-        <body style="font-family: 'Tahoma', sans-serif; text-align: center; padding: 50px;">
-            <h1>⚠️ خطای سرور</h1>
-            <p>متأسفانه یک خطای پیش‌بینی نشده در سرور رخ داده است. تیم فنی در حال بررسی مشکل است.</p>
-            <a href="/">🏠 بازگشت به صفحه اصلی</a>
-        </body>
+# API health check
+@app.get("/api/auth/health")
+async def api_health():
+    """API health check for Docker healthcheck"""
+    return {"status": "healthy", "api": "running", "ready": app_ready}
+
+# Simple ping endpoint
+@app.get("/ping")
+async def ping():
+    """Simple ping endpoint"""
+    return {"ping": "pong", "ready": app_ready}
+
+# Root endpoint - serve main dashboard
+@app.get("/", response_class=HTMLResponse)
+async def root(request: Request):
+    """Serve the main dashboard"""
+    try:
+        index_path = frontend_path / "index.html"
+        if index_path.exists():
+            return FileResponse(str(index_path))
+        else:
+            # Fallback HTML if index.html doesn't exist
+            return HTMLResponse(generate_fallback_html())
+    except Exception as e:
+        logger.error(f"Error serving root: {e}")
+        return HTMLResponse(generate_fallback_html())
+
+def generate_fallback_html():
+    """Generate fallback HTML when index.html is not available"""
+    return """
+    <!DOCTYPE html>
+    <html lang="fa" dir="rtl">
+    <head>
+        <title>Legal Dashboard | داشبورد حقوقی</title>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <link href="https://fonts.googleapis.com/css2?family=Vazir:wght@300;400;500;600;700&display=swap" rel="stylesheet">
+        <link href="https://cdnjs.cloudflare.com/ajax/libs/bootstrap/5.3.0/css/bootstrap.min.css" rel="stylesheet">
+        <style>
+            * { font-family: 'Vazir', sans-serif; }
+            body { 
+                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                min-height: 100vh;
+                direction: rtl;
+            }
+            .container { 
+                max-width: 1200px; 
+                margin: 50px auto; 
+                background: rgba(255,255,255,0.95); 
+                padding: 40px; 
+                border-radius: 15px; 
+                box-shadow: 0 8px 32px rgba(0,0,0,0.1);
+            }
+            .status-badge {
+                display: inline-block;
+                padding: 5px 15px;
+                border-radius: 20px;
+                font-size: 0.9rem;
+                margin: 5px;
+            }
+            .status-healthy { background: #28a745; color: white; }
+            .status-loading { background: #ffc107; color: black; }
+            .nav-grid {
+                display: grid;
+                grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+                gap: 20px;
+                margin-top: 30px;
+            }
+            .nav-card {
+                background: #f8f9fa;
+                padding: 20px;
+                border-radius: 10px;
+                text-align: center;
+                text-decoration: none;
+                color: #333;
+                transition: transform 0.3s;
+            }
+            .nav-card:hover {
+                transform: translateY(-5px);
+                color: #333;
+                box-shadow: 0 5px 15px rgba(0,0,0,0.1);
+            }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <div class="text-center mb-4">
+                <h1 class="display-4 mb-3">🏛️ داشبورد حقوقی</h1>
+                <p class="lead">سیستم پیشرفته مدیریت اسناد حقوقی</p>
+                
+                <div class="mt-4">
+                    <span class="status-badge status-healthy">سیستم آنلاین</span>
+                    <span class="status-badge status-loading" id="ocrStatus">OCR در حال بارگذاری...</span>
+                </div>
+            </div>
+            
+            <div class="nav-grid">
+                <a href="/api/docs" class="nav-card">
+                    <h5>📚 مستندات API</h5>
+                    <p>مشاهده و تست API endpoints</p>
+                </a>
+                
+                <a href="/health/detailed" class="nav-card">
+                    <h5>🔍 وضعیت سیستم</h5>
+                    <p>بررسی جزئیات سلامت سرویس‌ها</p>
+                </a>
+                
+                <a href="/static/documents.html" class="nav-card">
+                    <h5>📄 مدیریت اسناد</h5>
+                    <p>آپلود و مدیریت فایل‌ها</p>
+                </a>
+                
+                <a href="/static/analytics.html" class="nav-card">
+                    <h5>📊 تحلیل و آمار</h5>
+                    <p>نمودارها و گزارشات</p>
+                </a>
+            </div>
+            
+            <div class="text-center mt-4">
+                <button class="btn btn-primary" onclick="location.reload()">🔄 تازه‌سازی</button>
+                <button class="btn btn-outline-primary" onclick="checkStatus()">📊 بررسی وضعیت</button>
+            </div>
+            
+            <div id="statusResult" class="mt-4"></div>
+        </div>
+        
+        <script>
+            // Check OCR status
+            setTimeout(() => {
+                fetch('/health/detailed')
+                    .then(r => r.json())
+                    .then(data => {
+                        const ocrStatus = document.getElementById('ocrStatus');
+                        if (data.services?.ocr?.status === 'healthy') {
+                            ocrStatus.textContent = 'OCR آماده';
+                            ocrStatus.className = 'status-badge status-healthy';
+                        }
+                    })
+                    .catch(() => {});
+            }, 5000);
+            
+            function checkStatus() {
+                const result = document.getElementById('statusResult');
+                result.innerHTML = '<p>در حال بررسی...</p>';
+                
+                fetch('/health/detailed')
+                    .then(r => r.json())
+                    .then(data => {
+                        let html = '<div class="alert alert-info"><h5>وضعیت سرویس‌ها:</h5><ul>';
+                        for (const [service, status] of Object.entries(data.services)) {
+                            html += `<li><strong>${service}:</strong> ${status.status} - ${status.message}</li>`;
+                        }
+                        html += '</ul></div>';
+                        result.innerHTML = html;
+                    })
+                    .catch(e => {
+                        result.innerHTML = '<div class="alert alert-danger">خطا در دریافت وضعیت</div>';
+                    });
+            }
+        </script>
+    </body>
     </html>
-    """, status_code=500)
+    """
+
+# Catch-all route for frontend SPA routing
+@app.get("/{path:path}", response_class=HTMLResponse)
+async def catch_all(path: str):
+    """Serve static files or fallback to index"""
+    try:
+        # Try to serve static file first
+        file_path = frontend_path / path
+        if file_path.exists() and file_path.is_file():
+            return FileResponse(str(file_path))
+        
+        # If it's an HTML request, serve the appropriate HTML file
+        if path.endswith('.html'):
+            html_path = frontend_path / path
+            if html_path.exists():
+                return FileResponse(str(html_path))
+        
+        # Fallback to main page for SPA routing
+        index_path = frontend_path / "index.html"
+        if index_path.exists():
+            return FileResponse(str(index_path))
+        
+        # Final fallback
+        raise HTTPException(status_code=404, detail="Page not found")
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error in catch-all route: {e}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+# Make services available globally
+def get_database_service():
+    return database_service
+
+def get_ocr_service():
+    return ocr_service
 
+def get_ai_service():
+    return ai_service
 
-# --- Development Server Runner ---
 if __name__ == "__main__":
     import uvicorn
-    # This block is for development purposes only.
-    # For production, use a proper process manager like Gunicorn with Uvicorn workers.
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    
+    # Check if running in container
+    in_container = os.path.exists('/.dockerenv')
+    
+    uvicorn.run(
+        "app.main:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=False,
+        workers=1,
+        access_log=True,
+        log_level="info"
+    )