/**
 * 客户实体
 * 使用业务术语 "Customer" 而非 "User" 或 "Account"
 */
public class Customer {
    private final CustomerId id;
    private String name;
    private EmailAddress email;
    private PhoneNumber phoneNumber;
    private CustomerStatus status;
    private LoyaltyPoints loyaltyPoints;
    
    public Customer(CustomerId id, String name, EmailAddress email) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.status = CustomerStatus.ACTIVE;
        this.loyaltyPoints = LoyaltyPoints.zero();
    }
    
    /**
     * 放置订单 - 使用业务术语 "placeOrder" 而非 "createOrder"
     * 因为 "place" 更准确地表达了客户的购买行为
     */
    public Order placeOrder(ShoppingCart cart, ShippingAddress address) {
        if (this.status != CustomerStatus.ACTIVE) {
            throw new IllegalStateException("Inactive customer cannot place orders");
        }
        
        if (cart.isEmpty()) {
            throw new IllegalArgumentException("Cannot place order with empty cart");
        }
        
        // 创建订单
        Order order = new Order(this.id, cart.getItems(), address);
        
        // 累积积分
        this.loyaltyPoints = this.loyaltyPoints.add(order.calculateEarnedPoints());
        
        return order;
    }
    
    /**
     * 取消订单 - 业务术语
     */
    public void cancelOrder(Order order, CancellationReason reason) {
        if (!order.belongsTo(this.id)) {
            throw new IllegalArgumentException("Order does not belong to this customer");
        }
        
        order.cancel(reason);
        
        // 扣除相应积分
        this.loyaltyPoints = this.loyaltyPoints.subtract(order.calculateEarnedPoints());
    }
    
    // Getters
    public CustomerId getId() { return id; }
    public String getName() { return name; }
    public EmailAddress getEmail() { return email; }
    public CustomerStatus getStatus() { return status; }
    public LoyaltyPoints getLoyaltyPoints() { return loyaltyPoints; }
}

/**
 * 订单项 - 值对象
 * 使用业务术语 "OrderItem" 而非 "OrderDetail" 或 "LineItem"
 */
public class OrderItem {
    private final ProductId productId;
    private final String productName;
    private final Money unitPrice;
    private final int quantity;
    
    public OrderItem(ProductId productId, String productName, Money unitPrice, int quantity) {
        this.productId = productId;
        this.productName = productName;
        this.unitPrice = unitPrice;
        this.quantity = quantity;
    }
    
    public Money subtotal() {
        return unitPrice.multiply(quantity);
    }
    
    // Getters
    public ProductId getProductId() { return productId; }
    public String getProductName() { return productName; }
    public Money getUnitPrice() { return unitPrice; }
    public int getQuantity() { return quantity; }
}

/**
 * 购物车 - 领域概念
 */
public class ShoppingCart {
    private final CustomerId customerId;
    private final Map<ProductId, CartItem> items;
    
    public ShoppingCart(CustomerId customerId) {
        this.customerId = customerId;
        this.items = new HashMap<>();
    }
    
    /**
     * 添加商品到购物车 - 业务行为
     */
    public void addItem(Product product, int quantity) {
        if (quantity <= 0) {
            throw new IllegalArgumentException("Quantity must be positive");
        }
        
        ProductId productId = product.getId();
        if (items.containsKey(productId)) {
            CartItem existingItem = items.get(productId);
            items.put(productId, existingItem.increaseQuantity(quantity));
        } else {
            items.put(productId, new CartItem(productId, product.getName(), product.getPrice(), quantity));
        }
    }
    
    /**
     * 从购物车移除商品
     */
    public void removeItem(ProductId productId) {
        items.remove(productId);
    }
    
    /**
     * 判断购物车是否为空
     */
    public boolean isEmpty() {
        return items.isEmpty();
    }
    
    /**
     * 获取购物车中的所有商品项
     */
    public Collection<CartItem> getItems() {
        return Collections.unmodifiableCollection(items.values());
    }
    
    /**
     * 计算购物车总价
     */
    public Money calculateTotal() {
        return items.values().stream()
                .map(CartItem::subtotal)
                .reduce(Money.zero(), Money::add);
    }
}

/**
 * 订单状态 - 使用业务术语
 */
public enum OrderStatus {
    CREATED,      // 已创建
    CONFIRMED,    // 已确认
    PAID,         // 已支付
    SHIPPED,      // 已发货
    DELIVERED,    // 已送达
    CANCELLED,    // 已取消
    REFUNDED      // 已退款
}

/**
 * 取消原因 - 业务概念
 */
public enum CancellationReason {
    CUSTOMER_REQUEST,     // 客户主动取消
    OUT_OF_STOCK,         // 缺货
    PAYMENT_FAILED,       // 支付失败
    SUSPECTED_FRAUD,      // 疑似欺诈
    SYSTEM_ERROR          // 系统错误
}

from dataclasses import dataclass
from datetime import date, timedelta
from enum import Enum
from typing import List, Optional


class MembershipStatus(Enum):
    """会员状态 - 业务术语"""
    ACTIVE = "active"           # 正常
    SUSPENDED = "suspended"     # 暂停
    EXPIRED = "expired"         # 过期
    BLACKLISTED = "blacklisted" # 黑名单


