package com.panzhihua.service_community.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.panzhihua.common.constants.PayCpmstant;
import com.panzhihua.common.model.dtos.shop.WxPayNotifyOrderDTO;
import com.panzhihua.common.model.vos.common.ComBatteryCommodityOrderVo;
import com.panzhihua.common.model.vos.common.ComBatteryCommoditySpecsVo;
import com.panzhihua.common.model.vos.common.ComBatteryCommodityVo;
import com.panzhihua.common.model.vos.common.ComBatteryUserAddressVo;
import com.panzhihua.common.utlis.DateUtils;
import com.panzhihua.common.utlis.Snowflake;
import com.panzhihua.common.utlis.WxPayUtils;
import com.panzhihua.service_community.dao.*;
import com.panzhihua.service_community.entity.*;
import com.panzhihua.service_community.service.ComBatteryCommodityOrderService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.panzhihua.service_community.service.ComBatteryTradeOrderService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import com.panzhihua.common.model.dtos.common.*;
import com.panzhihua.common.model.vos.R;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * title: 电动车商城-订单表表服务实现类
 * <p>
 * projectName 成都呐喊信息技术有限公司-智慧社区项目
 * <p>
 * description: 电动车商城-订单表表服务实现类
 *
 * @author lyq
 * @date 2022-03-29 16:05:48
 */
@Slf4j
@Service("comBatteryCommodityOrderService")
public class ComBatteryCommodityOrderServiceImpl extends ServiceImpl<ComBatteryCommodityOrderMapper, ComBatteryCommodityOrder> implements ComBatteryCommodityOrderService {

    @Resource
    private ComBatteryCommodityMapper commodityMapper;
    @Resource
    private ComBatteryCommoditySpecsMapper commoditySpecsMapper;
    @Resource
    private ComBatteryUserAddressMapper userAddressMapper;
    @Resource
    private SysUserMapper userMapper;
    @Resource
    private ComBatteryTradeOrderService tradeOrderService;
    @Value("${min.app.isTest}")
    private Boolean isTest;
    @Value("${min.app.appid}")
    private String appid;
    @Value("${min.app.payKey}")
    private String payKey;
    @Value("${min.app.mchId}")
    private String mchId;
//    @Value("${min.app.currencyNotifyUrl}")
//    private String currencyNotifyUrl;
    @Resource
    private ComBatteryCommodityOrderCollageTeamMapper orderCollageTeamMapper;
    @Resource
    private ComBatteryCommodityOrderCollageTeamPeopleMapper orderCollageTeamPeopleMapper;
    @Resource
    private ComBatteryCommodityActivityMapper commodityActivityMapper;
    @Resource
    private ComBatteryCommodityOrderBargainMapper orderBargainMapper;

    /**
     * description  queryByPage  分页查询
     *
     * @param comBatteryCommodityOrder 请求参数
     * @return 分页查询列表数据
     * @author lyq
     * @date 2022-03-29 16:05:48
     */
    @Override
    public R queryByPage(PageComBatteryCommodityOrderDto comBatteryCommodityOrder) {
        return R.ok(this.baseMapper.queryAllByLimit(comBatteryCommodityOrder, new Page(comBatteryCommodityOrder.getPageNum(), comBatteryCommodityOrder.getPageSize())));
    }

    /**
     * description  insert  新增数据
     *
     * @param comBatteryCommodityOrder 请求参数
     * @return 新增结果
     * @author lyq
     * @date 2022-03-29 16:05:48
     */
    @Override
    public R insert(AddComBatteryCommodityOrderDto comBatteryCommodityOrder) {
        ComBatteryCommodityOrder entity = new ComBatteryCommodityOrder();
        BeanUtils.copyProperties(comBatteryCommodityOrder, entity);
        if (this.baseMapper.insert(entity) > 0) {
            return R.ok();
        }
        return R.fail("添加失败");
    }

    /**
     * description  update  修改数据
     *
     * @param editDto 请求参数
     * @return 修改结果
     * @author lyq
     * @date 2022-03-29 16:05:48
     */
    @Override
    public R update(EditComBatteryCommodityOrderDto editDto) {
        ComBatteryCommodityOrder entity = this.baseMapper.selectById(editDto.getId());
        if (entity == null) {
            return R.fail("未查询到该记录");
        }
        BeanUtils.copyProperties(editDto, entity);
        if (this.baseMapper.updateById(entity) > 0) {
            return R.ok();
        }
        return R.fail("修改失败");
    }

    /**
     * description  deleteById  通过主键删除数据
     *
     * @param id 主键id
     * @return 删除结果
     * @author lyq
     * @date 2022-03-29 16:05:48
     */
    @Override
    public R deleteById(Long id) {
        ComBatteryCommodityOrder entity = new ComBatteryCommodityOrder();
        entity.setId(id);
        entity.setIsDel(ComBatteryCommodityOrder.IsDel.YES);
        if (this.baseMapper.updateById(entity) > 0) {
            return R.ok();
        }
        return R.fail("删除失败");
    }

