# poetry를 사용하는 경우
poetry new fastapi-sqlalchemy-project
cd fastapi-sqlalchemy-project
poetry add fastapi uvicorn sqlalchemy asyncpg pydantic python-dotenv

# pip를 사용하는 경우
mkdir fastapi-sqlalchemy-project
cd fastapi-sqlalchemy-project
python -m venv venv
source venv/bin/activate # Windows: .\venv\Scripts\activate
pip install fastapi uvicorn sqlalchemy asyncpg pydantic python-dotenv

# .env 파일 예시
DATABASE_URL="postgresql+asyncpg://user:password@localhost:5432/mydatabase"

# app/database.py
import os
from typing import AsyncGenerator

from dotenv import load_dotenv
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
from sqlalchemy.orm import declarative_base, sessionmaker, scoped_session

# .env 파일 로드
load_dotenv()

# 환경 변수에서 DB URL 가져오기
DATABASE_URL = os.getenv("DATABASE_URL")

if not DATABASE_URL:
    raise ValueError("DATABASE_URL 환경 변수가 설정되지 않았습니다.")

# 비동기 엔진 생성
# pool_size: 연결 풀에 유지할 최소 연결 수
# max_overflow: pool_size를 초과하여 생성할 수 있는 최대 연결 수
# echo=True: SQL 쿼리를 로깅 (개발 환경에서 유용)
async_engine = create_async_engine(
    DATABASE_URL,
    echo=True,
    pool_size=10,
    max_overflow=20
)

# 비동기 세션 팩토리 생성
# expire_on_commit=False: 커밋 후에도 객체가 만료되지 않도록 설정 (세션 종료까지 유효)
AsyncSessionFactory = async_sessionmaker(
    async_engine,
    expire_on_commit=False,
    class_=AsyncSession # AsyncSession을 명시적으로 사용
)

# 요청 스코프 세션 관리를 위한 async_scoped_session
# contextvars를 사용하여 비동기 컨텍스트 내에서 세션을 관리합니다.
# 각 비동기 Task(요청)마다 고유한 세션을 보장합니다.
AsyncScopedSession = scoped_session(
    AsyncSessionFactory,
    scopefunc=None # asyncio의 contextvars를 자동으로 사용하므로 None으로 설정
)

Base = declarative_base()

# 데이터베이스 테이블 생성 및 삭제 함수
async def create_db_and_tables():
    async with async_engine.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)
    print("Database tables created.")

async def drop_db_and_tables():
    async with async_engine.begin() as conn:
        await conn.run_sync(Base.metadata.drop_all)
    print("Database tables dropped.")

# FastAPI 의존성 주입을 위한 세션 제너레이터
async def get_db() -> AsyncGenerator[AsyncSession, None]:
    async with AsyncScopedSession() as session:
        try:
            yield session
            await session.commit()
        except Exception:
            await session.rollback()
            raise
        finally:
            # scoped_session은 .remove()를 통해 세션을 정리합니다.
            await AsyncScopedSession.remove()

# app/models.py
from datetime import datetime
from typing import Optional
from sqlalchemy import Column, Integer, String, DateTime, Boolean
from sqlalchemy.orm import Mapped, mapped_column

from app.database import Base

class User(Base):
    __tablename__ = "users"

    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
    username: Mapped[str] = mapped_column(String, unique=True, index=True, nullable=False)
    email: Mapped[str] = mapped_column(String, unique=True, index=True, nullable=False)
    hashed_password: Mapped[str] = mapped_column(String, nullable=False)
    is_active: Mapped[bool] = mapped_column(Boolean, default=True)
    created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.now)
    updated_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.now, onupdate=datetime.now)

    def __repr__(self):
        return f"<User(id={self.id}, username={self.username}, email={self.email})>"

class Item(Base):
    __tablename__ = "items"

    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
    name: Mapped[str] = mapped_column(String, index=True, nullable=False)
    description: Mapped[Optional[str]] = mapped_column(String, nullable=True)
    price: Mapped[int] = mapped_column(Integer, nullable=False)
    owner_id: Mapped[int] = mapped_column(Integer, index=True) # 외래키 관계는 이후에 추가 가능

    def __repr__(self):
        return f"<Item(id={self.id}, name={self.name}, price={self.price})>"

# 모델 정의는 이 파일에 계속 추가할 수 있습니다.

# app/main.py
from typing import List
from fastapi import FastAPI, Depends, HTTPException, status
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select

from app.database import create_db_and_tables, get_db, async_engine
from app.models import User, Item
from app.schemas import UserCreate, UserResponse, ItemCreate, ItemResponse, UserUpdate, ItemUpdate

# FastAPI 애플리케이션 초기화
app = FastAPI(
    title="FastAPI + SQLAlchemy 2.0 Async ORM Example",
    description="FastAPI와 SQLAlchemy 2.0 비동기 ORM 실전 패턴을 보여주는 예제입니다.",
    version="1.0.0"
)

# 애플리케이션 시작 시 데이터베이스 테이블 생성
@app.on_event("startup")
async def on_startup():
    await create_db_and_tables()

# 애플리케이션 종료 시 DB 연결 종료 (선택 사항)
@app.on_event("shutdown")
async def on_shutdown():
    await async_engine.dispose()
    print("Database engine disposed.")

### User 관련 CRUD 라우터 ###