class BookStatus(Enum):
    """图书状态 - 业务术语"""
    AVAILABLE = "available"         # 可借阅
    BORROWED = "borrowed"           # 已借出
    RESERVED = "reserved"           # 已预约
    LOST = "lost"                   # 遗失
    DAMAGED = "damaged"             # 损坏


@dataclass(frozen=True)
class ISBN:
    """值对象：ISBN号"""
    value: str
    
    def __post_init__(self):
        if len(self.value) not in [10, 13]:
            raise ValueError("ISBN must be 10 or 13 digits")


@dataclass(frozen=True)
class MemberId:
    """值对象：会员ID"""
    value: str


@dataclass(frozen=True)
class LoanPeriod:
    """值对象：借阅期限"""
    days: int
    
    def __post_init__(self):
        if self.days <= 0:
            raise ValueError("Loan period must be positive")
    
    def end_date_from(self, start_date: date) -> date:
        """计算归还日期"""
        return start_date + timedelta(days=self.days)


class Book:
    """实体：图书"""
    
    def __init__(self, isbn: ISBN, title: str, author: str, loan_period: LoanPeriod):
        self._isbn = isbn
        self._title = title
        self._author = author
        self._loan_period = loan_period
        self._status = BookStatus.AVAILABLE
        self._borrower_id: Optional[MemberId] = None
        self._due_date: Optional[date] = None
    
    @property
    def isbn(self) -> ISBN:
        return self._isbn
    
    @property
    def title(self) -> str:
        return self._title
    
    @property
    def status(self) -> BookStatus:
        return self._status
    
    def borrow(self, member_id: MemberId, borrow_date: date):
        """借阅图书 - 业务行为"""
        if self._status != BookStatus.AVAILABLE:
            raise RuntimeError(f"Book is not available: {self._status.value}")
        
        self._status = BookStatus.BORROWED
        self._borrower_id = member_id
        self._due_date = self._loan_period.end_date_from(borrow_date)
    
    def return_book(self, return_date: date) -> 'ReturnResult':
        """归还图书 - 业务行为"""
        if self._status != BookStatus.BORROWED:
            raise RuntimeError("Book is not currently borrowed")
        
        overdue_days = max(0, (return_date - self._due_date).days)
        
        self._status = BookStatus.AVAILABLE
        previous_borrower = self._borrower_id
        self._borrower_id = None
        self._due_date = None
        
        if overdue_days > 0:
            return ReturnResult.overdue(previous_borrower, overdue_days)
        else:
            return ReturnResult.on_time(previous_borrower)
    
    def reserve(self, member_id: MemberId):
        """预约图书 - 业务行为"""
        if self._status != BookStatus.AVAILABLE:
            raise RuntimeError("Can only reserve available books")
        
        self._status = BookStatus.RESERVED


class Member:
    """实体：会员"""
    
    MAX_BORROW_LIMIT = 5  # 最大借阅数量
    
    def __init__(self, member_id: MemberId, name: str, membership_type: str):
        self._id = member_id
        self._name = name
        self._membership_type = membership_type
        self._status = MembershipStatus.ACTIVE
        self._borrowed_books: List[ISBN] = []
        self._overdue_count = 0
    
    @property
    def id(self) -> MemberId:
        return self._id
    
    @property
    def status(self) -> MembershipStatus:
        return self._status
    
    def borrow_book(self, book: Book, borrow_date: date):
        """借阅图书 - 业务行为"""
        if self._status != MembershipStatus.ACTIVE:
            raise RuntimeError(f"Cannot borrow: membership is {self._status.value}")
        
        if len(self._borrowed_books) >= self.MAX_BORROW_LIMIT:
            raise RuntimeError("Borrow limit reached")
        
        if self._overdue_count >= 3:
            raise RuntimeError("Too many overdue returns")
        
        book.borrow(self._id, borrow_date)
        self._borrowed_books.append(book.isbn)
    
    def return_book(self, book: Book, return_date: date) -> 'ReturnResult':
        """归还图书 - 业务行为"""
        result = book.return_book(return_date)
        
        if book.isbn in self._borrowed_books:
            self._borrowed_books.remove(book.isbn)
        
        if result.is_overdue:
            self._overdue_count += 1
        
        return result
    
    def can_borrow(self) -> bool:
        """判断是否可以借阅"""
        return (self._status == MembershipStatus.ACTIVE and 
                len(self._borrowed_books) < self.MAX_BORROW_LIMIT and
                self._overdue_count < 3)


@dataclass
class ReturnResult:
    """值对象：归还结果"""
    is_overdue: bool
    member_id: Optional[MemberId] = None
    overdue_days: int = 0
    
    @classmethod
    def on_time(cls, member_id: MemberId):
        return cls(is_overdue=False, member_id=member_id)
    
    @classmethod
    def overdue(cls, member_id: MemberId, days: int):
        return cls(is_overdue=True, member_id=member_id, overdue_days=days)


