/**
 * 限界上下文示例：电商系统中的销售和物流上下文
 * 
 * 展示如何通过包结构、模型隔离和防腐层来维护限界上下文的边界
 */

// ==================== 销售限界上下文 ====================

package com.ecommerce.sales;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.UUID;

/**
 * 销售上下文中的产品模型
 * 关注价格、促销、库存等销售相关属性
 */
public class SalesProduct {
    private final UUID productId;
    private final String name;
    private BigDecimal price;
    private Integer availableStock;
    private Boolean onPromotion;
    private BigDecimal promotionPrice;
    
    public SalesProduct(UUID productId, String name, BigDecimal price, Integer stock) {
        this.productId = productId;
        this.name = name;
        this.price = price;
        this.availableStock = stock;
        this.onPromotion = false;
    }
    
    public UUID getProductId() {
        return productId;
    }
    
    public String getName() {
        return name;
    }
    
    public BigDecimal getPrice() {
        if (onPromotion && promotionPrice != null) {
            return promotionPrice;
        }
        return price;
    }
    
    public Integer getAvailableStock() {
        return availableStock;
    }
    
    public void updateStock(Integer newStock) {
        if (newStock < 0) {
            throw new IllegalArgumentException("Stock cannot be negative");
        }
        this.availableStock = newStock;
    }
    
    public void setPromotion(BigDecimal promotionPrice) {
        if (promotionPrice.compareTo(this.price) >= 0) {
            throw new IllegalArgumentException("Promotion price must be lower than regular price");
        }
        this.promotionPrice = promotionPrice;
        this.onPromotion = true;
    }
    
    public void endPromotion() {
        this.onPromotion = false;
        this.promotionPrice = null;
    }
}

package com.ecommerce.sales;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

/**
 * 销售上下文中的订单聚合根
 * 包含订单项、总价计算等销售逻辑
 */
public class Order {
    private final UUID orderId;
    private final UUID customerId;
    private final List<OrderItem> items;
    private BigDecimal totalAmount;
    private OrderStatus status;
    private LocalDateTime createdAt;
    
    public Order(UUID orderId, UUID customerId) {
        this.orderId = orderId;
        this.customerId = customerId;
        this.items = new ArrayList<>();
        this.status = OrderStatus.CREATED;
        this.createdAt = LocalDateTime.now();
    }
    
    public void addItem(SalesProduct product, Integer quantity) {
        if (quantity <= 0) {
            throw new IllegalArgumentException("Quantity must be positive");
        }
        if (quantity > product.getAvailableStock()) {
            throw new IllegalArgumentException("Insufficient stock");
        }
        
        OrderItem item = new OrderItem(product.getProductId(), product.getName(), 
                                       product.getPrice(), quantity);
        items.add(item);
        recalculateTotal();
    }
    
    private void recalculateTotal() {
        this.totalAmount = items.stream()
                .map(item -> item.getPrice().multiply(BigDecimal.valueOf(item.getQuantity())))
                .reduce(BigDecimal.ZERO, BigDecimal::add);
    }
    
    public void confirm() {
        if (this.status != OrderStatus.CREATED) {
            throw new IllegalStateException("Order can only be confirmed from CREATED state");
        }
        this.status = OrderStatus.CONFIRMED;
    }
    
    public void cancel() {
        if (this.status == OrderStatus.SHIPPED || this.status == OrderStatus.DELIVERED) {
            throw new IllegalStateException("Cannot cancel shipped or delivered order");
        }
        this.status = OrderStatus.CANCELLED;
    }
    
    // Getters
    public UUID getOrderId() { return orderId; }
    public UUID getCustomerId() { return customerId; }
    public List<OrderItem> getItems() { return new ArrayList<>(items); }
    public BigDecimal getTotalAmount() { return totalAmount; }
    public OrderStatus getStatus() { return status; }
    public LocalDateTime getCreatedAt() { return createdAt; }
}

