"""
FastAPI application entry point for Aiguid Backend API.
Handles application initialization, middleware setup, and routing.
"""

import logging
import sys
from pathlib import Path
from datetime import datetime

import sentry_sdk
from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
from sentry_sdk.integrations.asgi import SentryAsgiMiddleware
from sentry_sdk.integrations.logging import LoggingIntegration

# Local imports
from config import settings
from database import engine
from models import Base
# from debug_middleware import DebugMiddleware  # Только для отладки
from routers import auth
from middleware import RateLimitMiddleware, LoggingMiddleware, SecurityMiddleware

# Import models from /opt/aiguide for table creation
sys.path.append('/opt/aiguide/app/models')
from models_db import Base as AiguideBase

# Configure logging
logging.basicConfig(
    level=getattr(logging, settings.LOG_LEVEL),
    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S"
)
logger = logging.getLogger(__name__)

# Initialize Sentry
sentry_logging = LoggingIntegration(
    level=logging.INFO,      # INFO and above as breadcrumbs
    event_level=logging.ERROR  # ERROR and above as separate events
)

if settings.SENTRY_DSN:
    sentry_sdk.init(
        dsn=settings.SENTRY_DSN,
        integrations=[sentry_logging],
        send_default_pii=True,
        traces_sample_rate=1.0,
    )

def init_database() -> None:
    """Initialize database tables."""
    try:
        AiguideBase.metadata.create_all(bind=engine)
        Base.metadata.create_all(bind=engine)
        logger.info("✅ Database initialized successfully")
    except Exception as e:
        logger.error(f"❌ Database initialization error: {e}")
        raise

def create_app() -> FastAPI:
    """Create and configure FastAPI application."""
    app = FastAPI(
        title=settings.APP_NAME,
        description="Backend API for Aiguid travel application",
        version=settings.APP_VERSION,
        docs_url="/api/docs",
        redoc_url="/api/redoc"
    )
    
    # Debug middleware отключен для production
    # app.add_middleware(DebugMiddleware)
    
    # Add custom middleware
    if settings.ENABLE_RATE_LIMITING:
        app.add_middleware(RateLimitMiddleware, requests_per_minute=settings.RATE_LIMIT_REQUESTS)
    
    app.add_middleware(LoggingMiddleware)
    app.add_middleware(SecurityMiddleware)
    
    # Add Sentry middleware
    app.add_middleware(SentryAsgiMiddleware)
    
    # Add CORS middleware
    if settings.ENABLE_CORS:
        app.add_middleware(
            CORSMiddleware,
            allow_origins=settings.ALLOWED_ORIGINS,
            allow_credentials=True,
            allow_methods=["*"],
            allow_headers=["*"],
        )
    
    # Include routers
    app.include_router(auth.router)
    
    return app

# Initialize database
init_database()

# Create application
app = create_app()

@app.get("/api/health")
async def health_check() -> dict:
    """Health check endpoint."""
    logger.info("🔍 Health check request")
    
    # Check database connection
    try:
        from sqlalchemy import text
        with engine.connect() as conn:
            conn.execute(text("SELECT 1"))
        db_status = "healthy"
    except Exception as e:
        logger.error(f"Database health check failed: {e}")
        db_status = "unhealthy"
    
    return {
        "status": "ok", 
        "message": "Aiguid API is running",
        "timestamp": datetime.now().isoformat(),
        "version": settings.APP_VERSION,
        "database": db_status,
        "environment": "production"
    }

if __name__ == "__main__":
    import uvicorn
    logger.info("🚀 Starting Aiguid Backend API")
    uvicorn.run(app, host="127.0.0.1", port=8010)