/**
 * 订单聚合根
 * 
 * 订单聚合包括订单本身和订单项，它们作为一个整体被修改。
 * 订单总额必须等于各订单项小计之和，这是一个不变量。
 */
public class Order extends AggregateRoot {
    private final OrderId id;
    private final CustomerId customerId;
    private OrderStatus status;
    private final List<OrderItem> items;
    private Money totalAmount;
    private ShippingAddress shippingAddress;
    
    public Order(OrderId id, CustomerId customerId) {
        this.id = id;
        this.customerId = customerId;
        this.status = OrderStatus.CREATED;
        this.items = new ArrayList<>();
        this.totalAmount = Money.zero();
    }
    
    /**
     * 添加商品项
     * 这个方法确保订单总额的正确性（不变量）
     */
    public void addItem(Product product, int quantity) {
        if (status != OrderStatus.CREATED) {
            throw new IllegalStateException("Can only add items to created orders");
        }
        if (quantity <= 0) {
            throw new IllegalArgumentException("Quantity must be positive");
        }
        
        OrderItem item = new OrderItem(product.getId(), product.getName(), product.getPrice(), quantity);
        this.items.add(item);
        
        // 重新计算总额，确保不变量
        recalculateTotal();
    }
    
    /**
     * 移除商品项
     */
    public void removeItem(ProductId productId) {
        if (status != OrderStatus.CREATED) {
            throw new IllegalStateException("Can only remove items from created orders");
        }
        
        boolean removed = this.items.removeIf(item -> item.getProductId().equals(productId));
        if (removed) {
            recalculateTotal();
        }
    }
    
    /**
     * 确认订单
     * 确认后不能再修改
     */
    public void confirm() {
        if (status != OrderStatus.CREATED) {
            throw new IllegalStateException("Order can only be confirmed from CREATED status");
        }
        if (items.isEmpty()) {
            throw new IllegalStateException("Cannot confirm empty order");
        }
        
        this.status = OrderStatus.CONFIRMED;
        
        // 发布领域事件
        registerEvent(new OrderConfirmedEvent(id, customerId, totalAmount));
    }
    
    /**
     * 取消订单
     */
    public void cancel(CancellationReason reason) {
        if (status == OrderStatus.DELIVERED) {
            throw new IllegalStateException("Cannot cancel delivered order");
        }
        
        this.status = OrderStatus.CANCELLED;
        
        // 发布领域事件
        registerEvent(new OrderCancelledEvent(id, reason));
    }
    
    /**
     * 更新配送地址
     */
    public void updateShippingAddress(ShippingAddress address) {
        if (status != OrderStatus.CREATED && status != OrderStatus.CONFIRMED) {
            throw new IllegalStateException("Can only update address for created or confirmed orders");
        }
        
        this.shippingAddress = address;
    }
    
    /**
     * 重新计算订单总额
     * 这是维护不变量的关键方法
     */
    private void recalculateTotal() {
        this.totalAmount = items.stream()
                .map(OrderItem::subtotal)
                .reduce(Money.zero(), Money::add);
    }
    
    // Getters - 注意返回不可变视图
    public OrderId getId() { return id; }
    public CustomerId getCustomerId() { return customerId; }
    public OrderStatus getStatus() { return status; }
    
    public List<OrderItem> getItems() {
        return Collections.unmodifiableList(items);
    }
    
    public Money getTotalAmount() { return totalAmount; }
    
    public Optional<ShippingAddress> getShippingAddress() {
        return Optional.ofNullable(shippingAddress);
    }
}

/**
 * 订单项 - 聚合内部的实体
 * 
 * 订单项只在订单聚合内部有意义，不需要全局唯一标识。
 */
