package org.linlinjava.litemall.wx.web;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.linlinjava.litemall.db.domain.*;
import org.linlinjava.litemall.db.service.*;
import org.linlinjava.litemall.db.util.JacksonUtil;
import org.linlinjava.litemall.db.util.OrderHandleOption;
import org.linlinjava.litemall.db.util.OrderUtil;
import org.linlinjava.litemall.db.util.ResponseUtil;
import org.linlinjava.litemall.wx.annotation.LoginUser;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import org.springframework.web.bind.annotation.*;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/*
 * 订单设计
 *
 * 订单状态：
 * 101 订单生成，未支付；102，订单生产，但是未支付就取消；
 * 201 支付完成，商家未发货；202，订单生产，已付款未发货，但是退款取消；
 * 301 商家发货，用户未确认；
 * 401 用户确认收货，订单结束； 402 用户没有确认收货，但是快递反馈已收获后，超过一定时间，系统自动确认收货，订单结束。
 *
 * 当101用户未付款时，此时用户可以进行的操作是取消订单，或者付款操作
 * 当201支付完成而商家未发货时，此时用户可以取消订单并申请退款
 * 当301商家已发货时，此时用户可以有确认收货的操作
 * 当401用户确认收货以后，此时用户可以进行的操作是删除订单，评价商品，或者再次购买
 * 当402系统自动确认收货以后，此时用户可以删除订单，评价商品，或者再次购买
 *
 * 目前不支持订单退货和售后服务
 *
 */
@RestController
@RequestMapping("/wx/order")
public class WxOrderController {
    private final Log logger = LogFactory.getLog(WxOrderController.class);

    @Autowired
    private LitemallOrderService orderService;
    @Autowired
    private LitemallOrderGoodsService orderGoodsService;
    @Autowired
    private LitemallAddressService addressService;
    @Autowired
    private LitemallCartService cartService;
    @Autowired
    private LitemallRegionService regionService;
    @Autowired
    private LitemallProductService productService;

    public WxOrderController() {
    }

    private String detailedAddress(LitemallAddress zmallAddress) {
        Integer provinceId = zmallAddress.getProvinceId();
        Integer cityId = zmallAddress.getCityId();
        Integer areaId = zmallAddress.getAreaId();
        String provinceName = regionService.findById(provinceId).getName();
        String cityName = regionService.findById(cityId).getName();
        String areaName = regionService.findById(areaId).getName();
        String fullRegion = provinceName + " " + cityName + " " + areaName;
        return fullRegion + " " + zmallAddress.getAddress();
    }

    /**
     * 订单列表
     * @param userId 用户ID
     * @param showType 订单信息
     *          0， 全部订单
     *          1，待付款
     *          2，待发货
     *          3，待收货
     *          4，待评价
     * @param page 分页页数
     * @param size 分页大小
     * @return 订单操作结果
     *   成功则
     *   {
     *      errno: 0,
     *      errmsg: '成功',
     *      data:
     *          {
     *              data: xxx ,
     *              count: xxx
     *          }
     *   }
     *  失败则 { errno: XXX, errmsg: XXX }
     */
    @RequestMapping("list")
    public Object list(@LoginUser Integer userId, Integer showType,
                       @RequestParam(value = "page", defaultValue = "1") Integer page,
                       @RequestParam(value = "size", defaultValue = "10") Integer size) {
        if(userId == null){
            return ResponseUtil.fail401();
        }
        if(showType == null){
            showType = 0;
        }

        List<Short> orderStatus = OrderUtil.orderStatus(showType);
        List<LitemallOrder> orderList = orderService.queryByOrderStatus(userId, orderStatus);
        int count = orderService.countByOrderStatus(userId, orderStatus);

        List<Map<String, Object>> orderVoList = new ArrayList<>(orderList.size());
        for(LitemallOrder order : orderList){
            Map<String, Object> orderVo = new HashMap<>();
            orderVo.put("id", order.getId());
            orderVo.put("orderSn", order.getOrderSn());
            orderVo.put("actualPrice", order.getActualPrice());
            orderVo.put("orderStatusText", OrderUtil.orderStatusText(order));
            orderVo.put("handleOption", OrderUtil.build(order));

            List<LitemallOrderGoods> orderGoodsList = orderGoodsService.queryByOid(order.getId());
            List<Map<String, Object>> orderGoodsVoList = new ArrayList<>(orderGoodsList.size());
            for(LitemallOrderGoods orderGoods : orderGoodsList){
                Map<String, Object> orderGoodsVo = new HashMap<>();
                orderGoodsVo.put("id", orderGoods.getId());
                orderGoodsVo.put("goodsName", orderGoods.getGoodsName());
                orderGoodsVo.put("number", orderGoods.getNumber());
                orderGoodsVo.put("picUrl", orderGoods.getPicUrl());
                orderGoodsVoList.add(orderGoodsVo);
            }
            orderVo.put("goodsList", orderGoodsVoList);

            orderVoList.add(orderVo);
        }
        Map<String, Object> result = new HashMap<>();
        result.put("count", count);
        result.put("data", orderVoList);

        return ResponseUtil.ok(result);
    }