    /**
     * description  detailById  查询详情
     *
     * @param id 主键id
     * @return 详情数据
     * @author lyq
     * @date 2022-03-29 16:05:48
     */
    @Override
    public R detailById(Long id) {
        ComBatteryCommodityOrderVo commodityOrderVo = this.baseMapper.queryById(id);
        if (commodityOrderVo != null) {
            //查询商品信息
            ComBatteryCommodityVo commodityVo = commodityMapper.queryById(commodityOrderVo.getCommodityId());
            commodityOrderVo.setCommodityVo(commodityVo);
            //查询商品规格信息
            ComBatteryCommoditySpecsVo commoditySpecsVo = commoditySpecsMapper.queryById(commodityOrderVo.getSpecsId());
            commodityOrderVo.setCommoditySpecsVo(commoditySpecsVo);
            //查询用户收货地址
            ComBatteryUserAddressVo userAddressVo = userAddressMapper.queryById(commodityOrderVo.getAddressId());
            commodityOrderVo.setUserAddressVo(userAddressVo);
        }
        return R.ok(commodityOrderVo);
    }

    /**
     * description  queryByPage  查询列表
     *
     * @param comBatteryCommodityOrder 请求参数
     * @return 列表数据
     * @author lyq
     * @date 2022-03-29 16:05:48
     */
    @Override
    public R queryByList(PageComBatteryCommodityOrderDto comBatteryCommodityOrder) {
        return R.ok(this.baseMapper.queryAllByList(comBatteryCommodityOrder));
    }

    /**
     * 修改订单收货地址
     *
     * @param editOrderAddressDto 请求参数
     * @return 修改结果
     */
    @Override
    public R updateOrderAddress(EditOrderAddressDto editOrderAddressDto) {
        ComBatteryCommodityOrder entity = new ComBatteryCommodityOrder();
        BeanUtils.copyProperties(editOrderAddressDto, entity);
        if (this.baseMapper.updateById(entity) > 0) {
            return R.ok();
        }
        return R.fail("修改失败");
    }

    /**
     * 修改订单物流信息
     *
     * @param editOrderLogisticsDto 请求参数
     * @return 修改结果
     */
    @Override
    public R updateOrderLogistics(EditOrderLogisticsDto editOrderLogisticsDto) {
        ComBatteryCommodityOrder entity = new ComBatteryCommodityOrder();
        BeanUtils.copyProperties(editOrderLogisticsDto, entity);
        if (this.baseMapper.updateById(entity) > 0) {
            return R.ok();
        }
        return R.fail("修改失败");
    }

    /**
     * 电动车商城购买商品支付回调
     *
     * @param notifyOrderDTO 请求参数
     * @return 购买商品支付回调
     */
    @Override
    public R batteryPayNotify(WxPayNotifyOrderDTO notifyOrderDTO) {
        Date payTime = DateUtils.stringToDate(notifyOrderDTO.getPayTime(), new SimpleDateFormat("yyyyMMddHHmmss"));
        Date nowDate = new Date();
        String orderNo = notifyOrderDTO.getOrderTradeNo();
        String payNo = notifyOrderDTO.getWxTradeNo();
        BigDecimal cashFee = new BigDecimal(notifyOrderDTO.getCashFee());
        ComBatteryCommodityOrder commodityOrder = this.baseMapper.selectOne(new QueryWrapper<ComBatteryCommodityOrder>().lambda()
                .eq(ComBatteryCommodityOrder::getOrderNo, orderNo));
        if (commodityOrder == null) {
            log.error("用户购买商品订单微信支付回调错误，未查询到支付订单记录，支付订单号：" + orderNo);
            return R.fail("未查询到用户购买商品支付订单记录");
        }
        if (!commodityOrder.getPayStatus().equals(ComBatteryCommodityOrder.PayStatus.WZF)) {
            log.error("用户购买商品订单微信支付回调错误,错误原因：支付订单状态已发生改变，不可重复回调,订单号：" + orderNo);
            return R.fail("支付订单状态已发生改变，不可重复回调");
        }
        //更新订单
        commodityOrder.setStatus(ComBatteryCommodityOrder.Status.DFH);
        commodityOrder.setPayStatus(ComBatteryCommodityOrder.PayStatus.YZF);
        commodityOrder.setPayNo(payNo);
        commodityOrder.setPayAmount(cashFee);
        commodityOrder.setUpdateAt(nowDate);
        commodityOrder.setPayTime(payTime);
        this.baseMapper.updateById(commodityOrder);

        // 更新微信支付流水记录
        tradeOrderService.renewPayTrade(commodityOrder.getId(), cashFee, notifyOrderDTO.getWxTradeNo(), payTime, nowDate);
        return R.ok();
    }