public class OrderItem {
    private final ProductId productId;
    private final String productName;
    private final Money unitPrice;
    private 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 abstract class AggregateRoot {
    private final List<DomainEvent> events = new ArrayList<>();
    
    protected void registerEvent(DomainEvent event) {
        events.add(event);
    }
    
    public List<DomainEvent> getEvents() {
        return Collections.unmodifiableList(events);
    }
    
    public void clearEvents() {
        events.clear();
    }
}

from dataclasses import dataclass, field
from datetime import datetime
from typing import List, Optional
import uuid


@dataclass(frozen=True)
class PostId:
    """值对象：文章ID"""
    value: str = field(default_factory=lambda: str(uuid.uuid4()))


@dataclass(frozen=True)
class AuthorId:
    """值对象：作者ID"""
    value: str


@dataclass(frozen=True)
class CommentId:
    """值对象：评论ID"""
    value: str = field(default_factory=lambda: str(uuid.uuid4()))


@dataclass(frozen=True)
class Tag:
    """值对象：标签"""
    name: str
    
    def __post_init__(self):
        if not self.name or len(self.name.strip()) == 0:
            raise ValueError("Tag name cannot be empty")


class Comment:
    """聚合内部实体：评论
    
    评论只在文章聚合内部有意义，不需要全局唯一标识。
    """
    
    def __init__(self, comment_id: CommentId, author_id: str, content: str):
        self._id = comment_id
        self._author_id = author_id
        self._content = content
        self._created_at = datetime.now()
        self._is_deleted = False
    
    @property
    def id(self) -> CommentId:
        return self._id
    
    @property
    def author_id(self) -> str:
        return self._author_id
    
    @property
    def content(self) -> str:
        return self._content
    
    @property
    def is_deleted(self) -> bool:
        return self._is_deleted
    
    def delete(self):
        """软删除评论"""
        self._is_deleted = True


class BlogPost:
    """聚合根：博客文章
    
    文章聚合包括文章本身和评论。
    评论数量必须与实际评论数一致，这是一个不变量。
    """
    
    MAX_COMMENTS_PER_POST = 100  # 每篇文章最多100条评论
    
    def __init__(self, post_id: PostId, author_id: AuthorId, title: str):
        self._id = post_id
        self._author_id = author_id
        self._title = title
        self._content = ""
        self._tags: List[Tag] = []
        self._comments: List[Comment] = []
        self._comment_count = 0
        self._published = False
        self._created_at = datetime.now()
        self._updated_at = self._created_at
    
    @property
    def id(self) -> PostId:
        return self._id
    
    @property
    def title(self) -> str:
        return self._title
    
    @property
    def published(self) -> bool:
        return self._published
    
    def update_content(self, content: str):
        """更新文章内容"""
        if self._published:
            raise RuntimeError("Cannot modify published post content")
        
        self._content = content
        self._touch()
    
    def add_tag(self, tag: Tag):
        """添加标签"""
        if tag not in self._tags:
            self._tags.append(tag)
            self._touch()
    
    def remove_tag(self, tag: Tag):
        """移除标签"""
        if tag in self._tags:
            self._tags.remove(tag)
            self._touch()
    
    def publish(self):
        """发布文章"""
        if not self._content:
            raise RuntimeError("Cannot publish empty post")
        
        self._published = True
        self._touch()
    
    def add_comment(self, author_id: str, content: str) -> Comment:
        """添加评论
        
        确保评论数量不超过限制（不变量）
        """
        if not self._published:
            raise RuntimeError("Cannot comment on unpublished post")
        
        if len(self._comments) >= self.MAX_COMMENTS_PER_POST:
            raise RuntimeError("Comment limit reached")
        
        if not content or len(content.strip()) == 0:
            raise ValueError("Comment content cannot be empty")
        
        comment = Comment(CommentId(), author_id, content)
        self._comments.append(comment)
        self._comment_count = len(self._comments)  # 维护不变量
        self._touch()
        
        return comment
    
    def delete_comment(self, comment_id: CommentId):
        """删除评论"""
        comment = next((c for c in self._comments if c.id == comment_id), None)
        if comment:
            comment.delete()
            # 重新计算评论数，确保不变量
            self._comment_count = sum(1 for c in self._comments if not c.is_deleted)
            self._touch()
    
    def get_comments(self) -> List[Comment]:
        """获取有效评论列表"""
        return [c for c in self._comments if not c.is_deleted]
    
    @property
    def comment_count(self) -> int:
        return self._comment_count
    
    @property
    def tags(self) -> List[Tag]:
        return list(self._tags)  # 返回副本
    
