from fastapi import FastAPI, Request, status
from fastapi.middleware.cors import CORSMiddleware
from fastapi.staticfiles import StaticFiles
from starlette.responses import FileResponse, JSONResponse
from starlette.staticfiles import StaticFiles as StarletteStaticFiles
from app.api.v1.api import api_router
from app.core.config import settings
from app.db.session import engine
from app.db.base import Base
from app.core.logging_config import setup_logging
from app.core.firebase_config import initialize_firebase
import os
import logging
import time


import app.models.user           
import app.models.password_reset

# Create logs directory if it doesn't exist
os.makedirs("logs", exist_ok=True)

# Setup logging
logger = setup_logging()

# Create database tables
Base.metadata.create_all(bind=engine)

app = FastAPI(
    title="Adimsayer API",
    description="Adimsayer Backend API",
    version="1.0.0",
    openapi_url=f"{settings.API_V1_STR}/openapi.json",
    docs_url=f"{settings.API_V1_STR}/docs",
    redoc_url=f"{settings.API_V1_STR}/redoc",
)

# Set all CORS enabled origins
if settings.BACKEND_CORS_ORIGINS:
    app.add_middleware(
        CORSMiddleware,
        allow_origins=["*"],
        allow_credentials=True,
        allow_methods=["*"],
        allow_headers=["*"],
        expose_headers=["*"],
    )

# Include API router
app.include_router(api_router, prefix=settings.API_V1_STR)

# Mount the uploads directory so files can be served via: http://<domain>/uploads/...
# 정적 파일에 CORS 헤더 추가
class CustomStaticFiles(StaticFiles):
    async def __call__(self, scope, receive, send):
        async def custom_send(message):
            if message["type"] == "http.response.start":
                message.setdefault("headers", [])
                message["headers"].append((b"Access-Control-Allow-Origin", b"*"))
                message["headers"].append((b"Access-Control-Allow-Methods", b"*"))
                message["headers"].append((b"Access-Control-Allow-Headers", b"*"))
                message["headers"].append((b"Access-Control-Expose-Headers", b"*"))
            await send(message)
        
        await super().__call__(scope, receive, custom_send)

app.mount("/uploads", CustomStaticFiles(directory="uploads"), name="uploads")

# Firebase 초기화
@app.on_event("startup")
async def startup_event():
    """애플리케이션 시작 시 실행되는 이벤트"""
    logger.info("Application starting up...")
    
    # Firebase Admin SDK 초기화
    try:
        initialize_firebase()
        logger.info("Firebase initialized successfully")
    except Exception as e:
        logger.error(f"Error initializing Firebase: {str(e)}")
        # Firebase 초기화 실패해도 애플리케이션은 계속 실행
        logger.warning("Application will continue without Firebase push support")

@app.middleware("http")
async def log_requests(request: Request, call_next):
    """모든 요청에 대한 로깅 미들웨어"""
    start_time = time.time()
    
    try:
        response = await call_next(request)
        
        # 요청 처리 시간 계산
        process_time = time.time() - start_time
        logger.info(
            f"{request.method} {request.url.path} completed in {process_time:.4f}s "
            f"with status code {response.status_code}"
        )
        
        return response
    except Exception as e:
        logger.error(f"Request failed: {request.method} {request.url.path} - {str(e)}")
        return JSONResponse(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            content={"detail": "Internal server error"}
        )

@app.get("/")
async def root():
    logger.info("Root endpoint accessed")
    return {"message": "Welcome to Adimsayer API"}

if __name__ == "__main__":
    import uvicorn
    logger.info("Starting Adimsayer API server")
    uvicorn.run(app, host="0.0.0.0", port=8000)