/**
 * 这里用到了DP模型的概念，可以参考上一期：Entity-ValueObject-DeomainService
 */
public static Product create(ProductName name, ProductDesc desc, Price price) {
    return new Product(name, desc, price);
}

private Product(ProductName name, ProductDesc desc, Price price) {
    // this.name = ...;
}

/**
 * 下单
 * @param co
 * @Param currentUser 当前用户上下文
 * @Return 订单领域对象
 */
@Transactional(rollbackFor = Exception.class)
@Override
public Order placeOrder(@NonNull PlaceOrderCO co, @NonNull UserProfile currentUser) {
    // log;

    // check permission;

    // 把co封装成若干个值对象，值对象的构造函数中包含了校验逻辑。
    // 这里涉及到DP模型的概念，可以查看上一期中的链接。
    // 这里应该不会出现参数校验的代码，即 co.checkParams() or OrderValidator.checkPlaceOrder(co);
    OrderAmount amount = new OrderAmount(co.getAmount());
    Currency currency = new Currency(co.getCurrency());

    // place order;
    Order order = Order.place(co.getGid(), co.getUid(), amount, currency);

    // create history;
    // 严格来说，这里的order和上面的order不在同一个上下文中，这里的order仅仅是一个值对象。
    OrderHistory history = OrderHistory.create(OperateAction.create, co.getUid(), order);
    
    // save repo;
    orderRepo.save(order);
    historyRepo.save(history);

    // publish event;
    // 严格来说，这里的order也不是原来的order。
    eventPublisher.publishEvent(new OrderCreatedEvent(order));

    // log;

    return order;
}

/**
 * 取消订单
 * @param co
 * @Param currentUser 当前用户上下文
 */
@Transactional(rollbackFor = Exception.class)
@Override
public void cancelOrder(@NonNull CancelOrder co, @NonNull UserProfile currentUser) {
    // log;
  
    // 大部分方法的第一行，应该都是根据id获取领域对象。
    // lock order;
    Order order = orderRepo.lock(co.getOrderId());

    // check permission;

    // cancel order;
    order.cancel();

    // create history;
    // 严格来说，这里的order和上面的order不在同一个上下文中，这里的order仅仅是一个值对象。
    OrderHistory history = OrderHistory.create(OperateAction.create, co.getUid(), order);
    
    // save repo;
    orderRepo.save(order);
    historyRepo.save(history);

    // publish event;
    // 严格来说，这里的order也不是原来的order。
    eventPublisher.publishEvent(new OrderCanceledEvent(order));
  
  // log;
}

/**
 * package: domain.object.entity
 */
public final class Order {

    /**
     * empty gid;
     */
    public static final String EMPTY_GID = StrUtil.EMPTY;

    /**
     * the default valid time of order.
     * 60min latter, order will be auto cancelled.
     */
    public static final long AUTO_CANCEL_MINUTES = 60L;

    private Long id;

    private LocalDateTime insertTime;

    private String uid;

    private String gid;

    private OrderPayment orderPayment;

    private OrderStatus status;

    /**
     * if this order.status is canceled.
     */
    public boolean canceled() {
        return status != null && status == OrderStatus.canceled;
    }
    
    /**
     * place a new order.
     */
    public static Order place(@NonNull String uid, @NonNull OrderAmount amount, @NonNull Currency currency, @NonNull OrderOrigin origin) {
        // new and set;
        Order order = new Order();
        // set;
        return order;
    }

     /**
     * confirm payment.
     * status and valid will be checked before.
     */
    public void confirmPayment(@NonNull String paymentIntentId) {
        // check status;
        // check valid;
        status = OrderStatus.waitForPayAction;
        OrderPayment newOrderPayment = new OrderPayment();
        newOrderPayment.setPaymentIntentId(paymentIntentId);
        orderPayment = newOrderPayment;
    }
  
    /**
     * success.
     * status will be reset to success and payment method will be assignment.
     * status will be checked before.
     */
    public void success(@NonNull String paymentMethodType) {
        if (!waitForPayAction()) {
            log.warn("[success] order status not matches, order.id: {}, order.status: {}", id, status);
             throw new ServiceException(ResultEnum.orderIsNotWaitingForPayment);
        }
        status = OrderStatus.paidSuccess;
        orderPayment.setPaymentMethod(paymentMethodType);
    }

    /**
     * cancel order.
     * status will be checked before.
     */
    public void cancel() {
        if (paidSuccess() || canceled()) {
            log.warn("[cancel] order can not be cancelled, status: {}", status);
            throw new ServiceException(ResultEnum.paidSuccessOrCancelledOrderCanNotBeCancelled);
        }
        status = OrderStatus.canceled;
    }

}

/*
 * package: infrastructure.repository.po
 */
public class OrderParticularsPO {

    /**
     * 唯一索引。
     * 描述这条明细属于哪个订单。
     */
    private Long orderId;

    private JSONObject metadata;  
  
     /**
     * 国家和省份，定义成两个字段，方便db搜索。
     */
    private String country;
  
    private String province;

}

/**
 * package: domain.object.value
 * 注意在值对象中，orderId被忽略了。
 */
public class OrderParticulars {

    private JSONObject metadata;

    private Address address;

}

/**
 * package: domain.object.value
 */
public class Address {
  
    private String country;
  
    private String province;
  
}