enum OrderStatus {
    CREATED, CONFIRMED, SHIPPED, DELIVERED, CANCELLED
}

class OrderItem {
    private final UUID productId;
    private final String productName;
    private final BigDecimal price;
    private final Integer quantity;
    
    public OrderItem(UUID productId, String productName, BigDecimal price, Integer quantity) {
        this.productId = productId;
        this.productName = productName;
        this.price = price;
        this.quantity = quantity;
    }
    
    public UUID getProductId() { return productId; }
    public String getProductName() { return productName; }
    public BigDecimal getPrice() { return price; }
    public Integer getQuantity() { return quantity; }
}

// ==================== 物流限界上下文 ====================

package com.ecommerce.logistics;

import java.util.UUID;

/**
 * 物流上下文中的产品模型
 * 关注尺寸、重量、运输条件等物流相关属性
 * 
 * 注意：这与销售上下文中的 SalesProduct 是不同的模型，
 * 即使它们代表同一个物理产品
 */
public class LogisticsProduct {
    private final UUID productId;
    private final String name;
    private final Double weightKg;      // 重量（千克）
    private final Double lengthCm;      // 长度（厘米）
    private final Double widthCm;       // 宽度（厘米）
    private final Double heightCm;      // 高度（厘米）
    private final StorageCondition storageCondition;  // 存储条件
    
    public LogisticsProduct(UUID productId, String name, Double weightKg,
                           Double lengthCm, Double widthCm, Double heightCm,
                           StorageCondition storageCondition) {
        this.productId = productId;
        this.name = name;
        this.weightKg = weightKg;
        this.lengthCm = lengthCm;
        this.widthCm = widthCm;
        this.heightCm = heightCm;
        this.storageCondition = storageCondition;
    }
    
    public UUID getProductId() {
        return productId;
    }
    
    public Double calculateVolume() {
        return lengthCm * widthCm * heightCm;
    }
    
    public boolean requiresSpecialHandling() {
        return storageCondition != StorageCondition.NORMAL;
    }
    
    // Getters
    public String getName() { return name; }
    public Double getWeightKg() { return weightKg; }
    public StorageCondition getStorageCondition() { return storageCondition; }
}

enum StorageCondition {
    NORMAL,           // 常温
    REFRIGERATED,     // 冷藏
    FROZEN,           // 冷冻
    FRAGILE           // 易碎
}

package com.ecommerce.logistics;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

/**
 * 物流上下文中的运单聚合根
 * 包含配送地址、包裹信息、物流轨迹等
 */
public class Shipment {
    private final UUID shipmentId;
    private final UUID orderId;
    private final DeliveryAddress deliveryAddress;
    private final List<Package> packages;
    private ShipmentStatus status;
    private final List<TrackingEvent> trackingEvents;
    
    public Shipment(UUID shipmentId, UUID orderId, DeliveryAddress address) {
        this.shipmentId = shipmentId;
        this.orderId = orderId;
        this.deliveryAddress = address;
        this.packages = new ArrayList<>();
        this.status = ShipmentStatus.PENDING;
        this.trackingEvents = new ArrayList<>();
    }
    
    public void addPackage(LogisticsProduct product, Integer quantity) {
        Package pkg = new Package(product, quantity);
        packages.add(pkg);
    }
    
    public void dispatch() {
        if (this.status != ShipmentStatus.PENDING) {
            throw new IllegalStateException("Can only dispatch pending shipment");
        }
        this.status = ShipmentStatus.IN_TRANSIT;
        addTrackingEvent("Shipment dispatched from warehouse");
    }
    
    public void deliver() {
        if (this.status != ShipmentStatus.IN_TRANSIT) {
            throw new IllegalStateException("Can only deliver in-transit shipment");
        }
        this.status = ShipmentStatus.DELIVERED;
        addTrackingEvent("Shipment delivered to recipient");
    }
    