    /**
     * 订单详情
     *
     * @param userId 用户ID
     * @param orderId 订单信息
     * @return 订单操作结果
     *   成功则
     *   {
     *      errno: 0,
     *      errmsg: '成功',
     *      data:
     *          {
     *              orderInfo: xxx ,
     *              orderGoods: xxx
     *          }
     *   }
     *   失败则 { errno: XXX, errmsg: XXX }
     */
    @GetMapping("detail")
    public Object detail(@LoginUser Integer userId, Integer orderId) {
        if(userId == null){
            return ResponseUtil.fail401();
        }
        if(orderId == null){
            return ResponseUtil.fail402();
        }

        // 订单信息
        LitemallOrder order = orderService.findById(orderId);
        if (null == order) {
            return ResponseUtil.fail(403, "订单不存在");
        }
        if(!order.getUserId().equals(userId)){
            return ResponseUtil.fail(403, "不是当前用户的订单");
        }
        Map<String, Object> orderVo = new HashMap<String, Object>();
        orderVo.put("id", order.getId());
        orderVo.put("orderSn", order.getOrderSn());
        orderVo.put("addTime", LocalDate.now());
        orderVo.put("consignee", order.getConsignee());
        orderVo.put("mobile", order.getMobile());
        orderVo.put("address", order.getAddress());
        orderVo.put("goodsPrice", order.getGoodsPrice());
        orderVo.put("freightPrice", order.getFreightPrice());
        orderVo.put("actualPrice", order.getActualPrice());
        orderVo.put("orderStatusText", OrderUtil.orderStatusText(order));
        orderVo.put("handleOption", OrderUtil.build(order));

        List<LitemallOrderGoods> orderGoodsList = orderGoodsService.queryByOid(order.getId());
        List<Map<String, Object>> orderGoodsVoList = new ArrayList<>(orderGoodsList.size());
        for(LitemallOrderGoods orderGoods : orderGoodsList){
            Map<String, Object> orderGoodsVo = new HashMap<>();
            orderGoodsVo.put("id", orderGoods.getId());
            orderGoodsVo.put("goodsName", orderGoods.getGoodsName());
            orderGoodsVo.put("number", orderGoods.getNumber());
            orderGoodsVo.put("picUrl", orderGoods.getPicUrl());
            orderGoodsVo.put("goodsSpecifitionValues", orderGoods.getGoodsSpecificationValues());
            orderGoodsVoList.add(orderGoodsVo);
        }

        Map<String, Object> result = new HashMap<>();
        result.put("orderInfo", orderVo);
        result.put("orderGoods", orderGoodsList);
        return ResponseUtil.ok(result);

    }

