main.py

"""
Java代码分析工具 - FastAPI主应用程序
"""
import logging
import os
from contextlib import asynccontextmanager
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import JSONResponse

from config.settings import Settings
from database.neo4j_client_singleton import neo4j_client
from api.analysis import router as analysis_router
from api.deep_agent import router as deep_agent_router
from api.web_analysis import router as web_analysis_router
from api.test_generation import router as test_generation_router
from services.ai.client import ai_client
from services.ai.agents.deep_agent_service import deep_agent_service


# 配置日志
def setup_logging(settings: Settings):
    """设置日志配置"""
    from utils.logger import LoggerSetup

    formatter = logging.Formatter(
        '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
        datefmt='%Y-%m-%d %H:%M:%S'
    )

    # 创建处理器并附加错误栈过滤器
    console_handler = logging.StreamHandler()
    console_handler.setFormatter(formatter)

    file_handler = logging.FileHandler(settings.log_file) if settings.log_file else None
    if file_handler:
        file_handler.setFormatter(formatter)

    stack_filter = LoggerSetup.ErrorStackFilter()
    console_handler.addFilter(stack_filter)
    if file_handler:
        file_handler.addFilter(stack_filter)

    handlers = [console_handler] + ([file_handler] if file_handler else [])

    logging.basicConfig(
        level=getattr(logging, settings.log_level.upper()),
        handlers=handlers
    )


# 应用程序生命周期管理
@asynccontextmanager
async def lifespan(app: FastAPI):
    """应用程序生命周期管理"""
    # 启动时执行
    settings = Settings()
    setup_logging(settings)
    logger = logging.getLogger(__name__)
    
    logger.info("启动Java代码分析工具...")
    
    # 初始化Neo4j连接和索引（单例）
    try:
        if neo4j_client.initialize():
            logger.info("Neo4j数据库连接成功（单例）")
        else:
            logger.error("Neo4j数据库连接失败")
    except Exception as e:
        logger.error(f"数据库初始化失败: {e}", exc_info=True)
    
    # 初始化AI客户端
    try:
        if ai_client.initialize():
            logger.info("AI客户端初始化并验证成功")
        else:
            logger.warning("AI客户端初始化失败或验证未通过，AI功能将不可用")
    except Exception as e:
        logger.error(f"AI客户端初始化异常: {e}", exc_info=True)
    
    # 初始化Deep Agent服务（需要AI客户端先初始化）
    try:
        if ai_client.is_available():
            if deep_agent_service.initialize():
                logger.info("Deep Agent 服务初始化成功")
            else:
                logger.warning("Deep Agent 服务初始化失败，智能对话功能将不可用")
        else:
            logger.warning("AI客户端不可用，跳过 Deep Agent 服务初始化")
    except Exception as e:
        logger.error(f"Deep Agent 服务初始化异常: {e}", exc_info=True)
    
    logger.info("应用程序启动完成")
    
    yield
    
    # 关闭时执行
    logger.info("关闭Java代码分析工具...")
    try:
        neo4j_client.close()
    except Exception as e:
        logger.error(f"关闭数据库连接时出错: {e}", exc_info=True)


# 创建FastAPI应用
def create_app() -> FastAPI:
    """创建FastAPI应用程序"""
    settings = Settings()
    
    app = FastAPI(
        title=settings.app_name,
    version=settings.app_version,
        description="Java代码分析工具 - 提供代码解析、调用关系分析和可视化功能",
        lifespan=lifespan,
        docs_url="/docs",
        redoc_url="/redoc"
    )
    
    # 配置CORS
    app.add_middleware(
        CORSMiddleware,
        allow_origins=["*"],  # 在生产环境中应该限制具体的域名
        allow_credentials=True,
        allow_methods=["*"],
        allow_headers=["*"],
    )
    
    # 注册路由
    app.include_router(analysis_router, prefix=settings.api_prefix)
    app.include_router(deep_agent_router, prefix=settings.api_prefix)
    app.include_router(web_analysis_router, prefix=settings.api_prefix)
    app.include_router(test_generation_router, prefix=settings.api_prefix)
    
    # 全局异常处理
    @app.exception_handler(Exception)
    async def global_exception_handler(request, exc):
        """全局异常处理器"""
        logger = logging.getLogger(__name__)
        logger.error(f"未处理的异常: {exc}", exc_info=True)
        
        return JSONResponse(
            status_code=500,
            content={
                "detail": "内部服务器错误",
                "error": str(exc) if settings.debug else "服务器内部错误"
            }
        )
    
    # 根路径
    @app.get("/")
    async def root():
        """根路径 - 返回API信息"""
        return {
            "name": settings.app_name,
        "version": settings.app_version,
            "description": "Java代码分析工具API",
            "docs_url": "/docs",
            "redoc_url": "/redoc",
            "api_prefix": settings.api_prefix
        }
    
    # 健康检查
    @app.get("/health")
    async def health():
        """简单的健康检查"""
        return {"status": "healthy", "service": settings.app_name}
    
    return app


# 创建应用实例
app = create_app()


if __name__ == "__main__":
    import uvicorn
    
    settings = Settings()
    
    uvicorn.run(
        "main:app",
        host=settings.host,
        port=settings.port,
        reload=settings.debug,
        log_level=settings.log_level.lower()
    )