"""
FastAPI 应用主入口
"""

import os
import logging
import uuid
from contextlib import asynccontextmanager
from fastapi import FastAPI, Request
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import JSONResponse
from fastapi.staticfiles import StaticFiles
from fastapi.exceptions import RequestValidationError
from starlette.exceptions import HTTPException as StarletteHTTPException

from app.core.config import settings

# 安全配置：CORS 允许的源
# 生产环境必须配置 CORS_ORIGINS 环境变量，多个源用逗号分隔
# 例如: CORS_ORIGINS=https://your-domain.com,https://admin.your-domain.com
_cors_origins_env = os.getenv("CORS_ORIGINS", "")
if _cors_origins_env:
    CORS_ORIGINS = [origin.strip() for origin in _cors_origins_env.split(",") if origin.strip()]
else:
    # 开发环境默认值
    CORS_ORIGINS = [
        "http://localhost:3000",
        "http://localhost:5173",
        "http://127.0.0.1:3000",
        "http://127.0.0.1:5173",
    ]

# 环境判断
IS_PRODUCTION = os.getenv("ENV", "development").lower() == "production"
from app.core.logging import setup_logging
from app.core.database import init_db, close_db
from app.routers.auth_router import router as auth_router
from app.routers.import_router import router as import_router
from app.routers.normalized_router import router as normalized_router
from app.routers.product_router import router as product_router
from app.routers.procurement_router import router as procurement_router
from app.routers.procurement_router_v2 import router as procurement_router_v2
from app.routers.products_master_router import router as products_master_router
from app.routers.procurement_confirmation import router as procurement_confirmation_router
from app.routers.offset_management import router as offset_management_router
from app.routers.monitoring import router as monitoring_router
from app.routers.audit_logging import router as audit_logging_router
from app.routers.pdf_export import router as pdf_export_router
from app.routers.progress_router import router as progress_router
from app.routers.sync_router import router as sync_router
from app.routers.shipping_router import router as shipping_router
from app.routers.shop_report_router import router as shop_report_router
from app.routers.new_shipping_router import router as new_shipping_router
from app.routers.brand_config_router import router as brand_config_router
from app.routers.cloud_storage_router import router as cloud_storage_router
from app.routers.system_config_router import router as system_config_router
from app.routers.inventory_registration_router import router as inventory_registration_router
# from app.middleware import MonitoringMiddleware
from app.workers.scheduler import start_scheduler, stop_scheduler

# 设置日志
setup_logging()
logger = logging.getLogger("app.main")


@asynccontextmanager
async def lifespan(app: FastAPI):
    """应用生命周期管理"""
    # 启动时执行
    logger.info("Starting Order Processing System...")
    
    try:
        # 初始化数据库
        await init_db()
        logger.info("Database initialized")
        
        # 启动统一调度器（包含：导入→产品主表→采购订单）
        await start_scheduler()
        logger.info("Unified scheduler started (Import → Products Master → Procurement Orders)")
        
        # 注释掉独立的采购订单同步，已集成到统一调度器中
        # from app.workers.procurement_sync_scheduler import procurement_sync_scheduler
        # procurement_sync_scheduler.start(interval_minutes=10)
        # logger.info("Procurement orders auto-sync started")
        
        yield
        
    finally:
        # 关闭时执行
        logger.info("Shutting down Order Processing System...")
        
        try:
            # 停止统一调度器
            await stop_scheduler()
            logger.info("Unified scheduler stopped")
            
            # 注释掉独立的采购订单同步停止，已集成到统一调度器中
            # from app.workers.procurement_sync_scheduler import procurement_sync_scheduler
            # procurement_sync_scheduler.stop()
            # logger.info("Procurement orders auto-sync stopped")
            
            # 关闭数据库连接
            await close_db()
            logger.info("Database connections closed")
            
        except Exception as e:
            logger.error(f"Error during shutdown: {e}")


# 创建 FastAPI 应用
# 生产环境禁用 API 文档以提高安全性
app = FastAPI(
    title=settings.PROJECT_NAME,
    version=settings.VERSION,
    description="基于 FastAPI 的现代化订单处理系统",
    docs_url=None if IS_PRODUCTION else "/docs",
    redoc_url=None if IS_PRODUCTION else "/redoc",
    lifespan=lifespan
)

# CORS 中间件
# 生产环境使用严格的 CORS_ORIGINS，开发环境允许更宽松的访问
if IS_PRODUCTION:
    # 生产环境：严格限制允许的源
    app.add_middleware(
        CORSMiddleware,
        allow_origins=CORS_ORIGINS,
        allow_credentials=True,
        allow_methods=["GET", "POST", "PUT", "DELETE", "PATCH"],
        allow_headers=["Content-Type", "Authorization", "X-Requested-With"],
    )
    logger.info(f"CORS configured for production with origins: {CORS_ORIGINS}")
else:
    # 开发环境：允许所有源以支持局域网访问
    app.add_middleware(
        CORSMiddleware,
        allow_origins=["*"],
        allow_credentials=True,
        allow_methods=["*"],
        allow_headers=["*"],
    )
    logger.info("CORS configured for development (allow all origins)")

# 监控中间件 - 临时禁用以解决数据库锁定问题
# app.add_middleware(
#     MonitoringMiddleware,
#     enable_performance_monitoring=True,
#     enable_audit_logging=True,
#     excluded_paths=["/docs", "/redoc", "/openapi.json", "/favicon.ico", "/health", "/static"]
# )


