package com.ishop.mobile.api;

import com.iplatform.base.Constants;
import com.iplatform.base.PlatformRuntimeException;
import com.ishop.merchant.OrderConstants;
import com.ishop.merchant.ProductConstants;
import com.ishop.mobile.BaseApi;
import com.ishop.mobile.pojo.PreOrderRequest;
import com.ishop.mobile.util.OrderUtils;
import com.ishop.mobile.util.VoUtils;
import com.ishop.model.MyRecord;
import com.ishop.model.po.EbMerchant;
import com.ishop.model.po.EbMerchantOrder;
import com.ishop.model.po.EbOrder;
import com.ishop.model.po.EbOrderDetail;
import com.ishop.model.po.EbProduct;
import com.ishop.model.po.EbProductAttrValue;
import com.ishop.model.po.EbUser;
import com.ishop.model.po.EbUserAddress;
import com.ishop.model.request.CreateOrderRequest;
import com.ishop.model.request.OrderComputedPriceRequest;
import com.ishop.model.request.OrderMerchantRequest;
import com.ishop.model.response.ComputedMerchantOrderResponse;
import com.ishop.model.response.ComputedOrderPriceResponse;
import com.ishop.model.response.MerchantOrderFrontDetailResponse;
import com.ishop.model.response.OrderFrontDetailResponse;
import com.ishop.model.vo.OrderDetailFrontVo;
import com.ishop.model.vo.OrderFrontVo;
import com.ishop.model.vo.OrderNoVo;
import com.ishop.model.vo.PreMerchantOrderVo;
import com.ishop.model.vo.PreOrderDetailVo;
import com.ishop.model.vo.PreOrderResponse;
import com.ishop.model.vo.PreOrderVo;
import com.walker.db.page.GenericPager;
import com.walker.db.page.ListPageContext;
import com.walker.infrastructure.utils.JsonUtils;
import com.walker.infrastructure.utils.NumberFormatUtils;
import com.walker.infrastructure.utils.NumberGenerator;
import com.walker.infrastructure.utils.StringUtils;
import com.walker.web.ResponseValue;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@RestController
@RequestMapping("/front/order")
public class OrderApi extends BaseApi {

    /**
     * 获取订单状态图
     * @return
     * @date 2023-07-13
     */
    @RequestMapping(value = "/status/image", method = RequestMethod.GET)
    public ResponseValue getOrderStatusImage(){
        List<HashMap<String, Object>> mapList = this.acquireGroupDataConfigList(Constants.GROUP_DATA_ID_ORDER_STATUS_IMAGE, this.getCdnUrl());
        return ResponseValue.success(mapList);
    }

