package com.nova.sankuai.service.impl;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.IdUtil;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.nova.sankuai.domain.api.rongyitui.RongYiTuiResponse;
import com.nova.sankuai.domain.api.rongyitui.RongYiTuiUtil;
import com.nova.sankuai.domain.api.yangqianguan.YqgUtil;
import com.nova.sankuai.domain.api.yangqianguan.dto.OrderUpdateStatusDto;
import com.nova.sankuai.domain.api.yangqianguan.dto.RepayResultReturnDto;
import com.nova.sankuai.domain.api.yangqianguan.response.CreditResultResponse;
import com.nova.sankuai.domain.api.yangqianguan.response.RepayPlanResponse;
import com.nova.sankuai.domain.api.yangqianguan.vo.RepayDetailPlanVo;
import com.nova.sankuai.domain.api.yixin.TXOcrUtil;
import com.nova.sankuai.domain.api.yixin.YXSignUtil;
import com.nova.sankuai.domain.api.yixin.YXUtil;
import com.nova.sankuai.domain.api.yixin.callback.YxAuditCallbackRequest;
import com.nova.sankuai.domain.api.yixin.callback.YxLoanApplyCallbackResult;
import com.nova.sankuai.domain.api.yixin.dto.YxRepaymentPlanQueryDto;
import com.nova.sankuai.domain.api.yixin.response.*;
import com.nova.sankuai.domain.api.yixin.vo.YxpkgListVo;
import com.nova.sankuai.domain.entity.*;
import com.nova.sankuai.domain.enums.capitalInfo.*;
import com.nova.sankuai.infra.config.CommonException;
import com.nova.sankuai.infra.constants.ResultCode;
import com.nova.sankuai.infra.mapper.CustomerCapitalResultMapper;
import com.nova.sankuai.infra.mapper.CustomerMapper;
import com.nova.sankuai.infra.mapper.YqgRepayOrderDetailMapper;
import com.nova.sankuai.infra.mapper.YqgRepayOrderMapper;
import com.nova.sankuai.infra.utils.ImageUtil;
import com.nova.sankuai.infra.utils.ResultJson;
import com.nova.sankuai.security.UserDetail;
import com.nova.sankuai.service.ICustomerUserService;
import com.nova.sankuai.service.IYiXinService;
import lombok.AllArgsConstructor;
import org.apache.commons.lang.StringUtils;
import org.apache.http.util.TextUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import sun.misc.BASE64Decoder;

import java.text.SimpleDateFormat;
import java.util.*;

/**
 * @author weikangdi
 * @create 2022/3/15
 */

@Service
@AllArgsConstructor
public class YiXinServiceImpl implements IYiXinService {

    private final ICustomerUserService customerUserService;

    private final YXUtil yxUtil;

    private static final Logger logger = LoggerFactory.getLogger("lvdiLogger");

    private final CustomerMapper customerMapper;

    private final ImageUtil imageUtil;

    private final CustomerCapitalResultMapper customerCapitalResultMapper;

    private final YqgUtil yqgUtil;

    private final RongYiTuiUtil rongYiTuiUtil;

    private final YqgRepayOrderMapper yqgRepayOrderMapper;

    private final YqgRepayOrderDetailMapper yqgRepayOrderDetailMapper;

    private static final Logger systemLogger = LoggerFactory.getLogger("systemLogger");

