package com.izouma.nineth.service;

import com.alibaba.fastjson.JSONObject;
import com.alipay.api.AlipayApiException;
import com.alipay.api.AlipayClient;
import com.alipay.api.request.AlipayTradePrecreateRequest;
import com.alipay.api.response.AlipayTradePrecreateResponse;
import com.google.zxing.WriterException;
import com.izouma.nineth.config.AlipayProperties;
import com.izouma.nineth.config.Constants;
import com.izouma.nineth.config.GeneralProperties;
import com.izouma.nineth.domain.*;
import com.izouma.nineth.domain.nftdomain.DomainAsk;
import com.izouma.nineth.dto.PayQuery;
import com.izouma.nineth.dto.UserBankCard;
import com.izouma.nineth.enums.*;
import com.izouma.nineth.event.OrderNotifyEvent;
import com.izouma.nineth.exception.BusinessException;
import com.izouma.nineth.repo.*;
import com.izouma.nineth.repo.nftdomain.DomainAskRepo;
import com.izouma.nineth.service.nftdomain.DomainAskService;
import com.izouma.nineth.utils.SnowflakeIdWorker;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.swing.text.DateFormatter;
import java.awt.*;
import java.io.IOException;
import java.math.BigDecimal;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.text.DateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Stream;

@Service
@Slf4j
@AllArgsConstructor
public class OrderPayService {
    private static String PAY_CHANNEL = Constants.PayChannel.SAND;

    private final OrderService             orderService;
    private final OrderRepo                orderRepo;
    private final MintOrderRepo            mintOrderRepo;
    private final GiftOrderRepo            giftOrderRepo;
    private final SandPayService           sandPayService;
    private final HMPayService             hmPayService;
    private final GeneralProperties        generalProperties;
    private final UserBalanceService       userBalanceService;
    private final RocketMQTemplate         rocketMQTemplate;
    private final GiftOrderService         giftOrderService;
    private final MintOrderService         mintOrderService;
    private final UserRepo                 userRepo;
    private final SnowflakeIdWorker        snowflakeIdWorker;
    private final RechargeOrderRepo        rechargeOrderRepo;
    private final SysConfigService         sysConfigService;
    private final PasswordEncoder          passwordEncoder;
    private final PayEaseService           payEaseService;
    private final UserBankCardRepo         userBankCardRepo;
    private final AuctionOrderRepo         auctionOrderRepo;
    private final AuctionOrderService      auctionOrderService;
    private final IdentityAuthRepo         identityAuthRepo;
    private final AlipayClient             alipayClient;
    private final AlipayProperties         alipayProperties;
    private final AlipayService            alipayService;
    private final PhotoAssetRepo           photoAssetRepo;
    private final PhotoAssetService        photoAssetService;
    private final DomainOrderService       domainOrderService;
    private final DomainOrderRepo          domainOrderRepo;
    private final TradeAuctionRepo         tradeAuctionRepo;
    private final TradeAuctionOrderRepo    tradeAuctionOrderRepo;
    private final TradeAuctionOrderService tradeAuctionOrderService;
    private final DomainAskRepo            domainAskRepo;
    private final DomainAskService         domainAskService;

    public static void setPayChannel(String payChannel) {
        log.info("set pay channel {}", payChannel);
        if (Constants.PayChannel.HM.equals(payChannel) || Constants.PayChannel.SAND.equals(payChannel)) {
            PAY_CHANNEL = payChannel;
        }
    }

    @Cacheable(value = "payOrder", key = "'order#'+#orderId")
    public String payOrder(Long orderId) {
        Order order = orderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != OrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        switch (PAY_CHANNEL) {
            case Constants.PayChannel.SAND:
                return sandPayService.pay(orderId + "", order.getName(), order.getTotalPrice(),
                        order.getCreatedAt().plusMinutes(3), "order");
            case Constants.PayChannel.HM:
                return hmPayService.requestAlipay(orderId + "", order.getTotalPrice(), order.getName(),
                        HMPayService.getTimeout(order.getCreatedAt(), 180), Constants.OrderNotifyType.ORDER,
                        generalProperties.resolveFrontUrl(order.getCompanyId(), "/orderDetail?id=" + orderId));
        }
        throw new BusinessException(Constants.PAY_ERR_MSG);
    }

    private String aliRequest(Long orderId, BigDecimal amount, String subject, String type) {
        AlipayTradePrecreateRequest request = new AlipayTradePrecreateRequest();
        request.setNotifyUrl(alipayProperties.getNotifyUrl());
        JSONObject bizContent = new JSONObject();
        bizContent.put("out_trade_no", orderId + "");
        bizContent.put("total_amount", amount);
        bizContent.put("subject", subject);
        DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        bizContent.put("time_expire", df.format(LocalDateTime.now().plusSeconds(175)));
        JSONObject body = new JSONObject();
        body.put("type", type);
        body.put("orderId", orderId);
        bizContent.put("body", body.toString());

        request.setBizContent(bizContent.toString());
        AlipayTradePrecreateResponse response = null;
        try {
            response = alipayClient.execute(request);
        } catch (AlipayApiException e) {
            e.printStackTrace();
            throw new BusinessException(Constants.PAY_ERR_MSG, e.getErrMsg());
        }
        if (response.isSuccess()) {
            return response.getQrCode();
        } else {
            throw new BusinessException(response.getSubMsg());
        }
    }

    @Cacheable(value = "payOrder", key = "'order#'+#orderId")
    public String payOrderAli(Long orderId) {
        Order order = orderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != OrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }

        String qrCode = aliRequest(orderId, order.getTotalPrice(), order.getName(), Constants.OrderNotifyType.ORDER);