    private void addTrackingEvent(String description) {
        trackingEvents.add(new TrackingEvent(description, LocalDateTime.now()));
    }
    
    // Getters
    public UUID getShipmentId() { return shipmentId; }
    public UUID getOrderId() { return orderId; }
    public ShipmentStatus getStatus() { return status; }
    public List<Package> getPackages() { return new ArrayList<>(packages); }
    public List<TrackingEvent> getTrackingEvents() { return new ArrayList<>(trackingEvents); }
}

enum ShipmentStatus {
    PENDING, IN_TRANSIT, DELIVERED, RETURNED, LOST
}

class DeliveryAddress {
    private final String street;
    private final String city;
    private final String state;
    private final String zipCode;
    private final String country;
    
    public DeliveryAddress(String street, String city, String state, String zipCode, String country) {
        this.street = street;
        this.city = city;
        this.state = state;
        this.zipCode = zipCode;
        this.country = country;
    }
    
    // Getters
    public String getStreet() { return street; }
    public String getCity() { return city; }
    public String getState() { return state; }
    public String getZipCode() { return zipCode; }
    public String getCountry() { return country; }
}

class Package {
    private final UUID productId;
    private final String productName;
    private final Integer quantity;
    private final Double weightKg;
    private final Double volumeCm3;
    
    public Package(LogisticsProduct product, Integer quantity) {
        this.productId = product.getProductId();
        this.productName = product.getName();
        this.quantity = quantity;
        this.weightKg = product.getWeightKg() * quantity;
        this.volumeCm3 = product.calculateVolume() * quantity;
    }
    
    // Getters
    public UUID getProductId() { return productId; }
    public Integer getQuantity() { return quantity; }
    public Double getWeightKg() { return weightKg; }
    public Double getVolumeCm3() { return volumeCm3; }
}

class TrackingEvent {
    private final String description;
    private final LocalDateTime timestamp;
    
    public TrackingEvent(String description, LocalDateTime timestamp) {
        this.description = description;
        this.timestamp = timestamp;
    }
    
    public String getDescription() { return description; }
    public LocalDateTime getTimestamp() { return timestamp; }
}

// ==================== 防腐层：连接销售和物流上下文 ====================

package com.ecommerce.integration;

import com.ecommerce.logistics.LogisticsProduct;
import com.ecommerce.logistics.StorageCondition;
import com.ecommerce.sales.SalesProduct;

import java.util.UUID;

/**
 * 防腐层：将销售上下文的产品转换为物流上下文的产品
 * 
 * 这个转换器防止销售模型的复杂性渗透到物流模型中，
 * 同时也保护销售模型不受物流模型变化的影响
 */
public class ProductContextTranslator {
    
    /**
     * 从销售产品创建物流产品
     * 
     * 注意：这里需要补充物流特有的信息（尺寸、存储条件等），
     * 这些信息可能来自另一个数据源
     */
    public LogisticsProduct translateToLogisticsProduct(
            SalesProduct salesProduct,
            ProductLogisticsInfo logisticsInfo) {
        
        if (logisticsInfo == null) {
            throw new IllegalArgumentException("Logistics info is required");
        }
        
        return new LogisticsProduct(
            salesProduct.getProductId(),
            salesProduct.getName(),
            logisticsInfo.getWeightKg(),
            logisticsInfo.getLengthCm(),
            logisticsInfo.getWidthCm(),
            logisticsInfo.getHeightCm(),
            logisticsInfo.getStorageCondition()
        );
    }
    
    /**
     * 物流附加信息，通常存储在单独的数据表中
     */
    public static class ProductLogisticsInfo {
        private final Double weightKg;
        private final Double lengthCm;
        private final Double widthCm;
        private final Double heightCm;
        private final StorageCondition storageCondition;
        
