/**
 * 转账领域服务
 * 
 * 转账操作涉及两个账户的协调，不属于任何一个账户的自然职责，
 * 因此使用领域服务来表达这个业务概念。
 */
public class FundsTransferService {
    
    private final AccountRepository accountRepository;
    private final TransferLimitPolicy transferLimitPolicy;
    private final DomainEventPublisher eventPublisher;
    
    public FundsTransferService(AccountRepository accountRepository,
                               TransferLimitPolicy transferLimitPolicy,
                               DomainEventPublisher eventPublisher) {
        this.accountRepository = accountRepository;
        this.transferLimitPolicy = transferLimitPolicy;
        this.eventPublisher = eventPublisher;
    }
    
    /**
     * 执行转账
     * 
     * 这是一个典型的跨聚合操作：
     * 1. 从付款账户扣款
     * 2. 向收款账户存款
     * 3. 记录交易日志
     * 4. 发布领域事件
     */
    public TransferResult transfer(TransferCommand command) {
        // 验证命令
        validateCommand(command);
        
        // 获取账户
        Account payerAccount = accountRepository.findById(command.getPayerAccountId());
        if (payerAccount == null) {
            return TransferResult.failure("Payer account not found");
        }
        
        Account payeeAccount = accountRepository.findById(command.getPayeeAccountId());
        if (payeeAccount == null) {
            return TransferResult.failure("Payee account not found");
        }
        
        // 检查是否是同一账户
        if (payerAccount.getId().equals(payeeAccount.getId())) {
            return TransferResult.failure("Cannot transfer to the same account");
        }
        
        // 限额检查
        if (!transferLimitPolicy.isWithinLimit(payerAccount, command.getAmount())) {
            return TransferResult.failure("Transfer amount exceeds limit");
        }
        
        // 执行转账
        try {
            Transaction transaction = Transaction.initiate(
                payerAccount.getId(),
                payeeAccount.getId(),
                command.getAmount(),
                command.getDescription()
            );
            
            // 扣款和存款
            payerAccount.debit(transaction);
            payeeAccount.credit(transaction);
            
            // 保存账户（在应用层实际持久化）
            accountRepository.save(payerAccount);
            accountRepository.save(payeeAccount);
            
            // 发布领域事件
            eventPublisher.publish(new FundsTransferredEvent(
                transaction.getId(),
                payerAccount.getId(),
                payeeAccount.getId(),
                command.getAmount(),
                LocalDateTime.now()
            ));
            
            return TransferResult.success(transaction.getId());
            
        } catch (InsufficientFundsException e) {
            return TransferResult.failure("Insufficient funds");
        } catch (Exception e) {
            // 记录错误日志
            return TransferResult.failure("Transfer failed: " + e.getMessage());
        }
    }
    
    private void validateCommand(TransferCommand command) {
        if (command.getAmount() == null || !command.getAmount().isPositive()) {
            throw new IllegalArgumentException("Transfer amount must be positive");
        }
        if (command.getPayerAccountId() == null) {
            throw new IllegalArgumentException("Payer account is required");
        }
        if (command.getPayeeAccountId() == null) {
            throw new IllegalArgumentException("Payee account is required");
        }
    }
}

/**
 * 转账命令对象
 */
public class TransferCommand {
    private final AccountId payerAccountId;
    private final AccountId payeeAccountId;
    private final Money amount;
    private final String description;
    