    /**
     * 小程序用户创建订单
     *
     * @param createOrderDto 请求参数
     * @return 创建结果
     */
    @Override
    public R appletsOrderCreate(UserCreateOrderDto createOrderDto) {
        //查询商品
        ComBatteryCommodity commodity = commodityMapper.selectById(createOrderDto.getCommodityId());
        if (commodity == null) {
            return R.fail("未查询到商品信息");
        }
        //查询商品规格信息
        ComBatteryCommoditySpecs commoditySpecs = commoditySpecsMapper.selectById(createOrderDto.getSpecsId());
        if (commoditySpecs == null) {
            return R.fail("未查询到商品规格信息");
        }
        //判断商品库存
        if (commoditySpecs.getStock() < createOrderDto.getCount()) {
            return R.fail("您购买的商品库存不足");
        }
        //查询用户收货地址
        ComBatteryUserAddress userAddress = userAddressMapper.selectById(createOrderDto.getAddressId());
        if (userAddress == null) {
            return R.fail("未查询到用户收货地址");
        }
        //查询用户信息
        SysUser user = userMapper.selectOne(new QueryWrapper<SysUser>().lambda().eq(SysUser::getUserId,createOrderDto.getUserId()));
        if (user == null) {
            return R.fail("未查询到用户信息");
        }
        Date nowDate = new Date();
        //初始化订单信息
        ComBatteryCommodityOrder commodityOrder = getCreateOrder(commodity, userAddress, user, commoditySpecs, createOrderDto, nowDate);
        Map<String, Object> resultMap = new HashMap<>(2);
        if (this.baseMapper.insert(commodityOrder) > 0) {
            //更新商品库存
            commoditySpecs.setStock(commoditySpecs.getStock() - createOrderDto.getCount());
            commoditySpecsMapper.updateById(commoditySpecs);

            //微信支付需要调取小程序微信支付
            String result = getWxPayResult(commodityOrder.getFinalAmount(), commodityOrder.getOpenId(), commodityOrder.getOrderNo(), "购买商品");
            resultMap.put("payResult", result);
            resultMap.put("orderId", commodityOrder.getId());

            // 添加微信支付交易流水
            String wxTradeOrderNo = "wx" + Snowflake.getId();
            tradeOrderService.addOrderTradeRecord(user.getUserId(), user.getOpenid(), wxTradeOrderNo, ComBatteryTradeOrder.PayType.WX,
                    commodityOrder.getFinalAmount(), ComBatteryTradeOrder.TradeType.DDC_SHOP, commodityOrder.getId(),
                    commodityOrder.getOrderNo(), user.getUserId(), nowDate);
        }
        return R.ok(resultMap);
    }

    /**
     * 初始化订单数据
     *
     * @param commodity      商品数据
     * @param userAddress    用户收货地址信息
     * @param user           用户数据
     * @param commoditySpecs 商品规格数据
     * @param createOrderDto 用户请求参数
     * @param nowDate        操作时间
     * @return 初始化订单数据
     */
    public static ComBatteryCommodityOrder getCreateOrder(ComBatteryCommodity commodity, ComBatteryUserAddress userAddress
            , SysUser user, ComBatteryCommoditySpecs commoditySpecs, UserCreateOrderDto createOrderDto, Date nowDate) {
        ComBatteryCommodityOrder commodityOrder = new ComBatteryCommodityOrder();
        commodityOrder.setUserId(user.getUserId());
        commodityOrder.setOpenId(user.getOpenid());
        commodityOrder.setStoreId(commodity.getStoreId());
        commodityOrder.setCommodityId(commodity.getId());
        commodityOrder.setSpecsId(commoditySpecs.getId());
        commodityOrder.setOrderNo("BS" + Snowflake.getId());
        commodityOrder.setStatus(ComBatteryCommodityOrder.Status.DFK);
        commodityOrder.setPayStatus(ComBatteryCommodityOrder.PayStatus.WZF);
        commodityOrder.setIsDel(ComBatteryCommodityOrder.IsDel.NO);
        commodityOrder.setPayType(ComBatteryCommodityOrder.PayType.WX);
        commodityOrder.setCount(createOrderDto.getCount());
        commodityOrder.setPrice(commoditySpecs.getPrice());
        commodityOrder.setAmount(commoditySpecs.getPrice().multiply(BigDecimal.valueOf(createOrderDto.getCount())));
        commodityOrder.setFreight(commodity.getPostage());
        commodityOrder.setFinalAmount(commodityOrder.getAmount().add(commodityOrder.getFreight()));
        commodityOrder.setCreateAt(nowDate);
        commodityOrder.setCreateBy(user.getUserId());
        commodityOrder.setRemark(createOrderDto.getRemark());
        //收货地址
        commodityOrder.setAddressId(userAddress.getId());
        commodityOrder.setReceivingName(userAddress.getName());
        commodityOrder.setReceivingPhone(userAddress.getPhone());
        commodityOrder.setReceivingRegionCode(userAddress.getProvinceAdcode() + "-" + userAddress.getCityAdcode() + "-" + userAddress.getDistrictAdcode());
        commodityOrder.setReceivingRegion(userAddress.getProvinceName() + userAddress.getCityName() + userAddress.getDistrictName());
        commodityOrder.setReceivingAddress(userAddress.getAddress());
        return commodityOrder;
    }