        public ProductLogisticsInfo(Double weightKg, Double lengthCm, Double widthCm,
                                   Double heightCm, StorageCondition storageCondition) {
            this.weightKg = weightKg;
            this.lengthCm = lengthCm;
            this.widthCm = widthCm;
            this.heightCm = heightCm;
            this.storageCondition = storageCondition;
        }
        
        public Double getWeightKg() { return weightKg; }
        public Double getLengthCm() { return lengthCm; }
        public Double getWidthCm() { return widthCm; }
        public Double getHeightCm() { return heightCm; }
        public StorageCondition getStorageCondition() { return storageCondition; }
    }
}

"""
团队接口契约示例

展示如何设计清晰、稳定、版本化的 API 契约，
支持团队独立开发和演进
"""

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


# ==================== 契约定义 ====================

class APIVersion(Enum):
    """API 版本枚举"""
    V1 = "v1"
    V2 = "v2"


@dataclass
class Money:
    """金额值对象"""
    amount: float
    currency: str = "USD"
    
    def __post_init__(self):
        if self.amount < 0:
            raise ValueError("Amount cannot be negative")
    
    def to_dict(self):
        return {"amount": self.amount, "currency": self.currency}
    
    @classmethod
    def from_dict(cls, data: dict) -> 'Money':
        return cls(amount=data["amount"], currency=data.get("currency", "USD"))


@dataclass
class Address:
    """地址值对象"""
    street: str
    city: str
    state: str
    zip_code: str
    country: str
    
    def to_dict(self):
        return {
            "street": self.street,
            "city": self.city,
            "state": self.state,
            "zip_code": self.zip_code,
            "country": self.country
        }
    
    @classmethod
    def from_dict(cls, data: dict) -> 'Address':
        return cls(
            street=data["street"],
            city=data["city"],
            state=data["state"],
            zip_code=data["zip_code"],
            country=data["country"]
        )


class OrderStatus(Enum):
    """订单状态枚举"""
    CREATED = "created"
    CONFIRMED = "confirmed"
    SHIPPED = "shipped"
    DELIVERED = "delivered"
    CANCELLED = "cancelled"


@dataclass
class OrderItem:
    """订单项"""
    product_id: str
    product_name: str
    quantity: int
    unit_price: Money
    
    def __post_init__(self):
        if self.quantity <= 0:
            raise ValueError("Quantity must be positive")
    
    def subtotal(self) -> Money:
        return Money(
            amount=self.unit_price.amount * self.quantity,
            currency=self.unit_price.currency
        )
    
    def to_dict(self):
        return {
            "product_id": self.product_id,
            "product_name": self.product_name,
            "quantity": self.quantity,
            "unit_price": self.unit_price.to_dict()
        }
    
    @classmethod
    def from_dict(cls, data: dict) -> 'OrderItem':
        return cls(
            product_id=data["product_id"],
            product_name=data["product_name"],
            quantity=data["quantity"],
            unit_price=Money.from_dict(data["unit_price"])
        )