    @Override
    public ResultJson getTXFaceInfo(String phone, String name, String idNo, String channelInfo) {
        try {
            CustomerUser customerUser = customerUserService.getUserByPhone(phone);
            if (customerUser == null) {
                throw new CommonException("用户不存在");
            }
            Map<String, String> keyInfo = yxUtil.getTxKeyInfo(channelInfo);
            String appId = keyInfo.get("appId");
            String secret = keyInfo.get("secret");
            String accessTokenInfo = TXOcrUtil.getAccessToken(appId, secret);
            systemLogger.info("zbb378 accessTokenInfo:{}", accessTokenInfo);
            if (!TextUtils.isEmpty(accessTokenInfo)) {
                String access_token = JSON.parseObject(accessTokenInfo).getString("access_token");
                if (!TextUtils.isEmpty(access_token)) {
                    String signTicket = TXOcrUtil.getSignTicket(appId, access_token);
                    systemLogger.info("zbb378 signTicket:{}", signTicket);
                    if (!TextUtils.isEmpty(signTicket)) {
                        Map<String, String> faceInfoMap = new HashMap<>();
                        UUID uuid = UUID.randomUUID();
                        String nonce = uuid.toString().replace("-", "");
                        List<String> values = new ArrayList<>();
                        values.add(appId);
                        values.add(String.valueOf(customerUser.getId()));
                        values.add("1.0.0");
                        values.add(nonce);
                        String sign = TXOcrUtil.sign(values, signTicket);
                        final String order = "sankuai" + System.currentTimeMillis();
                        String faceId = TXOcrUtil.getFaceId(appId, order, String.valueOf(customerUser.getId()), sign, name, idNo, nonce);
                        String nonceTicket = TXOcrUtil.getNonceTicket(appId, access_token, String.valueOf(customerUser.getId()));
                        systemLogger.info("zbb378 nonceTicket:{}", nonceTicket);
                        if (!TextUtils.isEmpty(nonceTicket)) {
                            List<String> nonceValues = new ArrayList<>();
                            nonceValues.add(appId);
                            nonceValues.add(String.valueOf(customerUser.getId()));
                            nonceValues.add("1.0.0");
                            nonceValues.add(nonce);
                            String nonceSign = TXOcrUtil.sign(nonceValues, nonceTicket);
                            systemLogger.info("zbb378 nonceSign:{}", nonceSign);
                            if (!TextUtils.isEmpty(faceId)) {
                                //mode, appId, order, sign, faceId
                                faceInfoMap.put("sign", nonceSign);
                                faceInfoMap.put("appId", appId);
                                faceInfoMap.put("order", order);
                                faceInfoMap.put("faceId", faceId);
                                faceInfoMap.put("nonce", nonce);
                                faceInfoMap.put("userId", String.valueOf(customerUser.getId()));
                                return ResultJson.ok(faceInfoMap);
                            }
                        }
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        throw new CommonException("获取人脸核身的SIGN和NONCE信息失败");
    }

    @Override
    public ResultJson getTXOcrInfo(String phone, String channelInfo) {
        try {
            CustomerUser customerUser = customerUserService.getUserByPhone(phone);
            if (customerUser == null) {
                throw new CommonException("用户不存在");
            }
            Map<String, String> keyInfo = yxUtil.getTxKeyInfo(channelInfo);
            String appId = keyInfo.get("appId");
            String secret = keyInfo.get("secret");
            String accessTokenInfo = TXOcrUtil.getAccessToken(appId, secret);
            systemLogger.info("zbb378 getTXOcrInfo: appId {} secret {} accessTokenInfo {} ", appId, secret, accessTokenInfo);
            if (!TextUtils.isEmpty(accessTokenInfo)) {
                String access_token = JSON.parseObject(accessTokenInfo).getString("access_token");
                if (!TextUtils.isEmpty(access_token)) {
                    String nonceTicket = TXOcrUtil.getNonceTicket(appId, access_token, String.valueOf(customerUser.getId()));
                    if (!TextUtils.isEmpty(nonceTicket)) {
                        Map<String, String> ocrInfo = new HashMap<>();
                        UUID uuid = UUID.randomUUID();
                        String nonce = uuid.toString().replace("-", "");
                        List<String> nonceValues = new ArrayList<>();
                        nonceValues.add(appId);
                        nonceValues.add(String.valueOf(customerUser.getId()));
                        nonceValues.add("1.0.0");
                        nonceValues.add(nonce);
                        String nonceSign = TXOcrUtil.sign(nonceValues, nonceTicket);
                        final String order = "sankuaiOcr" + System.currentTimeMillis();
                        //mode, appId, order, sign, faceId
                        ocrInfo.put("sign", nonceSign);
                        ocrInfo.put("appId", appId);
                        ocrInfo.put("order", order);
                        ocrInfo.put("nonce", nonce);
                        ocrInfo.put("userId", String.valueOf(customerUser.getId()));
                        return ResultJson.ok(ocrInfo);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        throw new CommonException("获取ocr签名信息失败");
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public ResultJson getYxContractListQuery(UserDetail userDetail) {
        CustomerUser customerUser = customerUserService.lambdaQuery().eq(CustomerUser::getPhone, userDetail.getPhone()).one();
        if (customerUser == null) {
            throw new CommonException("用户不存在");
        }
        String logNumber = IdUtil.randomUUID();
//        logger.info("日志编号:" + logNumber + "获取绿地授信合同开始");
        YxContractResponse yxContractResponse = yxUtil.yxContractListQuery(String.valueOf(customerUser.getId()), "00", null, YXUtil.FUNDING_YIXIN, logger, logNumber);
        if (yxContractResponse != null && yxContractResponse.isSuccess()) {

            return ResultJson.ok(yxContractResponse.getContractLists());
        }
//        logger.info("日志编号:" + logNumber + "获取绿地授信合同结束");
        return ResultJson.failure(ResultCode.BAD_REQUEST, yxContractResponse == null ? "" : yxContractResponse.getResponseMsg() == null ? "" : yxContractResponse.getResponseMsg());
    }


    @Override
    public String yxAuditCallback(Map<String, String> request) throws Exception {
        Map<String, Object> resultMap = new HashMap<>();
        String logNumber = IdUtil.randomUUID();
        logger.info("日志编号：" + logNumber + "授信审批结果通知参数:{}", request);
        if (request != null) {
            Map<String, Object> result = YXSignUtil.parseLVDiRequest(request, YXUtil.getLocalPrivateKey(), yxUtil.getLvDiPublicKey());
            String params = result.get("params").toString();
            if (!TextUtils.isEmpty(params)) {
                logger.info("params:{}", params);
                YxAuditCallbackRequest yxAuditCallbackRequest = JSON.parseObject(params, YxAuditCallbackRequest.class);
                if (yxAuditCallbackRequest != null) {
                    String creditNo = yxAuditCallbackRequest.getCreditNo();
                    logger.info("creditNo:{}", creditNo);
                    if (creditNo != null) {
                        CustomerCapitalResult capitalResult = customerCapitalResultMapper.selectOne(Wrappers.<CustomerCapitalResult>lambdaQuery()
                                .eq(CustomerCapitalResult::getCreditNo, creditNo));
                        if (capitalResult != null) {
                            Integer approvalResult = capitalResult.getApprovalResult();
                            capitalResult = updateByApprovalReturn(capitalResult, yxAuditCallbackRequest);
                            notifyYqgByAudit(capitalResult, approvalResult, logger, logNumber);
                            rongYiTuiBack(capitalResult, yxAuditCallbackRequest);
                            resultMap.put("responseCode", "0000");
                            resultMap.put("responseMsg", "成功");
                            logger.info("日志编号：" + logNumber + "授信审批结果成功回调:{}", resultMap);
                            return YXSignUtil.buildResponse(resultMap, YXUtil.getLocalPrivateKey(), yxUtil.getLvDiPublicKey());
                        }
                    }
                }
            }
        }
        resultMap.put("responseCode", "9999");
        resultMap.put("responseMsg", "失败");
        logger.info("日志编号：" + logNumber + "授信审批结果失败回调:{}", resultMap);
        return YXSignUtil.buildResponse(resultMap, YXUtil.getLocalPrivateKey(), yxUtil.getLvDiPublicKey());
    }

    private void notifyYqgByAudit(CustomerCapitalResult capitalResult, Integer approvalResult, Logger logger, String logNumber) {
        try {
            if (CapitalApprovalResultEnum.APPROVAL_SUCCESS.getCode().equals(capitalResult.getApprovalResult())
                    && StringUtils.isEmpty(capitalResult.getSubExpDate())) {
                YXAuditResponse yxAuditResponse = yxUtil.yxGetCreditAudit(capitalResult.getCustomerUserId().toString(), capitalResult.getCreditNo(), YXUtil.FUNDING_JQTX, logger, logNumber);
                if (yxAuditResponse != null && yxAuditResponse.isSuccess() && capitalResult != null) {
                    capitalResult = updateByApprovalReturn(capitalResult, yxAuditResponse);
                }
            }
            //洋钱罐授信状态更新
            if (CapitalApprovalResultEnum.APPROVAL_WAIT.getCode().equals(approvalResult)
                    && !Objects.equals(approvalResult, capitalResult.getApprovalResult())
                    && CapitalResultSourceCodeEnum.YANG_QIAN_GUAN.getCode().equals(capitalResult.getCapitalResultSourceCode())) {
                CreditResultResponse feedBackDto = CreditResultResponse.parse(capitalResult);
                if (feedBackDto != null) {
                    logger.info("日志编号：" + logNumber + "授信审批回调通知洋钱罐开始,原始参数" + feedBackDto.toString());
                    yqgUtil.creditResultFeedBack(feedBackDto, logger, logNumber);
                }
            }
        } catch (Exception e) {
            logger.error("日志编号：" + logNumber + "授信审批回调通知洋钱罐异常", e);
        }
    }

    @Override
    public YXAuditResponse getYxCreditAudit(String phone) {
        CustomerUser customerUser = customerUserService.getUserByPhone(phone);
        if (customerUser == null) {
            throw new CommonException("该用户不存在");
        }
        Customer customer = customerMapper.getLatestCustomerRecord(customerUser.getPhone());
        if (customer == null) {
            throw new CommonException("没有有效的申请记录");
        }
        CustomerCapitalResult capitalResult = customerCapitalResultMapper.selectOne(Wrappers.<CustomerCapitalResult>lambdaQuery()
                .eq(CustomerCapitalResult::getCustomerUserId, customerUser.getId())
                .eq(CustomerCapitalResult::getCustomerRecordId, customer.getId())
                .eq(CustomerCapitalResult::getCapitalInfoCode, CapitalInfoTypeCodeEnum.YI_XIN));
        if (TextUtils.isEmpty(capitalResult.getCreditNo())) {
            throw new CommonException("授信编号为空");
        }
        String logNumber = IdUtil.randomUUID();
        logger.info("日志编号:" + logNumber + "授信申请查询开始");
        YXAuditResponse yxResponse = yxUtil.yxGetCreditAudit(customerUser.getId().toString(), capitalResult.getCreditNo(), yxUtil.getFunding(capitalResult.getCapitalInfoCode()), logger, logNumber);
        if (yxResponse != null) {
            if (yxResponse.isSuccess()) {
                if (capitalResult != null) {
                    updateByApprovalReturn(capitalResult, yxResponse);
                }
                return yxResponse;
            } else {
                if (yxResponse.getResponseCode().equals("ER0128")) {
                    logger.error("日志编号:" + logNumber + "授信审批查询失败" + yxResponse);
                    throw new CommonException("授信审批查询失败" + yxResponse);
                }
                logger.error("日志编号:" + logNumber + "参数不合法" + yxResponse);
                throw new CommonException("参数不合法" + yxResponse.getResponseMsg() == null ? "" : yxResponse.getResponseMsg());
            }
        }
        logger.info("日志编号:" + logNumber + "授信申请查询结束");
        throw new CommonException("宜信接口调用错误,授信审批查询失败");
    }

    @Override
    public CustomerCapitalResult updateByApprovalReturn(CustomerCapitalResult capitalResult, YXAuditResponse yxResponse) {
        String currentDate = DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss");
        capitalResult.setTotalCredit(yxResponse.getTotalCredit());
        capitalResult.setSubExpDate(yxResponse.getSubExpDate());
        capitalResult.setRateType(yxResponse.getRateType());
        capitalResult.setQuotaRate(yxResponse.getQuotaRate());
        capitalResult.setAvailableAmount(yxResponse.getAvailableAmount());
        capitalResult.setCreditContractNo(yxResponse.getCreditContractNo());
        capitalResult.setFailedReason(yxResponse.getFailedReason());
        capitalResult.setStepAmount(yxResponse.getStepAmount());
        capitalResult.setPeriods(yxResponse.getPeriods());
        capitalResult.setMaxAmount(yxResponse.getMaxAmount());
        capitalResult.setMinAmount(yxResponse.getMinAmount());
        capitalResult.setApprovalTermUnit(yxResponse.getApprovalTermUnit());
        capitalResult.setFreezeTime(yxResponse.getFreezeTime());
        if (StringUtils.isNotEmpty(yxResponse.getCreditApplyTime())) {
            capitalResult.setCreditApplyTime(yxResponse.getCreditApplyTime());
        } else {
            capitalResult.setCreditApplyTime(currentDate);
        }
        if (YxAuditCallbackRequest.SUCCESS.equals(yxResponse.getApprovalResult())) {
            capitalResult.setApprovalResult(CapitalApprovalResultEnum.APPROVAL_SUCCESS.getCode());
        } else if (YxAuditCallbackRequest.REFUSE.equals(yxResponse.getApprovalResult())) {
            capitalResult.setApprovalResult(CapitalApprovalResultEnum.APPROVAL_REFUSE.getCode());
        }
        capitalResult.setLastUpdatedDate(new Date());
        customerCapitalResultMapper.update(null, Wrappers.<CustomerCapitalResult>lambdaUpdate()
                .set(CustomerCapitalResult::getTotalCredit, capitalResult.getTotalCredit())
                .set(CustomerCapitalResult::getSubExpDate, capitalResult.getSubExpDate())
                .set(CustomerCapitalResult::getRateType, capitalResult.getRateType())
                .set(CustomerCapitalResult::getQuotaRate, capitalResult.getQuotaRate())
                .set(CustomerCapitalResult::getAvailableAmount, capitalResult.getAvailableAmount())
                .set(CustomerCapitalResult::getCreditContractNo, capitalResult.getCreditContractNo())
                .set(CustomerCapitalResult::getCreditApplyTime, capitalResult.getCreditApplyTime())
                .set(CustomerCapitalResult::getFailedReason, capitalResult.getFailedReason())
                .set(CustomerCapitalResult::getStepAmount, capitalResult.getStepAmount())
                .set(CustomerCapitalResult::getPeriods, capitalResult.getPeriods())
                .set(CustomerCapitalResult::getMaxAmount, capitalResult.getMaxAmount())
                .set(CustomerCapitalResult::getMinAmount, capitalResult.getMinAmount())
                .set(CustomerCapitalResult::getApprovalTermUnit, capitalResult.getApprovalTermUnit())
                .set(CustomerCapitalResult::getFreezeTime, capitalResult.getFreezeTime())
                .set(CustomerCapitalResult::getApprovalResult, capitalResult.getApprovalResult())
                .set(CustomerCapitalResult::getLastUpdatedDate, capitalResult.getLastUpdatedDate())
                .eq(CustomerCapitalResult::getId, capitalResult.getId()));
        return capitalResult;
    }

    @Override
    public YXCreditLimitResponse getYxCreditLimit(UserDetail userDetail) {
        CustomerUser customerUser = customerUserService.getUserByPhone(userDetail.getPhone());
        if (customerUser == null) {
            throw new CommonException("用户不存在");
        }
        Customer customer = customerMapper.getLatestCustomerRecord(customerUser.getPhone());
        if (customer == null) {
            throw new CommonException("没有有效的申请记录");
        }
        CustomerCapitalResult capitalResult = customerCapitalResultMapper.selectOne(Wrappers.<CustomerCapitalResult>lambdaQuery()
                .eq(CustomerCapitalResult::getCustomerUserId, customerUser.getId())
                .eq(CustomerCapitalResult::getCustomerRecordId, customer.getId())
                .eq(CustomerCapitalResult::getCapitalInfoCode, CapitalInfoTypeCodeEnum.YI_XIN));
        if (capitalResult == null) {
            throw new CommonException("用户资方对接结果不存在");
        }
        String logNumber = IdUtil.randomUUID();
        logger.info("日志编号:" + logNumber + "授信额度查询开始");
        YXCreditLimitResponse yxResponse = yxUtil.yxGetCreditLimit(customerUser.getId().toString(), capitalResult.getCreditNo(), yxUtil.getFunding(capitalResult.getCapitalInfoCode()), logger, logNumber);
        if (yxResponse != null) {
            if (yxResponse.isSuccess()) {
                return yxResponse;
            } else {
                if (yxResponse.getResponseCode().equals("ER0128")) {
                    logger.error("日志编号:" + logNumber + "额度查询失败" + yxResponse);
                    throw new CommonException("额度查询失败" + yxResponse);
                }
                logger.error("日志编号:" + logNumber + "参数不合法" + yxResponse);
                throw new CommonException("参数不合法" + yxResponse.getResponseMsg() == null ? "" : yxResponse.getResponseMsg());
            }
        }
        logger.info("日志编号:" + logNumber + "授信额度查询结束");
        throw new CommonException("宜信接口调用错误,额度查询失败");
    }

    @Override
    public ResultJson uploadBase64File(String base64Info) {
        // 通过base64来转化图片
        if (base64Info.contains("data:image/jpeg;base64")) {
            base64Info = base64Info.replaceAll("data:image/jpeg;base64,", "");
        } else if (base64Info.contains("data:image/jpg;base64,")) {
            base64Info = base64Info.replaceAll("data:image/jpg;base64,", "");
        } else if (base64Info.contains("data:image/png;base64,")) {
            base64Info = base64Info.replaceAll("data:image/png;base64,", "");
        }
        BASE64Decoder decoder = new BASE64Decoder();
        // Base64解码
        byte[] imageByte;
        try {
            imageByte = decoder.decodeBuffer(base64Info);
            for (int i = 0; i < imageByte.length; ++i) {
                //调整异常数据
                if (imageByte[i] < 0) {
                    imageByte[i] += 256;
                }
            }
            String fileUrl = imageUtil.uploadBase64File(imageByte, false);
            systemLogger.info("base64上传图片成功：{}",fileUrl);
            return ResultJson.ok(fileUrl);
        } catch (Exception e) {
            e.printStackTrace();
            systemLogger.error("base64上传图片失败：{}",e);
        }
        return ResultJson.failure(ResultCode.SERVER_ERROR);
    }


    @Override
    public String yxLoanApplyCallback(Map<String, String> request) throws Exception {
        Map<String, Object> resultMap = new HashMap<>();
        String logNumber = IdUtil.randomUUID();
        logger.info("日志编号：" + logNumber + "用信结果通知回调接口参数:{}", request);
        if (request != null) {
            Map<String, Object> result = YXSignUtil.parseLVDiRequest(request, YXUtil.getLocalPrivateKey(), yxUtil.getLvDiPublicKey());
            String params = result.get("params").toString();
            if (!TextUtils.isEmpty(params)) {
                logger.info("params:{}", params);
                YxLoanApplyCallbackResult yxAuditCallbackRequest = JSON.parseObject(params, YxLoanApplyCallbackResult.class);
                if (yxAuditCallbackRequest != null) {
                    String loanNo = yxAuditCallbackRequest.getLoanNo();
                    logger.info("loanNo:{}", loanNo);
                    if (loanNo != null) {
                        CustomerCapitalResult capitalResult = customerCapitalResultMapper.selectOne(Wrappers.<CustomerCapitalResult>lambdaQuery()
                                .eq(CustomerCapitalResult::getLoanNo, loanNo));
                        if (capitalResult != null) {
                            Integer loanApplyResult = capitalResult.getLoanApplyResult();
                            capitalResult = updateByLoanReturn(capitalResult, yxAuditCallbackRequest);
                            notifyYqgByLoanApply(capitalResult, loanApplyResult, logger, logNumber);
                            resultMap.put("responseCode", "0000");
                            resultMap.put("responseMsg", "成功");
                            logger.info("日志编号：" + logNumber + "用信结果通知接口成功回调:{}", resultMap);
                            return YXSignUtil.buildResponse(resultMap, YXUtil.getLocalPrivateKey(), yxUtil.getLvDiPublicKey());
                        }
                    }
                }
            }
        }
        resultMap.put("responseCode", "9999");
        resultMap.put("responseMsg", "失败");
        logger.info("日志编号：" + logNumber + "用信结果通知接口失败回调:{}", resultMap);
        return YXSignUtil.buildResponse(resultMap, YXUtil.getLocalPrivateKey(), yxUtil.getLvDiPublicKey());
    }

    private void notifyYqgByLoanApply(CustomerCapitalResult capitalResult, Integer loanApplyResult, Logger logger, String logNumber) {
        try {
            //洋钱罐订单状态更新
            if (CapitalLoanApplyResultEnum.WAIT.getCode().equals(loanApplyResult)
                    && !Objects.equals(loanApplyResult, capitalResult.getLoanApplyResult())
                    && CapitalResultSourceCodeEnum.YANG_QIAN_GUAN.getCode().equals(capitalResult.getCapitalResultSourceCode())) {
                OrderUpdateStatusDto orderUpdateStatusDto = OrderUpdateStatusDto.parseDto(capitalResult);
                if (orderUpdateStatusDto != null) {
                    logger.info("日志编号：" + logNumber + "借款结果回调通知洋钱罐开始,原始参数", orderUpdateStatusDto.toString());
                    yqgUtil.orderUpdateStatus(orderUpdateStatusDto, logger, logNumber);
                }
            }
        } catch (Exception e) {
            logger.error("日志编号：" + logNumber + "借款结果回调通知洋钱罐异常", e);
        }
    }

    @Override
    public CustomerCapitalResult updateByLoanReturn(CustomerCapitalResult capitalResult, YxLoanResultQueryResponse yxResponse) {
        if (CapitalResultStatusEnum.LOAN.getCode().equals(capitalResult.getStatus()) &&
                CapitalLoanApplyResultEnum.WAIT.getCode().equals(capitalResult.getLoanApplyResult())) {
            capitalResult.setLoanResultDesc(yxResponse.getLoanResultDesc());
            capitalResult.setLoanTime(yxResponse.getLoanTime());
            capitalResult.setFreezeTime(yxResponse.getFreezeTime());
            Integer result = CapitalLoanApplyResultEnum.parseLvDiLoanResult(yxResponse.getLoanResult());
            capitalResult.setLoanApplyResult(result);
            capitalResult.setLastUpdatedDate(new Date());
            customerCapitalResultMapper.update(null, Wrappers.<CustomerCapitalResult>lambdaUpdate()
                    .set(CustomerCapitalResult::getLoanResultDesc, capitalResult.getLoanResultDesc())
                    .set(CustomerCapitalResult::getLoanTime, capitalResult.getLoanTime())
                    .set(CustomerCapitalResult::getFreezeTime, capitalResult.getFreezeTime())
                    .set(CustomerCapitalResult::getLoanApplyResult, capitalResult.getLoanApplyResult())
                    .set(CustomerCapitalResult::getLastUpdatedDate, capitalResult.getLastUpdatedDate())
                    .eq(CustomerCapitalResult::getId, capitalResult.getId()));
        }
        return capitalResult;
    }

    @Override
    public String yxRepayPlanCallback(Map<String, String> request) throws Exception {
        Map<String, Object> resultMap = new HashMap<>();
        String logNumber = IdUtil.randomUUID();
        logger.info("日志编号：" + logNumber + "绿地还款计划变动通知回调接口参数:{}", request);
        if (request != null) {
            Map<String, Object> result = YXSignUtil.parseLVDiRequest(request, YXUtil.getLocalPrivateKey(), yxUtil.getLvDiPublicKey());
            String params = result.get("params").toString();
            if (!TextUtils.isEmpty(params)) {
                logger.info("params:{}", params);
                YxRepaymentPlanQueryResponse response = JSON.parseObject(params, YxRepaymentPlanQueryResponse.class);
                if (response != null) {
                    String loanNo = response.getLoanNo();
                    logger.info("loanNo:{}", loanNo);
                    if (loanNo != null) {
                        CustomerCapitalResult capitalResult = customerCapitalResultMapper.selectOne(Wrappers.<CustomerCapitalResult>lambdaQuery()
                                .eq(CustomerCapitalResult::getLoanNo, loanNo));
                        if (capitalResult != null) {
                            List<String> periodNoList = yqgRepayOrderDetailMapper.getRepayPeriodNoList(capitalResult.getLoanNo());
                            RepayPlanResponse repayPlanResponse = new RepayPlanResponse();
                            List<RepayDetailPlanVo> detailPlans = new ArrayList<>();
                            repayPlanResponse.setOrderNo(capitalResult.getLoanNo());
                            repayPlanResponse.setCanPrepay(Integer.valueOf(response.getCanPrepay()));
                            boolean isClean = true;
                            for (YxpkgListVo yxpkgListVo : response.getPkgList()) {
                                RepayDetailPlanVo repayDetailPlanVo = RepayDetailPlanVo.parseVo(yxpkgListVo, periodNoList);
                                if (!RepayDetailPlanVo.STATUS_REPAID.equals(repayDetailPlanVo.getBillStatus())) {
                                    isClean = false;
                                }
                                detailPlans.add(repayDetailPlanVo);
                            }
                            if (capitalResult.getRepayResult() == null && isClean) {
                                capitalResult.setRepayResult(1);
                                capitalResult.setLastUpdatedDate(new Date());
                                customerCapitalResultMapper.update(null, Wrappers.<CustomerCapitalResult>lambdaUpdate()
                                        .set(CustomerCapitalResult::getRepayResult, capitalResult.getRepayResult())
                                        .set(CustomerCapitalResult::getLastUpdatedDate, capitalResult.getLastUpdatedDate())
                                        .eq(CustomerCapitalResult::getId, capitalResult.getId()));
                                OrderUpdateStatusDto orderUpdateStatusDto = OrderUpdateStatusDto.parseDto(capitalResult);
                                if (orderUpdateStatusDto != null) {
                                    yqgUtil.orderUpdateStatus(orderUpdateStatusDto, logger, logNumber);
                                }
                            }
                            repayPlanResponse.setDetailPlans(detailPlans);
                            yqgUtil.repaymentUpdatePlan(repayPlanResponse, logger, logNumber);
                            resultMap.put("responseCode", "0000");
                            resultMap.put("responseMsg", "成功");
                            logger.info("日志编号：" + logNumber + "绿地还款计划变动通知接口成功回调:{}", resultMap);
                            return YXSignUtil.buildResponse(resultMap, YXUtil.getLocalPrivateKey(), yxUtil.getLvDiPublicKey());
                        }
                    }
                }
            }
        }
        resultMap.put("responseCode", "9999");
        resultMap.put("responseMsg", "失败");
        logger.info("日志编号：" + logNumber + "绿地还款计划变动通知接口失败回调:{}", resultMap);
        return YXSignUtil.buildResponse(resultMap, YXUtil.getLocalPrivateKey(), yxUtil.getLvDiPublicKey());
    }

    @Override
    public String yxRepayResultCallback(Map<String, String> request) throws Exception {
        Map<String, Object> resultMap = new HashMap<>();
        String logNumber = IdUtil.randomUUID();
        logger.info("日志编号：" + logNumber + "绿地还款结果通知接口参数:{}", request);
        if (request != null) {
            Map<String, Object> result = YXSignUtil.parseLVDiRequest(request, YXUtil.getLocalPrivateKey(), yxUtil.getLvDiPublicKey());
            String params = result.get("params").toString();
            if (!TextUtils.isEmpty(params)) {
                logger.info("params:{}", params);
                YxRepaymentResultResponse yxRepaymentResult = JSON.parseObject(params, YxRepaymentResultResponse.class);
                if (yxRepaymentResult != null) {
                    String repayApplyNo = yxRepaymentResult.getRepayApplyNo();
                    logger.info("repayApplyNo:{}", repayApplyNo);
                    if (StringUtils.isNotEmpty(repayApplyNo)) {
                        CustomerCapitalResult capitalResult = customerCapitalResultMapper.selectOne(Wrappers.<CustomerCapitalResult>lambdaQuery()
                                .eq(CustomerCapitalResult::getLoanNo, yxRepaymentResult.getLoanNo()));
                        YqgRepayOrder yqgRepayOrder = yqgRepayOrderMapper.selectOne(Wrappers.<YqgRepayOrder>lambdaQuery()
                                .eq(YqgRepayOrder::getRepayApplyNo, repayApplyNo));
                        if (capitalResult != null && yqgRepayOrder != null) {
                            Integer status = yqgRepayOrder.getStatus();
                            yqgRepayOrder = updateByRepayResultReturn(yqgRepayOrder, yxRepaymentResult);
                            notifyYqgByRepayResult(yqgRepayOrder, capitalResult, status, logger, logNumber);
                            resultMap.put("responseCode", "0000");
                            resultMap.put("responseMsg", "成功");
                            logger.info("日志编号：" + logNumber + "绿地还款结果通知接口成功回调:{}", resultMap);
                            return YXSignUtil.buildResponse(resultMap, YXUtil.getLocalPrivateKey(), yxUtil.getLvDiPublicKey());
                        }
                    }
                }
            }
        }
        resultMap.put("responseCode", "9999");
        resultMap.put("responseMsg", "失败");
        logger.info("日志编号：" + logNumber + "绿地还款结果通知接口失败回调:{}", resultMap);
        return YXSignUtil.buildResponse(resultMap, YXUtil.getLocalPrivateKey(), yxUtil.getLvDiPublicKey());
    }

    public void rongYiTuiBack(CustomerCapitalResult capitalResult, YxAuditCallbackRequest yxAuditCallbackRequest) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String entryDate = simpleDateFormat.format(System.currentTimeMillis());
        try {
            CustomerUser customerUser = customerUserService.getOne(new LambdaQueryWrapper<CustomerUser>().eq(CustomerUser::getId, capitalResult.getCustomerUserId()));
            if (CapitalApprovalResultEnum.APPROVAL_SUCCESS.getCode().equals(capitalResult.getApprovalResult()) &&
                    CapitalResultSourceCodeEnum.RONG_YI_TUI.getCode().equals(capitalResult.getCapitalResultSourceCode()) &&
                    customerUser.getCallBackResult() == 0) {
                String totalCredit = yxAuditCallbackRequest.getTotalCredit();
                Integer integer = null;
                if (StringUtils.isNotEmpty(totalCredit)) {
                    integer = Integer.parseInt(totalCredit) * 100;
                }
                RongYiTuiResponse rongYiTuiResponse = rongYiTuiUtil.creditResult(customerUser.getPhone(), customerUser.getBusinessNo(), yxAuditCallbackRequest, integer, entryDate);
                if (rongYiTuiResponse != null) {
                    logger.info("融易推授信结果通知返回：{}", rongYiTuiResponse.toString());
                } else {
                    logger.info("融易推授信结果通知返回失败");
                }
                customerUserService.update(Wrappers.<CustomerUser>lambdaUpdate()
                        .set(CustomerUser::getCallBackResult, 1)
                        .eq(CustomerUser::getId, customerUser.getId()));
            }
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("融易推授信结果回调绿地接口失败,错误信息:", e);
        }
    }


    private void notifyYqgByRepayResult(YqgRepayOrder yqgRepayOrder, CustomerCapitalResult capitalResult, Integer status, Logger logger, String logNumber) {
        try {
            //洋钱罐订单状态更新
            if (YqgRepayOrder.STATUS_WAIT.equals(status)
                    && !Objects.equals(status, yqgRepayOrder.getStatus())) {
                RepayResultReturnDto feedBackDto = null;
                if (YqgRepayOrder.STATUS_SUCCESS.equals(yqgRepayOrder.getStatus())) {
                    YxRepaymentPlanQueryDto yxRepaymentPlanQueryDto = new YxRepaymentPlanQueryDto(capitalResult);
                    YxRepaymentPlanQueryResponse planQuery = yxUtil.yxRepaymentPlanQuery(yxRepaymentPlanQueryDto, yxUtil.getFunding(capitalResult.getCapitalInfoCode()), logger, logNumber);
                    feedBackDto = RepayResultReturnDto.parseDto(yqgRepayOrder, planQuery);
                } else {
                    feedBackDto = RepayResultReturnDto.parseDto(yqgRepayOrder, null);
                }
                if (feedBackDto != null) {
                    logger.info("日志编号：" + logNumber + "还款结果回调通知洋钱罐开始,原始参数" + feedBackDto.toString());
                    yqgUtil.repayResultFeedBack(feedBackDto, logger, logNumber);
                } else {
                    logger.error("日志编号：" + logNumber + "还款结果回调通知洋钱罐失败,构建还款成功请求参数失败:" + yqgRepayOrder.toString());
                }
            }
        } catch (Exception e) {
            logger.error("日志编号：" + logNumber + "还款结果回调通知洋钱罐异常", e);
        }
    }


    public YqgRepayOrder updateByRepayResultReturn(YqgRepayOrder yqgRepayOrder, YxRepaymentResultResponse yxRepaymentResult) {
        if (YqgRepayOrder.STATUS_WAIT.equals(yqgRepayOrder.getStatus())) {
            Integer status = YqgRepayOrder.parseLvDiStatus(yxRepaymentResult.getStatus());
            if (status != null) {
                yqgRepayOrder.setStatus(status);
                yqgRepayOrder.setRepayTime(yxRepaymentResult.getRepayTime());
                yqgRepayOrder.setRemark(yxRepaymentResult.getResult());
                yqgRepayOrder.setLastUpdatedDate(new Date());
                yqgRepayOrderMapper.update(null, Wrappers.<YqgRepayOrder>lambdaUpdate()
                        .set(YqgRepayOrder::getStatus, yqgRepayOrder.getStatus())
                        .set(YqgRepayOrder::getRepayTime, yqgRepayOrder.getRepayTime())
                        .set(YqgRepayOrder::getRemark, yqgRepayOrder.getRemark())
                        .set(YqgRepayOrder::getLastUpdatedDate, yqgRepayOrder.getLastUpdatedDate())
                        .eq(YqgRepayOrder::getId, yqgRepayOrder.getId()));
                Integer detailStatus = YqgRepayOrderDetail.parseStatus(status);
                if (detailStatus != null) {
                    yqgRepayOrderDetailMapper.updateStatusByRepayResult(yqgRepayOrder.getRepayNo(), detailStatus);
                }
            }
        }
        return yqgRepayOrder;
    }
}