    def _touch(self):
        """更新时间戳"""
        self._updated_at = datetime.now()


# 使用示例
def blog_post_example():
    """演示博客文章聚合的使用"""
    # 创建文章
    post = BlogPost(PostId(), AuthorId("A001"), "My First Post")
    
    # 更新内容
    post.update_content("Hello, World!")
    
    # 添加标签
    post.add_tag(Tag("Python"))
    post.add_tag(Tag("DDD"))
    
    # 发布文章
    post.publish()
    
    # 添加评论
    comment = post.add_comment("U001", "Great post!")
    print(f"Comment count: {post.comment_count}")
    
    # 删除评论
    post.delete_comment(comment.id)
    print(f"Comment count after deletion: {post.comment_count}")

/**
 * 库存聚合根
 */
public class Inventory extends AggregateRoot {
    private final ProductId productId;
    private int availableQuantity;
    
    public Inventory(ProductId productId, int initialQuantity) {
        this.productId = productId;
        this.availableQuantity = initialQuantity;
    }
    
    /**
     * 扣减库存
     */
    public void reduceStock(int quantity) {
        if (quantity <= 0) {
            throw new IllegalArgumentException("Quantity must be positive");
        }
        if (quantity > availableQuantity) {
            throw new InsufficientStockException(productId, availableQuantity, quantity);
        }
        
        this.availableQuantity -= quantity;
        
        // 发布领域事件
        registerEvent(new StockReducedEvent(productId, quantity, availableQuantity));
    }
    
    public ProductId getProductId() { return productId; }
    public int getAvailableQuantity() { return availableQuantity; }
}

/**
 * 库存扣减事件
 */
public class StockReducedEvent extends DomainEvent {
    private final ProductId productId;
    private final int reducedQuantity;
    private final int remainingQuantity;
    
    public StockReducedEvent(ProductId productId, int reducedQuantity, int remainingQuantity) {
        this.productId = productId;
        this.reducedQuantity = reducedQuantity;
        this.remainingQuantity = remainingQuantity;
    }
    
    // Getters
    public ProductId getProductId() { return productId; }
    public int getReducedQuantity() { return reducedQuantity; }
    public int getRemainingQuantity() { return remainingQuantity; }
}

/**
 * 订单应用服务
 * 
 * 协调订单聚合和库存聚合的操作
 */
@Service
public class OrderApplicationService {
    private final OrderRepository orderRepository;
    private final InventoryRepository inventoryRepository;
    private final DomainEventPublisher eventPublisher;
    
    @Transactional
    public CreateOrderResult createOrder(CreateOrderRequest request) {
        // 创建订单聚合
        Order order = orderFactory.createOrder(request);
        
        // 对每个商品，扣减库存（单独的聚合）
        for (OrderItem item : order.getItems()) {
            Inventory inventory = inventoryRepository.findByProductId(item.getProductId());
            inventory.reduceStock(item.getQuantity());
            inventoryRepository.save(inventory);
        }
        
        // 保存订单
        orderRepository.save(order);
        
        // 发布订单创建事件
        for (DomainEvent event : order.getEvents()) {
            eventPublisher.publish(event);
        }
        
        return CreateOrderResult.success(order.getId());
    }
}

/**
 * 库存事件订阅者
 * 
 * 订阅库存扣减事件，更新其他相关数据
 */
@Component
public class StockReducedSubscriber implements EventSubscriber {
    private final ProductSearchIndex searchIndex;
    
    @Override
    public boolean supports(Class<? extends DomainEvent> eventType) {
        return StockReducedEvent.class.isAssignableFrom(eventType);
    }
    
    @Override
    public void handle(DomainEvent event) {
        StockReducedEvent stockEvent = (StockReducedEvent) event;
        
        // 更新搜索索引中的库存信息
        searchIndex.updateStock(
            stockEvent.getProductId(),
            stockEvent.getRemainingQuantity()
        );
    }
}

public class Order {
    private Long id;
    private Customer customer;  // 直接持有对象引用
    private List<OrderItem> items;
    
    public Customer getCustomer() {
        return customer;  // 暴露内部引用
    }
    
    public List<OrderItem> getItems() {
        return items;  // 暴露可变集合
    }
}