@dataclass
class Order:
    """订单实体 - 团队接口的核心契约"""
    
    order_id: str
    customer_id: str
    items: List[OrderItem]
    status: OrderStatus = OrderStatus.CREATED
    shipping_address: Optional[Address] = None
    total_amount: Optional[Money] = None
    created_at: Optional[str] = None
    
    def __post_init__(self):
        if not self.items:
            raise ValueError("Order must have at least one item")
        # 计算总金额
        if self.total_amount is None:
            currency = self.items[0].unit_price.currency
            total = sum(item.subtotal().amount for item in self.items)
            self.total_amount = Money(amount=total, currency=currency)
        if self.created_at is None:
            self.created_at = datetime.utcnow().isoformat()
    
    def validate(self) -> List[str]:
        """验证订单，返回错误列表"""
        errors = []
        
        if not self.order_id:
            errors.append("order_id is required")
        if not self.customer_id:
            errors.append("customer_id is required")
        if not self.items:
            errors.append("Order must have at least one item")
        
        # 检查所有订单项的货币一致性
        currencies = set(item.unit_price.currency for item in self.items)
        if len(currencies) > 1:
            errors.append("All items must have the same currency")
        
        return errors
    
    def to_dict(self):
        """序列化为字典（用于 JSON 传输）"""
        return {
            "order_id": self.order_id,
            "customer_id": self.customer_id,
            "items": [item.to_dict() for item in self.items],
            "status": self.status.value,
            "shipping_address": self.shipping_address.to_dict() if self.shipping_address else None,
            "total_amount": self.total_amount.to_dict() if self.total_amount else None,
            "created_at": self.created_at
        }
    
    @classmethod
    def from_dict(cls, data: dict) -> 'Order':
        """从字典反序列化"""
        return cls(
            order_id=data["order_id"],
            customer_id=data["customer_id"],
            items=[OrderItem.from_dict(item) for item in data["items"]],
            status=OrderStatus(data.get("status", "created")),
            shipping_address=Address.from_dict(data["shipping_address"]) if data.get("shipping_address") else None,
            total_amount=Money.from_dict(data["total_amount"]) if data.get("total_amount") else None,
            created_at=data.get("created_at")
        )
    
    def to_json(self) -> str:
        """序列化为 JSON 字符串"""
        return json.dumps(self.to_dict(), ensure_ascii=False)
    
    @classmethod
    def from_json(cls, json_str: str) -> 'Order':
        """从 JSON 字符串反序列化"""
        return cls.from_dict(json.loads(json_str))


# ==================== 契约演进：V2 版本 ====================

@dataclass
class OrderItemV2(OrderItem):
    """V2 版本的订单项，增加了折扣字段"""
    discount_percent: float = 0.0
    
    def __post_init__(self):
        super().__post_init__()
        if not (0 <= self.discount_percent <= 100):
            raise ValueError("Discount percent must be between 0 and 100")
    
    def subtotal(self) -> Money:
        base_amount = self.unit_price.amount * self.quantity
        discounted_amount = base_amount * (1 - self.discount_percent / 100)
        return Money(amount=discounted_amount, currency=self.unit_price.currency)
    
    def to_dict(self):
        data = super().to_dict()
        data["discount_percent"] = self.discount_percent
        return data
    
    @classmethod
    def from_dict(cls, data: dict) -> 'OrderItemV2':
        return cls(
            product_id=data["product_id"],
            product_name=data["product_name"],
            quantity=data["quantity"],
            unit_price=Money.from_dict(data["unit_price"]),
            discount_percent=data.get("discount_percent", 0.0)
        )


@dataclass
class OrderV2(Order):
    """V2 版本的订单，支持折扣和优惠券"""
    items: List[OrderItemV2] = field(default_factory=list)
    coupon_code: Optional[str] = None
    coupon_discount: Optional[Money] = None
    
    def to_dict(self):
        data = super().to_dict()
        data["coupon_code"] = self.coupon_code
        data["coupon_discount"] = self.coupon_discount.to_dict() if self.coupon_discount else None
        return data
    
    @classmethod
    def from_dict(cls, data: dict) -> 'OrderV2':
        return cls(
            order_id=data["order_id"],
            customer_id=data["customer_id"],
            items=[OrderItemV2.from_dict(item) for item in data["items"]],
            status=OrderStatus(data.get("status", "created")),
            shipping_address=Address.from_dict(data["shipping_address"]) if data.get("shipping_address") else None,
            total_amount=Money.from_dict(data["total_amount"]) if data.get("total_amount") else None,
            created_at=data.get("created_at"),
            coupon_code=data.get("coupon_code"),
            coupon_discount=Money.from_dict(data["coupon_discount"]) if data.get("coupon_discount") else None
        )


# ==================== 契约验证器 ====================