    /**
     * 提交订单
     * 1. 根据购物车ID、地址ID、优惠券ID，创建订单表项
     * 2. 购物车清空
     * 3. TODO 优惠券设置已用
     * 4. 商品货品数量减少
     *
     * @param userId 用户ID
     * @param body 订单信息，{ cartId：xxx, addressId: xxx, couponId: xxx }
     * @return 订单操作结果
     *   成功则 { errno: 0, errmsg: '成功', data: { orderInfo: xxx } }
     *   失败则 { errno: XXX, errmsg: XXX }
     */
    @PostMapping("submit")
    public Object submit(@LoginUser Integer userId, @RequestBody String body) {
        if(userId == null){
            return ResponseUtil.unlogin();
        }
        if(body == null){
            return ResponseUtil.badArgument();
        }
        Integer cartId = JacksonUtil.parseInteger(body, "cartId");
        Integer addressId = JacksonUtil.parseInteger(body, "addressId");
        Integer couponId = JacksonUtil.parseInteger(body, "couponId");
        if(cartId == null || addressId == null || couponId == null){
            return ResponseUtil.badArgument();
        }

        // 收货地址
        LitemallAddress checkedAddress = addressService.findById(addressId);

        // 获取可用的优惠券信息
        // 使用优惠券减免的金额
        BigDecimal couponPrice = new BigDecimal(0.00);

        // 货品价格
        List<LitemallCart> checkedGoodsList = null;
        if (cartId.equals(0)) {
            checkedGoodsList = cartService.queryByUidAndChecked(userId);
        }
        else {
            LitemallCart cart = cartService.findById(cartId);
            checkedGoodsList = new ArrayList<>(1);
            checkedGoodsList.add(cart);
        }
        if(checkedGoodsList.size() == 0){
            return ResponseUtil.badArgumentValue();
        }
        BigDecimal checkedGoodsPrice = new BigDecimal(0.00);
        for (LitemallCart checkGoods : checkedGoodsList) {
            checkedGoodsPrice = checkedGoodsPrice.add(checkGoods.getRetailPrice().multiply(new BigDecimal(checkGoods.getNumber())));
        }

        // 根据订单商品总价计算运费，满88则免运费，否则8元；
        BigDecimal freightPrice = new BigDecimal(0.00);
        if(checkedGoodsPrice.compareTo(new BigDecimal(88.00)) == -1){
            freightPrice = new BigDecimal(8.00);
        }

        // 可以使用的其他钱，例如用户积分
        BigDecimal integralPrice = new BigDecimal(0.00);


        // 订单费用
        BigDecimal orderTotalPrice = checkedGoodsPrice.add(freightPrice).subtract(couponPrice);
        BigDecimal actualPrice = orderTotalPrice.subtract(integralPrice);

        // 添加订单表
        LitemallOrder order = new LitemallOrder();
        order.setUserId(userId);
        order.setOrderSn(orderService.generateOrderSn(userId));
        order.setAddTime(LocalDateTime.now());
        order.setOrderStatus(OrderUtil.STATUS_CREATE);
        order.setConsignee(checkedAddress.getName());
        order.setMobile(checkedAddress.getMobile());
        String detailedAddress = detailedAddress(checkedAddress);
        order.setAddress(detailedAddress);
        order.setGoodsPrice(checkedGoodsPrice);
        order.setFreightPrice(freightPrice);
        order.setCouponPrice(couponPrice);
        order.setIntegralPrice(integralPrice);
        order.setOrderPrice(orderTotalPrice);
        order.setActualPrice(actualPrice);
        orderService.add(order);

        // 添加订单商品表
        for(LitemallCart cartGoods : checkedGoodsList){
            LitemallOrderGoods orderGoods = new LitemallOrderGoods();
            orderGoods.setOrderId(order.getId());
            orderGoods.setGoodsId(cartGoods.getGoodsId());
            orderGoods.setGoodsSn(cartGoods.getGoodsSn());
            orderGoods.setProductId(cartGoods.getProductId());
            orderGoods.setGoodsName(cartGoods.getGoodsName());
            orderGoods.setPicUrl(cartGoods.getPicUrl());
            orderGoods.setRetailPrice(cartGoods.getRetailPrice());
            orderGoods.setNumber(cartGoods.getNumber());
            orderGoods.setGoodsSpecificationIds(cartGoods.getGoodsSpecificationIds());
            orderGoods.setGoodsSpecificationValues(cartGoods.getGoodsSpecificationValues());
            orderGoodsService.add(orderGoods);
        }

        // 删除购物车里面的商品信息
        cartService.clearGoods(userId);

        // 商品货品数量减少
        for (LitemallCart checkGoods : checkedGoodsList) {
            checkedGoodsPrice = checkedGoodsPrice.add(checkGoods.getRetailPrice().multiply(new BigDecimal(checkGoods.getNumber())));
            Integer productId= checkGoods.getProductId();
            LitemallProduct product = productService.findById(productId);
            if(product == null){
                return ResponseUtil.badArgumentValue();
            }

            Integer remainNumber = product.getGoodsNumber() - checkGoods.getNumber();
            if(remainNumber < 0){
                return ResponseUtil.badArgumentValue();
            }
            product.setGoodsNumber(remainNumber);
            productService.updateById(product);
        }

        Map<String, Object> data = new HashMap<>();
        data.put("orderInfo", order);
        return ResponseUtil.ok(data);
    }

