package com.ydd.app.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.github.binarywang.wxpay.exception.WxPayException;
import com.ijpay.core.enums.TradeType;
import com.ydd.app.dto.AddressReq;
import com.ydd.app.dto.OrderReq;
import com.ydd.app.dto.ValuationRes;
import com.ydd.app.listener.DeliveryOrderEvent;
import com.ydd.app.service.ApiCouponService;
import com.ydd.app.service.ApiOrderNewService;
import com.ydd.app.service.ApiOrderService;
import com.ydd.app.service.ApiProductService;
import com.ydd.common.constant.RedisKeyConstant;
import com.ydd.common.core.redis.RedisCache;
import com.ydd.common.enums.WaimaiTypeEnums;
import com.ydd.common.utils.DateUtils;
import com.ydd.common.utils.StringUtils;
import com.ydd.ecloud.core.utils.BigDecimalUtils;
import com.ydd.ecloud.core.utils.JsonMapper;
import com.ydd.module.domain.*;
import com.ydd.module.dto.CouponDto;
import com.ydd.module.dto.OrderFreightDto;
import com.ydd.module.enums.*;
import com.ydd.module.expection.CustomAppException;
import com.ydd.module.pay.alipay.AliPayService;
import com.ydd.module.pay.dto.OrderPaySignResponse;
import com.ydd.module.pay.wechat.service.WechatPayService;
import com.ydd.module.push.MessagePushService;
import com.ydd.module.service.*;
import com.ydd.system.service.ISysConfigService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionSynchronizationAdapter;
import org.springframework.transaction.support.TransactionSynchronizationManager;

import java.math.BigDecimal;
import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * Project：lb-server
 * Class：ApiOrderServiceImpl
 * Description：TODO
 * Time：2021/2/23 14:41
 *
 * @author zoe
 */
@Slf4j
@Service
@RequiredArgsConstructor(onConstructor_ = @Autowired)
public class ApiOrderNewServiceImpl implements ApiOrderNewService {

    private final ApiProductService apiProductService;

    private final ApiCouponService apiCouponService;

    private final IOrderService iOrderService;

    private final IOrderLogService iOrderLogService;

    private final IMemberService iMemberService;

    private final IMemberBalanceLogService iMemberBalanceLogService;

    private final IWaimaiOrderService iWaimaiOrderService;

    private final ApplicationContext applicationContext;

    private final ISysConfigService iSysConfigService;

    private final IDspConfigService iDspConfigService;
    private final ApiCacheUserAddress apiCacheUserAddress;
    private final IAgentService iAgentService;
    private final AliPayService aliPayService;
    private final WechatPayService wechatPayService;
    private final IPaymentService paymentService;

    private final IWaimaiOrderDetailService iWaimaiOrderDetailService;

    private final IMerchantService iMerchantService;
    private final MessagePushService messagePushService;
    private final ApiOrderService apiOrderService;
    private final IMerchantDeliveryFeeService iMerchantDeliveryFeeService;

    private final RedisCache redisCache;
    private final IOrderFreightService iOrderFreightService;