    /**
     * 订单列表：订单详情
     * @param orderNo
     * @return
     * @date 2023-07-13
     */
    @RequestMapping(value = "/detail/{orderNo}", method = RequestMethod.GET)
    public ResponseValue detail(@PathVariable String orderNo){
        if(StringUtils.isEmpty(orderNo)){
            return ResponseValue.error("请选择一个订单");
        }
        EbOrder order = this.getOrderService().queryOrder(orderNo);
        if(order == null){
            return ResponseValue.error("订单不存在");
        }

        OrderFrontDetailResponse response = VoUtils.acquireOrderFrontDetailResponse(order);
        List<EbMerchantOrder> merchantOrderList = this.getOrderService().queryMerchantOrderList(orderNo);
        List<EbOrderDetail> orderDetailList = this.getOrderService().queryOrderDetailList(orderNo);

        Map<Integer, List<EbOrderDetail>> orderDetailMap = orderDetailList.stream().collect(Collectors.groupingBy(EbOrderDetail::getMerId));

        List<MerchantOrderFrontDetailResponse> merDetailResponseList = new ArrayList<>(8);
        MerchantOrderFrontDetailResponse merDetailResponse = null;
        EbMerchant merchant = null;
        for (EbMerchantOrder merchantOrder : merchantOrderList) {
            merDetailResponse = new MerchantOrderFrontDetailResponse();
            merchant = this.getMerchantCache().get(merchantOrder.getMerId());
            merDetailResponse.setMerName(merchant.getName());
            if (merchantOrder.getShippingType().equals(OrderConstants.ORDER_SHIPPING_TYPE_PICK_UP)) {
                merDetailResponse.setMerPhone(merchant.getPhone());
                merDetailResponse.setMerProvince(merchant.getProvince());
                merDetailResponse.setMerCity(merchant.getCity());
                merDetailResponse.setMerDistrict(merchant.getDistrict());
                merDetailResponse.setMerAddressDetail(merchant.getAddressDetail());
                merDetailResponse.setMerLatitude(merchant.getLatitude());
                merDetailResponse.setMerLongitude(merchant.getLongitude());
            }
            List<EbOrderDetail> detailList = orderDetailMap.get(merchantOrder.getMerId());
            List<OrderDetailFrontVo> dataResponseList = new ArrayList<>(2);
            OrderDetailFrontVo detailFrontVo = null;
            for(EbOrderDetail detail : detailList){
                detailFrontVo = com.ishop.merchant.util.VoUtils.acquireOrderDetailFrontVo(detail);
                dataResponseList.add(detailFrontVo);
            }
            merDetailResponse.setOrderInfoList(dataResponseList);
            merDetailResponseList.add(merDetailResponse);
        }
        response.setMerchantOrderList(merDetailResponseList);
        return ResponseValue.success(response);
    }