        String ua = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest()
                                                                                            .getHeader("User-Agent");
        if (ua.toLowerCase().contains("micromessenger")) {
            return "/static/wx_alipay_bridge.html?payUrl=" + URLEncoder
                    .encode(Constants.ALIPAY_URL_SCHEME + qrCode, StandardCharsets.UTF_8)
                    + "&orderId=" + orderId + "&type=order&returnUrl="
                    + URLEncoder
                    .encode(generalProperties.resolveFrontUrl(order.getCompanyId(), "/store"), StandardCharsets.UTF_8);
        } else {
            return Constants.ALIPAY_URL_SCHEME + qrCode;
        }
    }

    @Cacheable(value = "payOrder", key = "'order#'+#orderId")
    public String payOrderQuick(Long orderId) {
        Order order = orderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != OrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        return sandPayService.payQuick(orderId + "", order.getName(), order.getTotalPrice(),
                order.getCreatedAt().plusMinutes(3), Constants.OrderNotifyType.ORDER,
                generalProperties.resolveFrontUrl(order.getCompanyId(), "/store"));
    }

    @Cacheable(value = "payOrder", key = "'order#'+#orderId")
    public String payOrderQuickBind(Long orderId) {
        Order order = orderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != OrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        IdentityAuth identityAuth = identityAuthRepo
                .findFirstByUserIdAndStatusAndDelFalseOrderByCreatedAtDesc(order.getUserId(), AuthStatus.SUCCESS)
                .orElseThrow(new BusinessException("请先完成实名认证"));
        return sandPayService.payQuickBind(orderId + "", order.getName(), order.getTotalPrice(),
                order.getCreatedAt().plusMinutes(3), Constants.OrderNotifyType.ORDER,
                generalProperties.resolveFrontUrl(order.getCompanyId(), "/store"),
                order.getUserId(), identityAuth.getRealName(), identityAuth.getIdNo());
    }

    public void payOrderBalance(Long orderId, Long userId, String tradeCode) {
        Order order = orderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != OrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        checkTradeCode(userId, tradeCode, order.getUserId());
        BalanceRecord record = userBalanceService
                .balancePay(order.getUserId(), order.getTotalPrice(), orderId, order.getName());
        rocketMQTemplate.syncSend(generalProperties.getOrderNotifyTopic(),
                new OrderNotifyEvent(orderId, PayMethod.BALANCE, record.getId().toString(),
                        System.currentTimeMillis()));
    }

    @Cacheable(value = "payOrder", key = "'order#'+#orderId")
    public Map<String, Object> payOrderAgreement(Long orderId, String bindCardId) {
        Order order = orderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != OrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        if (StringUtils.isEmpty(bindCardId)) {
            bindCardId = userBankCardRepo.findByUserId(order.getUserId())
                                         .stream().map(UserBankCard::getBindCardId).findFirst().orElse(null);
        }
        if (StringUtils.isEmpty(bindCardId)) {
            throw new BusinessException("请先绑定银行卡");
        }
        return payEaseService.pay(order.getName(), orderId.toString(), order.getTotalPrice(),
                order.getUserId().toString(), bindCardId, Constants.OrderNotifyType.ORDER);
    }

    public void confirmOrderAgreement(String requestId, String paymentOrderId, String code) {
        try {
            payEaseService.payConfirm(requestId, paymentOrderId, code);
        } catch (BusinessException e) {
            try {
                new Thread(() -> {
                    orderService.cancel(Long.parseLong(requestId));
                }).start();
            } catch (Exception ee) {
            }
            throw e;
        }
    }

    @Cacheable(value = "payOrder", key = "'gift#'+#orderId")
    public String payGiftOrder(Long orderId) {
        GiftOrder order = giftOrderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != OrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        switch (PAY_CHANNEL) {
            case Constants.PayChannel.SAND:
                return sandPayService.pay(orderId + "", "转赠" + order.getAssetId(), order.getGasPrice(),
                        order.getCreatedAt().plusMinutes(3), Constants.OrderNotifyType.GIFT);
            case Constants.PayChannel.HM:
                return hmPayService.requestAlipay(orderId + "", order.getGasPrice(),
                        "转赠" + order.getAssetId(),
                        HMPayService.getTimeout(order.getCreatedAt(), 180),
                        Constants.OrderNotifyType.GIFT, generalProperties
                                .resolveFrontUrl(order.getCompanyId(), "/store"));
        }
        throw new BusinessException(Constants.PAY_ERR_MSG);
    }

    @Cacheable(value = "payOrder", key = "'gift#'+#orderId")
    public String payGiftAli(Long orderId) {
        GiftOrder order = giftOrderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != OrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }

        String qrCode = aliRequest(orderId, order.getGasPrice(), "转赠", Constants.OrderNotifyType.GIFT);

        String ua = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest()
                                                                                            .getHeader("User-Agent");
        if (ua.toLowerCase().contains("micromessenger")) {
            return "/static/wx_alipay_bridge.html?payUrl=" + URLEncoder
                    .encode(Constants.ALIPAY_URL_SCHEME + qrCode, StandardCharsets.UTF_8)
                    + "&orderId=" + orderId + "&type=gift&returnUrl="
                    + URLEncoder
                    .encode(generalProperties.resolveFrontUrl(order.getCompanyId(), "/store"), StandardCharsets.UTF_8);
        } else {
            return Constants.ALIPAY_URL_SCHEME + qrCode;
        }
    }

    @Cacheable(value = "payOrder", key = "'gift#'+#orderId")
    public String payGiftQuick(Long orderId) {
        GiftOrder order = giftOrderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != OrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        return sandPayService.payQuick(orderId + "", "转赠" + order.getAssetId(), order.getGasPrice(),
                order.getCreatedAt().plusMinutes(3), Constants.OrderNotifyType.GIFT,
                generalProperties.resolveFrontUrl(order.getCompanyId(), "/store"));
    }

    @Cacheable(value = "payOrder", key = "'gift#'+#orderId")
    public String payGiftQuickBind(Long orderId) {
        GiftOrder order = giftOrderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != OrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        IdentityAuth identityAuth = identityAuthRepo
                .findFirstByUserIdAndStatusAndDelFalseOrderByCreatedAtDesc(order.getUserId(), AuthStatus.SUCCESS)
                .orElseThrow(new BusinessException("请先完成实名认证"));
        return sandPayService.payQuickBind(orderId + "", "转赠" + order.getAssetId(), order.getGasPrice(),
                order.getCreatedAt().plusMinutes(3), Constants.OrderNotifyType.GIFT,
                generalProperties.resolveFrontUrl(order.getCompanyId(), "/store"),
                order.getUserId(), identityAuth.getRealName(), identityAuth.getIdNo());
    }

    public void payGiftBalance(Long orderId, Long userId, String tradeCode) {
        GiftOrder order = giftOrderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != OrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        checkTradeCode(userId, tradeCode, order.getUserId());
        BalanceRecord record = userBalanceService.balancePay(order.getUserId(), order.getGasPrice(), orderId, "转赠");
        giftOrderService.giftNotify(orderId, PayMethod.BALANCE, record.getId().toString());
    }

    @Cacheable(value = "payOrder", key = "'gift#'+#orderId")
    public Map<String, Object> payGiftOrderAgreement(Long orderId, String bindCardId) {
        GiftOrder order = giftOrderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != OrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        if (StringUtils.isEmpty(bindCardId)) {
            bindCardId = userBankCardRepo.findByUserId(order.getUserId())
                                         .stream().map(UserBankCard::getBindCardId).findFirst().orElse(null);
        }
        if (StringUtils.isEmpty(bindCardId)) {
            throw new BusinessException("请先绑定银行卡");
        }
        return payEaseService.pay("转赠" + order.getAssetId(), orderId.toString(), order.getGasPrice(),
                order.getUserId().toString(), bindCardId, Constants.OrderNotifyType.GIFT);
    }

    @Cacheable(value = "payOrder", key = "'mintOrder#'+#orderId")
    public String payMintOrder(Long orderId) {
        MintOrder order = mintOrderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != MintOrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        switch (PAY_CHANNEL) {
            case Constants.PayChannel.SAND:
                return sandPayService.pay(orderId + "", "铸造活动:" + order.getMintActivityId(),
                        order.getGasPrice(), order.getCreatedAt().plusMinutes(3), Constants.OrderNotifyType.MINT);
            case Constants.PayChannel.HM:
                return hmPayService.requestAlipay(orderId + "", order.getGasPrice(),
                        "铸造活动:" + order.getMintActivityId(),
                        HMPayService.getTimeout(order.getCreatedAt(), 180),
                        Constants.OrderNotifyType.MINT, generalProperties
                                .resolveFrontUrl(order.getCompanyId(), "/home"));
        }
        throw new BusinessException("绿洲宇宙冷却系统已启动，请稍后支付");
    }

    @Cacheable(value = "payOrder", key = "'mintOrder#'+#orderId")
    public String payMintAli(Long orderId) {
        MintOrder order = mintOrderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != MintOrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }

        String qrCode = aliRequest(orderId, order.getGasPrice(), "铸造活动:" + order
                .getMintActivityId(), Constants.OrderNotifyType.MINT);

        String ua = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest()
                                                                                            .getHeader("User-Agent");
        if (ua.toLowerCase().contains("micromessenger")) {
            return "/static/wx_alipay_bridge.html?payUrl=" + URLEncoder
                    .encode(Constants.ALIPAY_URL_SCHEME + qrCode, StandardCharsets.UTF_8)
                    + "&orderId=" + orderId + "&type=mintOrder&returnUrl="
                    + URLEncoder
                    .encode(generalProperties.resolveFrontUrl(order.getCompanyId(), "/home"), StandardCharsets.UTF_8);
        } else {
            return Constants.ALIPAY_URL_SCHEME + qrCode;
        }
    }

    @Cacheable(value = "payOrder", key = "'mintOrder#'+#orderId")
    public String payMintQuick(Long orderId) {
        MintOrder order = mintOrderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != MintOrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        return sandPayService.payQuick(orderId + "", "铸造活动:" + order.getMintActivityId(),
                order.getGasPrice(), order.getCreatedAt().plusMinutes(3), Constants.OrderNotifyType.MINT,
                generalProperties.resolveFrontUrl(order.getCompanyId(), "/home"));
    }

    @Cacheable(value = "payOrder", key = "'mintOrder#'+#orderId")
    public String payMintQuickBind(Long orderId) {
        MintOrder order = mintOrderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != MintOrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        IdentityAuth identityAuth = identityAuthRepo
                .findFirstByUserIdAndStatusAndDelFalseOrderByCreatedAtDesc(order.getUserId(), AuthStatus.SUCCESS)
                .orElseThrow(new BusinessException("请先完成实名认证"));
        return sandPayService.payQuickBind(orderId + "", "铸造活动:" + order.getMintActivityId(),
                order.getGasPrice(), order.getCreatedAt().plusMinutes(3), Constants.OrderNotifyType.MINT,
                generalProperties.resolveFrontUrl(order.getCompanyId(), "/home"),
                order.getUserId(), identityAuth.getRealName(), identityAuth.getIdNo());
    }

    public void payMintOrderBalance(Long orderId, Long userId, String tradeCode) {
        MintOrder order = mintOrderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != MintOrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        checkTradeCode(userId, tradeCode, order.getUserId());
        BalanceRecord record = userBalanceService.balancePay(order.getUserId(), order.getGasPrice(), orderId, "铸造活动");
        mintOrderService.mintNotify(orderId, PayMethod.BALANCE, record.getId().toString());
    }

    private void checkTradeCode(Long userId, String tradeCode, Long orderUserId) {
        if (!Objects.equals(orderUserId, userId)) {
            throw new BusinessException("订单不属于该用户");
        }
        String encodedPwd = userRepo.findTradeCode(userId);
        if (StringUtils.isEmpty(encodedPwd)) {
            throw new BusinessException("请先设置交易密码");
        }
        if (!passwordEncoder.matches(tradeCode, encodedPwd)) {
            throw new BusinessException("交易码错误");
        }
    }

    @Cacheable(value = "payOrder", key = "'mint#'+#orderId")
    public Map<String, Object> payMintOrderAgreement(Long orderId, String bindCardId) {
        MintOrder order = mintOrderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != MintOrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        if (StringUtils.isEmpty(bindCardId)) {
            bindCardId = userBankCardRepo.findByUserId(order.getUserId())
                                         .stream().map(UserBankCard::getBindCardId).findFirst().orElse(null);
        }
        if (StringUtils.isEmpty(bindCardId)) {
            throw new BusinessException("请先绑定银行卡");
        }
        return payEaseService.pay("铸造活动:" + order.getMintActivityId(), orderId.toString(), order.getGasPrice(),
                order.getUserId().toString(), bindCardId, Constants.OrderNotifyType.MINT);
    }

    private Long getCompanyId() {
        Long companyId = 1L;
        try {
            String hCompanyId = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest()
                                                                                                        .getHeader("companyId");
            if (StringUtils.isNotBlank(hCompanyId)) {
                companyId = Long.parseLong(hCompanyId);
            }
        } catch (Exception ignored) {
        }
        return companyId;
    }

    public String recharge(Long userId, BigDecimal amount) {
        BigDecimal minAmount = sysConfigService.getBigDecimal("min_recharge_amount");
        if (amount.compareTo(minAmount) < 0) {
            throw new BusinessException("充值金额不能小于" + minAmount);
        }
//        if (amount.compareTo(new BigDecimal("50000")) > 0) {
//            throw new BusinessException("充值金额不能大于50000");
//        }
        RechargeOrder order = RechargeOrder.builder()
                                           .id(snowflakeIdWorker.nextId())
                                           .userId(userId)
                                           .amount(amount)
                                           .status(OrderStatus.NOT_PAID)
                                           .build();
        rechargeOrderRepo.save(order);

        switch (PAY_CHANNEL) {
            case Constants.PayChannel.SAND:
                return sandPayService.pay(order.getId() + "", "余额充值", order.getAmount(),
                        order.getCreatedAt().plusMinutes(3), Constants.OrderNotifyType.RECHARGE);
            case Constants.PayChannel.HM:
                return hmPayService.requestAlipay(order.getId() + "", order.getAmount(),
                        "余额充值",
                        HMPayService.getTimeout(order.getCreatedAt(), 180),
                        Constants.OrderNotifyType.RECHARGE, generalProperties.resolveFrontUrl(getCompanyId(), "/home"));
        }
        throw new BusinessException("绿洲宇宙冷却系统已启动，请稍后支付");
    }

    public String payRechargeAli(Long userId, BigDecimal amount) {
        BigDecimal minAmount = sysConfigService.getBigDecimal("min_recharge_amount");
        if (amount.compareTo(minAmount) < 0) {
            throw new BusinessException("充值金额不能小于" + minAmount);
        }
        if (amount.compareTo(new BigDecimal("50000")) > 0) {
            throw new BusinessException("充值金额不能大于50000");
        }
        RechargeOrder order = RechargeOrder.builder()
                                           .id(snowflakeIdWorker.nextId())
                                           .userId(userId)
                                           .amount(amount)
                                           .status(OrderStatus.NOT_PAID)
                                           .build();
        rechargeOrderRepo.save(order);

        String qrCode = aliRequest(order.getId(), order.getAmount(), "余额充值", Constants.OrderNotifyType.RECHARGE);

        String ua = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest()
                                                                                            .getHeader("User-Agent");
        if (ua.toLowerCase().contains("micromessenger")) {
            return "/static/wx_alipay_bridge.html?payUrl=" + URLEncoder
                    .encode(Constants.ALIPAY_URL_SCHEME + qrCode, StandardCharsets.UTF_8)
                    + "&orderId=" + order.getId() + "&type=recharge&returnUrl="
                    + URLEncoder
                    .encode(generalProperties.resolveFrontUrl(getCompanyId(), "/home"), StandardCharsets.UTF_8);
        } else {
            return Constants.ALIPAY_URL_SCHEME + qrCode;
        }
    }

    public Map<String, Object> rechargeAgreement(Long userId, BigDecimal amount, String bindCardId) {
        BigDecimal minAmount = sysConfigService.getBigDecimal("min_recharge_amount");
        if (amount.compareTo(minAmount) < 0) {
            throw new BusinessException("充值金额不能小于" + minAmount);
        }
        if (amount.compareTo(new BigDecimal("50000")) > 0) {
            throw new BusinessException("充值金额不能大于50000");
        }
        RechargeOrder order = RechargeOrder.builder()
                                           .id(snowflakeIdWorker.nextId())
                                           .userId(userId)
                                           .amount(amount)
                                           .status(OrderStatus.NOT_PAID)
                                           .build();
        rechargeOrderRepo.save(order);
        if (StringUtils.isEmpty(bindCardId)) {
            bindCardId = userBankCardRepo.findByUserId(order.getUserId())
                                         .stream().map(UserBankCard::getBindCardId).findFirst().orElse(null);
        }
        if (StringUtils.isEmpty(bindCardId)) {
            throw new BusinessException("请先绑定银行卡");
        }
        return payEaseService.pay("余额充值", order.getId().toString(), order.getAmount(),
                order.getUserId().toString(), bindCardId, Constants.OrderNotifyType.RECHARGE);
    }

    public String rechargeQuick(Long userId, BigDecimal amount, Long companyId) {
        BigDecimal minAmount = sysConfigService.getBigDecimal("min_recharge_amount");
        if (amount.compareTo(minAmount) < 0) {
            throw new BusinessException("充值金额不能小于" + minAmount);
        }
        if (amount.compareTo(new BigDecimal("50000")) > 0) {
            throw new BusinessException("充值金额不能大于50000");
        }
        RechargeOrder order = RechargeOrder.builder()
                                           .id(snowflakeIdWorker.nextId())
                                           .userId(userId)
                                           .amount(amount)
                                           .status(OrderStatus.NOT_PAID)
                                           .build();
        rechargeOrderRepo.save(order);
        return sandPayService.payQuick(order.getId() + "", "余额充值",
                order.getAmount(), LocalDateTime.now().plusMinutes(3), Constants.OrderNotifyType.RECHARGE,
                generalProperties.resolveFrontUrl(companyId, "/home"));
    }

    public String rechargeQuickBind(Long userId, BigDecimal amount, Long companyId) {
        BigDecimal minAmount = sysConfigService.getBigDecimal("min_recharge_amount");
        if (amount.compareTo(minAmount) < 0) {
            throw new BusinessException("充值金额不能小于" + minAmount);
        }
        if (amount.compareTo(new BigDecimal("50000")) > 0) {
            throw new BusinessException("充值金额不能大于50000");
        }
        IdentityAuth identityAuth = identityAuthRepo
                .findFirstByUserIdAndStatusAndDelFalseOrderByCreatedAtDesc(userId, AuthStatus.SUCCESS)
                .orElseThrow(new BusinessException("请先完成实名认证"));
        RechargeOrder order = RechargeOrder.builder()
                                           .id(snowflakeIdWorker.nextId())
                                           .userId(userId)
                                           .amount(amount)
                                           .status(OrderStatus.NOT_PAID)
                                           .build();
        rechargeOrderRepo.save(order);
        return sandPayService.payQuickBind(order.getId() + "", "余额充值",
                order.getAmount(), LocalDateTime.now().plusMinutes(3), Constants.OrderNotifyType.RECHARGE,
                generalProperties.resolveFrontUrl(companyId, "/home"),
                userId, identityAuth.getRealName(), identityAuth.getIdNo());
    }

    public JSONObject refund(String orderId, String transactionId, BigDecimal amount, String channel) {
        switch (channel) {
            case Constants.PayChannel.SAND: {
                JSONObject res = sandPayService.refund(orderId, amount);
                if (!"000000".equals(res.getJSONObject("head").getString("respCode"))) {
                    String msg = res.getJSONObject("head").getString("respMsg");
                    throw new BusinessException("退款失败:" + msg);
                }
                return res;
            }
            case Constants.PayChannel.HM: {
                JSONObject res = hmPayService.refund(orderId, amount);
                if (!"REFUND_SUCCESS".equals(res.getString("sub_code"))) {
                    String msg = res.getString("msg");
                    throw new BusinessException("退款失败:" + msg);
                }
                return res;
            }
            case Constants.PayChannel.PE: {
                JSONObject res = payEaseService.refund(orderId, transactionId, amount);
                String status = res.getString("status");
                if (!"SUCCESS".equals(status)) {
                    String error = res.getString("error");
                    String cause = res.getString("cause");
                    throw new BusinessException("退款失败:" + error + ";" + cause);
                }
                return res;
            }
            case Constants.PayChannel.ALI: {
                alipayService.refund(orderId, amount);
                return null;
            }
        }
        throw new BusinessException("退款失败");
    }

    public PayQuery query(String orderId) {
        return query(orderId, null);
    }

    public PayQuery query(String orderId, String channel) {
        if (StringUtils.isNotEmpty(channel)) {
            switch (channel) {
                case Constants.PayChannel.SAND:
                    return sandPayService.payQuery(orderId);
                case Constants.PayChannel.HM:
                    return hmPayService.payQuery(orderId);
                case Constants.PayChannel.PE:
                    return payEaseService.payQuery(orderId);
            }
        }
        PayQuery query = sandPayService.payQuery(orderId);
        if (query == null || !query.isExist()) {
            query = hmPayService.payQuery(orderId);
        }
        if (query == null || !query.isExist()) {
            query = payEaseService.payQuery(orderId);
        }
        if (query == null || !query.isExist()) {
            query = alipayService.payQuery(orderId);
        }
        return Optional.ofNullable(query).orElse(PayQuery.builder().exist(false).build());
    }

    @Cacheable(value = "payOrder", key = "'auctionOrder#'+#orderId")
    public String payAuctionOrder(Long orderId) {
        AuctionOrder order = auctionOrderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != AuctionOrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        switch (PAY_CHANNEL) {
            case Constants.PayChannel.SAND:
                return sandPayService.pay(orderId + "", "拍卖:" + order.getName(), order.getTotalPrice(),
                        order.getCreatedAt().plusMinutes(3), Constants.OrderNotifyType.AUCTION);
            case Constants.PayChannel.HM:
                return hmPayService.requestAlipay(orderId + "", order.getTotalPrice(),
                        "拍卖:" + order.getName(), HMPayService.getTimeout(order.getCreatedAt(), 180),
                        Constants.OrderNotifyType.AUCTION, generalProperties.resolveFrontUrl(getCompanyId(), "/home"));
        }
        throw new BusinessException("绿洲宇宙冷却系统已启动，请稍后支付");
    }

    @Cacheable(value = "payOrder", key = "'auctionOrder#'+#orderId")
    public String payAuctionAli(Long orderId) {
        AuctionOrder order = auctionOrderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != AuctionOrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }

        String qrCode = aliRequest(orderId, order.getTotalPrice(), "拍卖:" + order
                .getName(), Constants.OrderNotifyType.AUCTION);

        String ua = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest()
                                                                                            .getHeader("User-Agent");
        if (ua.toLowerCase().contains("micromessenger")) {
            return "/static/wx_alipay_bridge.html?payUrl=" + URLEncoder
                    .encode(Constants.ALIPAY_URL_SCHEME + qrCode, StandardCharsets.UTF_8)
                    + "&orderId=" + orderId + "&type=auctionOrder&returnUrl="
                    + URLEncoder
                    .encode(generalProperties.resolveFrontUrl(getCompanyId(), "/home"), StandardCharsets.UTF_8);
        } else {
            return Constants.ALIPAY_URL_SCHEME + qrCode;
        }
    }

    @Cacheable(value = "payOrder", key = "'auctionOrder#'+#orderId")
    public String payAuctionQuick(Long orderId) {
        AuctionOrder order = auctionOrderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != AuctionOrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        IdentityAuth identityAuth = identityAuthRepo
                .findFirstByUserIdAndStatusAndDelFalseOrderByCreatedAtDesc(order.getUserId(), AuthStatus.SUCCESS)
                .orElseThrow(new BusinessException("请先完成实名认证"));
        return sandPayService.payQuick(orderId + "", "拍卖:" + order.getName(),
                order.getTotalPrice(), order.getCreatedAt().plusMinutes(3), Constants.OrderNotifyType.AUCTION,
                generalProperties.resolveFrontUrl(getCompanyId(), "/home"));
    }

    @Cacheable(value = "payOrder", key = "'auctionOrder#'+#orderId")
    public String payAuctionQuickBind(Long orderId) {
        AuctionOrder order = auctionOrderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != AuctionOrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        IdentityAuth identityAuth = identityAuthRepo
                .findFirstByUserIdAndStatusAndDelFalseOrderByCreatedAtDesc(order.getUserId(), AuthStatus.SUCCESS)
                .orElseThrow(new BusinessException("请先完成实名认证"));
        return sandPayService.payQuickBind(orderId + "", "拍卖:" + order.getName(),
                order.getTotalPrice(), order.getCreatedAt().plusMinutes(3), Constants.OrderNotifyType.AUCTION,
                generalProperties.resolveFrontUrl(getCompanyId(), "/home"),
                order.getUserId(), identityAuth.getRealName(), identityAuth.getIdNo());
    }

    public void payAuctionOrderBalance(Long orderId, Long userId, String tradeCode) {
        AuctionOrder order = auctionOrderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != AuctionOrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        checkTradeCode(userId, tradeCode, order.getUserId());
        BalanceRecord record = userBalanceService.balancePay(order.getUserId(), order.getTotalPrice(), orderId, "拍卖");
        auctionOrderService.notify(orderId, PayMethod.BALANCE, record.getId().toString());
    }

    public void payTradeAuctionOrderBalance(Long orderId, Long userId, String tradeCode) {
        TradeAuctionOrder order = tradeAuctionOrderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        TradeAuction tradeAuction = tradeAuctionRepo.findById(order.getTradeAuctionId())
                                                    .orElseThrow(new BusinessException("暂无"));
        if (order.getStatus() != AuctionOrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        if (tradeAuction.getStock() < 1) {
            throw new BusinessException("库存不足");
        }
        if (LocalDateTime.now().compareTo(tradeAuction.getCurrentStartTime()) < 0) {
            throw new BusinessException("未到竞价时间");
        }
        if (!tradeAuction.getStatus().equals(TradeAuctionStatus.ONGOING) & !tradeAuction.getStatus()
                                                                                        .equals(TradeAuctionStatus.PURCHASED)) {
            throw new BusinessException("易拍产品未处在竞价状态");
        }
        if (order.getPaymentType().equals(AuctionPaymentType.DEPOSIT)) {
            if (order.getPrice().compareTo(tradeAuction.getNextPrice()) != 0) {
                throw new BusinessException("已经失去购买资格");
            }
            if (tradeAuction.getSale() >= 30) {
                throw new BusinessException("已无购买资格");
            }
        }
        checkTradeCode(userId, tradeCode, order.getUserId());
        BigDecimal amount;
        if (order.getPaymentType() != AuctionPaymentType.DEPOSIT) {
            amount = order.getPrice();
        } else {
            amount = order.getServiceCharge();
        }
        BalanceRecord record = userBalanceService
                .balancePay(order.getUserId(), amount, orderId, "拍卖");
        tradeAuctionOrderService.commission(order, order.getPrice());
        tradeAuctionOrderService.notify(orderId, record.getId().toString(), PayMethod.BALANCE);
    }

    @Cacheable(value = "payOrder", key = "'auctionOrder#'+#orderId")
    public Map<String, Object> payAuctionOrderAgreement(Long orderId, String bindCardId) {
        AuctionOrder order = auctionOrderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != AuctionOrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        if (StringUtils.isEmpty(bindCardId)) {
            bindCardId = userBankCardRepo.findByUserId(order.getUserId())
                                         .stream().map(UserBankCard::getBindCardId).findFirst().orElse(null);
        }
        if (StringUtils.isEmpty(bindCardId)) {
            throw new BusinessException("请先绑定银行卡");
        }
        return payEaseService.pay("拍卖:" + order.getAuctionId(), orderId.toString(), order.getTotalPrice(),
                order.getUserId().toString(), bindCardId, Constants.OrderNotifyType.AUCTION);
    }

    @Cacheable(value = "payOrder", key = "'picOrder#'+#orderId")
    public String payPicOrder(Long orderId) {
        PhotoAsset order = photoAssetRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getOrderStatus() != OrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        switch (PAY_CHANNEL) {
            case Constants.PayChannel.SAND:
                return sandPayService.pay(orderId + "", "星图:" + order.getPicName(), order.getPrice(),
                        order.getCreatedAt().plusMinutes(3), Constants.OrderNotifyType.PIC);
            case Constants.PayChannel.HM:
                return hmPayService.requestAlipay(orderId + "", order.getPrice(),
                        "星图:" + order.getPicName(), HMPayService.getTimeout(order.getCreatedAt(), 180),
                        Constants.OrderNotifyType.PIC, generalProperties
                                .resolveFrontUrl(getCompanyId(), "/orderDetail?id=" + orderId));
        }
        throw new BusinessException("绿洲宇宙冷却系统已启动，请稍后支付");
    }

    @Cacheable(value = "payOrder", key = "'picOrder#'+#orderId")
    public String payPicAli(Long orderId) {
        PhotoAsset order = photoAssetRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getOrderStatus() != OrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }

        String qrCode = aliRequest(orderId, order.getPrice(), "星图:" + order
                .getPicName(), Constants.OrderNotifyType.PIC);

        String ua = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest()
                                                                                            .getHeader("User-Agent");
        if (ua.toLowerCase().contains("micromessenger")) {
            return "/static/wx_alipay_bridge.html?payUrl=" + URLEncoder
                    .encode(Constants.ALIPAY_URL_SCHEME + qrCode, StandardCharsets.UTF_8)
                    + "&orderId=" + orderId + "&type=pic&returnUrl="
                    + URLEncoder
                    .encode(generalProperties
                            .resolveFrontUrl(getCompanyId(), "/orderDetail?id=" + orderId), StandardCharsets.UTF_8);
        } else {
            return Constants.ALIPAY_URL_SCHEME + qrCode;
        }
    }

    @Cacheable(value = "payOrder", key = "'picOrder#'+#orderId")
    public String payPicQuick(Long orderId) {
        PhotoAsset order = photoAssetRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getOrderStatus() != OrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        IdentityAuth identityAuth = identityAuthRepo
                .findFirstByUserIdAndStatusAndDelFalseOrderByCreatedAtDesc(order.getUserId(), AuthStatus.SUCCESS)
                .orElseThrow(new BusinessException("请先完成实名认证"));
        return sandPayService.payQuick(orderId + "", "星图:" + order.getPicName(),
                order.getPrice(), order.getCreatedAt().plusMinutes(3), Constants.OrderNotifyType.PIC,
                generalProperties.resolveFrontUrl(getCompanyId(), "/orderDetail?id=" + orderId));
    }

    @Cacheable(value = "payOrder", key = "'picOrder#'+#orderId")
    public String payPicQuickBind(Long orderId) {
        PhotoAsset order = photoAssetRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getOrderStatus() != OrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        IdentityAuth identityAuth = identityAuthRepo
                .findFirstByUserIdAndStatusAndDelFalseOrderByCreatedAtDesc(order.getUserId(), AuthStatus.SUCCESS)
                .orElseThrow(new BusinessException("请先完成实名认证"));
        return sandPayService.payQuickBind(orderId + "", "星图:" + order.getPicName(),
                order.getPrice(), order.getCreatedAt().plusMinutes(3), Constants.OrderNotifyType.PIC,
                generalProperties.resolveFrontUrl(getCompanyId(), "/orderDetail?id=" + orderId),
                order.getUserId(), identityAuth.getRealName(), identityAuth.getIdNo());
    }

    public void payPicOrderBalance(Long orderId, Long userId, String tradeCode) {
        PhotoAsset order = photoAssetRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getOrderStatus() != OrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        checkTradeCode(userId, tradeCode, order.getUserId());
        BalanceRecord record = userBalanceService.balancePay(order.getUserId(), order.getPrice(), orderId, "星图");
        photoAssetService.notify(orderId, PayMethod.BALANCE, record.getId().toString());
    }

    @Cacheable(value = "payOrder", key = "'picOrder#'+#orderId")
    public Map<String, Object> payPicOrderAgreement(Long orderId, String bindCardId) {
        PhotoAsset order = photoAssetRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getOrderStatus() != OrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        if (StringUtils.isEmpty(bindCardId)) {
            bindCardId = userBankCardRepo.findByUserId(order.getUserId())
                                         .stream().map(UserBankCard::getBindCardId).findFirst().orElse(null);
        }
        if (StringUtils.isEmpty(bindCardId)) {
            throw new BusinessException("请先绑定银行卡");
        }
        return payEaseService.pay("星图:" + order.getPicName(), orderId.toString(), order.getPrice(),
                order.getUserId().toString(), bindCardId, Constants.OrderNotifyType.PIC);
    }


    @Cacheable(value = "payOrder", key = "'domain#'+#orderId")
    public String payDomainOrder(Long orderId) {
        DomainOrder order = domainOrderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getOrderStatus() != OrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        switch (PAY_CHANNEL) {
            case Constants.PayChannel.SAND:
                return sandPayService.pay(orderId + "", "域名:" + order.getPicName(), order.getPrice(),
                        order.getCreatedAt().plusMinutes(3), Constants.OrderNotifyType.DOMAIN);
            case Constants.PayChannel.HM:
                return hmPayService.requestAlipay(orderId + "", order.getPrice(),
                        "域名:" + order.getPicName(), HMPayService.getTimeout(order.getCreatedAt(), 180),
                        Constants.OrderNotifyType.DOMAIN, generalProperties
                                .resolveFrontUrl(getCompanyId(), "/domainname"));
        }
        throw new BusinessException("绿洲宇宙冷却系统已启动，请稍后支付");
    }

    @Cacheable(value = "payOrder", key = "'domain#'+#orderId")
    public String payDomainAli(Long orderId) {
        DomainOrder order = domainOrderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getOrderStatus() != OrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }

        String qrCode = aliRequest(orderId, order.getPrice(), "域名:" + order
                .getPicName(), Constants.OrderNotifyType.DOMAIN);

        String ua = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest()
                                                                                            .getHeader("User-Agent");
        if (ua.toLowerCase().contains("micromessenger")) {
            return "/static/wx_alipay_bridge.html?payUrl=" + URLEncoder
                    .encode(Constants.ALIPAY_URL_SCHEME + qrCode, StandardCharsets.UTF_8)
                    + "&orderId=" + orderId + "&type=domain&returnUrl="
                    + URLEncoder
                    .encode(generalProperties
                            .resolveFrontUrl(getCompanyId(), "/domainname"), StandardCharsets.UTF_8);
        } else {
            return Constants.ALIPAY_URL_SCHEME + qrCode;
        }
    }

    @Cacheable(value = "payOrder", key = "'domain#'+#orderId")
    public String payDomainQuick(Long orderId) {
        DomainOrder order = domainOrderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getOrderStatus() != OrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        IdentityAuth identityAuth = identityAuthRepo
                .findFirstByUserIdAndStatusAndDelFalseOrderByCreatedAtDesc(order.getUserId(), AuthStatus.SUCCESS)
                .orElseThrow(new BusinessException("请先完成实名认证"));
        return sandPayService.payQuick(orderId + "", "域名:" + order.getPicName(),
                order.getPrice(), order.getCreatedAt().plusMinutes(3), Constants.OrderNotifyType.DOMAIN,
                generalProperties.resolveFrontUrl(getCompanyId(), "/domainname"));
    }

    @Cacheable(value = "payOrder", key = "'domain#'+#orderId")
    public String payDomainQuickBind(Long orderId) {
        DomainOrder order = domainOrderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getOrderStatus() != OrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        IdentityAuth identityAuth = identityAuthRepo
                .findFirstByUserIdAndStatusAndDelFalseOrderByCreatedAtDesc(order.getUserId(), AuthStatus.SUCCESS)
                .orElseThrow(new BusinessException("请先完成实名认证"));
        return sandPayService.payQuickBind(orderId + "", "域名:" + order.getPicName(),
                order.getPrice(), order.getCreatedAt().plusMinutes(3), Constants.OrderNotifyType.DOMAIN,
                generalProperties.resolveFrontUrl(getCompanyId(), "/domainname"),
                order.getUserId(), identityAuth.getRealName(), identityAuth.getIdNo());
    }

    public void payDomainOrderBalance(Long orderId, Long userId, String tradeCode) throws FontFormatException, IOException, WriterException {
        DomainOrder order = domainOrderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getOrderStatus() != OrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        checkTradeCode(userId, tradeCode, order.getUserId());
        BalanceRecord record = userBalanceService.balancePay(order.getUserId(), order.getPrice(), orderId, "域名");
        domainOrderService.notify(orderId, PayMethod.BALANCE, record.getId().toString());
    }

    @Cacheable(value = "payOrder", key = "'domain#'+#orderId")
    public Map<String, Object> payDomainOrderAgreement(Long orderId, String bindCardId) {
        DomainOrder order = domainOrderRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getOrderStatus() != OrderStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        if (StringUtils.isEmpty(bindCardId)) {
            bindCardId = userBankCardRepo.findByUserId(order.getUserId())
                                         .stream().map(UserBankCard::getBindCardId).findFirst().orElse(null);
        }
        if (StringUtils.isEmpty(bindCardId)) {
            throw new BusinessException("请先绑定银行卡");
        }
        return payEaseService.pay("域名:" + order.getPicName(), orderId.toString(), order.getPrice(),
                order.getUserId().toString(), bindCardId, Constants.OrderNotifyType.DOMAIN);
    }

    public void payDomainAskBalance(Long orderId, Long userId, String tradeCode) throws FontFormatException, IOException, WriterException {
        DomainAsk order = domainAskRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != DomainAskStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        checkTradeCode(userId, tradeCode, order.getUserId());
        BalanceRecord record = userBalanceService.balancePay(order.getUserId(), order.getPrice(), orderId, "元域名叫价");
        domainAskService.notifyOrder(orderId, PayMethod.BALANCE, record.getId().toString());
    }

    @Cacheable(value = "payOrder", key = "'ask#'+#orderId")
    public String payAskOrder(Long orderId) {
        DomainAsk order = domainAskRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != DomainAskStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        switch (PAY_CHANNEL) {
            case Constants.PayChannel.SAND:
                return sandPayService.pay(orderId + "", "域名:" + order.getName(), order.getPrice(),
                        order.getCreatedAt().plusMinutes(3), Constants.OrderNotifyType.ASK);
            case Constants.PayChannel.HM:
                return hmPayService.requestAlipay(orderId + "", order.getPrice(),
                        "域名:" + order.getName(), HMPayService.getTimeout(order.getCreatedAt(), 180),
                        Constants.OrderNotifyType.ASK, generalProperties
                                .resolveFrontUrl(getCompanyId(), "/domainname"));
        }
        throw new BusinessException("绿洲宇宙冷却系统已启动，请稍后支付");
    }

    @Cacheable(value = "payOrder", key = "'ask#'+#orderId")
    public String payAskAli(Long orderId) {
        DomainAsk order = domainAskRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != DomainAskStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        String qrCode = aliRequest(orderId, order.getPrice(), "叫价:" + order
                .getName(), Constants.OrderNotifyType.ASK);

        String ua = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest()
                                                                                            .getHeader("User-Agent");
        if (ua.toLowerCase().contains("micromessenger")) {
            return "/static/wx_alipay_bridge.html?payUrl=" + URLEncoder
                    .encode(Constants.ALIPAY_URL_SCHEME + qrCode, StandardCharsets.UTF_8)
                    + "&orderId=" + orderId + "&type=domain&returnUrl="
                    + URLEncoder
                    .encode(generalProperties
                            .resolveFrontUrl(getCompanyId(), "/domainname"), StandardCharsets.UTF_8);
        } else {
            return Constants.ALIPAY_URL_SCHEME + qrCode;
        }
    }

    @Cacheable(value = "payOrder", key = "'ask#'+#orderId")
    public String payAskQuick(Long orderId) {
        DomainAsk order = domainAskRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != DomainAskStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        IdentityAuth identityAuth = identityAuthRepo
                .findFirstByUserIdAndStatusAndDelFalseOrderByCreatedAtDesc(order.getUserId(), AuthStatus.SUCCESS)
                .orElseThrow(new BusinessException("请先完成实名认证"));
        return sandPayService.payQuick(orderId + "", "叫价:" + order.getName(),
                order.getPrice(), order.getCreatedAt().plusMinutes(3), Constants.OrderNotifyType.ASK,
                generalProperties.resolveFrontUrl(getCompanyId(), "/domainname"));
    }

    @Cacheable(value = "payOrder", key = "'ask#'+#orderId")
    public String payAskQuickBind(Long orderId) {
        DomainAsk order = domainAskRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != DomainAskStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        IdentityAuth identityAuth = identityAuthRepo
                .findFirstByUserIdAndStatusAndDelFalseOrderByCreatedAtDesc(order.getUserId(), AuthStatus.SUCCESS)
                .orElseThrow(new BusinessException("请先完成实名认证"));
        return sandPayService.payQuickBind(orderId + "", "叫价:" + order.getName(),
                order.getPrice(), order.getCreatedAt().plusMinutes(3), Constants.OrderNotifyType.ASK,
                generalProperties.resolveFrontUrl(getCompanyId(), "/domainname"),
                order.getUserId(), identityAuth.getRealName(), identityAuth.getIdNo());
    }

    @Cacheable(value = "payOrder", key = "'ask#'+#orderId")
    public Map<String, Object> payAskOrderAgreement(Long orderId, String bindCardId) {
        DomainAsk order = domainAskRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        if (order.getStatus() != DomainAskStatus.NOT_PAID) {
            throw new BusinessException("订单状态错误");
        }
        if (StringUtils.isEmpty(bindCardId)) {
            bindCardId = userBankCardRepo.findByUserId(order.getUserId())
                                         .stream().map(UserBankCard::getBindCardId).findFirst().orElse(null);
        }
        if (StringUtils.isEmpty(bindCardId)) {
            throw new BusinessException("请先绑定银行卡");
        }
        return payEaseService.pay("叫价:" + order.getName(), orderId.toString(), order.getPrice(),
                order.getUserId().toString(), bindCardId, Constants.OrderNotifyType.ASK);
    }
}