    @Override
    @Transactional(rollbackFor = Exception.class)
    public Object createOrder(Long loginId, OrderReq req, Integer type) {
        log.info("<===========>提交下单参数" + JsonMapper.nonEmptyMapper().toJson(req));
//        try {
        if (CollectionUtils.isEmpty(req.getValuationRes())) {
            throw new CustomAppException("暂无运力, 下单失败!");
        }
        String orderNo = req.getValuationRes().get(0).getOrderNo();
        List<Order> orderLists = iOrderService.list(new QueryWrapper<Order>().eq("order_sn", orderNo));
        if (CollectionUtils.isNotEmpty(orderLists)) {
            req.setOrderId(orderLists.get(0).getId());
            // 校验订单状态
            Integer status = orderLists.get(0).getStatus();
            if (!PayStatusEnum.NO_PAYED.status.equals(status)) {
                log.warn("orderSn:{}, status: {}, 该状态不支持下单操作!", orderNo, status);
                throw new CustomAppException("该状态不支持下单操作!");
            }
        }
        Member member = iMemberService.getById(loginId);
        if (member.getMemberType().equals(MemberTypeEnum.SHOP.type)) {
            member = iMemberService.getOne(new QueryWrapper<Member>().eq("member_type", MemberTypeEnum.MERCHANT.type).eq("merchant_id", member.getMerchantId()));
        }
        Product product = apiProductService.findById(req.getProductId());
        if (product == null) {
            throw new CustomAppException(ExceptionEnum.PRODUCT_NOT_EXISTS);
        }
        CouponDto couponDto = null;
        if (req.getCouponId() != null) {
            couponDto = apiCouponService.findDetail(req.getCouponId());
            if (couponDto == null && type.intValue() != 3) {
                throw new CustomAppException("优惠券不存在！");
            }
        }
        //地址处理重复楼层
        address(req);
        // 保存发件信息, 如果发件Id不存在, 则为手工录入信息, 保存到缓存
//        apiCacheUserAddress.cacheAddress(loginId, req);
        try {
            apiCacheUserAddress.cacheSendReceiveAddress(loginId, req.getSendAddress(), req.getReceiptAddress());
        } catch (Exception e) {
            log.error("缓存收发件地址异常, {}", e.getMessage());
        }

        Order order = createOrder(product, couponDto, req, loginId);

        if (order.getId() != null && order.getDeliveryStatus() != null && order.getDeliveryStatus() >= DeliveryStatusEnum.ORDERS_TO_BE_RECEIVED.status && order.getDeliveryStatus() != DeliveryStatusEnum.FINISH.status) {
            return null;
        }
        if (order.getId() != null && order.getDeliveryStatus() != null && (DeliveryStatusEnum.CANCEL.status.equals(order.getDeliveryStatus())
                || DeliveryStatusEnum.FINISH.status.equals(order.getDeliveryStatus())
                || DeliveryStatusEnum.ABNORMAL.status.equals(order.getDeliveryStatus()))) {
            resetOrder(order, product);
        }

        // 获取达达收付配送商计价信息
        OrderFreightDto orderFreightDto = redisCache.getCacheObject(orderNo);
        // 达达配送订单订单标识
        boolean isDadaOrder = false;
        // 达达收付订单订单标识
        boolean isDadaRapDelivery = false;
        if (orderFreightDto != null && orderFreightDto.getValuationType() != null) {
            isDadaOrder = true;
            if (orderFreightDto.getValuationType() == 2) {
                order.setDadaDspType(OrderDadaDspTypeEnum.DELIVERY.type);
            } else {
                isDadaRapDelivery = true;
                order.setDadaDspType(OrderDadaDspTypeEnum.DELIVERY_RAP.type);
            }
            order.setDadaDspId(orderFreightDto.getDadaDspId());
        }

        order.setMemberId(loginId);
        order.setCreateTime(new Date());
        order.setTakeType(req.getTakeType());
        if (TakeTypeEnum.APPOINTMENT.type.equals(req.getTakeType())) {
            if (DateUtils.addMinutes(new Date(), 130).compareTo(DateUtils.dateTime(DateUtils.YYYY_MM_DD_HH_MM_SS, req.getTakeTime())) > 0) {
                //order.setTakeTime(null);
                order.setTakeType(TakeTypeEnum.APPOINTMENT_2.type);
            } else {
                order.setTakeTime(DateUtils.dateTime(DateUtils.YYYY_MM_DD_HH_MM_SS, req.getTakeTime()));
            }
        }

        BigDecimal tip = BigDecimal.ZERO;
        if (req.getTipAmount() != null && req.getTipAmount().compareTo(BigDecimal.ZERO) > 0) {
            order.setUseTip(StatusEnum.SHOW.status);
            tip = req.getTipAmount();
            order.setTipAmount(tip);
        }

        //发单算钱
        List<ValuationRes> resList = req.getValuationRes();
        List<ValuationRes> maxReslIst = new ArrayList<>();
        if (couponDto != null) {
            for (ValuationRes res : resList) {
                if (couponDto.getType().equals(CouponTypeEnum.MAN_JIAN.type)) {
                    if (res.getDeliveryAmount().compareTo(couponDto.getLimitFee()) >= 0 && res.getIsMine() == 0) {
                        res.setDeliveryAmount(res.getDeliveryAmount().subtract(couponDto.getMoney()));
                        res.setCouponAmount(couponDto.getMoney());
                    }
                } else if (couponDto.getType().equals(CouponTypeEnum.LI_JIAN.type) && res.getIsMine() == 0) {
                    res.setDeliveryAmount(res.getDeliveryAmount().subtract(couponDto.getMoney()));
                    res.setCouponAmount(couponDto.getMoney());
                } else if (couponDto.getType().equals(CouponTypeEnum.ZHE_KOU.type) && res.getIsMine() == 0) {
                    BigDecimal discount = res.getDeliveryAmount().multiply(couponDto.getDiscount()).divide(BigDecimal.TEN).setScale(2, BigDecimal.ROUND_HALF_UP);
                    if ((res.getDeliveryAmount().subtract(discount)).compareTo(couponDto.getMaxDiscount()) > 0) {
                        discount = res.getDeliveryAmount().subtract(couponDto.getMaxDiscount());
                    } else {
                        discount = res.getDeliveryAmount().subtract(res.getDeliveryAmount().subtract(discount));
                    }
                    res.setCouponAmount(res.getDeliveryAmount().subtract(discount));
                    res.setDeliveryAmount(discount);
                }
            }
        }
        // 默认没有选择绑定三方运力下单
        List<Long> deliveryIds = new ArrayList<>();
        for (ValuationRes r : resList) {
            if (r.getIsMine() == 0) {
                maxReslIst.add(r);
            }
            if (r.getIsMine() == 1) {
                // 自运力
                deliveryIds.add(r.getDeliveryId());
            }
        }
        Optional<ValuationRes> max = null;
        // false用我们平台支付，true用用户自己绑定三方平台支付
        boolean isMine = false;
        if (maxReslIst != null && maxReslIst.size() > 0) {
            max = maxReslIst.stream().max(Comparator.comparing(ValuationRes::getDeliveryAmount));
        } else {
            max = resList.stream().max(Comparator.comparing(ValuationRes::getDeliveryAmount));
            isMine = true;
        }
        if (order.getWaimaiOrderId() != null) {
            getWaiMaiInfo(order, req);
        } else {
            this.setOrderSource(order, req);
        }
        //金额折扣
        BigDecimal deliveryAmount = max.get().getDeliveryAmount();//取最高价
        // req.setOrderSn(max.get().getOrderSn());
        order.setOrderSn(max.get().getOrderNo());
        //计算优惠券
        order.setTotalAmount(deliveryAmount.add(tip));
        order.setMaxAmount(deliveryAmount.add(tip));
        order.setCouponAmount(BigDecimal.ZERO);
        if (couponDto != null && !isDadaOrder) {
            if (couponDto.getType().equals(CouponTypeEnum.MAN_JIAN.type)) {
                if (order.getTotalAmount().compareTo(couponDto.getLimitFee()) >= 0 && !isMine) {
                    order.setCouponAmount(couponDto.getMoney());
                    order.setCouponId(Long.valueOf(couponDto.getId()));
                    couponDto.setStatus(MemberCouponStatusEnum.USED.getStatus());
                }
            } else if (couponDto.getType().equals(CouponTypeEnum.LI_JIAN.type) && !isMine) {
                order.setCouponAmount(couponDto.getMoney());
                order.setCouponId(Long.valueOf(couponDto.getId()));
                couponDto.setStatus(MemberCouponStatusEnum.USED.getStatus());
            } else if (couponDto.getType().equals(CouponTypeEnum.ZHE_KOU.type) && !isMine) {
                BigDecimal discount = order.getTotalAmount().multiply(couponDto.getDiscount()).divide(BigDecimal.TEN).setScale(2, BigDecimal.ROUND_HALF_UP);
                if ((order.getTotalAmount().subtract(discount)).compareTo(couponDto.getMaxDiscount()) > 0) {
                    discount = order.getTotalAmount().subtract(couponDto.getMaxDiscount());
                }
                order.setCouponAmount(order.getTotalAmount().subtract(discount));
                order.setCouponId(Long.valueOf(couponDto.getId()));
                couponDto.setStatus(MemberCouponStatusEnum.USED.getStatus());
            }
        }

//        // 此处是判断货拉拉下单不享受新人优惠, 前端请求接口外卖单未传transport字段
//        Integer deliveryType = null;
//        if (CollectionUtils.isNotEmpty(resList)) {
//            deliveryType = resList.get(0).getDeliveryType();
//        }
        BigDecimal firstCoupon = BigDecimal.ZERO;//取消新人首单立减
//        if (!isMine && !DeliveryTypeEnums.HUO_LA_LA.getType().equals(deliveryType) && !isDadaOrder) {
//            //新用户只要没有产生过订单数据的算首单，并且是用平台支付
//            List<Order> orderList;
//            if (member.getShopId() != null) {
//                orderList = iOrderService.list(new QueryWrapper<Order>().eq("shop_id", member.getShopId()).eq("status", PayStatusEnum.PAYED.status));
//            } else {
//                orderList = iOrderService.list(new QueryWrapper<Order>().eq("member_id", loginId).eq("status", PayStatusEnum.PAYED.status));
//            }
//            if (CollectionUtils.isEmpty(orderList)) {
//                String configValue = iSysConfigService.selectConfigByKey("NEW_COMERS");
//                firstCoupon = new BigDecimal(configValue);
//            }
//        }
        order.setFirstCoupon(firstCoupon);
        order.setPayAmount(order.getTotalAmount().subtract(firstCoupon));

        if (order.getCouponAmount().compareTo(order.getTotalAmount().add(order.getCouponAmount())) > 0) {
            order.setPayAmount(BigDecimal.ZERO);
            order.setCommission(BigDecimal.ZERO);
        } else if (order.getPayAmount().compareTo(BigDecimal.ZERO) < 0) {
            order.setPayAmount(BigDecimal.ZERO);
        } else {
            //代理商佣金
            order.setCommission(max.get().getCommission());
        }
        if (order.getDadaDspType() != null) {
            order.setCommission(BigDecimal.ZERO);
        }
        // 非自运力下单、或自运力达达收付配送商下单, 校验猎豹账户余额
        if ((!isMine || isDadaRapDelivery) && order.getPayAmount().compareTo(member.getAmount()) > 0 && PaymentTypeEnum.BALANCE.type.equals(req.getPaymentType())) {
            // 余额不足推送消息通知
            checkAmount(member.getId());
            log.error("余额不足, memberId: {}, orderSn: {}", member.getId(), order.getOrderSn());
//            throw new CustomAppException(ExceptionEnum.AMOUNT_ERROR);
            return "amount_not_enough";
        }
        // 下单运力中含有自运力校验账户余额, 达达配送商模式无需校验
        if (deliveryIds.size() > 0 && isMine && !isDadaOrder) {
            checkMemberAmount(member, deliveryIds);
        }
        //下单
        req.setProduct(product);
        order.setMerchantId(member.getMerchantId());
        if (!isDadaOrder) {
            if (member.getAgentId() != null) {
                order.setAgentId(member.getAgentId());
                order.setAgentIdSource(member.getAgentSource());
                if (member.getPersonnelId() != null) {
                    order.setPersonnelId(member.getPersonnelId());
                }
            } else {
                // 判断区域,只给一级代理商
                Agent agent = iAgentService.findByArea(order.getSendCityName(), order.getSendDistrictName());
                if (agent != null) {
                    order.setAgentId(agent.getId());
                    order.setAgentIdSource(AgentSourceEnum.QU_YU.status);
                }
            }
        }
        if (isMine && PaymentTypeEnum.BALANCE.type.equals(req.getPaymentType()) && !isDadaRapDelivery) {
            order.setPaymentType(PaymentTypeEnum.LOCAL.type);
        } else if ((!isMine || isDadaRapDelivery) && PaymentTypeEnum.BALANCE.type.equals(req.getPaymentType())) {
            order.setPaymentType(PaymentTypeEnum.BALANCE.type);
        } else {
            order.setPaymentType(req.getPaymentType());
        }
        Object resp = "ok";
        BigDecimal payAmount = order.getPayAmount().setScale(2, BigDecimal.ROUND_HALF_UP);
        if (PaymentTypeEnum.BALANCE.type.equals(req.getPaymentType()) && isMine) {
            order.setStatus(PayStatusEnum.PAYED.status);
            order.setDeliveryStatus(DeliveryStatusEnum.ORDERS_TO_BE_RECEIVED.status);
        }
        if (PaymentTypeEnum.BALANCE.type.equals(req.getPaymentType()) && (!isMine || isDadaRapDelivery)) {
            order.setStatus(PayStatusEnum.PAYED.status);
            order.setDeliveryStatus(DeliveryStatusEnum.ORDERS_TO_BE_RECEIVED.status);
            // 判断余额是否低于50/100
            checkAmount(member.getId());
        } else if (PaymentTypeEnum.ZHI_FU_BAO.type.equals(req.getPaymentType()) && order.getPayAmount().compareTo(BigDecimal.ZERO) > 0) {
            // PC下单
            if (req.getCreateType() != null && req.getCreateType() == 1) {
                resp = apiOrderService.getPaymentQRCode(payAmount, order.getOrderSn(), PaymentTypeEnum.ZHI_FU_BAO.type);
            } else {
                // APP下单
                order.setDeliveryStatus(DeliveryStatusEnum.ORDERS_TO_BE_BILLED.status);
                order.setStatus(PayStatusEnum.NO_PAYED.status);
                resp = aliPayService.pay(order.getOrderSn(), payAmount.toString(), order.getOrderSn());
            }
        } else if (PaymentTypeEnum.WEI_XIN.type.equals(req.getPaymentType()) && order.getPayAmount().compareTo(BigDecimal.ZERO) > 0) {
            // PC下单
            if (req.getCreateType() != null && req.getCreateType() == 1) {
                resp = apiOrderService.getPaymentQRCode(payAmount, order.getOrderSn(), PaymentTypeEnum.WEI_XIN.type);
            } else {
                // APP下单
                order.setDeliveryStatus(DeliveryStatusEnum.ORDERS_TO_BE_BILLED.status);
                order.setStatus(PayStatusEnum.NO_PAYED.status);
                OrderPaySignResponse.WechatPayParam respon = null;
                try {
                    respon = wechatPayService.pay(payAmount, order.getOrderSn(), order.getOrderSn(), TradeType.APP);
                } catch (WxPayException e) {
                   // e.printStackTrace();
                }
                resp = JSONObject.toJSONString(respon);
            }
        }
        if (payAmount.compareTo(BigDecimal.ZERO) == 0) {
            order.setStatus(PayStatusEnum.PAYED.status);
            order.setDeliveryStatus(DeliveryStatusEnum.ORDERS_TO_BE_RECEIVED.status);
        }
        if (order.getPayAmount().compareTo(BigDecimal.ZERO) > 0) {
            paymentService.savePayment(order.getMemberId(), order.getOrderSn(), order.getPayAmount(), req.getPaymentType(), TradeTypeEnum.ORDER.type, JSONObject.toJSONString(resList), order.getOrderSn());
        }
        order.setRefundMoney(BigDecimal.ZERO);
        // 设置外卖平台, 订单流水号
        if ((order.getShopId() != null || order.getMemberId() != null) && req.getPlatformType() != null) {
            if (req.getPlatformType() != 0 && req.getDaySeq() == null) {
                throw new CustomAppException("流水号不能为空!");
            }
            if (req.getPlatformType() == 0) {
                // 猎豹平台生成流水号
                String daySeq = this.getLieBaoDaySeq(order.getShopId(), order.getMemberId());
                req.setDaySeq(daySeq);
            }
            order.setPlatformType(req.getPlatformType());
            order.setLbDaySeq(req.getDaySeq());
        }
        if (order.getId() != null) {
            iOrderService.updateById(order);
        } else {
            iOrderService.save(order);
        }
        // 达达收付配送商计价明细入库
        if (isDadaRapDelivery) {
            OrderFreight orderFreight = new OrderFreight();
            BeanUtil.copyProperties(orderFreightDto, orderFreight);
            orderFreight.setOrderId(order.getId());
            iOrderFreightService.save(orderFreight);
        }

        // iOrderLogService.addOrderLog(order.getId(), OrderStatusEnum.ORDER_CREATE.status);
        iOrderLogService.addOrderLog(order.getId(), OrderStatusEnum.NO_PAYED.status);
        if (PaymentTypeEnum.BALANCE.type.equals(req.getPaymentType())) {

            iOrderLogService.addOrderLog(order.getId(), OrderStatusEnum.PAYED.status);
            iOrderLogService.addOrderLog(order.getId(), OrderStatusEnum.ORDERS_TO_BE_RECEIVED.status);
            if (!isMine || isDadaRapDelivery) {
                //扣款
                iMemberService.updateAmount(member.getId(), payAmount.negate());
                //扣款记录
                iMemberBalanceLogService.saveLog(loginId, LogTypeEnum.REDUCE.type, "下单支付", LogSourceEnum.CONSUMPTION.status, order.getPayAmount(), member.getMerchantId(), order.getId(), order.getPaymentType());
            }
        }
        if (PaymentTypeEnum.BALANCE.type.equals(req.getPaymentType()) || payAmount.compareTo(BigDecimal.ZERO) == 0) {
            //更改优惠券状态
            apiCouponService.updateCoupon(couponDto);
            // 发单
            if (CollectionUtils.isNotEmpty(resList)) {
                //   order.setProduct(product);
                CouponDto finalCouponDto = couponDto;
                TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                    @Override
                    public void afterCommit() {
                        applicationContext.publishEvent(new DeliveryOrderEvent(order, resList, finalCouponDto));
                    }
                });
            }
        }
        return resp;
