# database.py
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession

# 비동기 엔진 생성 (부우우웅~ 🏎️)
DATABASE_URL = "postgresql+asyncpg://user:password@localhost/dbname"
async_engine = create_async_engine(DATABASE_URL, echo=True)

# 비동기 세션
async def get_async_session():
    async with AsyncSession(async_engine) as session:
        try:
            yield session
        finally:
            await session.close()

# API 엔드포인트
@app.get("/items/")
async def get_items(session: AsyncSession = Depends(get_async_session)):
    # 비동기로 데이터 조회
    result = await session.execute(select(Item))
    items = result.scalars().all()
    return items

# 여러 작업 동시 처리하기
import asyncio

@app.get("/dashboard/")
async def get_dashboard():
    # 여러 API를 동시에 호출! (시간 절약! ⏰)
    user_task = asyncio.create_task(get_user_data())
    stats_task = asyncio.create_task(get_statistics())
    posts_task = asyncio.create_task(get_recent_posts())

    # 모든 결과를 한번에 기다려요
    user_data, stats, posts = await asyncio.gather(
        user_task, stats_task, posts_task
    )

    return {
        "user": user_data,
        "stats": stats,
        "posts": posts
    }

# cache.py
from fastapi_cache import FastAPICache
from fastapi_cache.backends.redis import RedisBackend
from fastapi_cache.decorator import cache
import aioredis

# Redis 연결 설정
@app.on_event("startup")
async def startup():
    redis = aioredis.from_url("redis://localhost", encoding="utf8")
    FastAPICache.init(RedisBackend(redis), prefix="fastapi-cache:")

# 캐시 적용 (자주 바뀌지 않는 데이터는 캐시해두면 좋아요! 📦)
@app.get("/products/{id}")
@cache(expire=3600)  # 1시간 동안 캐시
async def get_product(id: int):
    return await get_product_from_db(id)

from functools import lru_cache

# 메모리에 결과를 캐시해두고 재사용해요!
@lru_cache(maxsize=1000)
def get_settings():
    return Settings()

# 이렇게 하면 안 돼요! ❌
@app.get("/users/")
async def get_users_bad():
    users = await db.query(User).all()
    # N+1 문제 발생!
    for user in users:
        await db.query(Post).filter(Post.user_id == user.id).all()

# 이렇게 하세요! ✅
from sqlalchemy.orm import joinedload

@app.get("/users/")
async def get_users_good():
    # 한 번의 쿼리로 모든 데이터를 가져와요!
    users = await db.query(User).options(
        joinedload(User.posts)
    ).all()

# models.py
from sqlalchemy import Index

class User(Base):
    __tablename__ = "users"

    id = Column(Integer, primary_key=True)
    email = Column(String, index=True)  # 자주 검색하는 필드에 인덱스!
    username = Column(String)

    # 복합 인덱스도 만들 수 있어요!
    __table_args__ = (
        Index('idx_username_email', 'username', 'email'),
    )

from fastapi.middleware.gzip import GZipMiddleware

# 응답을 쏙~ 압축해서 보내요! 🎁
app.add_middleware(GZipMiddleware, minimum_size=1000)

from fastapi.encoders import jsonable_encoder
from orjson import orjson
from fastapi.responses import ORJSONResponse

# orjson은 기본 json보다 훨씬 빨라요! 🏃‍♂️
app = FastAPI(default_response_class=ORJSONResponse)

# locustfile.py
from locust import HttpUser, task, between

class FastAPIUser(HttpUser):
    wait_time = between(1, 3)

    @task
    def get_items(self):
        self.client.get("/items/")

# 부하 테스트 실행
locust -f locustfile.py --host=http://localhost:8000

import cProfile
import pstats

def profile_endpoint():
    profiler = cProfile.Profile()
    profiler.enable()
    # 여기에 테스트할 코드를 넣어요
    profiler.disable()

    stats = pstats.Stats(profiler).sort_stats('cumtime')
    stats.print_stats()

# 한 번에 여러 데이터 처리하기
async def bulk_create_items(items: List[Item]):
    await db.execute(insert(Item), items)

@app.get("/items/")
async def get_items(skip: int = 0, limit: int = 10):
    return await db.query(Item).offset(skip).limit(limit).all()

from fastapi.background import BackgroundTasks

@app.post("/send-email/")
async def send_email(background_tasks: BackgroundTasks):
    # 메일 전송은 백그라운드에서 처리! ✉️
    background_tasks.add_task(send_email_task)
    return {"message": "이메일 전송이 시작되었어요!"}

from prometheus_fastapi_instrumentator import Instrumentator

# 성능 지표 수집 (우리 앱이 얼마나 빠른지 볼까요? 📈)
Instrumentator().instrument(app).expose(app)