package com.caimei.service.impl;

import com.caimei.mapper.OrderSubmitMapper;
import com.caimei.mapper.ProductMapper;
import com.caimei.model.ResponseJson;
import com.caimei.model.po.*;
import com.caimei.model.vo.ActivityLadderVo;
import com.caimei.model.vo.AddressVo;
import com.caimei.model.vo.CartProductVo;
import com.caimei.model.vo.ShopVo;
import com.caimei.service.OrderSubmitService;
import com.caimei.service.ShoppingCartService;
import com.caimei.util.MathUtil;
import com.caimei.util.OrderNoUtils;
import com.caimei.util.ProductUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.atomic.AtomicReference;

/**
 * Description
 *
 * @author : plf
 * @date : 2021/4/25
 */
@Slf4j
@Service
public class OrderSubmitServiceImpl implements OrderSubmitService {
    @Resource
    private OrderSubmitMapper orderSubmitMapper;
    @Resource
    private ShoppingCartService shoppingCartService;
    @Resource
    private ProductMapper productMapper;
    @Value("${caimei.oldapi}")
    private String domain;

    @Override
    public ResponseJson<Map<String, Object>> orderConfirm(String cartIds, Integer productId, Integer productCount, Integer heUserId) {
        Map<String, Object> confirmData = new HashMap<>(5);
        log.info("<<<<< 结算订单 >>>>>");
        //商品总金额
        AtomicReference<BigDecimal> totalPrice = new AtomicReference<BigDecimal>(BigDecimal.ZERO);
        List<ShopVo> shopList = new ArrayList<>();
        if (productId != null && productId > 0) {
            //立即购买
            shopList.add(orderSubmitMapper.findShopByProductId(productId));
        } else {
            String[] cartId = cartIds.split(",");
            shopList = orderSubmitMapper.findShopByCartIds(cartId);
        }
        shopList.forEach(shop -> {
            shop.setLogo(ProductUtils.getImageURL("shopLogo", shop.getLogo(), 0, domain));
            List<CartProductVo> products = new ArrayList<>();
            if (productId != null && productId > 0) {
                CartProductVo cartProduct = orderSubmitMapper.findProductById(productId);
                cartProduct.setProductCount(productCount);
                cartProduct.setHeUserId(heUserId);
                products.add(cartProduct);
            } else {
                String[] cartId = cartIds.split(",");
                products = orderSubmitMapper.findByShopCartProduct(shop.getShopId(), cartId);
            }
            BigDecimal shopTotalPrice = BigDecimal.ZERO;
            for (CartProductVo product : products) {
                shoppingCartService.setPrice(product);
                shopTotalPrice = MathUtil.add(shopTotalPrice, MathUtil.mul(product.getProductCount(), product.getPrice()));
            }
            shop.setShopTotalPrice(shopTotalPrice);
            shop.setProductList(products);
            totalPrice.set(MathUtil.add(totalPrice.get(), shopTotalPrice));
        });
        confirmData.put("totalPrice", totalPrice);
        confirmData.put("shopList", shopList);
        return ResponseJson.success(confirmData);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public ResponseJson<Map<String, String>> orderSubmit(Integer userId, Integer cartType, Integer addressId, List<Map<String, Object>> orderInfo, Map<String, Object> payInfo) {
        /*
         * 逻辑处理 start
         */
        log.info("******************** 提交订单逻辑处理 start *******************");
        //机构用户
        UserPo user = orderSubmitMapper.findUser(userId);
        if (null == user) {
            return ResponseJson.error("用户信息异常", null);
        }
        // 商品总数量
        Integer productCount = 0;
        // 商品总金额 （商品单价乘以数量，再加上税费[默认0]）
        BigDecimal productTotalFee = BigDecimal.ZERO;
        // 小计金额（商品折后单价乘以数量，再加上税费[默认0])
        BigDecimal orderTotalFee = BigDecimal.ZERO;
        // 订单总额（小计金额减去经理折扣后，再加上运费[默认0])
        BigDecimal payTotalFee = BigDecimal.ZERO;
        // 真实支付金额（订单总额减去抵扣的账户余额）
        BigDecimal payableAmount = BigDecimal.ZERO;

        /*
         * 初始化主订单参数
         */
        CmOrderPo order = new CmOrderPo();
        String curDateStr = (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")).format(new Date());
        // 订单号
        String orderNo = null;
        orderNo = OrderNoUtils.getOrderNo("H");
        order.setOrderNo(orderNo);
        // 运营人员下单
        order.setBuyUserID(user.getUserID());
        order.setOrderType(2);
        order.setOrderSubmitType(0);
        order.setConfirmFlag("2");
        order.setUserID(user.getUserID().longValue());
        // 订单来源
        order.setOrderSource("6");
        order.setOrganizeID(0);
        order.setUpdateDate(curDateStr);
        order.setPayFlag("0");
        order.setCooFreeFlag("0");
        order.setCooFreeAmount(BigDecimal.ZERO);
        order.setCooFreeRate(0);
        order.setOnlinePayFlag("0");
        order.setPreferential(BigDecimal.ZERO);
        order.setDiscountFee(BigDecimal.ZERO);
        // 订单提交时间
        order.setOrderTime(curDateStr);
        // 默认订单可以拆分
        order.setSplitFlag("1");
        // 发票类型
        order.setInvoiceFlag("0");
        order.setReceiptStatus("1");
        order.setPayStatus("1");
        order.setZeroCostFlag(0);
        order.setSendOutStatus("1");
        order.setRefundType("0");
        // 是否包含活动商品(受订单未支付自动关闭时间影响)  0 否 1 是
        order.setHasActProduct("0");
        // 订单状态 0 有效  其它无效
        order.setDelFlag("0");
        // 是否确认付款供应商
        order.setAffirmPaymentFlag("0");
        /*
         * 订单商品
         */
        List<CmOrderProductPo> orderProductList = new ArrayList<>();
        for (Map<String, Object> shopOrderInfo : orderInfo) {
            Integer shopId = (Integer) shopOrderInfo.get("shopId");
            if (null == shopId) {
                return ResponseJson.error("供应商数据异常", null);
            }
            // 一个子订单对应的商品信息
            List<Map<String, Integer>> productInfoList = (List<Map<String, Integer>>) shopOrderInfo.get("productInfo");
            if (null == productInfoList) {
                return ResponseJson.error(-1, "订单商品数据异常", null);
            }
            /*
             * 整理订单商品信息
             */
            if (!CollectionUtils.isEmpty(productInfoList)) {
                // 遍历所有商品
                for (Map<String, Integer> productTemp : productInfoList) {
                    Integer productId = productTemp.get("productId");
                    Integer productNum = productTemp.get("productNum");
                    Integer heUserId = productTemp.get("heUserId");
                    heUserId = heUserId == null ? 0 : heUserId;
                    // 统计商品总数量
                    productCount += productNum;

                    // 获取商品信息
                    CmHeHeProductPo product = orderSubmitMapper.getProduct(productId);
                    if (null == product) {
                        return ResponseJson.error("订单商品数据异常", null);
                    }
                    if (null == productNum || productNum == 0) {
                        return ResponseJson.error("商品购买数量异常", null);
                    }
                    // 获取商品购买价格(活动阶梯价格)
                    BigDecimal productPrice = product.getPrice();
                    // 成本价
                    BigDecimal costPrice = BigDecimal.ZERO;
                    // 机构税费(单)
                    BigDecimal addedValueTax = new BigDecimal(0);
                    int priceType = 0;
                    //不含税可开票商品计算税费
                    Integer activityId = productMapper.findActivityByProductId(product.getProductId());
                    if (activityId != null && activityId > 0) {
                        //活动阶梯
                        List<ActivityLadderVo> ladderList = productMapper.findActivityLadder(activityId, product.getProductId());
                        if (ladderList != null && ladderList.size() > 0) {
                            priceType = 1;
                            for (ActivityLadderVo ladder : ladderList) {
                                if (productNum >= ladder.getBuyNum()) {
                                    productPrice = ladder.getBuyPrice();
                                }
                            }
                        }
                    }
                    //税费
                    boolean addTaxFlag = (0 == product.getIncludedTax()) && (1 == product.getInvoiceType() || 2 == product.getInvoiceType());
                    if (addTaxFlag) {
                        addedValueTax = MathUtil.div(MathUtil.mul(productPrice, product.getClubTaxPoint()), BigDecimal.valueOf(100));
                        productPrice = MathUtil.add(productPrice, addedValueTax);
                        product.setPrice(productPrice);
                    }
                    if (MathUtil.compare(productPrice, BigDecimal.ZERO) == 0) {
                        return ResponseJson.error("商品购买价格不能为0", null);
                    }
                    // 单个商品的金额
                    BigDecimal productFee = MathUtil.mul(productPrice, productNum);
                    // 统计商品总金额
                    productTotalFee = MathUtil.add(productTotalFee, productFee);

                    // 判断是否选中固定成本价
                    if (MathUtil.compare(product.getCostPrice(), 0) > 0 && 1 == product.getCostType()) {
                        costPrice = product.getCostPrice();
                    }
                    // 判断是否选中比例成本价
                    if (MathUtil.compare(product.getCostProportional(), 0) > 0 && 2 == product.getCostType()) {
                        // 通过售价*比例得到成本价
                        costPrice = BigDecimal.valueOf(MathUtil.div(MathUtil.mul(productPrice, product.getCostProportional()), 100).floatValue());
                    }
                    product.setCostPrice(costPrice);

                    /*
                     * 整理订单商品数据
                     */
                    CmOrderProductPo orderProduct = setOrderProduct(productNum, product, priceType, productPrice, addedValueTax);
                    orderProduct.setHeUserId(heUserId);
                    // 加入订单商品列表
                    orderProductList.add(orderProduct);

                    if (cartType == 1) {
                        orderSubmitMapper.deleteCartByProductId(user.getUserID(), product.getProductId(), heUserId);
                        log.info(">>>>>>>>>>>>>>>>>>>>>>>>>>删除用户购物车数据productId：" + product.getProductId());
                    }
                }
            }
        }

        // 设置是否是二手订单
        order.setSecondHandOrderFlag("0");
        order.setPromotionFullReduction(BigDecimal.ZERO);
        // 商品总数量
        order.setProductCount(productCount);
        // 赠品数量
        order.setPresentCount(0);
        //促销赠品数量
        order.setPromotionalGiftsCount(0);
        // 0包邮 -1到付 1 有运费
        order.setFreePostFlag("0");
        order.setFreight(BigDecimal.ZERO);
        // 商品总额
        order.setProductTotalFee(productTotalFee);
        // 订单总额（商品金额+运费）
        payTotalFee = productTotalFee;
        orderTotalFee = productTotalFee;
        order.setOrderTotalFee(orderTotalFee);
        order.setPayTotalFee(payTotalFee);
        payableAmount = payTotalFee;
        // 订单状态
        order.setStatus("11");
        order.setConfirmTime(curDateStr);

        // 余额支付金额
        order.setBalancePayFee(BigDecimal.ZERO);
        // 实际支付金额(商品金额+运费-余额抵扣)
        order.setPayableAmount(payableAmount);
        // 售后条款
        order.setClauseID(1L);
        order.setClauseName("无条款");
        // 是否返佣订单
        order.setRebateFlag("0");
        // 判断前端传入orderShouldPayFee订单应付金额,和后台计算应付金额对比
        BigDecimal orderShouldPayFee = new BigDecimal(payInfo.get("orderShouldPayFee").toString());
        double v = MathUtil.sub(payableAmount, orderShouldPayFee).doubleValue();
        log.info(">>>>>payableAmount:" + payableAmount + " ,orderShouldPayFee:" + orderShouldPayFee);
        // 考虑前端计算不精确
        if (v < -0.1d || v > 0.1d) {
            // 设置手动回滚事务
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return ResponseJson.error("订单付款金额异常", null);
        }

        /**
         * 保存主订单数据
         */
        orderSubmitMapper.insertOrder(order);
        log.info(">>>>>>>>>>>>>>>>>>>>>>>>>>新增主订单(insert[cm_order])orderId：" + order.getOrderID());

        /**
         * 设置订单商品订单号
         */
        for (CmOrderProductPo orderProduct : orderProductList) {
            orderProduct.setOrderID(order.getOrderID());
            orderProduct.setOrderNo(order.getOrderNo());
            orderProduct.setOrganizeID(order.getOrganizeID());
        }

        /**
         * 整理 子订单信息
         */
        // 收集子订单供应商ID字符串
        String shopOrderIds = "";
        for (Map<String, Object> shopOrderInfo : orderInfo) {
            Integer shopId = (Integer) shopOrderInfo.get("shopId");
            String shopNote = (String) shopOrderInfo.get("note");
            // 初始化子订单信息
            CmShopOrderPo shopOrder = saveShopOrder(order, orderProductList, shopId, shopNote);
            // 保存子订单号
            shopOrderIds += (("".equals(shopOrderIds) ? "" : ",") + shopOrder.getShopOrderID());
            // 设置订单商品子订单号
            for (CmOrderProductPo orderProduct : orderProductList) {
                if (shopId.longValue() == orderProduct.getShopID()) {
                    orderProduct.setShopOrderID(shopOrder.getShopOrderID());
                    orderProduct.setShopOrderNo(shopOrder.getShopOrderNo());
                }
            }
        }

        /**
         * 保存订单商品
         */
        List<OrderProductLadderPricePo> orderProductLadderPriceList = new ArrayList<>();
        for (CmOrderProductPo orderProduct : orderProductList) {
            // 保存订单商品数据
            orderSubmitMapper.insertOrderProduct(orderProduct);
            log.info(">>>>>>>>>>>>>>>>>>>>>>>>>>保存订单商品(insert[cm_order_product])OrderProductID：" + orderProduct.getOrderProductID());
            if ("1".equals(orderProduct.getLadderPriceFlag())) {
                //使用阶梯价格的订单商品保存下单时的阶梯价格列表
                Integer activityId = productMapper.findActivityByProductId(orderProduct.getProductID());
                if (activityId != null && activityId > 0) {
                    List<ActivityLadderVo> ladderPriceList = productMapper.findActivityLadder(activityId, orderProduct.getProductID());
                    int ladderNum = 0;
                    for (ActivityLadderVo ladder : ladderPriceList) {
                        ladderNum++;
                        OrderProductLadderPricePo orderProductLadderPrice = new OrderProductLadderPricePo();
                        orderProductLadderPrice.setOrderProductId(orderProduct.getOrderProductID());
                        orderProductLadderPrice.setBuyNum(ladder.getBuyNum());
                        orderProductLadderPrice.setBuyPrice(ladder.getBuyPrice());
                        orderProductLadderPrice.setCreateDate(new Date());
                        orderProductLadderPrice.setLadderNum(ladderNum);
                        orderProductLadderPriceList.add(orderProductLadderPrice);
                    }
                }
            }
        }
        if (!CollectionUtils.isEmpty(orderProductLadderPriceList)) {
            orderProductLadderPriceList.forEach(ladderPrice -> {
                orderSubmitMapper.insertOrderProductLadderPrice(ladderPrice);
            });
        }

        // 更新主订单信息, 子订单ID:1000,1002
        order.setShopOrderIDs(shopOrderIds);
        orderSubmitMapper.updateOrder(order);

        /**
         * 保存 订单用户地址
         */
        // 获取地址信息
        AddressVo address = orderSubmitMapper.findByAddressId(addressId);
        if (null != address) {
            //保存地址信息
            BpOrderUserInfoPo userInfo = new BpOrderUserInfoPo();
            userInfo.setOrderId(order.getOrderID());
            userInfo.setUserId(user.getUserID().longValue());
            userInfo.setName(user.getName() == null ? user.getUserName() : user.getName());
            userInfo.setShouHuoRen(address.getShouHuoRen());
            userInfo.setMobile(address.getMobile());
            userInfo.setPostalCode(address.getPhone());
            userInfo.setPostalCode(address.getPostalCode());
            userInfo.setTownId(address.getTownId());
            userInfo.setProvince(address.getProvinceName());
            userInfo.setCity(address.getCityName());
            userInfo.setTown(address.getTownName());
            userInfo.setAddress(address.getAddress());
            orderSubmitMapper.insertUserInfo(userInfo);
            log.info(">>>>>>>>>>>>>>>>>>>>>>>>>>保存订单用户地址(insert[bp_order_userinfo])orderId：" + order.getOrderID());
        } else {
            //设置手动回滚事务
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return ResponseJson.error("订单地址异常", null);
        }

        log.info("******************** 提交订单逻辑处理 end *******************");
        /*
         * 构造返回参数
         */
        Map<String, String> info = new HashMap<>(5);
        info.put("orderId", String.valueOf(order.getOrderID()));
        info.put("orderNo", String.valueOf(order.getOrderNo()));
        info.put("orderMark", "#" + order.getOrderID() + "#");
        //应付订单金额
        info.put("payTotalFee", String.valueOf(order.getPayTotalFee()));
        //真实需要付款金额
        info.put("payableAmount", String.valueOf(order.getPayableAmount()));
        return ResponseJson.success(info);
    }

    /**
     * 整理订单商品数据
     *
     * @param productNum
     * @param product
     * @param priceType    0机构价,1活动阶梯价
     * @param productPrice
     * @return
     */
    private CmOrderProductPo setOrderProduct(Integer productNum, CmHeHeProductPo product, int priceType, BigDecimal productPrice, BigDecimal addedValueTax) {
        CmOrderProductPo orderProduct = new CmOrderProductPo();
        orderProduct.setShopID(product.getShopId().longValue());
        orderProduct.setProductID(product.getProductId());
        orderProduct.setOrganizeProductID(product.getId());
        // 预留在保存保存子订单的时候添加
        orderProduct.setProductNo(null);
        orderProduct.setNum(productNum);
        orderProduct.setPresentNum(0);
        orderProduct.setProductUnit(product.getUnit());
        if (MathUtil.compare(product.getNormalPrice(), 0) > 0) {
            orderProduct.setNormalPrice(product.getNormalPrice());
        } else {
            orderProduct.setNormalPrice(BigDecimal.ZERO);
        }
        orderProduct.setCostPrice(product.getCostPrice());
        orderProduct.setPrice0(product.getPrice());
        orderProduct.setPrice1(product.getPrice());
        orderProduct.setTotalAmount(MathUtil.mul(product.getPrice(), productNum));

        orderProduct.setDiscount(new BigDecimal(100));
        // 经理折扣(优惠金额)
        orderProduct.setDiscountFee(new BigDecimal(0));
        //机构税率
        orderProduct.setTaxRate(product.getClubTaxPoint() == null ? new BigDecimal(0) : product.getClubTaxPoint());
        //供应商税率
        orderProduct.setSupplierTaxRate(BigDecimal.valueOf(0));
        orderProduct.setIncludedTax(product.getIncludedTax().toString());
        orderProduct.setInvoiceType(product.getInvoiceType().toString());
        BigDecimal singleShouldPayTotalTax = new BigDecimal(0);

        //不含税可开发票商品设置税费
        if (0 == product.getIncludedTax() && (1 == product.getInvoiceType() || 2 == product.getInvoiceType())) {
            //供应商税费(单)=成本价 * 供应商税率
            if (product.getShopTaxPoint() == null) {
                orderProduct.setSupplierTaxRate(product.getClubTaxPoint());
            } else {
                orderProduct.setSupplierTaxRate(product.getShopTaxPoint());
            }
            singleShouldPayTotalTax = MathUtil.div(MathUtil.mul(product.getCostPrice(), orderProduct.getSupplierTaxRate()), BigDecimal.valueOf(100));
        } else if (1 == product.getIncludedTax()) {
            //含税商品设置供应商税率
            if (product.getShopTaxPoint() == null) {
                orderProduct.setSupplierTaxRate(product.getClubTaxPoint());
            } else {
                orderProduct.setSupplierTaxRate(product.getShopTaxPoint());
            }
        } else if ((0 == product.getIncludedTax() && 3 == product.getInvoiceType()) || 2 == product.getIncludedTax()) {
            //不含税不可开票商品和未知商品，税率置为0
            orderProduct.setTaxRate(BigDecimal.ZERO);
            orderProduct.setSupplierTaxRate(BigDecimal.ZERO);
        }

        orderProduct.setAddedValueTax(addedValueTax);
        //机构税费(总)=机构税费(单) * 商品数量
        orderProduct.setTotalAddedValueTax(MathUtil.mul(addedValueTax, productNum));
        orderProduct.setSingleShouldPayTotalTax(singleShouldPayTotalTax);
        //供应商税费(总)=供应商税费(单) * 商品数量
        orderProduct.setShouldPayTotalTax(MathUtil.mul(singleShouldPayTotalTax, productNum));
        orderProduct.setTotalFee(MathUtil.mul(productPrice, productNum));
        orderProduct.setShouldPayFee(MathUtil.mul(productPrice, productNum));

        // 商品费=成本价快照*(购买数量  + 赠品数量)
        orderProduct.setShopProductAmount(MathUtil.mul(product.getCostPrice(), BigDecimal.valueOf(productNum)));
        //不含税可开票商品,单价/折后单价=售价-税费

        //阶梯价
        BigDecimal price1 = productPrice;
        //不含税可开票商品，单价/折后单价=售价-税费
        if (0 == product.getIncludedTax() && (1 == product.getInvoiceType() || 2 == product.getInvoiceType())) {
            price1 = MathUtil.sub(productPrice, orderProduct.getAddedValueTax());
        }
        orderProduct.setPrice(price1);
        orderProduct.setDiscountPrice(price1);

        //应付供应商(单)=成本价+供应商税费(单)
        BigDecimal singleShopFee = MathUtil.add(product.getCostPrice(), singleShouldPayTotalTax);
        orderProduct.setSingleShopFee(singleShopFee);
        // 应付供应商(总)=应付供应商(单) * 商品数量
        orderProduct.setShopFee(MathUtil.mul(singleShopFee, BigDecimal.valueOf(productNum)));
        orderProduct.setOtherFee(new BigDecimal(0));
        orderProduct.setSingleOtherFee(new BigDecimal(0));

        //应付采美(单)=单价+机构税费(单)-(成本(单)+供应商税费(单))
        BigDecimal singleCmFee = MathUtil.sub(MathUtil.add(product.getPrice(), orderProduct.getAddedValueTax()), MathUtil.add(product.getCostPrice(), singleShouldPayTotalTax));
        orderProduct.setSingleCmFee(singleCmFee);
        // 应付采美(总)=应付采美(单)*商品数量
        BigDecimal cmFee = MathUtil.mul(singleCmFee, BigDecimal.valueOf(productNum));
        orderProduct.setCmFee(cmFee);

        orderProduct.setTotalBeans(new BigDecimal(0));
        orderProduct.setUseBalanceAmount(0d);
        // 优惠金额
        orderProduct.setPreferential(new BigDecimal(0));
        orderProduct.setUseBalanceAmount(0d);
        // 订单商品供应商确认标志 0否 1是
        orderProduct.setConfirmProductFlag("0");

        orderProduct.setShopName(product.getShopName());
        orderProduct.setName(product.getName());
        orderProduct.setPayStatus("0");
        orderProduct.setBuyAgainFlag("0");
        // 未出库数量
        orderProduct.setNotOutStore(productNum);
        // 是否已评论 1 是 0 未评论
        orderProduct.setCommentFlag("0");
        orderProduct.setActPreferential(new BigDecimal(0));
        orderProduct.setActType(null);
        if (priceType == 1) {
            orderProduct.setIsActProduct("1");
            orderProduct.setLadderPriceFlag("1");
        } else {
            orderProduct.setIsActProduct("1");
            orderProduct.setLadderPriceFlag("0");
        }
        orderProduct.setProductImage(ProductUtils.getImageURL("product", product.getMainImage(), 0, domain));
        orderProduct.setProductType("0");
        return orderProduct;
    }

    /**
     * 保存子订单，并返回子订单ids
     *
     * @param order
     * @param orderProductList
     * @param shopId
     * @param shopNote
     * @return
     */
    private CmShopOrderPo saveShopOrder(CmOrderPo order, List<CmOrderProductPo> orderProductList, Integer shopId, String shopNote) {
        /*
         *  初始化子订单信息
         */
        CmShopOrderPo shopOrder = new CmShopOrderPo();
        // 子订单编号
        String shopOrderNo = "";
        String maxShopOrderNo = orderSubmitMapper.findMaxShopOrderNo(order.getOrderID());
        if (StringUtils.isNotBlank(maxShopOrderNo)) {
            shopOrderNo = maxShopOrderNo;
            shopOrder.setShopOrderNo(OrderNoUtils.getShopOrderNo(order.getOrderNo(), Integer.parseInt(shopOrderNo.substring(shopOrderNo.length() - 2, shopOrderNo.length())) + 1));
        } else {
            shopOrder.setShopOrderNo(OrderNoUtils.getShopOrderNo(order.getOrderNo(), 1));
        }
        shopOrder.setShopID(shopId);
        shopOrder.setOrderID(order.getOrderID());
        shopOrder.setOrderNo(order.getOrderNo());
        shopOrder.setUserID(order.getUserID().intValue());
        shopOrder.setOrganizeID(order.getOrganizeID());
        /*
         *  统计子订单金额信息
         */
        // 订单总金额
        BigDecimal totalAmount = new BigDecimal(0);
        // 商品总金额
        BigDecimal productAmount = new BigDecimal(0);
        // 需要支付金额
        BigDecimal needPayAmount = new BigDecimal(0);
        // 优惠金额
        BigDecimal preferential = new BigDecimal(0);
        // 佣金
        BigDecimal brokerage = new BigDecimal(0);
        // 商品费
        BigDecimal shopProductAmount = new BigDecimal(0);
        // 供应商税费
        BigDecimal shopTaxFee = new BigDecimal(0);
        // 总购买数
        Integer buyNum = 0;
        // 计算子订单信息
        for (CmOrderProductPo orderProduct : orderProductList) {
            if (shopId.longValue() == orderProduct.getShopID()) {
                // 商品总金额
                productAmount = MathUtil.add(productAmount, orderProduct.getTotalAmount());
                // 订单总金额 包括税费
                totalAmount = MathUtil.add(totalAmount, orderProduct.getTotalFee());
                // 应付金额
                needPayAmount = MathUtil.add(needPayAmount, orderProduct.getShouldPayFee());
                // 总购买数
                buyNum += orderProduct.getNum();
                preferential = MathUtil.add(preferential, orderProduct.getPreferential());
                brokerage = MathUtil.add(brokerage, orderProduct.getCmFee());
                if (null != orderProduct.getShopProductAmount()) {
                    shopProductAmount = MathUtil.add(shopProductAmount, orderProduct.getShopProductAmount());
                }
                if (null != orderProduct.getShouldPayTotalTax()) {
                    shopTaxFee = MathUtil.add(shopTaxFee, orderProduct.getShouldPayTotalTax());
                }
            }
        }
        shopOrder.setPromotionFullReduction(BigDecimal.ZERO);
        if (MathUtil.compare(shopOrder.getPromotionFullReduction(), 0) > 0) {
            totalAmount = MathUtil.sub(totalAmount, shopOrder.getPromotionFullReduction());
            productAmount = MathUtil.sub(productAmount, shopOrder.getPromotionFullReduction());
            needPayAmount = MathUtil.sub(needPayAmount, shopOrder.getPromotionFullReduction());
        }

        // freePostFlag: 0包邮 -1到付 1 有运费
        // fee: 运费：-1到付，0包邮，其他为具体运费(v5.0版本已废弃,运费已使用商品形式存储)
        if ("1".equals(order.getFreePostFlag())) {
            shopOrder.setFee(0d);
        } else {
            shopOrder.setFee(Double.parseDouble(order.getFreePostFlag()));
        }
        shopOrder.setNote(shopNote);
        shopOrder.setOrderTime(order.getOrderTime());
        shopOrder.setDiscountFee(BigDecimal.ZERO);
        shopOrder.setCanRefundFlag(1);
        shopOrder.setCanRefundAmount(needPayAmount.doubleValue());
        shopOrder.setAccountAmount(BigDecimal.ZERO);
        // 佣金 采美应收
        shopOrder.setBrokerage(brokerage);
        shopOrder.setBuyStatus("1");
        shopOrder.setPresentNum(0);
        shopOrder.setUseBeanFlag(0);
        shopOrder.setUseBeanAmount(0);
        shopOrder.setUseBalanceFlag(0);
        shopOrder.setRefundStatus(0);
        shopOrder.setRefundsAmount(BigDecimal.ZERO);
        shopOrder.setPayStatus("1");
        shopOrder.setZeroCostFlag(0);
        shopOrder.setSendOutStatus("1");
        shopOrder.setPayFlag("0");
        // 订单状态标识，1:非退货退款订单、2：退货退款中、3退货退款完成
        shopOrder.setOrderStatusFlag("1");
        shopOrder.setDelFlag("0");
        shopOrder.setOrderBeanAmount(0);
        // 购买商品数
        shopOrder.setItemCount(buyNum);
        // 普通订单 1 协销订单0 与cm_order一样
        shopOrder.setOrderType(0);
        shopOrder.setStatus(1);
        shopOrder.setOrderSubmitType(order.getOrderSubmitType());
        shopOrder.setTotalAmount(totalAmount);
        shopOrder.setProductAmount(productAmount);
        shopOrder.setNeedPayAmount(needPayAmount);
        shopOrder.setPreferential(preferential);
        shopOrder.setShopProductAmount(shopProductAmount);
        // 付给供应商运费
        shopOrder.setShopPostFee(BigDecimal.ZERO);
        // 付给供应商税费
        shopOrder.setShopTaxFee(shopTaxFee);
        // 已付款金额
        shopOrder.setPayedShopAmount(BigDecimal.ZERO);
        // 付第三方
        shopOrder.setShopOtherFee(BigDecimal.ZERO);
        // 付供应商 = 商品费 + 运费 + 税费
        shopOrder.setShouldPayShopAmount(MathUtil.add(shopProductAmount, shopTaxFee));
        // 订单能否拆分 1 为可拆分, 0为不可拆分
        if (buyNum > 1) {
            shopOrder.setSplitFlag("1");
        } else {
            shopOrder.setSplitFlag("0");
        }
        /*
         * 保存子订单信息到数据库
         */
        orderSubmitMapper.insertShopOrder(shopOrder);
        log.info(">>>>>>>>>>>>>>>>>>>>>>>>>>新增子订单(insert[cm_shop_order])shopOrderId：" + shopOrder.getShopOrderID());
        return shopOrder;
    }
}