    /**
     * 小程序唤起微信支付
     *
     * @param money   需要支付的金额
     * @param openId  用户唤起微信支付的openid
     * @param orderNo 业务订单号
     * @param remark  交易备注
     * @return 小程序支付参数
     */
    private String getWxPayResult(BigDecimal money, String openId, String orderNo, String remark) {
        String result = "";
        // 将剩余金额调起微信支付
        if (isTest) {
            money = BigDecimal.valueOf(0.01);
        }
        // 调用wx支付
//        result = WxPayUtils.getUnifiedorder(appid, mchId, payKey, currencyNotifyUrl + PayCpmstant.BATTERY_STORE_PAY_NOTIFY_URL
//                , remark, openId, orderNo, money,null);
        log.info("用户购买商品微信支付返回参数:" + result);
        return result;
    }

    /**
     * 定时关闭5分钟未支付订单
     *
     * @return 操作结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R syncCloseOrder() {
        log.info("定时器定时关闭超过5分钟未支付订单，并返回商品库存");
        Date nowDate = new Date();
        //获取当前时间减30分钟时间
        Date oldDate = DateUtils.addMinutes(nowDate, -5);
        List<ComBatteryCommodityOrder> commodityOrderList = this.baseMapper.selectList(new QueryWrapper<ComBatteryCommodityOrder>()
                .lambda().eq(ComBatteryCommodityOrder::getStatus, ComBatteryCommodityOrder.Status.DFK)
                .eq(ComBatteryCommodityOrder::getPayStatus, ComBatteryCommodityOrder.PayStatus.WZF)
                .eq(ComBatteryCommodityOrder::getIsDel, ComBatteryCommodityOrder.IsDel.NO)
                .lt(ComBatteryCommodityOrder::getCreateAt, oldDate));
        commodityOrderList.forEach(commodityOrder -> {
            commodityOrder.setStatus(ComBatteryCommodityOrder.Status.YGB);
            commodityOrder.setUpdateAt(nowDate);
            this.baseMapper.updateById(commodityOrder);
            //归还库存
            ComBatteryCommoditySpecs commoditySpecs = commoditySpecsMapper.selectById(commodityOrder.getSpecsId());
            if (commoditySpecs != null) {
                commoditySpecs.setStock(commoditySpecs.getStock() + commodityOrder.getCount());
                commoditySpecs.setUpdateAt(nowDate);
                commoditySpecsMapper.updateById(commoditySpecs);
            }
            if(commodityOrder.getActivityId() != null){
                ComBatteryCommodityActivity commodityActivity = commodityActivityMapper.selectById(commodityOrder.getActivityId());
                if(!commodityActivity.getType().equals(ComBatteryCommodityActivity.Type.PT)){
                    commodityActivity.setCommoditySaleNum(commodityActivity.getCommoditySaleNum() - commodityOrder.getCount());
                    commodityActivityMapper.updateById(commodityActivity);
                }
            }
        });
        return R.ok();
    }

    /**
     * 电动车商城用户确认收货
     *
     * @param id     订单id
     * @param userId 用户id
     * @return 确认结果
     */
    @Override
    public R appletsOrderReceiving(Long id, Long userId) {
        ComBatteryCommodityOrder commodityOrder = this.baseMapper.selectById(id);
        if (commodityOrder == null) {
            return R.fail("未查询到订单信息");
        }
        //确认收货
        commodityOrder.setStatus(ComBatteryCommodityOrder.Status.YWC);
        commodityOrder.setReceivingTime(new Date());
        commodityOrder.setUpdateAt(new Date());
        commodityOrder.setUpdateBy(userId);
        if (this.baseMapper.updateById(commodityOrder) > 0) {
            return R.ok();
        }
        return R.fail();
    }

    /**
     * 后台订单发货
     *
     * @param deliverAdminDto 请求参数
     * @return 发货结果
     */
    @Override
    public R orderDeliver(OrderDeliverAdminDto deliverAdminDto) {
        //查询订单
        ComBatteryCommodityOrder commodityOrder = this.baseMapper.selectById(deliverAdminDto.getId());
        if (commodityOrder == null) {
            return R.fail("未查询到订单信息");
        }
        Date nowDate = new Date();
        //判断操作类型
        if (deliverAdminDto.getType().equals(OrderDeliverAdminDto.Type.FH)) {
            commodityOrder.setLogisticsCompany(deliverAdminDto.getLogisticsCompany());
            commodityOrder.setLogisticsNo(deliverAdminDto.getLogisticsNo());
            commodityOrder.setUpdateBy(deliverAdminDto.getUserId());
            commodityOrder.setUpdateAt(nowDate);
            commodityOrder.setDeliveryTime(nowDate);
            commodityOrder.setStatus(ComBatteryCommodityOrder.Status.DSH);
        } else if (deliverAdminDto.getType().equals(OrderDeliverAdminDto.Type.XGWL)) {
            commodityOrder.setLogisticsCompany(deliverAdminDto.getLogisticsCompany());
            commodityOrder.setLogisticsNo(deliverAdminDto.getLogisticsNo());
            commodityOrder.setUpdateBy(deliverAdminDto.getUserId());
            commodityOrder.setUpdateAt(nowDate);
        }
        if (this.baseMapper.updateById(commodityOrder) > 0) {
            return R.ok();
        }
        return R.fail();
    }

    /**
     * 电动车商城购买活动商品支付回调
     *
     * @param notifyOrderDTO 请求参数
     * @return 购买商品支付回调
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public synchronized R batteryActivityPayNotify(WxPayNotifyOrderDTO notifyOrderDTO) {
        Date payTime = DateUtils.stringToDate(notifyOrderDTO.getPayTime(), new SimpleDateFormat("yyyyMMddHHmmss"));
        Date nowDate = new Date();
        String orderNo = notifyOrderDTO.getOrderTradeNo();
        String payNo = notifyOrderDTO.getWxTradeNo();
        BigDecimal cashFee = new BigDecimal(notifyOrderDTO.getCashFee());
        //查询该订单数据
        ComBatteryCommodityOrder commodityOrder = this.baseMapper.selectOne(new QueryWrapper<ComBatteryCommodityOrder>().lambda()
                .eq(ComBatteryCommodityOrder::getOrderNo, orderNo));
        if (commodityOrder == null) {
            log.error("用户购买商品订单微信支付回调错误，未查询到支付订单记录，支付订单号：" + orderNo);
            return R.fail("未查询到用户购买商品支付订单记录");
        }
        if (!commodityOrder.getPayStatus().equals(ComBatteryCommodityOrder.PayStatus.WZF)) {
            log.error("用户购买商品订单微信支付回调错误,错误原因：支付订单状态已发生改变，不可重复回调,订单号：" + orderNo);
            return R.fail("支付订单状态已发生改变，不可重复回调");
        }
        //更新订单
        if (commodityOrder.getActivityId() != null) {
            switch (commodityOrder.getActivityType()) {
                case ComBatteryCommodityOrder.ActivityType.PT:
                    //拼团订单成功支付处理
                    commodityOrder.setCollageStatus(ComBatteryCommodityOrder.CollageStatus.PTZ);
                    commodityOrder.setStatus(ComBatteryCommodityOrder.Status.DPT);
                    ComBatteryCommodityOrderCollageTeam orderCollageTeam = null;
                    if(notifyOrderDTO.getAttach() != null && notifyOrderDTO.getAttach().equals("1")){
                        //用户开团,创建团队信息
                        orderCollageTeam = getOrderCollageTeam(commodityOrder,nowDate);
                        orderCollageTeamMapper.insert(orderCollageTeam);
                        commodityOrder.setTeamId(orderCollageTeam.getId());
                    }else{
                        //用户参团,查询参加的团队信息
                        orderCollageTeam = orderCollageTeamMapper.selectById(commodityOrder.getTeamId());
                    }
                    if(orderCollageTeam != null){
                        //创建用户开团人员记录
                        ComBatteryCommodityOrderCollageTeamPeople orderCollageTeamPeople = getOrderCollageTeamPeople(commodityOrder.getUserId()
                                ,nowDate,orderCollageTeam,notifyOrderDTO.getAttach());
                        orderCollageTeamPeopleMapper.insert(orderCollageTeamPeople);
                    }
                    break;
                case ComBatteryCommodityOrder.ActivityType.KJ:
                    //砍价订单成功支付处理
                    commodityOrder.setBargainStatus(ComBatteryCommodityOrder.BargainStatus.KJZ);
                    commodityOrder.setStatus(ComBatteryCommodityOrder.Status.DKJ);
                    //创建用户发布待砍价记录
                    ComBatteryCommodityOrderBargain orderBargain = getOrderBargain(commodityOrder,nowDate);
                    orderBargainMapper.insert(orderBargain);
                    break;
                case ComBatteryCommodityOrder.ActivityType.MS:
                    commodityOrder.setStatus(ComBatteryCommodityOrder.Status.DFH);
                    break;
                default:
                    break;
            }
        }
        // 更新微信支付流水记录
        tradeOrderService.renewPayTrade(commodityOrder.getId(), cashFee, notifyOrderDTO.getWxTradeNo(), payTime, nowDate);

        commodityOrder.setPayStatus(ComBatteryCommodityOrder.PayStatus.YZF);
        commodityOrder.setPayNo(payNo);
        commodityOrder.setPayAmount(cashFee);
        commodityOrder.setUpdateAt(nowDate);
        commodityOrder.setPayTime(payTime);
        this.baseMapper.updateById(commodityOrder);

        if(commodityOrder.getTeamId() != null){
            //判断当前拼团人员是否已足够成团
            syncAssortedDoughStatus(commodityOrder.getTeamId(),nowDate);
        }
        if(commodityOrder.getActivityId() != null && commodityOrder.getActivityType().equals(ComBatteryCommodityOrder.ActivityType.PT)){
            //判断当前拼团活动是否已完成
            syncAssortedDoughActivityStatus(commodityOrder.getActivityId(),nowDate);
        }
        return R.ok();
    }

    /**
     * 初始化拼团团队数据
     * @param commodityOrder    用户订单数据
     * @param nowDate   操作时间
     * @return  拼团团队数据
     */
    private ComBatteryCommodityOrderCollageTeam getOrderCollageTeam(ComBatteryCommodityOrder commodityOrder,Date nowDate){
        ComBatteryCommodityOrderCollageTeam orderCollageTeam = new ComBatteryCommodityOrderCollageTeam();
        orderCollageTeam.setActivityId(commodityOrder.getActivityId());
        orderCollageTeam.setOrderId(commodityOrder.getId());
        orderCollageTeam.setOrderNo(commodityOrder.getOrderNo());
        orderCollageTeam.setUserId(commodityOrder.getUserId());
        orderCollageTeam.setStatus(ComBatteryCommodityOrderCollageTeam.Status.DDPT);
        orderCollageTeam.setCreateAt(nowDate);
        return orderCollageTeam;
    }

    /**
     * 初始化拼团团队人员数据
     * @param userId    用户id
     * @param nowDate   操作时间
     * @param orderCollageTeam  拼团团队数据
     * @param type  拼团类型（1.开团 2.参团）
     * @return  拼团团队人员数据
     */
    private ComBatteryCommodityOrderCollageTeamPeople getOrderCollageTeamPeople(Long userId
            ,Date nowDate,ComBatteryCommodityOrderCollageTeam orderCollageTeam,String type){
        ComBatteryCommodityOrderCollageTeamPeople orderCollageTeamPeople = new ComBatteryCommodityOrderCollageTeamPeople();
        orderCollageTeamPeople.setUserId(userId);
        orderCollageTeamPeople.setTeamId(orderCollageTeam.getId());
        orderCollageTeamPeople.setHeadUserId(orderCollageTeam.getUserId());
        orderCollageTeamPeople.setType(Integer.parseInt(type));
        orderCollageTeamPeople.setCreateAt(nowDate);
        orderCollageTeamPeople.setCreateBy(userId);
        return orderCollageTeamPeople;
    }

    /**
     * 同步拼团活动状态
     * @param activityId    活动id
     */
    private void syncAssortedDoughActivityStatus(Long activityId,Date nowDate){
        ComBatteryCommodityActivity commodityActivity = commodityActivityMapper.selectById(activityId);
        if(commodityActivity != null){
            //查询该活动已成团数量
            Integer count = orderCollageTeamMapper.selectCount(new QueryWrapper<ComBatteryCommodityOrderCollageTeam>().lambda()
                    .eq(ComBatteryCommodityOrderCollageTeam::getActivityId,activityId)
                    .eq(ComBatteryCommodityOrderCollageTeam::getStatus,ComBatteryCommodityOrderCollageTeam.Status.PTCG));
            if(count >= commodityActivity.getCollageNum()){
                //该活动已达到活动拼团数量，修改为已结束状态
                commodityActivity.setStatus(ComBatteryCommodityActivity.Status.YJS);
                commodityActivity.setUpdateAt(nowDate);
                commodityActivityMapper.updateById(commodityActivity);
            }
        }
    }

    /**
     * 判断当前拼团团队是否已满足拼团条件
     * @param teamId    拼团团队id
     * @param nowDate    操作时间
     */
    private void syncAssortedDoughStatus(Long teamId,Date nowDate){
        //查询拼团团队id
        ComBatteryCommodityOrderCollageTeam orderCollageTeam = orderCollageTeamMapper.selectById(teamId);
        if(orderCollageTeam != null){
            ComBatteryCommodityActivity commodityActivity = commodityActivityMapper.selectById(orderCollageTeam.getActivityId());
            if(commodityActivity != null){
                Integer count = orderCollageTeamPeopleMapper.selectCount(new QueryWrapper<ComBatteryCommodityOrderCollageTeamPeople>()
                        .lambda().eq(ComBatteryCommodityOrderCollageTeamPeople::getTeamId,teamId));
                if(count >= commodityActivity.getCollagePeopleNum()){
                    //拼团条件满足，将所有已拼单的用户的订单更新为待发货状态
                    //更新拼团团队记录
                    orderCollageTeam.setStatus(ComBatteryCommodityOrderCollageTeam.Status.PTCG);
                    orderCollageTeamMapper.updateById(orderCollageTeam);
                    //查询拼团订单并进行更新
                    List<ComBatteryCommodityOrder> commodityOrderList = this.baseMapper.selectList(new QueryWrapper<ComBatteryCommodityOrder>().lambda()
                            .eq(ComBatteryCommodityOrder::getTeamId,teamId).eq(ComBatteryCommodityOrder::getStatus,ComBatteryCommodityOrder.Status.DPT)
                            .eq(ComBatteryCommodityOrder::getCollageStatus,ComBatteryCommodityOrder.CollageStatus.PTZ)
                            .eq(ComBatteryCommodityOrder::getActivityType,ComBatteryCommodityOrder.ActivityType.PT));
                    commodityOrderList.forEach(commodityOrder -> {
                        commodityOrder.setStatus(ComBatteryCommodityOrder.Status.DFH);
                        commodityOrder.setCollageStatus(ComBatteryCommodityOrder.CollageStatus.PTCG);
                        commodityOrder.setUpdateAt(nowDate);
                        this.baseMapper.updateById(commodityOrder);
                    });
                }
            }
        }
    }

    /**
     * 初始化砍价记录
     * @param commodityOrder    订单数据
     * @param nowDate   操作时间
     * @return  砍价记录
     */
    private ComBatteryCommodityOrderBargain getOrderBargain(ComBatteryCommodityOrder commodityOrder,Date nowDate){
        ComBatteryCommodityOrderBargain orderBargain = new ComBatteryCommodityOrderBargain();
        BeanUtils.copyProperties(commodityOrder,orderBargain);
        orderBargain.setOrderId(commodityOrder.getId());
        orderBargain.setOrderNo(commodityOrder.getOrderNo());
        orderBargain.setCount(0);
        orderBargain.setCreateAt(nowDate);
        orderBargain.setCreateBy(commodityOrder.getUserId());
        //查询商品信息
        ComBatteryCommodity commodity = commodityMapper.selectById(commodityOrder.getCommodityId());
        if(commodity != null){
            orderBargain.setOriginalPrice(commodity.getPrice());
            orderBargain.setCurrentPrice(commodity.getPrice());
        }
        //查询活动信息
        ComBatteryCommodityActivity commodityActivity = commodityActivityMapper.selectById(commodityOrder.getActivityId());
        if(commodityActivity != null){
            orderBargain.setTargetPrice(commodityActivity.getPrice());
        }
        return orderBargain;
    }

    /**
     * 创建秒杀订单
     * @param orderDto  请求参数
     * @return  创建订单结果
     */
    @Override
    public R startSeckill(StartSeckillOrderDto orderDto) {
        ComBatteryCommodityActivity commodityActivity = commodityActivityMapper.selectById(orderDto.getActivityId());
        if(commodityActivity == null){
            return R.fail("未查询到秒杀活动");
        }
        if(commodityActivity.getCommodityNum() <= commodityActivity.getCommoditySaleNum()){
            return R.fail("活动商品已售空");
        }
        if(commodityActivity.getEndTime().getTime() - System.currentTimeMillis() <= 0
                || commodityActivity.getStatus().equals(ComBatteryCommodityActivity.Status.YJS)){
            return R.fail("该活动已结束");
        }
        if(commodityActivity.getStatus().equals(ComBatteryCommodityActivity.Status.YXJ)){
            return R.fail("该活动已下架");
        }
        Integer notSaleNum = commodityActivity.getCommodityNum() - commodityActivity.getCommoditySaleNum();
        if(notSaleNum <= orderDto.getCount()){
            return R.fail("活动商品库存不足");
        }
        //查询商品
        ComBatteryCommodity commodity = commodityMapper.selectById(orderDto.getCommodityId());
        if(commodity == null){
            return R.fail("未查询到商品信息");
        }
        //查询商品规格信息
        ComBatteryCommoditySpecs commoditySpecs = commoditySpecsMapper.selectById(commodityActivity.getSpecsId());
        if(commoditySpecs == null){
            return R.fail("未查询到商品规格信息");
        }
        if(commoditySpecs.getStock() < orderDto.getCount()){
            return R.fail("该商品库存不足，无法下单");
        }
        //查询用户信息
        SysUser user = userMapper.selectOne(new QueryWrapper<SysUser>().lambda().eq(SysUser::getUserId,orderDto.getUserId()));
        if(user == null){
            return R.fail("未查询到用户信息");
        }
        //查询用户收货地址
        ComBatteryUserAddress userAddress = userAddressMapper.selectById(orderDto.getAddressId());
        if(userAddress == null){
            return R.fail("未查询到用户收货地址");
        }
        Date nowDate = new Date();
        ComBatteryCommodityOrder commodityOrder = getCreateActivityOrder(commodity,userAddress,user,commoditySpecs,orderDto,nowDate,commodityActivity);
        Map<String,Object> resultMap = new HashMap<>(2);
        if(this.baseMapper.insert(commodityOrder) > 0){
            //更新活动商品库存
            commodityActivity.setCommoditySaleNum(commodityActivity.getCommoditySaleNum() + orderDto.getCount());
            commodityActivityMapper.updateById(commodityActivity);
            //更新商品库存
            commoditySpecs.setStock(commoditySpecs.getStock() - orderDto.getCount());
            commoditySpecsMapper.updateById(commoditySpecs);
            //微信支付需要调取小程序微信支付
            String result = getWxPayResult(commodityOrder.getFinalAmount(),commodityOrder.getOpenId()
                    ,commodityOrder.getOrderNo(),"购买商品");
            resultMap.put("payResult",result);
            resultMap.put("orderId",commodityOrder.getId());
            // 添加微信支付交易流水
            String wxTradeOrderNo = "wx" + Snowflake.getId();
            tradeOrderService.addOrderTradeRecord(user.getUserId(), user.getOpenid(), wxTradeOrderNo, ComBatteryTradeOrder.PayType.WX,
                    commodityOrder.getFinalAmount(), ComBatteryTradeOrder.TradeType.DDC_SHOP, commodityOrder.getId(),
                    commodityOrder.getOrderNo(), user.getUserId(), nowDate);
        }
        return R.ok(resultMap);
    }

    /**
     * 初始化活动订单数据
     * @param commodity         商品数据
     * @param userAddress       用户收货地址信息
     * @param user              用户数据
     * @param commoditySpecs    商品规格数据
     * @param orderDto          用户请求参数
     * @param nowDate           操作时间
     * @param commodityActivity           拼团活动数据
     * @return  初始化订单数据
     */
    public static ComBatteryCommodityOrder getCreateActivityOrder(ComBatteryCommodity commodity, ComBatteryUserAddress userAddress
            , SysUser user, ComBatteryCommoditySpecs commoditySpecs, StartSeckillOrderDto orderDto, Date nowDate
            ,ComBatteryCommodityActivity commodityActivity){
        ComBatteryCommodityOrder commodityOrder = new ComBatteryCommodityOrder();
        commodityOrder.setUserId(user.getUserId());
        commodityOrder.setOpenId(user.getOpenid());
        commodityOrder.setStoreId(commodity.getStoreId());
        commodityOrder.setActivityId(commodityActivity.getId());
        commodityOrder.setCommodityId(commodity.getId());
        commodityOrder.setSpecsId(commoditySpecs.getId());
        commodityOrder.setOrderNo("PT" + Snowflake.getId());
        commodityOrder.setActivityType(commodityActivity.getType());
        commodityOrder.setStatus(ComBatteryCommodityOrder.Status.DFK);
        commodityOrder.setPayStatus(ComBatteryCommodityOrder.PayStatus.WZF);
        commodityOrder.setIsDel(ComBatteryCommodityOrder.IsDel.NO);
        commodityOrder.setPayType(ComBatteryCommodityOrder.PayType.WX);
        commodityOrder.setCount(orderDto.getCount());
        commodityOrder.setPrice(commodityActivity.getPrice());
        commodityOrder.setAmount(commodityActivity.getPrice().multiply(BigDecimal.valueOf(orderDto.getCount())));
        commodityOrder.setFreight(commodity.getPostage());
        commodityOrder.setFinalAmount(commodityOrder.getAmount().add(commodityOrder.getFreight()));
        commodityOrder.setCreateAt(nowDate);
        commodityOrder.setCreateBy(user.getUserId());
        commodityOrder.setRemark(orderDto.getRemark());
        //收货地址
        commodityOrder.setAddressId(userAddress.getId());
        commodityOrder.setReceivingName(userAddress.getName());
        commodityOrder.setReceivingPhone(userAddress.getPhone());
        commodityOrder.setReceivingRegionCode(userAddress.getProvinceAdcode() + "-" + userAddress.getCityAdcode() + "-" + userAddress.getDistrictAdcode());
        commodityOrder.setReceivingRegion(userAddress.getProvinceName() + userAddress.getCityName() + userAddress.getDistrictName());
        commodityOrder.setReceivingAddress(userAddress.getAddress());
        return commodityOrder;
    }
}