    /**
     * 取消订单
     * 1. 检测当前订单是否能够取消
     * 2. 设置订单取消状态
     * 3. 商品货品数量增加
     * @param userId 用户ID
     * @param body 订单信息，{ orderId：xxx }
     * @return 订单操作结果
     *   成功则 { errno: 0, errmsg: '成功' }
     *   失败则 { errno: XXX, errmsg: XXX }
     */
    @PostMapping("cancel")
    public Object cancel(@LoginUser Integer userId, @RequestBody String body) {
        if(userId == null){
            return ResponseUtil.unlogin();
        }
        Integer orderId = JacksonUtil.parseInteger(body, "orderId");
        if(orderId == null){
            return ResponseUtil.badArgument();
        }

        LitemallOrder order = orderService.findById(orderId);
        if(order == null){
            return ResponseUtil.badArgumentValue();
        }
        if(!order.getUserId().equals(userId)){
            return ResponseUtil.badArgumentValue();
        }

        // 检测是否能够取消
        OrderHandleOption handleOption = OrderUtil.build(order);
        if(!handleOption.isCancel()){
            return ResponseUtil.fail(403, "订单不能取消");
        }

        // 设置订单已取消状态
        order.setOrderStatus(OrderUtil.STATUS_CANCEL);
        orderService.update(order);

        // 商品货品数量增加
        List<LitemallOrderGoods> orderGoodsList = orderGoodsService.queryByOid(orderId);
        for(LitemallOrderGoods orderGoods : orderGoodsList){
            Integer productId = orderGoods.getProductId();
            LitemallProduct product = productService.findById(productId);
            if(product == null){
                return ResponseUtil.badArgumentValue();
            }
            Integer number = product.getGoodsNumber() + orderGoods.getNumber();
            product.setGoodsNumber(number);
            productService.updateById(product);
        }
        return ResponseUtil.ok();
    }

    /**
     * 付款
     * 1. 检测当前订单是否能够付款
     * 2. 设置订单付款状态
     * 3. TODO 微信后台申请支付，同时设置付款状态
     * @param userId 用户ID
     * @param body 订单信息，{ orderId：xxx }
     * @return 订单操作结果
     *   成功则 { errno: 0, errmsg: '成功' }
     *   失败则 { errno: XXX, errmsg: XXX }
     */
    @PostMapping("pay")
    public Object pay(@LoginUser Integer userId, @RequestBody String body) {
        if(userId == null){
            return ResponseUtil.unlogin();
        }
        Integer orderId = JacksonUtil.parseInteger(body, "orderId");
        if(orderId == null){
            return ResponseUtil.badArgument();
        }

        LitemallOrder order = orderService.findById(orderId);
        if(order == null){
            return ResponseUtil.badArgument();
        }
        if(!order.getUserId().equals(userId)){
            return ResponseUtil.badArgumentValue();
        }

        // 检测是否能够付款
        OrderHandleOption handleOption = OrderUtil.build(order);
        if(!handleOption.isPay()){
            return ResponseUtil.fail(403, "订单不能付款");
        }

        // 微信后台申请微信支付订单号
        String payId = "";
        // 微信支付订单号生产未支付
        Short payStatus = 1;

        order.setOrderStatus(OrderUtil.STATUS_PAY);
        order.setPayId(payId);
        order.setPayStatus(payStatus);
        orderService.update(order);

        return ResponseUtil.ok();
    }

    /**
     * 付款成功回调接口
     * 1. 检测当前订单是否是付款状态
     * 2. 设置订单付款成功状态相关信息
     * @param userId 用户ID
     * @param body 订单信息，{ orderId：xxx, payId: xxx }
     * @return 订单操作结果
     *   成功则 { errno: 0, errmsg: '成功' }
     *   失败则 { errno: XXX, errmsg: XXX }
     *
     * 注意，这里pay_notify是示例地址，开发者应该设立一个隐蔽的回调地址
     * TODO 这里需要根据微信支付文档设计
     */
    @PostMapping("pay_notify")
    public Object pay_notify(@LoginUser Integer userId, @RequestBody String body) {
        if(userId == null){
            return ResponseUtil.unlogin();
        }
        Integer orderId = JacksonUtil.parseInteger(body, "orderId");
        Integer payId = JacksonUtil.parseInteger(body, "payId");
        if(orderId == null || payId == null){
            return ResponseUtil.badArgument();
        }

        LitemallOrder order = orderService.findById(orderId);
        if(order == null){
            return ResponseUtil.badArgument();
        }
        if(!order.getUserId().equals(userId)){
            return ResponseUtil.badArgumentValue();
        }

        // 检测是否是付款状态
        if(!order.getOrderStatus().equals(OrderUtil.STATUS_PAY)){
            logger.error("系统内部错误");
        }
        if(!order.getPayId().equals(payId)){
            logger.error("系统内部错误");
        }

        Short payStatus = (short)2;
        order.setPayStatus(payStatus);
        order.setPayTime(LocalDateTime.now());
        orderService.update(order);

        return ResponseUtil.ok();
    }


