from app.repositories.user_repo import UserRepository
from app.schemas import UserCreate
from app.models import User
from app.core.security import hash_password
from app.core.exceptions import DuplicateEmailError

class UserService:
    def __init__(self, repo: UserRepository):
        self.repo = repo

    async def create(self, data: UserCreate) -> User:
        # Business rule: email must be unique
        existing = await self.repo.find_by_email(data.email)
        if existing:
            raise DuplicateEmailError(data.email)

        # Business rule: password must be hashed before storage
        hashed = hash_password(data.password)
        return await self.repo.create(email=data.email, hashed_password=hashed)

    async def get_by_id(self, user_id: int) -> User | None:
        return await self.repo.find_by_id(user_id)

from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select
from app.models import User

class UserRepository:
    def __init__(self, session: AsyncSession):
        self.session = session

    async def find_by_id(self, user_id: int) -> User | None:
        result = await self.session.execute(
            select(User).where(User.id == user_id)
        )
        return result.scalar_one_or_none()

    async def find_by_email(self, email: str) -> User | None:
        result = await self.session.execute(
            select(User).where(User.email == email)
        )
        return result.scalar_one_or_none()

    async def create(self, *, email: str, hashed_password: str) -> User:
        user = User(email=email, hashed_password=hashed_password)
        self.session.add(user)
        await self.session.commit()
        await self.session.refresh(user)
        return user

from fastapi import Depends
from sqlalchemy.ext.asyncio import AsyncSession
from app.db import get_session
from app.repositories.user_repo import UserRepository
from app.services.user_service import UserService

async def get_user_service(session: AsyncSession = Depends(get_session)) -> UserService:
    repo = UserRepository(session)
    return UserService(repo)

# FastAPI's DI chain: Request → get_session → UserRepository → UserService → Controller

from dataclasses import dataclass
from decimal import Decimal

@dataclass(frozen=True)   # frozen=True makes it immutable + hashable
class Money:
    amount: Decimal
    currency: str

    def __post_init__(self):
        if self.amount < 0:
            raise ValueError("Money cannot be negative")

    def add(self, other: "Money") -> "Money":
        if self.currency != other.currency:
            raise ValueError("Cannot add different currencies")
        return Money(self.amount + other.amount, self.currency)

@dataclass(frozen=True)
class Email:
    value: str

    def __post_init__(self):
        if "@" not in self.value:
            raise ValueError("Invalid email")

# Usage
price = Money(Decimal("9.99"), "USD")
tax   = Money(Decimal("1.00"), "USD")
total = price.add(tax)   # Money(10.99, "USD") — new object, originals unchanged

from dataclasses import dataclass, field
from uuid import UUID, uuid4
from enum import Enum
from .value_objects import Money

class OrderStatus(Enum):
    PENDING   = "pending"
    CONFIRMED = "confirmed"
    CANCELLED = "cancelled"

@dataclass
class OrderItem:        # Child entity (only accessible via Order)
    product_id: UUID
    quantity: int
    unit_price: Money
    id: UUID = field(default_factory=uuid4)

@dataclass
class Order:            # Aggregate Root
    customer_id: UUID
    id: UUID = field(default_factory=uuid4)
    status: OrderStatus = OrderStatus.PENDING
    items: list[OrderItem] = field(default_factory=list)

    def add_item(self, product_id: UUID, qty: int, price: Money) -> None:
        """Business rule: can only add items to a PENDING order."""
        if self.status != OrderStatus.PENDING:
            raise ValueError("Cannot modify a non-pending order")
        self.items.append(OrderItem(product_id, qty, price))

    def confirm(self) -> None:
        """Business rule: must have items to confirm."""
        if not self.items:
            raise ValueError("Cannot confirm an empty order")
        self.status = OrderStatus.CONFIRMED

    def cancel(self) -> None:
        """Business rule: only PENDING or CONFIRMED orders can be cancelled."""
        if self.status == OrderStatus.CANCELLED:
            raise ValueError("Order already cancelled")
        self.status = OrderStatus.CANCELLED

    @property
    def total(self) -> Money:
        if not self.items:
            return Money(0, "USD")
        result = self.items[0].unit_price
        for item in self.items[1:]:
            result = result.add(item.unit_price)
        return result

from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select
from app.domain.user import User as DomainUser
from app.domain.interfaces import UserRepositoryInterface
from app.infrastructure.models import UserORM   # SQLAlchemy model

class SQLUserRepository(UserRepositoryInterface):
    """Concrete implementation — knows about SQLAlchemy."""

    def __init__(self, session: AsyncSession):
        self.session = session

    async def find_by_email(self, email: str) -> DomainUser | None:
        row = (await self.session.execute(
            select(UserORM).where(UserORM.email == email)
        )).scalar_one_or_none()
        return self._to_domain(row) if row else None

    async def save(self, user: DomainUser) -> None:
        orm = UserORM(id=user.id, email=user.email, hashed_password=user.hashed_password)
        self.session.add(orm)
        await self.session.commit()

    def _to_domain(self, row: UserORM) -> DomainUser:
        # Convert ORM model → pure domain entity
        return DomainUser(id=row.id, email=row.email, hashed_password=row.hashed_password)

from fastapi import APIRouter, Depends
from app.application.use_cases.register_user import RegisterUserUseCase, RegisterUserCommand
from app.api.dependencies import get_register_use_case
from app.api.schemas import RegisterRequest, RegisterResponse

router = APIRouter()

@router.post("/register", response_model=RegisterResponse, status_code=201)
async def register(
    req: RegisterRequest,
    use_case: RegisterUserUseCase = Depends(get_register_use_case),
):
    result = await use_case.execute(RegisterUserCommand(email=req.email, password=req.password))
    return RegisterResponse(user_id=result.user_id, email=result.email)