//        }catch (Exception e){
//            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//            log.error("下单异常",e);
//            return null;
//        }
    }

    private void setOrderSource(Order order, OrderReq req) {
        Integer platformType = req.getPlatformType();
        if (platformType != null && platformType > 0) {
            order.setPoiSeq(req.getDaySeq());
            // 美团、美团闪购
            if (platformType == 1 || platformType == 5) {
                order.setOrderSource("101");
            } else if (platformType == 2) {
                // 饿了么
                order.setOrderSource("102");
            } else if (platformType == 3) {
                // 饿百零售
                order.setOrderSource("103");
            }
        }
    }

    private String getLieBaoDaySeq(Long shopId, Long memberId) {
        int daySeq = 1;
        String memberKey = RedisKeyConstant.MEMBER_DAY_SEQ + DateUtils.getDate() + ":member_id:" + memberId;
        Boolean hasMemberKey = redisCache.hasKey(memberKey);
        if (shopId == null) {
            if (hasMemberKey) {
                daySeq = redisCache.increment(memberKey).intValue();
            } else {
                // 36小时后过期自动清除
                redisCache.setCacheObject(memberKey, daySeq, 36, TimeUnit.HOURS);
            }
        } else {
            String shopKey = RedisKeyConstant.SHOP_DAY_SEQ + DateUtils.getDate() + ":shop_id:" + shopId;
            if (redisCache.hasKey(shopKey)) {
                daySeq = redisCache.increment(shopKey).intValue();
            } else {
                // 个人申请成为门店账号, 订单流水号不间断
                if (hasMemberKey) {
                    daySeq = redisCache.increment(memberKey).intValue();
                }
                // 36小时后过期自动清除
                redisCache.setCacheObject(shopKey, daySeq, 36, TimeUnit.HOURS);
            }
        }
        return Integer.toString(daySeq);
    }


    private Order createOrder(Product product, CouponDto couponDto, OrderReq req, Long memberId) {
        Order order = new Order();
        if (req.getOrderId() != null) {
            order = iOrderService.getById(req.getOrderId());
            order.setPersonnelId(null);
            if (order.getWaimaiOrderId() == null) {
                order.setProductAmount(req.getProductAmount());
                order.setTakeType(req.getTakeType());
                order.setTakeRemark(req.getTakeRemark());
            } else {
                if (StringUtils.isNotBlank(req.getTakeRemark())) {
                    order.setTakeRemark(req.getTakeRemark());
                }
            }
            return order;
        }
        order.setMemberId(memberId);
        order.setWeight(req.getWeight());
        order.setTakeType(req.getTakeType());
        order.setTakeDate(DateUtils.parseDate(req.getTakeTime()));
        order.setTakeTime(DateUtils.parseDate(req.getTakeTime()));
        order.setTakeRemark(req.getTakeRemark());
        order.setDeliveryType(req.getDeliveryType());
        order.setPreDeliveryIds(req.getPreDeliveryIds());
        order.setOrderSn(req.getOrderNo());
        order.setProductId(product.getId());
        order.setProductName(product.getName());
        order.setCouponAmount(BigDecimal.ZERO);
        order.setTaxpayerId(req.getTaxpayerId());
        order.setInvoiceTitle(req.getInvoiceTitle());
        //  order.setProduct(product);
        Long shopId = req.getShopId();
        if (shopId == null) {
            Member member = iMemberService.getById(memberId);
            if (member.getShopId() != null) {
                shopId = member.getShopId();
                order.setDefaultShop(DefaultShopEnum.SHOW.status);
            }
        }
        order.setShopId(shopId);

        if (couponDto != null) {
            order.setCouponAmount(couponDto.getMoney());
            order.setCouponId(Long.valueOf(couponDto.getId()));
        }
        AddressReq sendAddress = req.getSendAddress();
        AddressReq receiveAddress = req.getReceiptAddress();
        if (StringUtils.isNotBlank(sendAddress.getStreet())) {
            order.setSendStreet(sendAddress.getStreet());
        }
        order.setSendAddress(sendAddress.getAddress());
        order.setSendAddressId(sendAddress.getId());
        order.setSendCityName(sendAddress.getCityName());
        order.setSendContactName(sendAddress.getContact());
        order.setSendPhone(sendAddress.getPhone());
        order.setSendExtension(sendAddress.getExtension());
        order.setSendDistrictName((String) sendAddress.getDistrictName());
        order.setSendProvinceName(sendAddress.getProvinceName());
        order.setSendLat(sendAddress.getLat());
        order.setSendLng(sendAddress.getLng());
        order.setSendCityCode(sendAddress.getCityCode());
        if (StringUtils.isNotBlank(receiveAddress.getStreet())) {
            order.setReceiptStreet(receiveAddress.getStreet());
        }
        order.setReceiptAddress(receiveAddress.getAddress());
        order.setReceiptAddressId(receiveAddress.getId());
        order.setReceiptCityName(receiveAddress.getCityName());
        order.setReceiptContactName(receiveAddress.getContact());
        order.setReceiptPhone(receiveAddress.getPhone());
        order.setReceiptExtension(receiveAddress.getExtension());
        order.setReceiptDistrictName((String) receiveAddress.getDistrictName());
        order.setReceiptProvinceName(receiveAddress.getProvinceName());
        order.setReceiptLat(receiveAddress.getLat());
        order.setReceiptLng(receiveAddress.getLng());
        order.setReceiptCityCode(receiveAddress.getCityCode());
        if (order.getWaimaiOrderId() != null) {
            order.setWaimaiOrderId(order.getWaimaiOrderId());
        } else {
            order.setWaimaiOrderId(req.getWaimaiOrderId());
        }
        order.setProductAmount(req.getProductAmount());
        return order;
    }

    @Override
    public void refund(String orderNo, BigDecimal refundMoney, String remark, Long memberId, Long merchantId) {
        Order order = iOrderService.getOne(new QueryWrapper<Order>().eq("order_sn", orderNo).eq("deleted", IsDeleteEnum.NORMAL.status));
        Member member = iMemberService.getById(memberId);
        if (member.getMemberType().equals(MemberTypeEnum.SHOP.type)) {
            member = iMemberService.getOne(new QueryWrapper<Member>().eq("member_type", MemberTypeEnum.MERCHANT.type).eq("merchant_id", member.getMerchantId()));
        }
        if (PaymentTypeEnum.BALANCE.type.equals(order.getPaymentType())) {
            iMemberService.updateAmount(member.getId(), refundMoney);
        } else if (PaymentTypeEnum.ZHI_FU_BAO.type.equals(order.getPaymentType())) {
            aliPayService.alipayRefundRequest(orderNo, refundMoney.doubleValue());
        } else if (PaymentTypeEnum.WEI_XIN.type.equals(order.getPaymentType())) {
            Payment payment = paymentService.getOne(new QueryWrapper<Payment>().eq("child_order_sn", orderNo).eq("payment_type", PaymentTypeEnum.WEI_XIN.type));
            wechatPayService.refund(orderNo, payment.getTotalAmount(), refundMoney, "");
        }
        iMemberBalanceLogService.saveLog(memberId, LogTypeEnum.INCREASE.type, remark, LogSourceEnum.REFUND.status, refundMoney, merchantId, order.getId(), order.getPaymentType());
        // 是否需要退服务费-绑定三方运力下单
        if (order.getBindFee().compareTo(BigDecimal.ZERO) == 1) {
            iMemberService.updateAmount(member.getId(), order.getBindFee());
            iMemberBalanceLogService.saveLog(memberId, LogTypeEnum.INCREASE.type, "订单取消,服务费退款", LogSourceEnum.REFUND.status, order.getBindFee(), merchantId, order.getId(), order.getPaymentType());
        }
    }

    public void refundTip(List<OrderTip> orderTips, String remark, Long memberId, Long merchantId) {
        BigDecimal tips = orderTips.stream().map(OrderTip::getAmount).reduce(BigDecimal.ZERO, BigDecimalUtils::sum);
        Member member = iMemberService.getById(memberId);
        if (member.getMemberType().equals(MemberTypeEnum.SHOP.type)) {
            member = iMemberService.getOne(new QueryWrapper<Member>().eq("member_type", MemberTypeEnum.MERCHANT.type).eq("merchant_id", member.getMerchantId()));
        }
        for (OrderTip orderTip : orderTips) {
            if (PaymentTypeEnum.BALANCE.type.equals(orderTip.getPayType())) {
                iMemberService.updateAmount(member.getId(), orderTip.getAmount());
            } else if (PaymentTypeEnum.ZHI_FU_BAO.type.equals(orderTip.getPayType())) {
                aliPayService.alipayRefundRequest(orderTip.getChildOrderNo(), orderTip.getAmount().doubleValue());
            } else if (PaymentTypeEnum.WEI_XIN.type.equals(orderTip.getPayType())) {
                wechatPayService.refund(orderTip.getChildOrderNo(), orderTip.getTotalAmout(), orderTip.getAmount(), "");
            }
        }
        if (tips.compareTo(BigDecimal.ZERO) > 0) {
            iMemberBalanceLogService.saveLog(memberId, LogTypeEnum.INCREASE.type, remark, LogSourceEnum.REFUND.status, tips, merchantId, Long.valueOf(orderTips.get(0).getOrderId()), orderTips.get(0).getPayType());
        }
    }

    @Override
    public void getWaiMaiInfo(Order order, OrderReq req) {
        WaimaiOrder waimaiOrder = iWaimaiOrderService.findById(order.getWaimaiOrderId());
        req.setAmount(waimaiOrder.getTotalPrice());
        order.setWmAmount(waimaiOrder.getTotalPrice());
        order.setShopId(waimaiOrder.getShopId());
        String remark = waimaiOrder.getCaution();
        req.setWaiMaiRemark(remark);
        order.setWaiMaiRemark(remark);
//        if (StringUtils.isNotBlank(remark) && remark.contains("收餐人隐私号")) {
//            remark = remark.substring(0, waimaiOrder.getCaution().indexOf("收餐人隐私号"));
//        }
//        if(StringUtils.isNotBlank(order.getTakeRemark())&&!order.getTakeRemark().equals(remark)){
//            remark = "【"+order.getTakeRemark()+"】" + remark;
//        }
//        if(StringUtils.isNotBlank(remark)&&remark.length()>200){
//            remark = remark.substring(0,200);
//        }
//        order.setTakeRemark(remark);

//        if (waimaiOrder.getCaution().contains("收餐人隐私号")){
//            order.setTakeRemark(waimaiOrder.getCaution().substring(0,waimaiOrder.getCaution().indexOf("收餐人隐私号")));
//        }else {
//            order.setTakeRemark(waimaiOrder.getCaution());
//        }

        if (DefaultShopEnum.SHOW.status.equals(order.getDefaultShop())) {
            order.setDefaultShop(DefaultShopEnum.STOP.status);
        }
        //order.setShopName(waimaiOrder.getPoiName());
        order.setPoiSeq(waimaiOrder.getDaySeq());
        order.setOrderingSourceNo(waimaiOrder.getOutOrderId());
        if (waimaiOrder.getOrderType().equals(WaimaiTypeEnums.MEI_TUAN.getType())) {
            order.setOrderSource("101");
        } else if (waimaiOrder.getOrderType().equals(WaimaiTypeEnums.E_LE_ME.getType())) {
            // 饿了么
            order.setOrderSource("102");
        } else if (waimaiOrder.getOrderType().equals(WaimaiTypeEnums.E_LE_ME_RETAIL.getType())) {
            // 饿百
            order.setOrderSource("103");
        }else if (waimaiOrder.getOrderType().equals(WaimaiOrderTypeEnum.MEI_TUAN_SG.getType())) {
            order.setOrderSource("101");
        }
        order.setPoiSeq(waimaiOrder.getDaySeq());
        // 外卖商品信息
        List<WaimaiOrderDetail> waiMaiOrderDetails = iWaimaiOrderDetailService.findList(order.getWaimaiOrderId());
        order.setWaimaiOrderDetails(waiMaiOrderDetails);
    }

    /**
     * 校验用户绑定三方运力，下单机制（这里校验的都是商家）
     */
    @Transactional(rollbackFor = Exception.class)
    public void checkMemberAmount(Member member, List<Long> deliveryIds) {
        if (member.getMerchantId() == null) {
            return;
        }
        MerchantDeliveryFee fee = iMerchantDeliveryFeeService.getByMerchantAndDeliveryIds(member.getMerchantId(), deliveryIds);
        if (fee == null) {
            return;
        }
        if (member.getAmount().compareTo(fee.getAmount()) == -1) {
            log.warn("选择运力为绑定运力，当前余额少于服务费，请充值后再下单！deliveryId: {}", fee.getDeliveryId());
            throw new CustomAppException("选择运力为绑定运力，当前余额少于服务费，请充值后再下单！", 250);
        }
    }

    @Override
    public boolean addRemark(Long orderId, String remark) {
        Order order = new Order();
        order.setTakeRemark(remark);
        order.setId(orderId);
        return iOrderService.updateById(order);
    }

    private void address(OrderReq req) {
        String sendAddress = req.getSendAddress().getAddress();
        String sendStreet = req.getSendAddress().getStreet();
        String receiptAddress = req.getReceiptAddress().getAddress();
        String receiptStreet = req.getReceiptAddress().getStreet();
        if (StringUtils.isNotBlank(sendStreet) && sendAddress.endsWith(sendStreet)) {
            req.getSendAddress().setAddress(sendAddress.substring(0, sendAddress.lastIndexOf(sendStreet)));
        }
        if (StringUtils.isNotBlank(receiptStreet) && receiptAddress.endsWith(receiptStreet)) {
            req.getReceiptAddress().setAddress(receiptAddress.substring(0, receiptAddress.lastIndexOf(receiptStreet)));
        }
    }


    private void resetOrder(Order order, Product product) {
        order.setId(null);
        order.setRefundMoney(BigDecimal.ZERO);
        order.setOutTradeNo("");
        order.setTakeDate(null);
        order.setDeliveryId(null);
        order.setDeliveryLogo("");
        order.setDeliveryName("");
        order.setDeliveryTime(null);
        order.setShipperName("");
        order.setShipperPhone("");
        order.setShipperLat(null);
        order.setShipperLng(null);
        order.setStatus(PayStatusEnum.NO_PAYED.status);
        order.setDeliveryStatus(null);
        order.setPaymentType(null);
        order.setCouponId(null);
        order.setCouponAmount(null);
        //order.setProduct(product);
        order.setCancelReason("");
        order.setTipAmount(null);
        order.setFirstCoupon(null);
        order.setUseTip(0);
        order.setTakeTime(new Date());
//        order.setTakeType(null);
        order.setProductId(product.getId());
        order.setProductName(product.getName());
        order.setBindFee(BigDecimal.ZERO);
        order.setCancelType(null);
    }

    /**
     * 判断用户余额
     *
     * @param memberId
     */
    public void checkAmount(Long memberId) {
        Member member = iMemberService.getById(memberId);
        if (member.getMerchantId() != null) {
            List<Member> members = iMemberService.selectListByMerchantId(member.getMerchantId().intValue());
            List<Long> mIds = new ArrayList<>();
            log.info("推送用户===" + JSONObject.toJSONString(members));
            if (member.getAmount().compareTo(new BigDecimal(50)) < 0) {
                // 自动配送关闭,关闭该商家的所有门店
                for (Member m : members) {
                    // 判断用户是否开启自配送
//                    MemberConfigDto memberConfigDto = iMemberConfigService.findDetail(m.getId());
//                    if (memberConfigDto == null || memberConfigDto.getOpenAutodelivery().equals(0)){
//                        continue;
//                    }
//                    MemberConfig memberConfig = iMemberConfigService.getById(memberConfigDto.getId());
//                    memberConfig.setOpenAutodelivery(0);
//                    iMemberConfigService.updateById(memberConfig);
                    mIds.add(m.getId());
                }
                // 发推送
                if (CollectionUtils.isNotEmpty(mIds)) {
                    messagePushService.memberAmountMessage(mIds, "您的平台余额低于50元", "您的平台余额已不足50元，可能导致自动发单失败，请及时充值！", 1);
                }
                return;
            }
            if (member.getAmount().compareTo(new BigDecimal(100)) < 0) {
                for (Member m : members) {
                    mIds.add(m.getId());
                }
                // 发推送
                if (CollectionUtils.isNotEmpty(mIds)) {
                    messagePushService.memberAmountMessage(mIds, "您的平台余额低于100元", "您的平台余额已不足100元，可能导致自动发单失败，请及时充值！", 2);
                }
            }
        }
    }
}