    /**
     * 退款取消订单
     * 1. 检测当前订单是否能够退款取消
     * 2. 设置订单退款取消状态
     * 3. TODO 退款
     * 4. 商品货品数量增加
     * @param userId 用户ID
     * @param body 订单信息，{ orderId：xxx }
     * @return 订单操作结果
     *   成功则 { errno: 0, errmsg: '成功' }
     *   失败则 { errno: XXX, errmsg: XXX }
     */
    @PostMapping("refund")
    public Object refund(@LoginUser Integer userId, @RequestBody String body) {
        if(userId == null){
            return ResponseUtil.unlogin();
        }
        Integer orderId = JacksonUtil.parseInteger(body, "orderId");
        if(orderId == null){
            return ResponseUtil.badArgument();
        }

        LitemallOrder order = orderService.findById(orderId);
        if(order == null){
            return ResponseUtil.badArgument();
        }
        if(!order.getUserId().equals(userId)){
            return ResponseUtil.badArgumentValue();
        }

        OrderHandleOption handleOption = OrderUtil.build(order);
        if(!handleOption.isRefund()){
            return ResponseUtil.fail(403, "订单不能取消");
        }

        // 设置订单取消状态
        order.setOrderStatus(OrderUtil.STATUS_REFUND);
        orderService.update(order);

        // 退款操作

        // 商品货品数量增加
        List<LitemallOrderGoods> orderGoodsList = orderGoodsService.queryByOid(orderId);
        for(LitemallOrderGoods orderGoods : orderGoodsList){
            Integer productId = orderGoods.getProductId();
            LitemallProduct product = productService.findById(productId);
            if(product == null){
                return ResponseUtil.badArgumentValue();
            }
            Integer number = product.getGoodsNumber() + orderGoods.getNumber();
            product.setGoodsNumber(number);
            productService.updateById(product);
        }

        return ResponseUtil.ok();
    }

    /**
     * 发货
     * 1. 检测当前订单是否能够发货
     * 2. 设置订单发货状态
     * @param userId 用户ID
     * @param body 订单信息，{ orderId：xxx, shipSn: xxx, shipChannel: xxx }
     * @return 订单操作结果
     *   成功则 { errno: 0, errmsg: '成功' }
     *   失败则 { errno: XXX, errmsg: XXX }
     */
    @PostMapping("ship")
    public Object ship(@LoginUser Integer userId, @RequestBody String body) {
        if(userId == null){
            return ResponseUtil.unlogin();
        }
        Integer orderId = JacksonUtil.parseInteger(body, "orderId");
        String shipSn = JacksonUtil.parseString(body, "shipSn");
        String shipChannel = JacksonUtil.parseString(body, "shipChannel");
        if(orderId == null || shipSn == null || shipChannel == null){
            return ResponseUtil.badArgument();
        }

        LitemallOrder order = orderService.findById(orderId);
        if(order == null){
            return ResponseUtil.badArgument();
        }
        if(!order.getUserId().equals(userId)){
            return ResponseUtil.badArgumentValue();
        }

        // 如果订单不是已付款状态，则不能发货
        if(!order.getOrderStatus().equals(OrderUtil.STATUS_PAY)){
            return ResponseUtil.fail(403, "订单不能确认收货");
        }

        order.setOrderStatus(OrderUtil.STATUS_SHIP);
        order.setShipSn(shipSn);
        order.setShipChannel(shipChannel);
        order.setShipStartTime(LocalDateTime.now());
        orderService.update(order);

        return ResponseUtil.ok();
    }