# 使用示例
def library_scenario():
    """图书馆业务场景演示"""
    # 创建图书
    isbn = ISBN("9780321125217")
    loan_period = LoanPeriod(14)  # 借阅期限14天
    book = Book(isbn, "Domain-Driven Design", "Eric Evans", loan_period)
    
    # 创建会员
    member = Member(MemberId("M001"), "张三", "premium")
    
    # 借阅图书
    borrow_date = date.today()
    member.borrow_book(book, borrow_date)
    print(f"Book status: {book.status.value}")  # borrowed
    
    # 归还图书（按时）
    return_date = borrow_date + timedelta(days=10)
    result = member.return_book(book, return_date)
    print(f"Return result: {'overdue' if result.is_overdue else 'on time'}")

/**
 * 转账领域服务
 * 使用业务术语表达转账流程
 */
public class FundsTransferService {
    
    private final AccountRepository accountRepository;
    private final TransferLimitPolicy transferLimitPolicy;
    private final FraudDetectionService fraudDetectionService;
    
    public FundsTransferService(AccountRepository accountRepository,
                               TransferLimitPolicy transferLimitPolicy,
                               FraudDetectionService fraudDetectionService) {
        this.accountRepository = accountRepository;
        this.transferLimitPolicy = transferLimitPolicy;
        this.fraudDetectionService = fraudDetectionService;
    }
    
    /**
     * 执行资金划转
     * 使用业务术语 "transferFunds" 而非 "moveMoney" 或 "updateBalance"
     */
    public TransferReceipt transferFunds(TransferRequest request) {
        // 验证转账请求
        validateTransferRequest(request);
        
        // 获取付款账户和收款账户
        Account payerAccount = accountRepository.findByAccountId(request.getPayerAccountId());
        Account payeeAccount = accountRepository.findByAccountId(request.getPayeeAccountId());
        
        // 反欺诈检查
        fraudDetectionService.checkForFraud(request);
        
        // 限额检查
        transferLimitPolicy.validateLimit(payerAccount, request.getAmount());
        
        // 执行转账
        Transaction transaction = Transaction.initiate(
            payerAccount.getId(),
            payeeAccount.getId(),
            request.getAmount(),
            request.getDescription()
        );
        
        payerAccount.debit(transaction);
        payeeAccount.credit(transaction);
        
        // 保存账户和交易记录
        accountRepository.save(payerAccount);
        accountRepository.save(payeeAccount);
        
        // 生成转账回执
        return TransferReceipt.issue(transaction);
    }
    
    private void validateTransferRequest(TransferRequest request) {
        if (request.getPayerAccountId().equals(request.getPayeeAccountId())) {
            throw new IllegalArgumentException("Payer and payee cannot be the same account");
        }
        if (request.getAmount().isLessThanOrEqual(Money.zero())) {
            throw new IllegalArgumentException("Transfer amount must be positive");
        }
    }
}

/**
 * 转账请求 - 使用业务术语
 */
public class TransferRequest {
    private final AccountId payerAccountId;   // 付款人账户
    private final AccountId payeeAccountId;   // 收款人账户
    private final Money amount;               // 金额
    private final String description;         // 描述
    
    public TransferRequest(AccountId payerAccountId, AccountId payeeAccountId,
                          Money amount, String description) {
        this.payerAccountId = payerAccountId;
        this.payeeAccountId = payeeAccountId;
        this.amount = amount;
        this.description = description;
    }
    
    // Getters
    public AccountId getPayerAccountId() { return payerAccountId; }
    public AccountId getPayeeAccountId() { return payeeAccountId; }
    public Money getAmount() { return amount; }
    public String getDescription() { return description; }
}

/**
 * 转账回执 - 业务凭证
 */
public class TransferReceipt {
    private final String receiptNumber;
    private final LocalDateTime timestamp;
    private final AccountId payerAccountId;
    private final AccountId payeeAccountId;
    private final Money amount;
    private final String description;
    
    private TransferReceipt(String receiptNumber, LocalDateTime timestamp,
                           AccountId payerAccountId, AccountId payeeAccountId,
                           Money amount, String description) {
        this.receiptNumber = receiptNumber;
        this.timestamp = timestamp;
        this.payerAccountId = payerAccountId;
        this.payeeAccountId = payeeAccountId;
        this.amount = amount;
        this.description = description;
    }
    
    public static TransferReceipt issue(Transaction transaction) {
        return new TransferReceipt(
            generateReceiptNumber(),
            LocalDateTime.now(),
            transaction.getPayerAccountId(),
            transaction.getPayeeAccountId(),
            transaction.getAmount(),
            transaction.getDescription()
        );
    }
    
    private static String generateReceiptNumber() {
        return "TR" + System.currentTimeMillis();
    }
    
    // Getters
    public String getReceiptNumber() { return receiptNumber; }
    public LocalDateTime getTimestamp() { return timestamp; }
    public AccountId getPayerAccountId() { return payerAccountId; }
    public AccountId getPayeeAccountId() { return payeeAccountId; }
    public Money getAmount() { return amount; }
    public String getDescription() { return description; }
}

public class UserData {
    private String userName;
    private String userEmail;
    public void saveData() { ... }
    public void updateInfo() { ... }
}