    public TransferCommand(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 TransferResult {
    private final boolean success;
    private final String errorMessage;
    private final String transactionId;
    
    private TransferResult(boolean success, String errorMessage, String transactionId) {
        this.success = success;
        this.errorMessage = errorMessage;
        this.transactionId = transactionId;
    }
    
    public static TransferResult success(String transactionId) {
        return new TransferResult(true, null, transactionId);
    }
    
    public static TransferResult failure(String errorMessage) {
        return new TransferResult(false, errorMessage, null);
    }
    
    public boolean isSuccess() { return success; }
    public String getErrorMessage() { return errorMessage; }
    public String getTransactionId() { return transactionId; }
}

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


class CustomerTier(Enum):
    """客户等级"""
    REGULAR = "regular"
    SILVER = "silver"
    GOLD = "gold"
    PLATINUM = "platinum"


@dataclass(frozen=True)
class PricingRule:
    """值对象：定价规则"""
    min_quantity: int
    discount_percentage: float
    
    def __post_init__(self):
        if self.min_quantity < 0:
            raise ValueError("Min quantity cannot be negative")
        if not (0 <= self.discount_percentage <= 100):
            raise ValueError("Discount percentage must be between 0 and 100")


@dataclass(frozen=True)
class PriceQuote:
    """值对象：报价"""
    unit_price: float
    quantity: int
    subtotal: float
    discount: float
    final_total: float
    
    def __post_init__(self):
        if self.unit_price < 0 or self.quantity < 0:
            raise ValueError("Price and quantity must be non-negative")


class PricingService:
    """定价领域服务
    
    负责根据多种因素计算商品价格，包括：
    - 基础价格
    - 数量折扣
    - 客户等级折扣
    - 促销活动
    """
    
    def __init__(self, pricing_rules: List[PricingRule]):
        self._pricing_rules = sorted(pricing_rules, key=lambda r: r.min_quantity, reverse=True)
    
    def calculate_price(self, base_price: float, quantity: int, 
                       customer_tier: CustomerTier, 
                       promotion_code: Optional[str] = None) -> PriceQuote:
        """计算最终价格
        
        Args:
            base_price: 商品基础单价
            quantity: 购买数量
            customer_tier: 客户等级
            promotion_code: 促销码（可选）
        
        Returns:
            PriceQuote: 报价详情
        """
        if base_price < 0:
            raise ValueError("Base price cannot be negative")
        if quantity <= 0:
            raise ValueError("Quantity must be positive")
        
        # 计算小计
        subtotal = base_price * quantity
        
        # 计算数量折扣
        quantity_discount = self._calculate_quantity_discount(subtotal, quantity)
        
        # 计算客户等级折扣
        tier_discount = self._calculate_tier_discount(subtotal - quantity_discount, customer_tier)
        
        # 计算促销折扣
        promotion_discount = self._calculate_promotion_discount(
            subtotal - quantity_discount - tier_discount, 
            promotion_code
        )
        
        # 计算最终价格
        total_discount = quantity_discount + tier_discount + promotion_discount
        final_total = max(0, subtotal - total_discount)
        
        return PriceQuote(
            unit_price=base_price,
            quantity=quantity,
            subtotal=subtotal,
            discount=total_discount,
            final_total=round(final_total, 2)
        )
    
    def _calculate_quantity_discount(self, subtotal: float, quantity: int) -> float:
        """计算数量折扣"""
        for rule in self._pricing_rules:
            if quantity >= rule.min_quantity:
                return subtotal * (rule.discount_percentage / 100)
        return 0
    
    def _calculate_tier_discount(self, amount: float, tier: CustomerTier) -> float:
        """计算客户等级折扣"""
        tier_discounts = {
            CustomerTier.REGULAR: 0,
            CustomerTier.SILVER: 5,
            CustomerTier.GOLD: 10,
            CustomerTier.PLATINUM: 15
        }
        discount_percentage = tier_discounts.get(tier, 0)
        return amount * (discount_percentage / 100)
    
    def _calculate_promotion_discount(self, amount: float, promotion_code: Optional[str]) -> float:
        """计算促销折扣"""
        if not promotion_code:
            return 0
        
        # 简化的促销逻辑
        promotions = {
            "SAVE10": 10,
            "SAVE20": 20,
            "HALF": 50
        }
        
        discount_percentage = promotions.get(promotion_code.upper(), 0)
        return amount * (discount_percentage / 100)


# 使用示例
def pricing_example():
    """演示定价服务的使用"""
    # 定义定价规则
    rules = [
        PricingRule(min_quantity=100, discount_percentage=15),
        PricingRule(min_quantity=50, discount_percentage=10),
        PricingRule(min_quantity=10, discount_percentage=5),
    ]
    
    # 创建定价服务
    pricing_service = PricingService(rules)
    
    # 计算价格
    quote = pricing_service.calculate_price(
        base_price=29.99,
        quantity=55,
        customer_tier=CustomerTier.GOLD,
        promotion_code="SAVE10"
    )
    
    print(f"Unit price: ${quote.unit_price}")
    print(f"Quantity: {quote.quantity}")
    print(f"Subtotal: ${quote.subtotal:.2f}")
    print(f"Discount: ${quote.discount:.2f}")
    print(f"Final total: ${quote.final_total:.2f}")

/**
 * 应用服务：订单应用服务
 * 
 * 负责协调领域对象完成"创建订单"用例
 */
public class OrderApplicationService {
    
    private final OrderRepository orderRepository;
    private final ProductRepository productRepository;
    private final PricingService pricingService;  // 领域服务
    private final InventoryService inventoryService;  // 领域服务
    private final DomainEventPublisher eventPublisher;
    
    public OrderApplicationService(OrderRepository orderRepository,
                                  ProductRepository productRepository,
                                  PricingService pricingService,
                                  InventoryService inventoryService,
                                  DomainEventPublisher eventPublisher) {
        this.orderRepository = orderRepository;
        this.productRepository = productRepository;
        this.pricingService = pricingService;
        this.inventoryService = inventoryService;
        this.eventPublisher = eventPublisher;
    }
    
    /**
     * 创建订单
     * 
     * 应用服务负责：
     * 1. 接收请求
     * 2. 开启事务
     * 3. 调用领域服务执行业务逻辑
     * 4. 持久化
     * 5. 发布事件
     * 6. 返回结果
     */
    @Transactional
    public CreateOrderResult createOrder(CreateOrderRequest request) {
        try {
            // 获取客户
            Customer customer = customerRepository.findById(request.getCustomerId());
            if (customer == null) {
                return CreateOrderResult.failure("Customer not found");
            }
            
            // 获取商品信息
            List<Product> products = productRepository.findByIds(request.getProductIds());
            
            // 调用定价领域服务计算价格
            PricingContext pricingContext = new PricingContext(customer.getTier(), request.getPromotionCode());
            Money totalAmount = pricingService.calculateTotal(products, request.getQuantities(), pricingContext);
            
            // 调用库存领域服务检查并预留库存
            inventoryService.reserveStock(products, request.getQuantities());
            
            // 创建订单实体
            Order order = orderFactory.createOrder(customer, products, request.getQuantities(), totalAmount);
            
            // 持久化
            orderRepository.save(order);
            
            // 发布领域事件
            eventPublisher.publish(new OrderCreatedEvent(order.getId(), customer.getId(), totalAmount));
            
            return CreateOrderResult.success(order.getId());
            
        } catch (Exception e) {
            // 事务回滚
            return CreateOrderResult.failure("Order creation failed: " + e.getMessage());
        }
    }
}

public class UserService {
    public void saveUser(User user) {
        // 直接操作数据库
        jdbcTemplate.update("INSERT INTO users ...");
    }
    
    public User getUser(Long id) {
        return jdbcTemplate.queryForObject("SELECT * FROM users WHERE id = ?", id);
    }
}