    /**
     * 确认收货
     * 1. 检测当前订单是否能够确认订单
     * 2. 设置订单确认状态
     * @param userId 用户ID
     * @param body 订单信息，{ orderId：xxx }
     * @return 订单操作结果
     *   成功则 { errno: 0, errmsg: '成功' }
     *   失败则 { errno: XXX, errmsg: XXX }
     */
    @PostMapping("confirm")
    public Object confirm(@LoginUser Integer userId, @RequestBody String body) {
        if(userId == null){
            return ResponseUtil.unlogin();
        }
        Integer orderId = JacksonUtil.parseInteger(body, "orderId");
        if(orderId == null){
            return ResponseUtil.badArgument();
        }

        LitemallOrder order = orderService.findById(orderId);
        if(order == null){
            return ResponseUtil.badArgument();
        }
        if(!order.getUserId().equals(userId)){
            return ResponseUtil.badArgumentValue();
        }

        OrderHandleOption handleOption = OrderUtil.build(order);
        if(!handleOption.isConfirm()){
            return ResponseUtil.fail(403, "订单不能确认收货");
        }

        order.setOrderStatus(OrderUtil.STATUS_CONFIRM);
        order.setConfirmTime(LocalDateTime.now());
        orderService.update(order);

        return ResponseUtil.ok();
    }


    /**
     * 自动确认收货
     * 1. 检测当前订单是否能够自动确认订单
     * 2. 设置订单自动确认状态
     * @param userId 用户ID
     * @param body 订单信息，{ orderId：xxx }
     * @return 订单操作结果
     *   成功则 { errno: 0, errmsg: '成功' }
     *   失败则 { errno: XXX, errmsg: XXX }
     */
    @PostMapping("autoconfirm")
    public Object autoconfirm(@LoginUser Integer userId, @RequestBody String body) {
        if(userId == null){
            return ResponseUtil.unlogin();
        }
        Integer orderId = JacksonUtil.parseInteger(body, "orderId");
        if(orderId == null){
            return ResponseUtil.badArgument();
        }

        LitemallOrder order = orderService.findById(orderId);
        if(order == null){
            return ResponseUtil.badArgument();
        }
        if(!order.getUserId().equals(userId)){
            return ResponseUtil.badArgumentValue();
        }

        OrderHandleOption handleOption = OrderUtil.build(order);
        if(!handleOption.isConfirm()){
            return ResponseUtil.fail(403, "订单不能确认收货");
        }

        order.setOrderStatus(OrderUtil.STATUS_AUTO_CONFIRM);
        order.setConfirmTime(LocalDateTime.now());
        orderService.update(order);

        return ResponseUtil.ok();
    }

    /**
     * 删除订单
     * 1. 检测当前订单是否删除
     * 2. 设置订单删除状态
     * @param userId 用户ID
     * @param body 订单信息，{ orderId：xxx }
     * @return 订单操作结果
     *   成功则 { errno: 0, errmsg: '成功' }
     *   失败则 { errno: XXX, errmsg: XXX }
     */
    @PostMapping("delete")
    public Object delete(@LoginUser Integer userId, @RequestBody String body) {
        if(userId == null){
            return ResponseUtil.unlogin();
        }
        Integer orderId = JacksonUtil.parseInteger(body, "orderId");
        if(orderId == null){
            return ResponseUtil.badArgument();
        }

        LitemallOrder order = orderService.findById(orderId);
        if(order == null){
            return ResponseUtil.badArgument();
        }
        if(!order.getUserId().equals(userId)){
            return ResponseUtil.badArgumentValue();
        }

        OrderHandleOption handleOption = OrderUtil.build(order);
        if(!handleOption.isDelete()){
            return ResponseUtil.fail(403, "订单不能删除");
        }

        // 订单order_status没有字段用于标识删除
        // 而是存在专门的delete字段表示是否删除
        orderService.deleteById(orderId);

        return ResponseUtil.ok();
    }

    /**
     * 可以评价的订单商品信息
     *
     * @param userId 用户ID
     * @param orderId 订单ID
     * @param goodsId 商品ID
     * @return 订单操作结果
     *   成功则 { errno: 0, errmsg: '成功', data: xxx }
     *   失败则 { errno: XXX, errmsg: XXX }
     */
    @GetMapping("comment")
    public Object comment(@LoginUser Integer userId, Integer orderId, Integer goodsId) {
        if(userId == null){
            return ResponseUtil.unlogin();
        }
        if(orderId == null){
            return ResponseUtil.badArgument();
        }

        List<LitemallOrderGoods> orderGoodsList = orderGoodsService.findByOidAndGid(orderId, goodsId);
        int size = orderGoodsList.size();

        Assert.state(size < 2, "存在多个符合条件的订单商品");

        if(size == 0){
            return ResponseUtil.badArgumentValue();
        }

        LitemallOrderGoods orderGoods = orderGoodsList.get(0);
        return ResponseUtil.ok(orderGoods);
    }
}