@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Customer customer = (Customer) o;
    return id != null && id.equals(customer.id);
}

@Override
public int hashCode() {
    return id != null ? id.hashCode() : 0;
}

/**
 * 订单实体
 * 订单具有唯一标识，其状态和内容可以随时间变化
 */
public class Order {
    private final OrderId id;
    private final CustomerId customerId;
    private OrderStatus status;
    private final List<OrderItem> items;
    private Money totalAmount;
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
    
    // 构造函数
    public Order(OrderId id, CustomerId customerId) {
        this.id = id;
        this.customerId = customerId;
        this.status = OrderStatus.CREATED;
        this.items = new ArrayList<>();
        this.totalAmount = Money.zero();
        this.createdAt = LocalDateTime.now();
        this.updatedAt = this.createdAt;
    }
    
    /**
     * 添加商品项
     * 只有在订单处于 CREATED 状态时才能添加商品
     */
    public void addItem(Product product, int quantity) {
        if (this.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();
        touch();
    }
    
    /**
     * 移除商品项
     */
    public void removeItem(ProductId productId) {
        if (this.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();
            touch();
        }
    }
    
    /**
     * 确认订单
     * 订单确认后不能再修改
     */
    public void confirm() {
        if (this.status != OrderStatus.CREATED) {
            throw new IllegalStateException("Order can only be confirmed from CREATED status");
        }
        if (this.items.isEmpty()) {
            throw new IllegalStateException("Cannot confirm empty order");
        }
        
        this.status = OrderStatus.CONFIRMED;
        touch();
    }
    
    /**
     * 取消订单
     */
    public void cancel(CancellationReason reason) {
        if (this.status == OrderStatus.DELIVERED) {
            throw new IllegalStateException("Cannot cancel delivered order");
        }
        
        this.status = OrderStatus.CANCELLED;
        touch();
    }
    
    private void recalculateTotal() {
        this.totalAmount = this.items.stream()
                .map(OrderItem::subtotal)
                .reduce(Money.zero(), Money::add);
    }
    
    private void touch() {
        this.updatedAt = LocalDateTime.now();
    }
    
    // 相等性判断：只基于标识
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Order order = (Order) o;
        return id != null && id.equals(order.id);
    }
    
    @Override
    public int hashCode() {
        return id != null ? id.hashCode() : 0;
    }
    
    // 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 LocalDateTime getCreatedAt() { return createdAt; }
    public LocalDateTime getUpdatedAt() { return updatedAt; }
}

/**
 * 订单项 - 作为值对象嵌入订单实体
 */
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; }
}

/**
 * 订单ID - 值对象
 */
public class OrderId {
    private final String value;
    
    public OrderId(String value) {
        if (value == null || value.isEmpty()) {
            throw new IllegalArgumentException("Order ID cannot be null or empty");
        }
        this.value = value;
    }
    
    public String getValue() {
        return value;
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        OrderId orderId = (OrderId) o;
        return value.equals(orderId.value);
    }
    
    @Override
    public int hashCode() {
        return value.hashCode();
    }
}

/**
 * 订单状态枚举
 */
public enum OrderStatus {
    CREATED, CONFIRMED, PAID, SHIPPED, DELIVERED, CANCELLED
}

from dataclasses import dataclass, field
from datetime import datetime
from enum import Enum
from typing import Optional
import uuid


class UserStatus(Enum):
    """用户状态"""
    ACTIVE = "active"
    SUSPENDED = "suspended"
    DELETED = "deleted"


@dataclass(frozen=True)
class UserId:
    """值对象：用户ID"""
    value: str
    
    def __post_init__(self):
        if not self.value:
            raise ValueError("User ID cannot be empty")
    
    def __str__(self):
        return self.value


@dataclass(frozen=True)
class Email:
    """值对象：邮箱地址"""
    value: str
    
    def __post_init__(self):
        if not self.value or "@" not in self.value:
            raise ValueError("Invalid email address")
    
    def __str__(self):
        return self.value


class User:
    """实体：用户
    
    用户具有唯一标识，其属性可以随时间变化。
    即使用户更改了邮箱或姓名，他仍然是同一个用户。
    """
    
    def __init__(self, user_id: UserId, email: Email, name: str):
        self._id = user_id
        self._email = email
        self._name = name
        self._status = UserStatus.ACTIVE
        self._created_at = datetime.now()
        self._updated_at = self._created_at
    
    @property
    def id(self) -> UserId:
        return self._id
    
    @property
    def email(self) -> Email:
        return self._email
    
    @property
    def name(self) -> str:
        return self._name
    
    @property
    def status(self) -> UserStatus:
        return self._status
    
    def change_email(self, new_email: Email):
        """更改邮箱"""
        if self._status != UserStatus.ACTIVE:
            raise RuntimeError("Cannot change email for inactive user")
        
        self._email = new_email
        self._touch()
    
    def change_name(self, new_name: str):
        """更改姓名"""
        if self._status != UserStatus.ACTIVE:
            raise RuntimeError("Cannot change name for inactive user")
        
        if not new_name or len(new_name.strip()) == 0:
            raise ValueError("Name cannot be empty")
        
        self._name = new_name
        self._touch()
    
    def suspend(self):
        """暂停用户"""
        if self._status != UserStatus.ACTIVE:
            raise RuntimeError("Can only suspend active users")
        
        self._status = UserStatus.SUSPENDED
        self._touch()
    
    def reactivate(self):
        """重新激活用户"""
        if self._status != UserStatus.SUSPENDED:
            raise RuntimeError("Can only reactivate suspended users")
        
        self._status = UserStatus.ACTIVE
        self._touch()
    
    def delete(self):
        """删除用户（软删除）"""
        self._status = UserStatus.DELETED
        self._touch()
    
    def _touch(self):
        """更新时间戳"""
        self._updated_at = datetime.now()
    
    # 相等性判断：只基于ID
    def __eq__(self, other):
        if not isinstance(other, User):
            return False
        return self._id == other._id
    
    def __hash__(self):
        return hash(self._id)
    
    def __repr__(self):
        return f"User(id={self._id}, email={self._email}, name={self._name})"


# 使用示例
def user_lifecycle_example():
    """演示用户实体的生命周期"""
    # 创建用户
    user_id = UserId(str(uuid.uuid4()))
    email = Email("john@example.com")
    user = User(user_id, email, "John Doe")
    
    print(f"Created: {user}")
    print(f"Status: {user.status.value}")
    
    # 更改邮箱
    user.change_email(Email("john.doe@example.com"))
    print(f"New email: {user.email}")
    
    # 暂停用户
    user.suspend()
    print(f"Status after suspension: {user.status.value}")
    
    # 尝试在暂停状态下更改邮箱（应该失败）
    try:
        user.change_email(Email("new@example.com"))
    except RuntimeError as e:
        print(f"Error: {e}")

/**
 * 订单工厂
 * 负责创建复杂的订单实体
 */
public class OrderFactory {
    
    /**
     * 创建新订单
     */
    public Order createOrder(CustomerId customerId, List<OrderItemRequest> items) {
        OrderId orderId = new OrderId(generateOrderId());
        Order order = new Order(orderId, customerId);
        
        for (OrderItemRequest itemRequest : items) {
            order.addItem(itemRequest.getProduct(), itemRequest.getQuantity());
        }
        
        return order;
    }
    
    /**
     * 从快照重建订单
     * 用于从持久化存储中恢复订单
     */
    public Order rebuildFromSnapshot(OrderSnapshot snapshot) {
        Order order = new Order(snapshot.getId(), snapshot.getCustomerId());
        
        // 恢复订单项
        for (OrderItemSnapshot itemSnapshot : snapshot.getItems()) {
            order.addItemDirectly(itemSnapshot.toOrderItem());
        }
        
        // 恢复状态
        order.setStatusForRebuild(snapshot.getStatus());
        
        return order;
    }
    
    private String generateOrderId() {
        return "ORD" + System.currentTimeMillis() + UUID.randomUUID().toString().substring(0, 8);
    }
}

public class Product {
    private Long id;
    private String name;
    private BigDecimal price;
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Product product = (Product) o;
        return Objects.equals(id, product.id) && 
               Objects.equals(name, product.name) && 
               Objects.equals(price, product.price);
    }
}