class ContractValidator:
    """契约验证器，确保请求和响应符合契约"""
    
    @staticmethod
    def validate_order(order: Order) -> bool:
        """验证订单是否符合契约"""
        errors = order.validate()
        if errors:
            raise ContractViolationError(f"Order validation failed: {', '.join(errors)}")
        return True
    
    @staticmethod
    def validate_response_status(status_code: int, expected_codes: List[int]) -> bool:
        """验证 HTTP 响应状态码"""
        if status_code not in expected_codes:
            raise ContractViolationError(
                f"Unexpected status code: {status_code}, expected one of: {expected_codes}"
            )
        return True


class ContractViolationError(Exception):
    """契约违反异常"""
    pass


# ==================== 模拟服务实现 ====================

class OrderService:
    """订单服务 - 模拟提供方团队的实现"""
    
    def create_order(self, order: Order) -> Order:
        """创建订单"""
        # 验证契约
        ContractValidator.validate_order(order)
        
        # 模拟业务逻辑
        print(f"Creating order: {order.order_id}")
        
        # 返回确认的订单
        order.status = OrderStatus.CONFIRMED
        return order
    
    def get_order(self, order_id: str) -> Optional[Order]:
        """获取订单"""
        # 模拟数据库查询
        print(f"Fetching order: {order_id}")
        # 实际实现会从数据库加载
        return None


class OrderClient:
    """订单客户端 - 模拟消费方团队的实现"""
    
    def __init__(self, service: OrderService):
        self.service = service
    
    def place_order(self, order_data: dict) -> Order:
        """下单 - 消费方调用提供方"""
        # 反序列化
        order = Order.from_dict(order_data)
        
        # 调用服务
        result = self.service.create_order(order)
        
        # 验证响应
        ContractValidator.validate_response_status(200, [200, 201])
        
        return result


# ==================== 测试 ====================

def test_contract():
    """测试契约的正确性"""
    print("\n===== 测试 V1 契约 =====")
    
    # 创建订单
    order = Order(
        order_id="ORD-001",
        customer_id="CUST-123",
        items=[
            OrderItem(
                product_id="PROD-1",
                product_name="Laptop",
                quantity=1,
                unit_price=Money(amount=999.99, currency="USD")
            ),
            OrderItem(
                product_id="PROD-2",
                product_name="Mouse",
                quantity=2,
                unit_price=Money(amount=29.99, currency="USD")
            )
        ],
        shipping_address=Address(
            street="123 Main St",
            city="San Francisco",
            state="CA",
            zip_code="94105",
            country="US"
        )
    )
    
    print(f"Order total: ${order.total_amount.amount:.2f}")
    print(f"Order JSON: {order.to_json()[:100]}...")
    
    # 序列化/反序列化测试
    json_str = order.to_json()
    restored = Order.from_json(json_str)
    assert restored.order_id == order.order_id
    assert len(restored.items) == len(order.items)
    print("Serialization test passed")
    
    # 服务调用测试
    service = OrderService()
    client = OrderClient(service)
    
    result = client.place_order(order.to_dict())
    print(f"Order status after creation: {result.status.value}")
    
    print("\n===== 测试 V2 契约 =====")
    
    # V2 订单带折扣
    order_v2 = OrderV2(
        order_id="ORD-002",
        customer_id="CUST-123",
        items=[
            OrderItemV2(
                product_id="PROD-1",
                product_name="Laptop",
                quantity=1,
                unit_price=Money(amount=999.99, currency="USD"),
                discount_percent=10.0
            )
        ],
        coupon_code="SAVE10",
        coupon_discount=Money(amount=10.0, currency="USD")
    )
    
    print(f"V2 Order total: ${order_v2.total_amount.amount:.2f}")
    print(f"Item subtotal after discount: ${order_v2.items[0].subtotal().amount:.2f}")
    
    json_v2 = order_v2.to_json()
    restored_v2 = OrderV2.from_json(json_v2)
    assert restored_v2.coupon_code == order_v2.coupon_code
    print("V2 Serialization test passed")


if __name__ == "__main__":
    test_contract()