    /**
     * 创建订单
     * @return
     * @date 2023-07-08
     */
    @RequestMapping(value = "/create", method = RequestMethod.POST)
    public ResponseValue createOrder(@RequestBody CreateOrderRequest orderRequest){
        if(orderRequest == null || StringUtils.isEmpty(orderRequest.getPreOrderNo())
            || StringUtils.isEmptyList(orderRequest.getOrderMerchantRequestList())){
            return ResponseValue.error("订单请求参数不完整");
        }
        EbUser user = this.getCurrentEbUser();
        PreOrderVo preOrderVo = this.getPreOrderCache().get(orderRequest.getPreOrderNo());
        if(preOrderVo == null){
            return ResponseValue.error("预下单记录不存在，请重新下单");
        }
        if(preOrderVo.getType().intValue() == OrderConstants.ORDER_TYPE_SECKILL){
            // 秒杀订单
            return ResponseValue.success(this.doCreateSecondsKillOrder());
        }

        List<OrderMerchantRequest> orderMerchantRequestList = orderRequest.getOrderMerchantRequestList();
        if(StringUtils.isEmptyList(orderMerchantRequestList)){
            throw new PlatformRuntimeException("商品列表不存在");
        }

        List<PreMerchantOrderVo> merchantOrderVoList = preOrderVo.getMerchantOrderVoList();
        EbUserAddress userAddress = null;
        boolean autoShippingDone = this.isAutoShippingDone(merchantOrderVoList);
        if(!autoShippingDone){
            // 实物商品，正常发货
            if(orderRequest.getAddressId() == null || orderRequest.getAddressId().longValue() <= 0){
                return ResponseValue.error("请选择收货地址");
            }
            userAddress = this.checkUserAddress(orderMerchantRequestList, orderRequest.getAddressId());
        }

        this.checkIsTakeTheir(orderMerchantRequestList);

        // 校验商品库存
        List<MyRecord> skuRecordList = this.checkProductStock(preOrderVo.getType(), merchantOrderVoList);
        // 计算订单各种价格
        this.doComputeFreightFee(preOrderVo, userAddress, autoShippingDone);
        this.acquireCouponFee(preOrderVo, orderMerchantRequestList, user.getId());    // getCouponFee()
        if (orderRequest.getIsUseIntegral() && user.getIntegral() > 0) {// 使用积分
            this.doComputeIntegralDeduction(preOrderVo, user.getIntegral());
        }

        // 平台订单
        EbOrder order = OrderUtils.acquirePlatformOrder(user.getId(), preOrderVo);
        // 商户订单
        List<Long> couponIdList = new ArrayList<>(4);
        Object[] orderResult = OrderUtils.acquireMerchantOrderList(couponIdList
                , merchantOrderVoList, orderMerchantRequestList, order.getOrderNo(), order.getType(), user.getId()
                , order.getCreateTime(), userAddress, autoShippingDone);
        List<EbMerchantOrder> merchantOrderList = (List<EbMerchantOrder>)orderResult[0];
        List<EbOrderDetail> orderDetailList = (List<EbOrderDetail>)orderResult[1];
        if(logger.isDebugEnabled()){
            try {
                logger.debug("订单生成：商户订单列表： {}", JsonUtils.objectToJsonString(merchantOrderList));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        this.getFrontOrderService().execCreateOrder(order.getType(), skuRecordList
                , orderRequest.getPreOrderNo(), order, merchantOrderList, orderDetailList, couponIdList, preOrderVo.getCartIdList());
        this.getPreOrderCache().remove(orderRequest.getPreOrderNo());
        logger.debug("订单创建成功！删除缓存：预订单记录," + orderRequest.getPreOrderNo());

        // 加入自动未支付自动取消队列
//        redisUtil.lPush(TaskConstants.ORDER_TASK_REDIS_KEY_AUTO_CANCEL_KEY, order.getOrderNo());
        OrderNoVo response = new OrderNoVo();
        response.setOrderNo(order.getOrderNo());
        response.setPayPrice(order.getPayPrice());
        return ResponseValue.success(response);
    }

    /**
     * 检测订单中商品是否（全部）为虚拟商品，如果是则无需发货，订单直接完成。
     * @param merchantOrderVoList
     * @return
     * @date 2023-09-09
     */
    private boolean isAutoShippingDone(List<PreMerchantOrderVo> merchantOrderVoList){
        for(PreMerchantOrderVo merchantOrderVo: merchantOrderVoList){
            EbProduct product = null;
            for(PreOrderDetailVo info: merchantOrderVo.getOrderInfoList()){
                product = this.getProductCache().get(info.getProductId());
                if(product.getTempId().intValue() != com.ishop.merchant.Constants.SHIPPING_TEMPLATE_ID_NO_SEND){
                    return false;
                }
            }
        }
        return true;
    }

    /**
     * 计算积分抵扣（创建订单），
     * <p>参考方法：integralDeductionComputed()</p>
     * @param preOrderVo
     * @param userIntegral
     */
    private void doComputeIntegralDeduction(PreOrderVo preOrderVo, int userIntegral){
        boolean integralDeductionEnabled = this.getArgumentVariable(com.ishop.merchant.Constants.CONFIG_KEY_INTEGRAL_DEDUCTION_MONEY).getBooleanValue();
        if(preOrderVo.getIsUseIntegral() && !integralDeductionEnabled){
            throw new PlatformRuntimeException("积分抵扣未开启，无法使用积分");
        }
        double payPrice = preOrderVo.getProTotalFee() - preOrderVo.getCouponFee();
        double integralDeductionStartMoney = this.getArgumentVariable(com.ishop.merchant.Constants.CONFIG_KEY_INTEGRAL_DEDUCTION_START_MONEY).getDoubleValue();
        if(integralDeductionStartMoney <= 0 || payPrice < integralDeductionStartMoney){
            throw new PlatformRuntimeException("支付金额不满足积分抵扣起始金额，请重新下单");
        }
        // 查询积分使用比例
        logger.warn("创建订单：计算积分抵扣代码未实现");
    }

    private List<MyRecord> checkProductStock(int orderType, List<PreMerchantOrderVo> merchantOrderVoList) {
        List<MyRecord> recordList = new ArrayList<>(4);
        if(orderType == OrderConstants.ORDER_TYPE_SECKILL){
            logger.warn("秒杀商品订单，检查库存代码未实现");
            return recordList;
        }
        if(orderType == OrderConstants.ORDER_TYPE_VIDEO){
            // 查询商品信息 视频号都是单品下单
            logger.warn("视频号商品订单，检查库存代码未实现");
            return recordList;
        }
        // 普通商品
        EbMerchant merchant = null;
        for(PreMerchantOrderVo merchantOrderVo: merchantOrderVoList){
            merchant = this.getMerchantCache().get(merchantOrderVo.getMerId());
            if(merchant.getIsSwitch().intValue() == 0){
                throw new PlatformRuntimeException("商户已关闭，请重新下单");
            }
            EbProduct product = null;
            for(PreOrderDetailVo info: merchantOrderVo.getOrderInfoList()){
//                product = this.getProductService().get(new EbProduct(info.getProductId()));
                product = this.getProductCache().get(info.getProductId());
                if(product == null || product.getIsDel().intValue() == 1){
                    throw new PlatformRuntimeException("购买的商品信息不存在");
                }
                if (product.getIsShow().intValue() == 0) {
                    throw new PlatformRuntimeException("购买的商品已下架");
                }
                if (product.getStock().intValue() == 0 || info.getPayNum().intValue() > product.getStock().intValue()) {
                    throw new PlatformRuntimeException("购买的商品库存不足");
                }
                EbProductAttrValue attrValue = this.getProductAttrValueService().queryByIdAndProductIdAndType(info.getAttrValueId(), product.getId(), ProductConstants.PRODUCT_TYPE_NORMAL);
                if (attrValue == null) {
                    throw new PlatformRuntimeException("购买的商品规格信息不存在");
                }
                if (attrValue.getStock().intValue() < info.getPayNum().intValue()) {
                    throw new PlatformRuntimeException("购买的商品库存不足");
                }
                MyRecord record = new MyRecord();
                record.set("productId", info.getProductId());
                record.set("num", info.getPayNum());
                record.set("attrValueId", info.getAttrValueId());
                record.set("attrValueVersion", attrValue.getVersion());
                recordList.add(record);
            }
        }
        return recordList;
    }

    private EbUserAddress checkUserAddress(List<OrderMerchantRequest> orderMerchantRequestList, Long addressId){
        EbUserAddress userAddress = null;
        for(OrderMerchantRequest request: orderMerchantRequestList){
            if(request.getShippingType().intValue() == OrderConstants.ORDER_SHIPPING_TYPE_EXPRESS){
                if(addressId == null || addressId.longValue() <= 0){
                    throw new PlatformRuntimeException("请选择收获地址");
                }
                userAddress = this.getUserAddressService().get(new EbUserAddress(addressId));
                if(userAddress == null || userAddress.getIsDel().intValue() == 1){
                    throw new PlatformRuntimeException("收获地址不存在");
                }
            }
        }
        return userAddress;
    }

    private OrderNoVo doCreateSecondsKillOrder(){
        logger.warn("秒杀订单，创建代码未实现");
        return new OrderNoVo();
    }

    /**
     * 计算订单价格。
     * @return
     */
    @RequestMapping(value = "/computed/price", method = RequestMethod.POST)
    public ResponseValue computedPrice(@RequestBody OrderComputedPriceRequest request){
        String key = request.getPreOrderNo();
        PreOrderVo preOrderVo = this.getPreOrderCache().get(key);
        if(preOrderVo == null){
            return ResponseValue.error("预下单信息不存在");
        }
        List<OrderMerchantRequest> orderMerchantRequestList = request.getOrderMerchantRequestList();
        if(StringUtils.isEmptyList(orderMerchantRequestList)){
            throw new PlatformRuntimeException("商品列表不存在");
        }
//        if(StringUtils.isEmptyList(orderMerchantRequestList)){
//            return ResponseValue.error("商品列表不存在");
//        }
//        for(OrderMerchantRequest orderMerchantRequest : orderMerchantRequestList){
//            if(orderMerchantRequest.getShippingType().intValue() == OrderConstants.ORDER_SHIPPING_TYPE_PICK_UP
//                && this.getMerchantCache().get(orderMerchantRequest.getMerId()).getIsTakeTheir() == 0){
//                return ResponseValue.error("商户未开启门店自提功能");
//            }
//        }
        this.checkIsTakeTheir(orderMerchantRequestList);
        boolean integralDeductionEnabled = this.getArgumentVariable(com.ishop.merchant.Constants.CONFIG_KEY_INTEGRAL_DEDUCTION_MONEY).getBooleanValue();
        if(request.getIsUseIntegral() && !integralDeductionEnabled){
            return ResponseValue.error("积分抵扣未开启，无法使用积分");
        }

        long userId = this.getCurrentUserId();
        EbUser user = this.getUserRegCache().get(userId);
        ComputedOrderPriceResponse response = this.doComputePrice(request, preOrderVo, userId, user.getIntegral(), integralDeductionEnabled);
        return ResponseValue.success(response);
    }

    /**
     * 检查门店自提是否合法
     * @param orderMerchantRequestList
     */
    private void checkIsTakeTheir(List<OrderMerchantRequest> orderMerchantRequestList){
        for(OrderMerchantRequest orderMerchantRequest : orderMerchantRequestList){
            if(orderMerchantRequest.getShippingType().intValue() == OrderConstants.ORDER_SHIPPING_TYPE_PICK_UP
                    && this.getMerchantCache().get(orderMerchantRequest.getMerId()).getIsTakeTheir() == 0){
                throw new PlatformRuntimeException("商户未开启门店自提功能");
            }
        }
    }

    /**
     * 计算订单金额
     * @param request
     * @param preOrderVo 预下单对象
     * @param userId 用户ID
     * @param integral 用户总积分
     * @param integralDeductionEnabled 是否允许积分抵扣
     * @return
     */
    private ComputedOrderPriceResponse doComputePrice(OrderComputedPriceRequest request, PreOrderVo preOrderVo
            , long userId, int integral, boolean integralDeductionEnabled){
        // 计算各种价格
        ComputedOrderPriceResponse priceResponse = new ComputedOrderPriceResponse();
        List<OrderMerchantRequest> orderMerchantRequestList = request.getOrderMerchantRequestList();
        for(PreMerchantOrderVo merchantOrderVo : preOrderVo.getMerchantOrderVoList()){
            for(OrderMerchantRequest o : orderMerchantRequestList){
                if(o.getMerId().intValue() == merchantOrderVo.getMerId().intValue()){
                    merchantOrderVo.setShippingType(o.getShippingType());
                    merchantOrderVo.setUserCouponId(o.getUserCouponId());
                }
            }
        }
        EbUserAddress userAddress = null;
        boolean autoShippingDone = this.isAutoShippingDone(preOrderVo.getMerchantOrderVoList());
        if(!autoShippingDone){
            // 2023-09-09 实物商品，正常发货
            userAddress = this.getUserAddressService().get(new EbUserAddress(request.getAddressId()));
        }
        this.doComputeFreightFee(preOrderVo, userAddress, autoShippingDone);
        priceResponse.setFreightFee(preOrderVo.getFreightFee());

        // 优惠券计算
        acquireCouponFee(preOrderVo, orderMerchantRequestList, userId);
        priceResponse.setCouponFee(preOrderVo.getCouponFee());

        List<ComputedMerchantOrderResponse> merOrderResponseList = new ArrayList<>(preOrderVo.getMerchantOrderVoList().size());
        ComputedMerchantOrderResponse computedMerchantOrder = null;
        for(PreMerchantOrderVo merchantOrderVo : preOrderVo.getMerchantOrderVoList()){
            computedMerchantOrder = new ComputedMerchantOrderResponse();
            computedMerchantOrder.setMerId(merchantOrderVo.getMerId());
            computedMerchantOrder.setCouponFee(merchantOrderVo.getCouponFee());
            computedMerchantOrder.setFreightFee(merchantOrderVo.getFreightFee());
            computedMerchantOrder.setUserCouponId(merchantOrderVo.getUserCouponId());
        }
        priceResponse.setMerOrderResponseList(merOrderResponseList);

        // 积分部分
        double integralDeductionStartMoney = this.getArgumentVariable(com.ishop.merchant.Constants.CONFIG_KEY_INTEGRAL_DEDUCTION_START_MONEY).getDoubleValue();
        Double payPrice = preOrderVo.getProTotalFee() - priceResponse.getCouponFee();   // 实际支付金额
        priceResponse.setIsUseIntegral(request.getIsUseIntegral()); // 是否使用积分
        priceResponse.setProTotalFee(preOrderVo.getProTotalFee());  // 支付总费用
        if (!request.getIsUseIntegral() || integral <= 0) {// 不使用积分
            priceResponse.setDeductionPrice(0d);
            priceResponse.setSurplusIntegral(integral); // 剩余积分
            priceResponse.setPayFee(payPrice + priceResponse.getFreightFee());
            priceResponse.setUsedIntegral(0);
            priceResponse.setIntegralDeductionSwitch(false);
            priceResponse.setIsUseIntegral(false);
            if (integralDeductionEnabled && payPrice >= integralDeductionStartMoney) {
                priceResponse.setIntegralDeductionSwitch(true);
            }
            return priceResponse;
        }

        // 使用积分
        if (request.getIsUseIntegral() && integral > 0) {
            if(integralDeductionStartMoney <= 0 || payPrice < integralDeductionStartMoney){
                priceResponse.setDeductionPrice(0d);
                priceResponse.setSurplusIntegral(integral);
                priceResponse.setPayFee(payPrice + priceResponse.getFreightFee());
                priceResponse.setUsedIntegral(0);
                priceResponse.setIntegralDeductionSwitch(false);
                priceResponse.setIsUseIntegral(false);
                return priceResponse;
            }

            // 查询积分使用比例
            double integralRatio = this.getArgumentVariable(com.ishop.merchant.Constants.CONFIG_KEY_INTEGRAL_DEDUCTION_RATIO).getDoubleValue();
            // 可抵扣金额（支付总额中能被抵扣的金额）
//            BigDecimal canDeductionPrice = payPrice.multiply(new BigDecimal(integralRatio)).divide(new BigDecimal("100"), 2, BigDecimal.ROUND_DOWN);
            double canDeductionPrice = NumberFormatUtils.scaleAccuracy2((payPrice * integralRatio) / 100);
            // 积分转换金额
            double integralDeductionMoney = this.getArgumentVariable(com.ishop.merchant.Constants.CONFIG_KEY_INTEGRAL_DEDUCTION_MONEY).getDoubleValue();
//            BigDecimal deductionPrice = new BigDecimal(user.getIntegral()).multiply(new BigDecimal(integralDeductionMoney));
            // 用户总积分可兑换金额
            double deductionPrice = integral * integralDeductionMoney;
            // 积分兑换金额小于实际支付可抵扣金额
            if (deductionPrice <= canDeductionPrice) {
//                payPrice = payPrice.subtract(deductionPrice);
                priceResponse.setSurplusIntegral(0);
                priceResponse.setUsedIntegral(integral);
            } else {
                deductionPrice = canDeductionPrice;
                if (canDeductionPrice > 0) {
//                    int usedIntegral = canDeductionPrice.divide(new BigDecimal(integralDeductionMoney), 0, BigDecimal.ROUND_UP).intValue();
                    int usedIntegral = new Double(Math.round((canDeductionPrice / integralDeductionMoney))).intValue();
                    priceResponse.setSurplusIntegral(integral - usedIntegral);
                    priceResponse.setUsedIntegral(usedIntegral);
                }
            }
//            payPrice = payPrice.subtract(deductionPrice);
            payPrice = payPrice - deductionPrice;
            priceResponse.setPayFee(payPrice + priceResponse.getFreightFee());
            priceResponse.setDeductionPrice(deductionPrice);
            priceResponse.setIsUseIntegral(true);
            priceResponse.setIntegralDeductionSwitch(true);
        }
        return priceResponse;
    }

    /**
     * 获取优惠金额，还未实现。
     * @param orderInfoVo
     * @param orderMerchantRequestList
     * @param uid
     */
    private void acquireCouponFee(PreOrderVo orderInfoVo, List<OrderMerchantRequest> orderMerchantRequestList, Long uid) {
        logger.warn("FrontOrderServiceImpl.getCouponFee()");
    }

    /**
     * 计算订单运费，暂时未实现。后续要加上
     * @param preOrderVo
     * @param userAddress
     * @date 2023-07-07
     */
    private void doComputeFreightFee(PreOrderVo preOrderVo, EbUserAddress userAddress, boolean autoShippingDone) {
        logger.warn("FrontOrderServiceImpl.getFreightFee()");
    }

    /**
     * 订单列表
     * @param status 订单状态（-1：全部，0：待支付，1：待发货,2：部分发货， 3：待核销，4：待收货,5：已收货,6：已完成，9：已取消）
     * @return
     * @date 2023-07-07
     */
    @RequestMapping(value = "/list", method = RequestMethod.GET)
    public ResponseValue orderList(Integer status){
        long userId = this.getCurrentUserId();
        GenericPager<EbOrder> pager = this.getOrderService().queryUserOrderList(userId, status);
        List<EbOrder> orderList = pager.getDatas();
        if(StringUtils.isEmptyList(orderList)){
            return ResponseValue.success(pager);
        }
        List<OrderFrontVo> responseList = new ArrayList<>(4);
        OrderFrontVo orderFrontVo = null;
        for(EbOrder order : orderList){
            orderFrontVo = VoUtils.acquireOrderFrontVo(order);
            // 订单详情对象列表
            List<EbOrderDetail> orderDetailList = this.getOrderService().queryOrderDetailList(order.getOrderNo());
            List<OrderDetailFrontVo> infoResponseList = new ArrayList<>(4);
            OrderDetailFrontVo detailFrontVo = null;
            for(EbOrderDetail detail : orderDetailList){
                detailFrontVo = com.ishop.merchant.util.VoUtils.acquireOrderDetailFrontVo(detail);
                infoResponseList.add(detailFrontVo);
            }
            orderFrontVo.setOrderInfoList(infoResponseList);
            if(order.getMerId() != null && order.getMerId().intValue() > 0){
                orderFrontVo.setMerName(this.getMerchantCache().get(order.getMerId()).getName());
            }
            responseList.add(orderFrontVo);
        }
        return ResponseValue.success(ListPageContext.createGenericPager(responseList, pager.getPageIndex(), pager.getPageSize(), (int)pager.getTotalRows()));
    }

    /**
     * 加载预下单
     * @return
     */
    @RequestMapping(value = "/load/pre/{preOrderNo}", method = RequestMethod.GET)
    public ResponseValue loadPreOrder(@PathVariable String preOrderNo){
        if(StringUtils.isEmpty(preOrderNo)){
            return ResponseValue.error(Constants.ERROR_ARGUMENT);
        }
        PreOrderVo vo = this.getPreOrderCache().get(preOrderNo);
        if(vo == null){
            return ResponseValue.error("预下单信息不存在");
        }

        PreOrderResponse response = new PreOrderResponse();
        response.setOrderInfoVo(vo);
        return ResponseValue.success(response);
    }

    /**
     * 预下单
     * @return
     * @date 2023-07-06
     */
    @RequestMapping(value = "/pre/order", method = RequestMethod.POST)
    public ResponseValue preOrder(@RequestBody PreOrderRequest request){
        if(request == null || StringUtils.isEmpty(request.getPreOrderType())){
            return ResponseValue.error(Constants.ERROR_ARGUMENT);
        }
        if(this.logger.isDebugEnabled()){
            try {
                logger.debug("预下单 = {}", JsonUtils.objectToJsonString(request));
            } catch (Exception e) {
                logger.warn("PreOrderRequest -> JSON 错误：" + e.getMessage());
            }
        }

        EbUser user = this.getUserRegCache().get(this.getCurrentUserId());

        PreOrderVo preOrderInfoVo = OrderUtils.validatePreOrderRequest(request, this.getCdnUrl());
        List<PreOrderDetailVo> orderInfoList = new ArrayList<>(4);
        for (PreMerchantOrderVo merchantOrderVo : preOrderInfoVo.getMerchantOrderVoList()) {
            orderInfoList.addAll(merchantOrderVo.getOrderInfoList());
            double merTotalPrice = 0;
            for(PreOrderDetailVo e: merchantOrderVo.getOrderInfoList()){
                merTotalPrice += e.getPrice() * e.getPayNum();
            }
            merchantOrderVo.setProTotalFee(merTotalPrice);
            merchantOrderVo.setProTotalNum(merchantOrderVo.getOrderInfoList().stream().mapToInt(PreOrderDetailVo::getPayNum).sum());
        }
        // 商品总计金额
        double totalPrice = 0;
        for(PreOrderDetailVo e : orderInfoList){
            totalPrice += e.getPrice() * e.getPayNum();
        }
        preOrderInfoVo.setProTotalFee(totalPrice);
        // 购买商品总数量
        int orderProNum = orderInfoList.stream().mapToInt(PreOrderDetailVo::getPayNum).sum();
        preOrderInfoVo.setOrderProNum(orderProNum);

        // 获取默认地址
//        UserAddress userAddress = userAddressService.getDefaultByUid(user.getId());
//        if (ObjectUtil.isNotNull(userAddress)) {
//            // 计算运费
//            getFreightFee(preOrderInfoVo, userAddress);
//            preOrderInfoVo.setAddressId(userAddress.getId());
//        } else {
//            preOrderInfoVo.setFreightFee(BigDecimal.ZERO);
//            preOrderInfoVo.setAddressId(0);
//        }
        preOrderInfoVo.setFreightFee(0d);
        preOrderInfoVo.setAddressId(0);

        // 实际支付金额
        preOrderInfoVo.setPayFee(preOrderInfoVo.getProTotalFee() + preOrderInfoVo.getFreightFee());
        preOrderInfoVo.setUserIntegral(user.getIntegral());
        preOrderInfoVo.setUserBalance(user.getNowMoney().doubleValue());
        preOrderInfoVo.setIntegralDeductionSwitch(false);
        preOrderInfoVo.setIsUseIntegral(false);
        boolean integralDeductionEnabled = this.getArgumentVariable(com.ishop.merchant.Constants.CONFIG_KEY_INTEGRAL_DEDUCTION_SWITCH).getBooleanValue();
        double integralDeductionStartMoney = this.getArgumentVariable(com.ishop.merchant.Constants.CONFIG_KEY_INTEGRAL_DEDUCTION_START_MONEY).getDoubleValue();
        if (integralDeductionEnabled && preOrderInfoVo.getProTotalFee() >= integralDeductionStartMoney) {
            preOrderInfoVo.setIntegralDeductionSwitch(true);
        }

        // 2023-09-09
        boolean autoShippingDone = this.isAutoShippingDone(preOrderInfoVo.getMerchantOrderVoList());
        preOrderInfoVo.setAutoShippingDone(autoShippingDone);

        // 缓存订单
        String key = new StringBuilder(user.getId().toString()).append(NumberGenerator.getLongSequenceNumber()).toString();
//        String key = user.getId() + CrmebDateUtil.getNowTime().toString() + CrmebUtil.getUuid();
        this.getPreOrderCache().save(key, preOrderInfoVo, OrderConstants.PRE_ORDER_CACHE_TIME);
        OrderNoVo response = new OrderNoVo();
        response.setOrderNo(key);
        response.setOrderType(preOrderInfoVo.getType());
        try {
            logger.info("preOrder response:{}", JsonUtils.objectToJsonString(response));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return ResponseValue.success(response);
    }
}