@app.post("/users/", response_model=UserResponse, status_code=status.HTTP_201_CREATED)
async def create_user(user: UserCreate, db: AsyncSession = Depends(get_db)):
    """새로운 사용자 생성"""
    # 사용자 이름이나 이메일 중복 검사
    existing_user = await db.execute(
        select(User).where((User.username == user.username) | (User.email == user.email))
    )
    if existing_user.scalars().first():
        raise HTTPException(
            status_code=status.HTTP_409_CONFLICT,
            detail="Username or Email already registered"
        )

    db_user = User(**user.model_dump())
    db.add(db_user)
    # get_db() 내에서 commit이 이루어지므로 여기서는 생략 가능하지만,
    # 명시적 트랜잭션 관리가 필요할 경우 async with db.begin(): 사용
    # await db.commit() # get_db()에서 처리
    await db.refresh(db_user) # DB에서 최신 데이터(id, created_at 등)를 로드
    return db_user

@app.get("/users/", response_model=List[UserResponse])
async def read_users(skip: int = 0, limit: int = 100, db: AsyncSession = Depends(get_db)):
    """모든 사용자 조회"""
    result = await db.execute(select(User).offset(skip).limit(limit))
    users = result.scalars().all()
    return users

@app.get("/users/{user_id}", response_model=UserResponse)
async def read_user(user_id: int, db: AsyncSession = Depends(get_db)):
    """특정 ID의 사용자 조회"""
    result = await db.execute(select(User).where(User.id == user_id))
    user = result.scalars().first()
    if user is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="User not found")
    return user

@app.put("/users/{user_id}", response_model=UserResponse)
async def update_user(user_id: int, user_update: UserUpdate, db: AsyncSession = Depends(get_db)):
    """특정 ID의 사용자 정보 업데이트"""
    result = await db.execute(select(User).where(User.id == user_id))
    db_user = result.scalars().first()
    if db_user is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="User not found")

    # Pydantic 모델의 dict() 대신 model_dump(exclude_unset=True) 사용
    update_data = user_update.model_dump(exclude_unset=True)
    for key, value in update_data.items():
        setattr(db_user, key, value)
    
    # get_db() 내에서 commit이 이루어지므로 여기서는 생략 가능
    # await db.commit()
    await db.refresh(db_user)
    return db_user

@app.delete("/users/{user_id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_user(user_id: int, db: AsyncSession = Depends(get_db)):
    """특정 ID의 사용자 삭제"""
    result = await db.execute(select(User).where(User.id == user_id))
    db_user = result.scalars().first()
    if db_user is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="User not found")

    await db.delete(db_user)
    # get_db() 내에서 commit이 이루어지므로 여기서는 생략 가능
    # await db.commit()
    return {"detail": "User deleted successfully"}

### Item 관련 CRUD 라우터 (생략, User와 유사한 패턴으로 구현) ###
# ...

# Pydantic 스키마 정의 (app/schemas.py)
# Pydantic은 FastAPI의 데이터 유효성 검사 및 직렬화/역직렬화에 사용됩니다.

# app/schemas.py
from typing import Optional
from datetime import datetime
from pydantic import BaseModel, Field

# User 스키마
class UserBase(BaseModel):
    username: str = Field(..., min_length=3, max_length=50)
    email: str = Field(..., pattern=r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$")
    is_active: Optional[bool] = True

class UserCreate(UserBase):
    hashed_password: str = Field(..., min_length=6)

class UserUpdate(UserBase):
    username: Optional[str] = Field(None, min_length=3, max_length=50)
    email: Optional[str] = Field(None, pattern=r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$")
    hashed_password: Optional[str] = Field(None, min_length=6)
    is_active: Optional[bool] = None

class UserResponse(UserBase):
    id: int
    created_at: datetime
    updated_at: datetime

    class Config:
        from_attributes = True # SQLAlchemy 모델로부터 Pydantic 모델 생성을 허용 (orm_mode 대신)

# Item 스키마
class ItemBase(BaseModel):
    name: str = Field(..., min_length=1, max_length=100)
    description: Optional[str] = Field(None, max_length=500)
    price: int = Field(..., gt=0)
    owner_id: int

class ItemCreate(ItemBase):
    pass

class ItemUpdate(ItemBase):
    name: Optional[str] = Field(None, min_length=1, max_length=100)
    description: Optional[str] = Field(None, max_length=500)
    price: Optional[int] = Field(None, gt=0)
    owner_id: Optional[int] = None

class ItemResponse(ItemBase):
    id: int

    class Config:
        from_attributes = True

from sqlalchemy.orm import selectinload, relationship
# app/models.py 에 User와 Item 간의 관계 정의
class User(Base):
    # ...
    items: Mapped[List["Item"]] = relationship("Item", back_populates="owner")

class Item(Base):
    # ...
    owner: Mapped["User"] = relationship("User", back_populates="items")

# app/main.py 에서 N+1 문제 해결
@app.get("/users_with_items/", response_model=List[UserResponseWithItems]) # UserResponseWithItems는 Item 목록 포함 스키마
async def read_users_with_items(db: AsyncSession = Depends(get_db)):
    # selectinload를 사용하여 User를 가져올 때 연관된 Item도 한 번의 쿼리로 가져옴
    result = await db.execute(select(User).options(selectinload(User.items)))
    users = result.scalars().all()
    return users

async def create_user_and_item(user: UserCreate, item: