qmjszx/qmjszx-pay/src/main/java/beilv/wx/pay/service/IWxPayService.java

package beilv.wx.pay.service;

import beilv.carinformation.mapper.CarInformationMapper;
import beilv.common.core.domain.AjaxResult;
import beilv.competition.mapper.CompetitionMapper;
import beilv.order.domain.StoreOrder;
import beilv.order.domain.StoreRefund;
import beilv.order.mapper.StoreOrderMapper;
import beilv.order.mapper.StoreRefundMapper;
import beilv.system.domain.SysMember;
import beilv.system.service.ISysMemberService;
import beilv.vipCardLog.domain.VipCardLog;
import beilv.vipCardLog.service.IVipCardLogService;
import beilv.wx.pay.config.WxPayProperties;
import beilv.wx.pay.domain.vo.AppPayParam;
import beilv.wx.pay.domain.vo.AppRefundParam;
import com.github.binarywang.wxpay.bean.notify.SignatureHeader;
import com.github.binarywang.wxpay.bean.notify.WxPayNotifyV3Response;
import com.github.binarywang.wxpay.bean.notify.WxPayNotifyV3Result;
import com.github.binarywang.wxpay.bean.notify.WxPayRefundNotifyV3Result;
import com.github.binarywang.wxpay.bean.request.WxPayOrderQueryRequest;
import com.github.binarywang.wxpay.bean.request.WxPayOrderQueryV3Request;
import com.github.binarywang.wxpay.bean.request.WxPayRefundV3Request;
import com.github.binarywang.wxpay.bean.request.WxPayUnifiedOrderV3Request;
import com.github.binarywang.wxpay.bean.result.BaseWxPayResult;
import com.github.binarywang.wxpay.bean.result.WxPayOrderQueryResult;
import com.github.binarywang.wxpay.bean.result.WxPayOrderQueryV3Result;
import com.github.binarywang.wxpay.bean.result.WxPayRefundV3Result;
import com.github.binarywang.wxpay.bean.result.WxPayUnifiedOrderV3Result.JsapiResult;
import com.github.binarywang.wxpay.bean.result.enums.TradeTypeEnum;
import com.github.binarywang.wxpay.constant.WxPayConstants;
import com.github.binarywang.wxpay.exception.WxPayException;
import com.github.binarywang.wxpay.service.WxPayService;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpServletRequest;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Set;
import java.util.UUID;

@Slf4j
@Service
@AllArgsConstructor
public class IWxPayService {

    @Autowired
    private CarInformationMapper carInformationMapper;
    @Autowired
    private StoreOrderMapper storeOrderMapper;
    @Autowired
    private CompetitionMapper competitionMapper;
    @Autowired
    private WxPayProperties wxPayProperties;
    @Autowired
    private ISysMemberService sysMemberService;
    @Autowired
    private StoreRefundMapper storeRefundMapper;
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private IVipCardLogService vipCardLogService;

    private WxPayService wxService;


    // Redis中订单延迟队列的key前缀
    private static final String ORDER_DELAY_QUEUE_PREFIX = "order:delay:queue:";
    // 订单超时时间(5分钟)
    private static final long ORDER_TIMEOUT_SECONDS = 5 * 60;

    /**
     * 统一下单接口
     *
     * @return 预支付交易会话标识
     */
    public JsapiResult unifiedOrder(AppPayParam param) throws Exception {
        log.info("开始处理统一下单请求，订单号: {}", param.getOrderId());
        // 幂等性校验 - 检查订单是否已存在且已支付
        StoreOrder existingOrder = storeOrderMapper.selectStoreOrderByOrderId(param.getOrderId());
        if (existingOrder != null && existingOrder.getPaid() != null && existingOrder.getPaid() == 1) {
            log.warn("订单 {} 已支付，不能重复下单", param.getOrderId());
            throw new Exception("订单已支付，不能重复下单");
        }
        SysMember user = getSysMember(param.getUserId());
        param.setSysMember(user);
        //微信支付需要的参数
        WxPayUnifiedOrderV3Request request = new WxPayUnifiedOrderV3Request();
        request.setAppid(wxPayProperties.getAppId());
        request.setMchid(wxPayProperties.getMchId());
        request.setDescription(param.getDescription());
        request.setOutTradeNo(param.getOrderId());
        request.setNotifyUrl(wxPayProperties.getNotifyUrl());
        WxPayUnifiedOrderV3Request.Amount amount = new WxPayUnifiedOrderV3Request.Amount();
        amount.setTotal(yuanToFen(param.getPayPrice()));
        amount.setCurrency("CNY");
        request.setAmount(amount);
        request.setPayer(new WxPayUnifiedOrderV3Request.Payer().setOpenid(user.getOpenId()));
        log.info("调用微信统一下单接口，订单号: {}", param.getOrderId());
        JsapiResult jsapiResult = this.wxService.createOrderV3(TradeTypeEnum.JSAPI, request);
        if (StringUtils.isNotEmpty(jsapiResult.getPackageValue())) {
            log.info("微信统一下单成功，订单号: {}，开始创建本地订单", param.getOrderId());
            //成功之后创建订单
            generateOrder(param, jsapiResult.getPackageValue());
            //将订单添加到延迟队列中
            addOrderToDelayQueue(param.getOrderId());
            log.info("订单创建完成并加入延迟队列，订单号: {}", param.getOrderId());
        } else {
            log.warn("微信统一下单失败，订单号: {}", param.getOrderId());
        }
        return jsapiResult;
    }

    //获取当前用户信息
    private SysMember getSysMember(Long userId) {
        log.debug("获取用户信息，用户ID: {}", userId);
        return sysMemberService.selectSysMemberById(userId);
    }


    /**
     * 元转分（不四舍五入，直接截取）
     *
     * @param amount 金额（元）
     * @return 分（整数）
     */
    public static int yuanToFen(BigDecimal amount) {
        if (amount == null) return 0;
        return amount.multiply(BigDecimal.valueOf(100))
                .setScale(0, RoundingMode.DOWN)  // 不四舍五入
                .intValueExact();
    }


    /**
     * 统一下单接口
     *
     * @return 预支付交易会话标识
     */
    private void generateOrder(AppPayParam param, String payId) {
        log.info("开始生成订单，订单号: {}", param.getOrderId());
        //查看是否已经生成订单，但是未支付
        if (!isOrderInDelayQueue(param.getOrderId())) {
            // 订单不存在，创建新订单
            log.info("订单不存在，创建新订单，订单号: {}", param.getOrderId());
            StoreOrder storeOrder = new StoreOrder();
            storeOrder.setOrderId(param.getOrderId());
            storeOrder.setUid(param.getSysMember().getId());
            storeOrder.setRealName(param.getSysMember().getUsername());
            storeOrder.setUserPhone(param.getSysMember().getMobile());
            storeOrder.setUserAddress(param.getSysMember().getAddress());
            storeOrder.setTotalNum(1);
            storeOrder.setTotalPrice(param.getTotalPrice());
            storeOrder.setPayPrice(param.getPayPrice());
            storeOrder.setPayTime(new Date());
            storeOrder.setPayId(payId);
            storeOrder.setCreateTime(new Date());
            storeOrderMapper.insertStoreOrder(storeOrder);
            log.info("新订单创建成功，订单号: {}", param.getOrderId());
        } else {
            StoreOrder order = storeOrderMapper.selectStoreOrderByOrderId(param.getOrderId());
            // 订单已存在，更新支付相关信息
            log.info("订单已存在，更新支付信息，订单号: {}", param.getOrderId());
            order.setPayTime(new Date());
            order.setPayId(payId);
            storeOrderMapper.updateStoreOrder(order);
            log.info("订单支付信息更新完成，订单号: {}", param.getOrderId());
        }
    }

    /**
     * 将订单添加到延迟队列
     *
     * @param orderId 订单ID
     */
    private void addOrderToDelayQueue(String orderId) {
        log.info("将订单添加到延迟队列，订单号: {}", orderId);
        // 计算订单超时时间戳（当前时间+5分钟）
        long expireTime = System.currentTimeMillis() + (ORDER_TIMEOUT_SECONDS * 1000);
        // 将订单添加到Redis有序集合中，以超时时间戳作为score
        redisTemplate.opsForZSet().add(ORDER_DELAY_QUEUE_PREFIX + "orders", orderId, expireTime);
        log.info("订单 {} 已添加到延迟队列，超时时间: {}", orderId, new Date(expireTime));
    }

    /**
     * 从延迟队列中移除订单（支付成功时调用）
     *
     * @param orderId 订单ID
     */
    private void removeOrderFromDelayQueue(String orderId) {
        log.info("从延迟队列中移除订单，订单号: {}", orderId);
        // 从Redis有序集合中移除订单
        redisTemplate.opsForZSet().remove(ORDER_DELAY_QUEUE_PREFIX + "orders", orderId);
        log.info("订单 {} 已从延迟队列中移除", orderId);
    }

    //生成退款订单号
    public String generateOutTradeNo() {
        String time = new SimpleDateFormat("yyyyMMddHHmmss").format(new Date());
        String random = String.valueOf((int) ((Math.random() * 9 + 1) * 100000)); // 6位随机
        return "REF" + time + random;
    }

    /**
     * 处理支付结果通知
     *
     * @return 处理结果
     */
    public AjaxResult handleNotify(String notifyData, HttpServletRequest request) {
        log.info("收到微信支付回调通知");
        SignatureHeader header = getRequestHeader(request);
        try {
            WxPayNotifyV3Result res = this.wxService.parseOrderNotifyV3Result(notifyData, header);
            WxPayNotifyV3Result.DecryptNotifyResult decryptRes = res.getResult();
            log.info("解析微信支付回调结果，订单号: {}, 交易状态: {}", decryptRes.getOutTradeNo(), decryptRes.getTradeState());
            if (WxPayConstants.WxpayTradeStatus.SUCCESS.equals(decryptRes.getTradeState())) {
                log.info("支付成功，开始处理订单，订单号: {}", decryptRes.getOutTradeNo());
                // 成功处理订单
                processOrderPayment(decryptRes.getOutTradeNo());
                //调用充值记录服务，更新充值记录状态
                VipCardLog vipCardLog = new VipCardLog();
                vipCardLog.setId(decryptRes.getOutTradeNo());
                vipCardLog.setPaymentStatus("payment_status_have_paid");
                vipCardLogService.updateVipCardLogByOrderId(vipCardLog);
                // 成功返回200/204，body无需有内容
                log.info("订单处理完成，订单号: {}", decryptRes.getOutTradeNo());
                return AjaxResult.success();
            } else {
                log.warn("支付失败，订单号: {}，状态: {}", decryptRes.getOutTradeNo(), decryptRes.getTradeState());
                // 失败返回4xx或5xx，且需要构造body信息
                return AjaxResult.error("订单支付失败");
            }
        } catch (WxPayException e) {
            log.error("处理微信支付回调失败", e);
            // 失败返回4xx或5xx，且需要构造body信息
            return AjaxResult.error("微信支付回调失败");
        }
    }

    /**
     * 处理订单支付完成后的业务逻辑
     *
     * @param orderId 订单号
     */
    private void processOrderPayment(String orderId) {
        log.info("开始处理订单支付完成逻辑，订单号: {}", orderId);
        
        // 使用Redis分布式锁防止并发处理
        String lockKey = "payment:lock:" + orderId;
        Boolean lockAcquired = redisTemplate.opsForValue().setIfAbsent(lockKey, "1", java.time.Duration.ofSeconds(30));
        
        if (Boolean.FALSE.equals(lockAcquired)) {
            log.warn("订单正在被其他线程处理，订单号: {}", orderId);
            return;
        }
        
        try {
            StoreOrder order = storeOrderMapper.selectStoreOrderByOrderId(orderId);
            if (order != null) {
                // 检查订单是否已被取消
                if (order.getStatus() != null && order.getStatus() == 3) {
                    log.warn("订单已超时取消，支付回调到达，订单号: {}", orderId);
                    // TODO: 这里应该调用退款接口，将钱退回给用户
                    return;
                }
                
                // 检查订单是否已经处理过
                if (order.getPaid() == null || order.getPaid() != 1) {
                    log.info("更新订单状态为已支付，订单号: {}", orderId);
                    // 更新订单状态
                    order.setPaid(1); // 设置为已支付
                    order.setStatus(1); // 设置订单状态为已支付
                    order.setPayTime(new Date()); // 设置支付时间
                    storeOrderMapper.updateStoreOrder(order);
                    // 从延迟队列中移除订单
                    removeOrderFromDelayQueue(orderId);
                    log.info("订单状态更新完成，订单号: {}", orderId);
                } else {
                    log.info("订单已处理过，无需重复处理，订单号: {}", orderId);
                }
            } else {
                log.warn("订单不存在，订单号: {}", orderId);
            }
        } finally {
            // 释放锁
            redisTemplate.delete(lockKey);
        }
    }

    /**
     * 微信支付-申请退款
     *
     */
    public WxPayRefundV3Result refund(AppRefundParam param) throws WxPayException {
        log.info("开始处理退款请求，订单号: {}", param.getOrderId());
        // 检查订单是否存在
        StoreOrder order = storeOrderMapper.selectStoreOrderByOrderId(param.getOrderId());
        if (order == null) {
            log.warn("退款失败，订单不存在，订单号: {}", param.getOrderId());
            throw new WxPayException("订单不存在");
        }

        // 检查订单是否已支付
        if (order.getPaid() == null || order.getPaid() != 1) {
            log.warn("退款失败，订单未支付，订单号: {}", param.getOrderId());
            throw new WxPayException("订单未支付，无法退款");
        }

        // 检查订单是否已退款
        if (order.getRefundStatus() != null && order.getRefundStatus() == 2) {
            log.warn("退款失败，订单已退款，订单号: {}", param.getOrderId());
            throw new WxPayException("订单已退款");
        }

        // 检查退款金额是否合法
        if (param.getRefundAmount().compareTo(order.getPayPrice()) > 0) {
            log.warn("退款失败，退款金额大于支付金额，订单号: {}", param.getOrderId());
            throw new WxPayException("退款金额不能大于支付金额");
        }
        WxPayRefundV3Request request = new WxPayRefundV3Request();
        //商户退款单号
        request.setOutRefundNo(param.getOrderId());
        //原支付商户订单号
        request.setOutTradeNo(param.getOrderId());
        //退款原因说明
        request.setReason(param.getReason());
        WxPayRefundV3Request.Amount amount = new WxPayRefundV3Request.Amount();
        //原订单实际支付金额（单位：分）
        amount.setTotal(yuanToFen(param.getTotalPrice()));
        //退款金额（单位：分）
        amount.setRefund(yuanToFen(param.getRefundAmount()));
        //货币类型，默认 "CNY"
        amount.setCurrency("CNY");
        request.setAmount(amount);
        request.setNotifyUrl(wxPayProperties.getRefundNotifyUrl());
        param.setSysMember(getSysMember(param.getUserId()));
        
        // 检查是否已存在退款记录
        StoreRefund existingRefund = storeRefundMapper.selectStoreRefundByOrderId(param.getOrderId());
        if (existingRefund != null && "2".equals(existingRefund.getRefundStatus())) {
            log.warn("退款失败，退款记录已存在且已完成，订单号: {}", param.getOrderId());
            throw new WxPayException("该订单已退款");
        }
        
        // 先调用微信退款接口
        log.info("调用微信退款接口，订单号: {}", param.getOrderId());
        WxPayRefundV3Result result = this.wxService.refundV3(request);
        log.info("微信退款接口调用成功，订单号: {}", param.getOrderId());
        
        // 微信退款成功后，再创建本地退款记录
        if (existingRefund == null) {
            log.info("微信退款成功，创建本地退款记录，订单号: {}", param.getOrderId());
            refundOrder(param);
        }
        
        return result;
    }

    /**
     * 统一退款接口
     *
     * @return 预支付交易会话标识
     */
    private void refundOrder(AppRefundParam param) {
        log.info("生成退款订单记录，订单号: {}", param.getOrderId());
        StoreRefund storeRefund = new StoreRefund();
        storeRefund.setUid(param.getSysMember().getId());
        storeRefund.setRefundNo(generateOutTradeNo());
        storeRefund.setOrderId(param.getOrderId());
        storeRefund.setRefundAmount(param.getRefundAmount());
        storeRefund.setRefundReason(param.getReason());
        storeRefund.setCreateTime(new Date());
        storeRefundMapper.insertStoreRefund(storeRefund);
        log.info("退款订单记录创建完成，订单号: {}", param.getOrderId());
    }

    /**
     * 退款结果通知
     *
     * @return 处理结果
     */
    public AjaxResult parseRefundNotify(String notifyData, HttpServletRequest request) {
        log.info("收到微信退款回调通知");
        SignatureHeader header = getRequestHeader(request);
        try {
            WxPayRefundNotifyV3Result res = this.wxService.parseRefundNotifyV3Result(notifyData, header);
            WxPayRefundNotifyV3Result.DecryptNotifyResult decryptRes = res.getResult();
            log.info("解析微信退款回调结果，订单号: {}, 退款状态: {}", decryptRes.getOutTradeNo(), decryptRes.getRefundStatus());
            // TODO 根据自己业务场景需要构造返回对象
            if (WxPayConstants.RefundStatus.SUCCESS.equals(decryptRes.getRefundStatus())) {
                log.info("退款成功，开始处理订单，订单号: {}", decryptRes.getOutTradeNo());
                // 成功处理订单
                processOrderRefund(decryptRes.getOutTradeNo());
                //成功返回200/204，body无需有内容
                log.info("退款处理完成，订单号: {}", decryptRes.getOutTradeNo());
                return AjaxResult.success();
            } else {
                log.warn("退款失败，订单号: {}，状态: {}", decryptRes.getOutTradeNo(), decryptRes.getRefundStatus());
                //失败返回4xx或5xx，且需要构造body信息
                return AjaxResult.error();
            }
        } catch (WxPayException e) {
            log.error("处理微信退款回调失败", e);
            //失败返回4xx或5xx，且需要构造body信息
            return AjaxResult.error("微信退款回调失败");
        }
    }

    /**
     * 退款完成后的业务逻辑
     *
     * @param orderId 订单号
     */
    private void processOrderRefund(String orderId) {
        log.info("开始处理订单退款完成逻辑，订单号: {}", orderId);
        StoreOrder order = storeOrderMapper.selectStoreOrderByOrderId(orderId);
        if (order != null) {
            // 检查订单是否已经处理过
            if (order.getRefundStatus() != null && order.getPaid() == 1) {
                log.info("更新订单状态为已退款，订单号: {}", orderId);
                //更新支付订单状态为退款
                order.setStatus(2); // 3表示已取消
                order.setUpdateTime(new Date());
                storeOrderMapper.updateStoreOrder(order);
                log.info("订单状态更新完成，订单号: {}", orderId);
            } else {
                log.info("订单退款状态无需更新，订单号: {}", orderId);
            }
        } else {
            log.warn("订单不存在，订单号: {}", orderId);
        }
        StoreRefund refund = storeRefundMapper.selectStoreRefundByOrderId(orderId);
        if (refund != null) {
            // 检查订单是否已经处理过
            if (refund.getRefundStatus() != null && refund.getRefundStatus().equals("1")) {
                log.info("更新退款记录状态为已退款，退款单号: {}", refund.getRefundNo());
                // 更新订单状态
                refund.setRefundStatus("2"); // 设置订单状态为已退款
                refund.setSuccessTime(new Date());
                storeRefundMapper.updateStoreRefund(refund);
                log.info("退款记录状态更新完成，退款单号: {}", refund.getRefundNo());
            } else {
                log.info("退款记录状态无需更新，退款单号: {}", refund.getRefundNo());
            }
        } else {
            log.warn("退款记录不存在，订单号: {}", orderId);
        }
    }


    /**
     * 组装请求头重的前面信息
     *
     * @param request
     * @return
     */
    private SignatureHeader getRequestHeader(HttpServletRequest request) {
        log.debug("解析微信回调请求头信息");
        // 获取通知签名
        String signature = request.getHeader("Wechatpay-Signature");
        String nonce = request.getHeader("Wechatpay-Nonce");
        String serial = request.getHeader("Wechatpay-Serial");
        String timestamp = request.getHeader("Wechatpay-Timestamp");
        SignatureHeader signatureHeader = new SignatureHeader();
        signatureHeader.setSignature(signature);
        signatureHeader.setNonce(nonce);
        signatureHeader.setSerial(serial);
        signatureHeader.setTimeStamp(timestamp);
        return signatureHeader;
    }

    /**
     * 处理超时订单
     * 定时任务调用此方法检查并处理超时订单
     */
    public void processTimeoutOrders() {
//        log.info("开始处理超时订单");
        // 获取当前时间戳
        long currentTime = System.currentTimeMillis();

        // 从Redis有序集合中获取所有已超时的订单（score小于当前时间的元素）
        redisTemplate.opsForZSet().rangeByScore(ORDER_DELAY_QUEUE_PREFIX + "orders", 0, currentTime)
                .forEach(orderId -> {
                    // 使用分布式锁防止与支付回调冲突
                    String lockKey = "payment:lock:" + orderId;
                    Boolean lockAcquired = redisTemplate.opsForValue().setIfAbsent(lockKey, "1", java.time.Duration.ofSeconds(30));
                    
                    if (Boolean.FALSE.equals(lockAcquired)) {
                        log.warn("订单正在被处理，跳过超时处理，订单号: {}", orderId);
                        return;
                    }
                    
                    try {
                        log.info("处理超时订单: {}", orderId);
                        // 查询订单信息
                        StoreOrder order = storeOrderMapper.selectStoreOrderByOrderId(orderId);
                        if (order != null && (order.getPaid() == null || order.getPaid() != 1)) {
                            // 订单未支付，执行删除操作或更新状态
                            // 这里我们更新订单状态为已取消
                            order.setStatus(3); // 3表示已取消
                            order.setUpdateTime(new Date());
                            storeOrderMapper.updateStoreOrder(order);
                            log.info("订单 {} 已超时，状态已更新为已取消", orderId);
                        } else if (order != null) {
                            log.info("订单 {} 已支付，无需处理", orderId);
                        } else {
                            log.warn("订单 {} 不存在", orderId);
                        }

                        // 从延迟队列中移除订单
                        redisTemplate.opsForZSet().remove(ORDER_DELAY_QUEUE_PREFIX + "orders", orderId);
                        log.info("超时订单 {} 处理完成", orderId);
                    } catch (Exception e) {
                        log.error("处理超时订单 {} 时发生错误", orderId, e);
                    } finally {
                        // 释放锁
                        redisTemplate.delete(lockKey);
                    }
                });
//        log.info("超时订单处理完成");
    }

    /**
     * 取消订单
     *
     * @param orderId 订单ID
     * @return 处理结果
     */
    public int cancelOrder(String orderId) {
        StoreOrder order = storeOrderMapper.selectStoreOrderByOrderId(orderId);
        order.setStatus(3); // 3表示已取消
        order.setUpdateTime(new Date());
        return storeOrderMapper.updateStoreOrder(order);
    }

    /**
     * 检查订单是否在延迟队列中
     *
     * @param orderId 订单ID
     * @return 如果订单在延迟队列中返回true，否则返回false
     */
    public boolean isOrderInDelayQueue(String orderId) {
        // 使用rank命令检查订单是否在有序集合中
        // 如果返回null，说明订单不在集合中
        Long rank = redisTemplate.opsForZSet().rank(ORDER_DELAY_QUEUE_PREFIX + "orders", orderId);
        return rank != null;
    }

}