from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
from starlette.middleware.sessions import SessionMiddleware
from config.settings import DEVELOPMENT, SECRET_KEY
from routes import sales
from services.email_service import initialize_email_sender
from services.logging_service import structured_logger, LogLevel
from middleware.no_cache import NoCacheMiddleware
from logging import getLogger

logger = getLogger(__name__)

def create_app() -> FastAPI:
    """Create and configure FastAPI application"""
    logger.info("Creating FastAPI application")
    
    try:
        if DEVELOPMENT:
            logger.info("Creating FastAPI app in development mode")
            app = FastAPI(
                title="Web Pedidos Klein - FastAPI Backend",
                description="Backend for the Web Pedidos Klein application using FastAPI"
            )
        else:
            logger.info("Creating FastAPI app in production mode")
            app = FastAPI(
                title="Web Pedidos Klein - FastAPI Backend",
                description="Backend for the Web Pedidos Klein application using FastAPI",
                version="1.0.0", 
                docs_url=None, 
                redoc_url=None
            )

        structured_logger.log_system_event(
            "FastAPI application created",
            LogLevel.INFO,
            {
                "development_mode": DEVELOPMENT,
                "docs_enabled": DEVELOPMENT,
                "title": "Web Pedidos Klein - FastAPI Backend"
            }
        )

        # Initialize email sender
        logger.info("Initializing email sender")
        initialize_email_sender()
        
        structured_logger.log_email_event(
            "Email sender initialized",
            LogLevel.INFO
        )

        # Add CORS middleware
        logger.info("Adding CORS middleware")
        app.add_middleware(
            CORSMiddleware,
            allow_origins=["https://admin.kleinexpress.store"],
            allow_credentials=True,
            allow_methods=["*"],
            allow_headers=["*"],
        )
        
        structured_logger.log_system_event(
            "CORS middleware configured",
            LogLevel.INFO,
            {
                "allowed_origins": ["https://admin.kleinexpress.store"],
                "allow_credentials": True
            }
        )
        
        # Add SessionMiddleware
        logger.info("Adding session middleware")
        app.add_middleware(
            SessionMiddleware,
            secret_key=SECRET_KEY,
            max_age=60 * 60  # max_age in seconds for Starlette
        )
        
        structured_logger.log_system_event(
            "Session middleware configured",
            LogLevel.INFO,
            {"max_age_seconds": 3600}
        )
        
        # Add NoCacheMiddleware
        logger.info("Adding no-cache middleware")
        app.add_middleware(NoCacheMiddleware)
        
        structured_logger.log_system_event(
            "No-cache middleware configured",
            LogLevel.INFO,
            {"description": "Middleware for preventing cache on public files"}
        )
        
        logger.info("FastAPI application created successfully")
        return app
        
    except Exception as e:
        error_msg = f"Error creating FastAPI application: {e}"
        logger.error(error_msg)
        structured_logger.log_system_event(
            "FastAPI application creation failed",
            LogLevel.ERROR,
            {
                "error": str(e),
                "error_type": type(e).__name__
            }
        )
        raise


def setup_routes(app: FastAPI):
    """Setup all application routes"""
    logger.info("Setting up application routes")
    
    try:
        from routes import chat, users, products, orders, static
        from fastapi import Depends
        from auth.security import get_current_user
        
        # Chat routes
        logger.info("Setting up chat routes")
        app.include_router(
            chat.chat_router, 
            prefix="/api/chat",
            tags=["Chat"], 
            dependencies=[Depends(get_current_user)]
        )

        # User routes
        logger.info("Setting up user routes")
        app.include_router(users.user_router, prefix="/api/users", tags=["Users"])

        # Product routes
        logger.info("Setting up product routes")
        app.include_router(
            products.product_router, 
            prefix="/api/products", 
            tags=["Products"],
            dependencies=[Depends(get_current_user)]
        )

        # Order routes
        logger.info("Setting up order routes")
        app.include_router(
            orders.order_router, 
            prefix="/api/orders", 
            tags=["Orders"], 
            dependencies=[Depends(get_current_user)]
        )
        
        # Sales routes
        logger.info("Setting up sales routes")
        app.include_router(
            sales.sales_router, 
            prefix="/api/sales", 
            tags=["Sales"], 
            dependencies=[Depends(get_current_user)]
        )

        # Verification routes
        logger.info("Setting up verification routes")
        app.include_router(users.verify_router, prefix="/verify", tags=["Verification"])
        
        # Static routes
        logger.info("Setting up static routes")
        from fastapi.responses import HTMLResponse
        app.add_api_route("/", static.serve_app_html, methods=["GET"], 
                         response_class=HTMLResponse, include_in_schema=False)
        app.add_api_route("/register", static.serve_register_html, methods=["GET"],
                         response_class=HTMLResponse, include_in_schema=False)
        app.add_api_route("/images/{image_path:path}", static.serve_image, methods=["GET"],
                         response_class=HTMLResponse, include_in_schema=False)

        # Mount static files
        logger.info("Mounting static file directories")
        static.mount_main_static_files(app)
        static.mount_register_static_files(app)

        structured_logger.log_system_event(
            "All application routes configured successfully",
            LogLevel.INFO,
            {
                "route_groups": [
                    "chat", "users", "products", "orders", 
                    "sales", "verification", "static"
                ]
            }
        )
        
        logger.info("Application routes setup completed successfully")
        
    except Exception as e:
        error_msg = f"Error setting up application routes: {e}"
        logger.error(error_msg)
        structured_logger.log_system_event(
            "Route setup failed",
            LogLevel.ERROR,
            {
                "error": str(e),
                "error_type": type(e).__name__
            }
        )
        raise