@app.get("/")
async def root():
    """根路径"""
    return {
        "message": f"Welcome to {settings.PROJECT_NAME}",
        "version": settings.VERSION,
        "docs": "/docs"
    }


@app.get("/health")
async def health_check():
    """健康检查"""
    return {
        "status": "healthy",
        "service": settings.PROJECT_NAME,
        "version": settings.VERSION
    }


@app.exception_handler(StarletteHTTPException)
async def http_exception_handler(request: Request, exc: StarletteHTTPException):
    """HTTP 异常处理 - 生产环境隐藏详细错误信息"""
    error_id = str(uuid.uuid4())[:8]

    # 记录完整错误信息到日志
    logger.warning(f"[{error_id}] HTTP {exc.status_code}: {exc.detail} - {request.url}")

    # 生产环境隐藏敏感错误信息
    if IS_PRODUCTION and exc.status_code >= 500:
        return JSONResponse(
            status_code=exc.status_code,
            content={
                "detail": "服务器内部错误",
                "error_id": error_id,
                "message": "请联系管理员并提供错误ID"
            }
        )

    return JSONResponse(
        status_code=exc.status_code,
        content={"detail": exc.detail}
    )


@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request: Request, exc: RequestValidationError):
    """请求验证异常处理"""
    error_id = str(uuid.uuid4())[:8]

    # 记录完整错误信息到日志
    logger.warning(f"[{error_id}] Validation error: {exc.errors()} - {request.url}")

    # 生产环境简化错误信息
    if IS_PRODUCTION:
        return JSONResponse(
            status_code=422,
            content={
                "detail": "请求参数验证失败",
                "error_id": error_id
            }
        )

    return JSONResponse(
        status_code=422,
        content={"detail": exc.errors()}
    )


@app.exception_handler(Exception)
async def global_exception_handler(request: Request, exc: Exception):
    """全局异常处理 - 捕获所有未处理的异常"""
    error_id = str(uuid.uuid4())[:8]

    # 记录完整错误信息到日志（包含堆栈跟踪）
    logger.error(f"[{error_id}] Unhandled exception: {exc}", exc_info=True)

    # 生产环境不暴露内部错误信息
    if IS_PRODUCTION:
        return JSONResponse(
            status_code=500,
            content={
                "detail": "服务器内部错误",
                "error_id": error_id,
                "message": "请联系管理员并提供错误ID"
            }
        )

    # 开发环境返回详细错误信息以便调试
    return JSONResponse(
        status_code=500,
        content={
            "detail": "Internal server error",
            "error": str(exc),
            "error_id": error_id,
            "type": type(exc).__name__
        }
    )


# 注册路由
# 认证 API
app.include_router(auth_router, prefix=settings.API_V1_PREFIX)
app.include_router(import_router, prefix=settings.API_V1_PREFIX)
app.include_router(normalized_router, prefix=settings.API_V1_PREFIX)
app.include_router(product_router, prefix=settings.API_V1_PREFIX)
app.include_router(procurement_router, prefix=settings.API_V1_PREFIX)
app.include_router(procurement_router_v2, prefix=settings.API_V1_PREFIX)
# 新架构：产品主表 API
app.include_router(products_master_router, prefix=settings.API_V1_PREFIX)
app.include_router(procurement_confirmation_router, prefix=settings.API_V1_PREFIX)
app.include_router(offset_management_router, prefix=settings.API_V1_PREFIX)
app.include_router(monitoring_router, prefix=settings.API_V1_PREFIX)
app.include_router(audit_logging_router, prefix=settings.API_V1_PREFIX)
app.include_router(pdf_export_router, prefix=settings.API_V1_PREFIX + "/pdf", tags=["PDF导出"])
# 进度跟踪 API
app.include_router(progress_router, prefix=settings.API_V1_PREFIX)
# 数据同步 API
app.include_router(sync_router)
# 发货管理 API
app.include_router(shipping_router)
# 店铺报表 API
app.include_router(shop_report_router)
# 新的独立发货管理 API
app.include_router(new_shipping_router)
# 品牌配置管理 API
app.include_router(brand_config_router, prefix=settings.API_V1_PREFIX)
# 云存储 API（视频同步到 115 网盘）
app.include_router(cloud_storage_router, prefix=settings.API_V1_PREFIX)
app.include_router(system_config_router, prefix=settings.API_V1_PREFIX)
# 库存登记 API
app.include_router(inventory_registration_router, prefix=settings.API_V1_PREFIX)

# 静态文件服务 - 提供本地图片访问
try:
    import os
    images_dir = os.path.join(os.getcwd(), "images")
    if os.path.exists(images_dir):
        app.mount(f"{settings.API_V1_PREFIX}/static/images", StaticFiles(directory=images_dir), name="images")
        logger.info(f"Static images directory mounted at {settings.API_V1_PREFIX}/static/images")
    else:
        logger.warning(f"Images directory not found: {images_dir}")
except Exception as e:
    logger.error(f"Failed to mount static files: {e}")


if __name__ == "__main__":
    import uvicorn
    uvicorn.run(
        "app.main:app",
        host="0.0.0.0",
        port=8000,
        reload=True,
        log_level=settings.LOG_LEVEL.lower()
    )