package com.nova.sankuai.infra.utils.hht;

import cn.hutool.core.util.IdUtil;
import cn.hutool.crypto.SecureUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.nova.sankuai.domain.api.aliyunIP.AliyunUtil;
import com.nova.sankuai.domain.api.aliyunIP.CustomerIpInfo;
import com.nova.sankuai.domain.api.hht.HhtIncomeResponse;
import com.nova.sankuai.domain.api.hjqb.HjqbResponse;
import com.nova.sankuai.domain.entity.*;
import com.nova.sankuai.domain.enums.capitalInfo.CapitalInfoTypeCodeEnum;
import com.nova.sankuai.domain.vo.capitalresult.LvdiPushResultVo;
import com.nova.sankuai.infra.config.CommonException;
import com.nova.sankuai.infra.mapper.CityMapper;
import com.nova.sankuai.infra.mapper.CustomerCapitalResultMapper;
import com.nova.sankuai.infra.mapper.CustomerMapper;
import com.nova.sankuai.infra.utils.RbUtil;
import com.nova.sankuai.infra.utils.ResultJson;
import com.nova.sankuai.infra.utils.UserUtil;
import com.nova.sankuai.security.HttpClientUtil;
import com.nova.sankuai.security.UserDetail;
import com.nova.sankuai.service.IChannelInfoService;
import com.nova.sankuai.service.ICustomerScyIncomeService;
import com.nova.sankuai.service.ICustomerUserService;
import com.nova.sankuai.service.IPlatformCapitalService;
import lombok.RequiredArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import org.jetbrains.annotations.Nullable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.util.DigestUtils;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import javax.servlet.http.HttpServletRequest;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.*;

import static java.util.Map.Entry.comparingByKey;
import static java.util.stream.Collectors.toMap;

/**
 * 好汇推对接
 */
@Component
@RequiredArgsConstructor
public class HhtUtil {
    private static final Logger log = LoggerFactory.getLogger("capitalLogger");

    private static final String CHARSET_NAME = "utf8";

    private static final Long capitalId = 41L;

    @Value("${hht.zkUrl}")
    private String zkUrl;

    @Value("${hht.jkUrl}")
    private String jkUrl;

    @Value("${hht.channelCode}")
    private String channelCode;

    @Value("${hht.version}")
    private String version;

    @Value("${hht.aesKey}")
    private String aesKey;

    @Value("${hht.secretKey}")
    private String secretKey;

    @Value("${hht.personalAuthorizationUrl}")
    private String personalAuthorizationUrl;

    private String getJobAage(String workStartTime, String workEndTime) {
        if (StringUtils.isBlank(workStartTime)) {// 若为空，则不取该条数据
            return "";
        }
        workStartTime = workStartTime.substring(0, 10);
        LocalDate endDate = null;
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        LocalDate startDate = LocalDate.parse(workStartTime, formatter);
        if (StringUtils.isNotBlank(workEndTime)) {
            workEndTime = workEndTime.substring(0, 10);
            endDate = LocalDate.parse(workEndTime, formatter);
        } else {
            endDate = LocalDate.now();
        }


        long month = ChronoUnit.MONTHS.between(startDate, endDate);

        // F:0-6个月 G:6-12个月 H:12个月以上
        if (month < 6) {
            return "F";
        } else if (month >= 6 && month < 12) {
            return "G";
        }

        return "H";
    }

    private final CustomerMapper customerMapper;
    private final CustomerCapitalResultMapper capitalResultMapper;
    private final IPlatformCapitalService platformCapitalService;
    private final ICustomerUserService customerUserService;
    private final ICustomerScyIncomeService customerZcyIncomeService;
    private final CityMapper cityMapper;


    //I:3万-5万 J:5万-10万 K:10万-30万 M:30万-50万 N:50万-100万
    public static String checkValue(double value) {
        if (value >= 30000 && value < 50000) {
            return "I"; // 3万到5万
        } else if (value >= 50000 && value < 100000) {
            return "J"; // 5万到10万
        } else if (value >= 100000 && value < 300000) {
            return "K"; // 10万到30万
        } else if  (value >= 300000 && value < 500000) {
            return "L"; // 30万到50万
        } else if (value >= 500000 && value < 1000000) {
            return "M"; // 50万到100万
        }else {
            return "I";
        }
    }

    private final IChannelInfoService channelInfoService;

    private JSONObject getParam(Customer customer) {
        // 获取source_channel
        Integer sourceChannel = customer.getSourceChannel();
        Integer version2Type = 0;//判断是否2.0开关子参数
        if (!Objects.isNull(sourceChannel)) {
            ChannelInfo channelInfo = channelInfoService.getOne(new LambdaQueryWrapper<ChannelInfo>().eq(ChannelInfo::getCode, sourceChannel).last(" limit 1 "));
            version2Type = channelInfo.getVersion2Type();
        }

        Random random = new Random();
        String[] values;
        int randomIndex;

        JSONObject param = new JSONObject();

        /*社保*/
        String soci = "BB";
        /*公积金*/
        String accu = "FF";
        /*信用卡 WW:无信用卡   MMM:1万及以下  NNN:1万以上*/
        String creditCard = "WW";

        if (version2Type == 1) { //线上放款
            /*社保  在"Z:连续6个月以下 AA:连续6个月"中随机匹配*/
            values = new String[]{"Z", "AA"};
            soci = values[random.nextInt(values.length)];

            /*公积金 均在"DD:连续6个月以下 FF:连续6个月"中随机匹配*/
            values = new String[]{"DD", "EE"};
            accu = values[random.nextInt(values.length)];

            /*信用卡 均在"MMM:1万及以下  NNN:1万以上"中随机匹配*/
            values = new String[]{"MMM", "NNN"};
            creditCard = values[random.nextInt(values.length)];


        }else { //银行直贷
            /*社保  Z:连续6个月以下 AA:连续6个月 BB:无本地社保*/
            Integer social = customer.getSocialSecurity();
            int soc = Objects.isNull(social) ? 0 : social.intValue();
            if (soc == 1) {
                soci = "Z";
            } else if (soc == 2) {
                soci = "AA";
            }

            /*公积金 DD:连续6个月以下 EE:连续6个月 FF:无本地公积金*/
            Integer accumulation = customer.getProvidentFund();
            int at = Objects.isNull(accumulation) ? 0 : accumulation.intValue();
            if (at == 1) accu = "DD";
            else if (at == 2) accu = "EE";

            /*信用卡 WW:无信用卡   MMM:1万及以下  NNN:1万以上*/
            Integer cc = customer.getCreditCard();
            int ccV = Objects.isNull(cc) ? 0 : cc.intValue();

            if (ccV == 3) {
                creditCard = "MMM";
            } else if (ccV == 4 || ccV == 5) {
                creditCard = "NNN";
            }
        }
        param.put("socialSecurity", soci);
        param.put("providentFund", accu);
        param.put("creditCard", creditCard);

        param.put("name", customer.getName());

        param.put("ip", !StringUtils.isEmpty(customer.getClientIp()) ? customer.getClientIp() : "127.0.0.1");

        /*系统类型
        android :安卓   ios:苹果*/
        param.put("osType", !StringUtils.isEmpty(customer.getOs()) ? customer.getOs() : "android");

        /*系统版本 如Android 6.0 iPhone OS 13_2_3 等*/
        param.put("osVersion", !StringUtils.isEmpty(customer.getDeviceOsVersion()) ? customer.getDeviceOsVersion() : "Android 14");

        /*性别
        SM：男  SW：女*/
        String sex = RbUtil.getGenderByIDCard(customer.getIdCard());
        param.put("sex", "男".equals(sex) ? "SM" : "SW");
        /*年龄 10-99的正整数。如34*/
        param.put("age", RbUtil.calculateAgeFromIdNumber(customer.getIdCard()));

        /*用户所在城市区划代码 */
        String cityCode = customer.getCity();
        if (StringUtils.isEmpty(cityCode)) {
            City cityInfo = cityMapper.selectOne(new LambdaQueryWrapper<City>().
                    likeRight(City::getName, customer.getCityName()).last(" limit 1 "));
            if (cityInfo != null) {
                cityCode = cityInfo.getCityId();
            }
        }
        if (StringUtils.isEmpty(cityCode)) {
            cityCode = "310100";
        }
        param.put("cityCode", cityCode.substring(0, 6));

        /*职业身份  A:上班族   B:个体户 C:自由职业 BS:企业主*/
        Integer pi = customer.getProfessionInfo();
        int professionInfo = 1;// 默认自由职业
        String job = "";
        if (!Objects.isNull(pi)) {
            professionInfo = pi.intValue();
        }
        if (professionInfo == 1) {
            job = "C";
        } else if (professionInfo == 2) {
            job = "A";
        } else if (professionInfo == 3) {
            job = "BS";
        }else {
            values = new String[]{"A", "B", "C", "BS"};
            randomIndex = random.nextInt(values.length);
            job = values[randomIndex];
        }
        param.put("profession", job);

        if ("A".equals(job)) {
            /*工资发放方式 D:银行卡 E:现金*/
            values = new String[]{"D", "E"};
            randomIndex = random.nextInt(values.length);
            param.put("payType", values[randomIndex]);
            /* 工龄 F:0-6个月 G:6-12个月 H:12个月以上*/
            values = new String[]{"F", "G", "H"};
            randomIndex = random.nextInt(values.length);
            param.put("workingAge", values[randomIndex]);
        }
        /*当职业身份为B时必填 */
        if ("B".equals(job)) {
            /*营业执照信息  BBB:有营业执照 CCC:无营业执照*/
            values = new String[]{"BBB", "CCC"};
            randomIndex = random.nextInt(values.length);
            param.put("license", values[randomIndex]);
        }
        /*当职业身份为BS时必填 */
        if ("BS".equals(job)) {
            /*企业注册时长  RT1:1年以内 RT2:2-3年 RT3:3-5年 RT4:5年以上*/
           values = new String[]{"RT1", "RT2", "RT3", "RT4"};
            // 随机选择一个索引
            randomIndex = random.nextInt(values.length);
            // 获取随机选择的值
            param.put("registerTime", values[randomIndex]);
            /*企业纳税总金额 TAXES1:0元-5000元 TAXES2:5000元-10万元 TAXES3:10万元-100万元 TAXES4:100万元以上*/
            values = new String[]{"TAXES1", "TAXES2", "TAXES3", "TAXES4"};
            randomIndex = random.nextInt(values.length);
            param.put("taxes", values[randomIndex]);
            /* 企业开票月份数 INVOICING1:18个月以上 INVOICING2:12个月以上 INVOICING3:9个月以上 INVOICING4:9个月以下*/
            values = new String[]{"INVOICING1", "INVOICING2", "INVOICING3", "INVOICING4"};
            randomIndex = random.nextInt(values.length);
            param.put("invoicing", values[randomIndex]);
        }

        /*借款金额(借多少) I:3万-5万 J:5万-10万 K:10万-30万 M:30万-50万 N:50万-100万*/
        param.put("loan", checkValue(customer.getLoanAmount()));
        /*借款时间(借多久) L:3个月 O:6个月  P:12个月 Q:24个月 R:36个月*/
        values = new String[]{"L", "O", "P", "Q", "R"};
        randomIndex = random.nextInt(values.length);
        param.put("loanTime", values[randomIndex]);
        /*文化程度 S:小学 T:初中 U:高中 V:中专 W:专科 X:本科及以上*/
        String et = customer.getEducation();
        String education = "S";
        if ("01".equals(et)) {
            values = new String[]{"S", "T", "U", "V"};
            education = values[random.nextInt(values.length)];
        } else if ("02".equals(et)) {
            education = "W";
        } else{
            education = "X";
        }
        param.put("education", education);


        /**
         * 房产 GG:有房产，接受抵押
        HH:有房产，不接受抵押
        II:无房产
         无论选什么,均在"GG:有房产，接受抵押HH:有房产，不接受抵押"中随机匹配
         */
        values = new String[]{"GG", "HH"};
        param.put("estate",  values[random.nextInt(values.length)]);
        /**
         * 当房产为：GG，HH时必填
          房产类型 EEE:商品房 FFF:自建房
          随机生成"EEE:商品房 FFF:自建房"
         */
        values = new String[]{"EEE", "FFF"};
        param.put("estateType", values[random.nextInt(values.length)]);
       /* 车产
              JJ:有车，可接受抵押
              KK:有车，不接受抵押
              LL:无车产
              无论选什么,均在"JJ:有车，可接受抵押 KK:有车，不接受抵押"中随机匹配
        */
        values = new String[]{"JJ", "KK"};
        param.put("car", values[random.nextInt(values.length)]);
        /*当车产为：JJ，KK时必填
        车产类型 GGG:全款车 HHH:贷款车
        随机生成"GGG:全款车 HHH:贷款车"
        */
        values = new String[]{"GGG", "HHH"};
        param.put("carType", values[random.nextInt(values.length)]);
        /*当车产为：JJ，KK时必填
        车产估值 III:估值9万以上 JJJ:估值9万以下
        随机生成"III:估值9万以上 JJJ:估值9万以下"
        */
        values = new String[]{"III", "JJJ"};
        param.put("carAmount", values[random.nextInt(values.length)]);
        /*个人保险 NN：无保单 KKK:6个月及以下  LLL:6个月以上
        * "无论选什么,均在""KKK:6个月及以下LLL:6个月以上""中随机匹配"
        * */
        values = new String[]{"KKK", "LLL"};
        param.put("personalInsurance", values[random.nextInt(values.length)]);
        /*芝麻分 OO:600以下 PP:600-650 DDD:650-700 QQ:700以上 RR:无*/
        Integer customerSesame = customer.getSesame();
        int cus = Objects.isNull(customerSesame) ? 1 : customerSesame.intValue();
        String sesame = "PP";// 默认 1 无
        if (cus == 2) {
            sesame = "PP";
        } else if (cus == 3) {
            sesame = "DDD";
        } else if (cus == 4) {
            sesame = "QQ";
        }
        param.put("creditScore", sesame);
        /*微粒贷借款额度 UU:无 SS:5000以下 TT:5000以上*/
        values = new String[]{"SS", "TT"};
        param.put("wldLoan", values[random.nextInt(values.length)]);

        values = new String[]{"YY", "ZZ", "AAA"};
        /*信用记录 XX:无贷款记录 YY:信用良好，无逾期 ZZ:1年内逾期少于3次 AAA:1年内逾期超过3次*/
        //param.put("creditRecord", values[random.nextInt(values.length)]);
        param.put("creditRecord", "YY");
        /*京东白条 QQQ:无京东白条 OOO:5000及以下 PPP:5000以上*/
        values = new String[]{"OOO", "PPP"};
        param.put("jdWhite", values[random.nextInt(values.length)]);
        /* 花呗  TTT:无花呗 RRR:5000及以下 SSS:5000以上*/
        values = new String[]{"RRR", "SSS"};
        param.put("aliBei", values[random.nextInt(values.length)]);

        return param;
    }

    /**
     * 中诚易数据推送到好汇推操作
     */
    public boolean zcyPushToHht(Customer customer, String logNumber) {
        boolean isSucc = false;
        log.info("日志编号：" + logNumber + "，手机号：{}，中诚易数据推送到好汇推流程开始", customer.getPhone());
        try {
            JSONObject param = getParam(customer);

            isSucc = push(customer, param, logNumber);
            Integer hht = 0;
            if (!isSucc) {
                log.error("日志编号：" + logNumber + "，手机号：{}，中诚易数据推送到好汇推失败", customer.getPhone());
            } else {
                hht = 1;
            }
            saveStatus(customer, hht);
        } catch (Exception ex) {
            log.error("日志编号：" + logNumber + "，手机号：{}，中诚易数据推送到好汇推失败", customer.getPhone());
        }
        return isSucc;
    }

    /**
     * 我来贷数据推送到好汇推操作
     */
    public boolean wldPushToHht(Customer customer, String logNumber) {
        boolean isSucc = false;
        log.info("日志编号：" + logNumber + "，手机号：{}，【我来贷】数据推送到好汇推流程开始", customer.getPhone());
        try {
            JSONObject param = getParam(customer);

            isSucc = push(customer, param, logNumber);
            Integer hht = 0;
            if (!isSucc) {
                log.error("日志编号：" + logNumber + "，手机号：{}，【我来贷】数据推送到好汇推失败", customer.getPhone());
            } else {
                hht = 1;
            }
            saveStatus(customer, hht);
            if (isSucc) {
                isSucc = wldIncomeToHht(customer, param, logNumber);
            }
        } catch (Exception ex) {
            log.error("日志编号：" + logNumber + "，手机号：{}，【我来贷】数据推送到好汇推失败：{}", customer.getPhone(), ex.getMessage());
            isSucc = false;
        }
        return isSucc;
    }

    /**
     * 我来贷进件数据给好汇推操作
     */
    public boolean wldIncomeToHht(Customer customer, JSONObject param, String logNumber) {
        boolean isSucc = false;
        log.info("日志编号：{}，手机号：{}，【我来贷】数据进件到好汇推流程开始", logNumber, customer.getPhone());
        try {
            Integer hht = 3;
            isSucc = getWldPushResult(logNumber, param, customer);
            if (!isSucc) {
                log.error("日志编号：{}，手机号：{}，【我来贷】数据进件到好汇推失败", logNumber, customer.getPhone());
            } else {
                hht = 4;
                log.info("日志编号：{}，手机号：{}，【我来贷】数据进件到好汇推成功", logNumber, customer.getPhone());
            }
            saveStatus(customer, hht);
        } catch (Exception ex) {
            log.error("日志编号：{}，手机号：{}，【我来贷】数据进件到好汇推失败： {}", logNumber, customer.getPhone(), ex.getMessage());
        }
        return isSucc;
    }


    public LvdiPushResultVo hhtPush(CustomerUser customerUser, String channelCode) {
        String logNumber = IdUtil.randomUUID();
        log.info("日志编号：" + logNumber + "好汇推 channelCode:" + channelCode + " 推送流程开始");
        Customer customer = customerMapper.getLatestCustomerRecord(customerUser.getPhone());
        CustomerCapitalResult capitalResult = capitalResultMapper.selectOne(new LambdaQueryWrapper<CustomerCapitalResult>()
                .eq(CustomerCapitalResult::getCustomerUserId, customerUser.getId())
                .eq(CustomerCapitalResult::getCustomerRecordId, customer.getId())
                .eq(CustomerCapitalResult::getCapitalInfoCode, CapitalInfoTypeCodeEnum.HHT.getCode()));
        if (capitalResult == null) {
            log.info("日志编号：" + logNumber + " 手机号：" + customerUser.getPhone() + " 好汇推数据库结果不存在, customerUser id:" +
                    customerUser.getId() + " customer id:" + customer.getId());
            throw new CommonException("资方对接结果不存在");
        }

        JSONObject param = getParam(customer);

        // 开始撞库
        boolean isSucc = push(customer, param, logNumber);
        if (!isSucc) {
            return null;
        }

        // 开始进件操作
        // 转成 LvdiPushResultVo
        LvdiPushResultVo result = new LvdiPushResultVo();
        result.setCheckResult(true);
        result.setUrlType("1");// APP下载链接
        return result;
    }


    /**
     * 撞库
     * @param customer
     * @param body
     * @param logNumber
     * @return
     */
    private boolean push(Customer customer, JSONObject body, String logNumber) {
        // 撞库签名参数
        String timestamp = String.valueOf(System.currentTimeMillis());
        JSONObject zkJsonObject = new JSONObject();
        String md5Phone = DigestUtils.md5DigestAsHex(customer.getPhone().getBytes()).toUpperCase();
        zkJsonObject.put("md5Phone", md5Phone);
        zkJsonObject.put("timestamp", timestamp);

        // 撞库签名
        body.put("sign", getSignStr(zkJsonObject));
        body.put("md5Phone", md5Phone);
        body.put("timestamp", timestamp);
        log.info("日志编号：" + logNumber + " 手机号为：" + customer.getPhone() + ",【好汇推】撞库请求的参数:{}", body);

        JSONObject jsonData = new JSONObject();
        jsonData.put("channelCode", channelCode);
        jsonData.put("version", version);
        // 撞库内容加密
        jsonData.put("content", encrypt(body.toJSONString()));

        String result = null;
        try {
            // 撞库
            result = HttpClientUtil.getInstance().postJsonData(zkUrl, jsonData.toJSONString());
            log.info("日志编号：" + logNumber + " 手机号为：" + customer.getPhone() + ",【好汇推】撞库返回参数:{}", result);
        } catch (Exception ex) {
            log.error("日志编号：" + logNumber + " 手机号为：{},【好汇推】撞库失败，传参：{} ex：{}", customer.getPhone(), jsonData, ex.getMessage());
        }
        try {
            HhtIncomeResponse res = JSON.parseObject(result, HhtIncomeResponse.class);
            if ("000000".equals(res.getHead().getReturnCode())) {
                log.info("日志编号：" + logNumber + " 手机号为：" + customer.getPhone() + ",【好汇推】推送成功");
                // 解析 返回的body
                String signsResult = JSON.toJSONString(res.getBody());
                log.info("日志编号：" + logNumber + " 手机号为：" + customer.getPhone() + ",【好汇推】推送成功: 返回的body转字符串: {}", signsResult);
                if (res.getBody().getResult()) {
                    PlatformCapital platformCapital = JSON.parseObject(signsResult, PlatformCapital.class);
                    // 删除同一资方的同一用户数据
                    LambdaQueryWrapper<PlatformCapital> wrapper = new LambdaQueryWrapper<>();
                    wrapper.eq(PlatformCapital::getCustomerId, customer.getId());
                    wrapper.eq(PlatformCapital::getCapitalId, capitalId);
                    platformCapitalService.remove(wrapper);
                    // 录入到数据库
                    platformCapital.setCustomerId(customer.getId());
                    platformCapital.setCapitalId(capitalId);
                    platformCapital.setLogoUrl(res.getBody().getLogo());
                    platformCapitalService.save(platformCapital);
                    return true;
                }
            } else {
                log.error("日志编号：" + logNumber + " 手机号为：{},【好汇推】推送失败：返回参数：{}，jsonData：{}", customer.getPhone(), res,jsonData);
            }
        } catch (Exception ex) {
            log.error("日志编号：" + logNumber + " 手机号为：{},【好汇推】推送原始返回参数转换失败，jsonData：{} ex：{}", customer.getPhone(), jsonData , ex.getMessage());
        }
        return false;
    }

    /**
     * 中诚易进件数据给好汇推操作
     */
    public void zcyIncomeToHht(Customer customer, String logNumber) {
        log.info("日志编号：" + logNumber + "，手机号：{}，中诚易数据进件到好汇推流程开始", customer.getPhone());
        try {
            Integer hht = 3;
            ResultJson<LvdiPushResultVo> rs = getPushResult(logNumber, customer);
            if (rs == null) {
                log.error("日志编号：" + logNumber + "，手机号：{}，中诚易数据进件到好汇推失败", customer.getPhone());
            } else {
                hht = 4;
                log.info("日志编号：" + logNumber + "，手机号：{}，中诚易数据进件到好汇推成功", customer.getPhone());
            }
            saveStatus(customer, hht);
        } catch (Exception ex) {
            log.error("日志编号：" + logNumber + "，手机号：{}，中诚易数据进件到好汇推失败", customer.getPhone());
        }
    }

    private void saveStatus(Customer customer, Integer hht) {
        // 录入或更新到customer_scy_income表
        LambdaQueryWrapper<CustomerScyIncome> wr = new LambdaQueryWrapper<>();
        wr.eq(CustomerScyIncome::getCustomerZcyId, customer.getId());
        wr.last(" limit 1 ");
        CustomerScyIncome csi = customerZcyIncomeService.getOne(wr);
        if (Objects.isNull(csi)) {
            csi = new CustomerScyIncome();
        }
        csi.setCustomerZcyId(customer.getId());
        csi.setHht(hht);
        customerZcyIncomeService.saveOrUpdate(csi);
    }
    /**
     * 进件
     */
    public ResultJson<?> income(HttpServletRequest request) {
        String logNumber = IdUtil.randomUUID();
        log.info("日志编号：" + logNumber + " 【好汇推】进件流程开始");
        String token = request.getHeader("Authorization");
        UserDetail user = UserUtil.getUser(token);
        if (user == null) {
            log.info("日志编号：" + logNumber + " 好汇推进件失败，原因：用户Token无效");
            throw new CommonException("用户Token无效");
        }


        Customer customer = customerMapper.getLatestCustomerRecord(user.getPhone());
        LambdaQueryWrapper<CustomerUser> wr = new LambdaQueryWrapper<>();
        wr.eq(CustomerUser::getPhone, user.getPhone());
        wr.eq(CustomerUser::getDeleteFlag, 0);
        wr.last(" limit 1 ");
        CustomerUser customerUser = customerUserService.getOne(wr);
        if (customerUser == null) {
            log.info("日志编号：" + logNumber + " 手机号：" + user.getPhone() + " 好汇推进件失败，原因：用户不存在");
            throw new CommonException("用户不存在");
        }
        CustomerCapitalResult capitalResult = capitalResultMapper.selectOne(new LambdaQueryWrapper<CustomerCapitalResult>()
                .eq(CustomerCapitalResult::getCustomerUserId, customerUser.getId())
                .eq(CustomerCapitalResult::getCustomerRecordId, customer.getId())
                .eq(CustomerCapitalResult::getCapitalInfoCode, CapitalInfoTypeCodeEnum.HHT.getCode()));
        if (capitalResult == null) {
            log.info("日志编号：" + logNumber + " 手机号：" + customerUser.getPhone() + "进件失败，原因：【好汇推】数据库结果不存在, customerUser id:" +
                    customerUser.getId() + " customer id:" + customer.getId());
            throw new CommonException("资方对接结果不存在");
        }
        return getPushResult(logNumber, customer);
    }

    @Nullable
    private ResultJson<LvdiPushResultVo> getPushResult(String logNumber, Customer customer) {
        // 判断是否数据库中是否有数据，有过数据就不推送了
        LambdaQueryWrapper<PlatformCapital> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(PlatformCapital::getCustomerId, customer.getId());
        wrapper.eq(PlatformCapital::getCapitalId, capitalId);
        wrapper.last(" limit 1 ");
        PlatformCapital platformCapital = platformCapitalService.getOne(wrapper);
        if (Objects.isNull(platformCapital)) {// 若没有数据
            log.info("日志编号：" + logNumber + " 手机号：" + customer.getPhone() + "进件失败，原因：【好汇推】推送结果不存在, customer id:" + customer.getId());
            throw new CommonException("资方推送结果不存在");
        }
        if (platformCapital.getIncomeStatus() == 1) {// 已进件成功
            log.info("日志编号：" + logNumber + " 手机号：" + customer.getPhone() + "进件失败，原因：【好汇推】已经进件成功过，不再进件, customer id:" + customer.getId());
            return null;
        }
        JSONObject param = getParam(customer);
        String phone = customer.getPhone();

        /*身份证号 等*/
        String idCardNo = customer.getIdCard();
        param.put("idCardNo", idCardNo);

        // 进件签名
        String timestamp = String.valueOf(System.currentTimeMillis());
        JSONObject orderJsonObject = new JSONObject();
        orderJsonObject.put("channelUserId", customer.getPhone());
        orderJsonObject.put("timestamp", timestamp);
        orderJsonObject.put("name", customer.getName());
        orderJsonObject.put("phone", customer.getPhone());

        param.put("sign", getSignStr(orderJsonObject));
        param.put("channelUserId", customer.getPhone());
        param.put("timestamp", timestamp);
        param.put("phone", customer.getPhone());
        String protoclUrl = StringUtils.replace(personalAuthorizationUrl, "id_str", platformCapital.getId() + "");
        param.put("personalAuthorizationUrl", protoclUrl);

        log.info("日志编号：" + logNumber + " 手机号：" + customer.getPhone() + "【好汇推】，进件参数：{}", param);

        // 进件内容加密
        JSONObject jsonData = new JSONObject();
        jsonData.put("content", encrypt(param.toJSONString()));
        jsonData.put("channelCode", channelCode);
        jsonData.put("version", version);
        log.info("日志编号：" + logNumber + " 手机号：" + customer.getPhone() + "开始进件给资方【好汇推】，参数：{}", jsonData);
        String result = null;
        try {
            // 进件
            result = HttpClientUtil.getInstance().postJsonData(jkUrl, jsonData.toJSONString());
            log.info("日志编号：" + logNumber + " 手机号为：" + customer.getPhone() + ",【好汇推】进件原始返回参数:{}", result);
        } catch (Exception ex) {
            log.error("日志编号：" + logNumber + " 手机号为：{},【好汇推】进件失败，传参：{} ex：{}", customer.getPhone(), jsonData, ex);
        }
        if (StringUtils.isBlank(result)) {
            log.error("日志编号：" + logNumber + " 手机号为：{},【好汇推】进件返回数据为空，传参：{} ", customer.getPhone(), jsonData);
        }
        try {
            HhtIncomeResponse res = JSON.parseObject(result, HhtIncomeResponse.class);
            if ("000000".equals(res.getHead().getReturnCode())) {
                if (res.getHead().getResult()) {
                    log.info("日志编号：" + logNumber + " 手机号为：" + customer.getPhone() + ",【好汇推】进件成功");
                    // 更新数据库
                    platformCapital.setIncomeStatus(1);
                    platformCapitalService.updateById(platformCapital);
                    LvdiPushResultVo rs = new LvdiPushResultVo();
                    rs.setCheckResult(true);
                    rs.setUrlType("1");// APP下载链接
                    return ResultJson.ok(rs);
                }

            } else {
                log.error("日志编号：" + logNumber + " 手机号为：{},【好汇推】进件失败：{}，jsonData：{}", customer.getPhone(), res.getHead().getReturnMessage(),jsonData);
            }
        } catch (Exception ex) {
            log.error("日志编号：" + logNumber + " 手机号为：{},【好汇推】进件原始返回参数转换失败，jsonData：{} ex：{}", customer.getPhone(), jsonData , ex);
        }
        return null;
    }

    private boolean getWldPushResult(String logNumber, JSONObject param, Customer customer) {
        // 判断是否数据库中是否有数据，有过数据就不推送了
        LambdaQueryWrapper<PlatformCapital> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(PlatformCapital::getCustomerId, customer.getId());
        wrapper.eq(PlatformCapital::getCapitalId, capitalId);
        wrapper.last(" limit 1 ");
        PlatformCapital platformCapital = platformCapitalService.getOne(wrapper);
        if (Objects.isNull(platformCapital)) {// 若没有数据
            log.info("日志编号：{} 手机号：{}进件失败，原因：【好汇推】推送结果不存在, customer id: {}", logNumber, customer.getPhone(), customer.getId());
            return false;
        }
        if (platformCapital.getIncomeStatus() == 1) {// 已进件成功
            log.info("日志编号：{} 手机号：{}进件失败，原因：【好汇推】已经进件成功过，不再进件, customer id: {}", logNumber, customer.getPhone(),  customer.getId());
            return false;
        }

        /*身份证号 等*/
        String idCardNo = customer.getIdCard();
        param.put("idCardNo", idCardNo);

        // 进件签名
        String timestamp = String.valueOf(System.currentTimeMillis());
        JSONObject orderJsonObject = new JSONObject();
        orderJsonObject.put("channelUserId", customer.getPhone());
        orderJsonObject.put("timestamp", timestamp);
        orderJsonObject.put("name", customer.getName());
        orderJsonObject.put("phone", customer.getPhone());

        param.put("sign", getSignStr(orderJsonObject));
        param.put("channelUserId", customer.getPhone());
        param.put("timestamp", timestamp);
        param.put("phone", customer.getPhone());
        String protoclUrl = StringUtils.replace(personalAuthorizationUrl, "id_str", platformCapital.getId() + "");
        protoclUrl = StringUtils.replace(protoclUrl, "getProtocolInfo", "getProtocolInfoWld");
        param.put("personalAuthorizationUrl", protoclUrl);

        log.info("日志编号：{} 手机号：{}【好汇推】，进件参数：{}", logNumber, customer.getPhone(), param);

        // 进件内容加密
        JSONObject jsonData = new JSONObject();
        jsonData.put("content", encrypt(param.toJSONString()));
        jsonData.put("channelCode", channelCode);
        jsonData.put("version", version);
        log.info("日志编号：{} 手机号：{}开始进件给资方【好汇推】，参数：{}", logNumber, customer.getPhone(), jsonData);
        String result = null;
        try {
            // 进件
            result = HttpClientUtil.getInstance().postJsonData(jkUrl, jsonData.toJSONString());
            log.info("日志编号：{}， 手机号为：{},【好汇推】进件原始返回参数:{}", logNumber, customer.getPhone(), result);
        } catch (Exception ex) {
            log.error("日志编号：{}， 手机号为：{},【好汇推】进件失败，传参：{} ex：{}", logNumber, customer.getPhone(), jsonData, ex);
        }
        if (StringUtils.isBlank(result)) {
            log.error("日志编号：{}， 手机号为：{},【好汇推】进件返回数据为空，传参：{} ", logNumber, customer.getPhone(), jsonData);
        }
        try {
            HhtIncomeResponse res = JSON.parseObject(result, HhtIncomeResponse.class);
            if ("000000".equals(res.getHead().getReturnCode())) {
                if (res.getHead().getResult()) {
                    log.info("日志编号：{}， 手机号为：{},【好汇推】进件成功", logNumber, customer.getPhone());
                    // 更新数据库
                    platformCapital.setIncomeStatus(1);
                    platformCapitalService.updateById(platformCapital);
                    LvdiPushResultVo rs = new LvdiPushResultVo();
                    rs.setCheckResult(true);
                    rs.setUrlType("1");// APP下载链接
                    return true;
                }
            } else {
                log.error("日志编号：{}， 手机号为：{},【好汇推】进件失败：{}，jsonData：{}", logNumber, customer.getPhone(), res.getHead().getReturnMessage(),jsonData);
            }
        } catch (Exception ex) {
            log.error("日志编号：{}， 手机号为：{},【好汇推】进件原始返回参数转换失败，jsonData：{} ex：{}", logNumber, customer.getPhone(), jsonData , ex.getMessage());
        }
        return false;
    }
    /**
     * 加密
     *
     * @param input  输入
     * @return {@code String}
     */
    private String encrypt(String input) {
        byte[] crypted = null;
        try {
            SecretKeySpec skey = new SecretKeySpec(aesKey.getBytes(CHARSET_NAME), "AES");
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5PADDING");
            cipher.init(Cipher.ENCRYPT_MODE, skey);
            crypted = cipher.doFinal(input.getBytes(CHARSET_NAME));
        } catch (Exception e) {
            log.error("aes加密错误，原因是：", e);
        }
        Base64.Encoder encoder = Base64.getEncoder();
        return encoder.encodeToString(crypted);
    }

    public String decrypt(String input) {
        byte[] output = null;
        try {
            Base64.Decoder decoder = Base64.getDecoder();
            SecretKeySpec skey = new SecretKeySpec(aesKey.getBytes(CHARSET_NAME), "AES");
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5PADDING");
            cipher.init(Cipher.DECRYPT_MODE, skey);
            output = cipher.doFinal(decoder.decode(input.getBytes(CHARSET_NAME)));
        } catch (Exception e) {
            log.error("aes解密错误，原因是：", e);
        }
        return new String(output);
    }

    public String getSignStr(JSONObject json) {
        String signContent = getSignContent(json);
        return SecureUtil.md5(signContent).toUpperCase();
    }

    /**
     * 1.第json的key 字典排序
     * 2.按排完序的key  获取对应的 value 拼接成字符串
     *
     * @param json
     * @return
     */
    public String getSignContent(JSONObject json) {
        Map<String, Object> map = new HashMap<>(json.size());
        json.forEach((s, v) -> {
            if (!"sign".equals(s)) {
                map.put(s, v);
            }
        });
        // 按值排序 升序
        Map<String, Object> sortMap = map
                .entrySet()
                .stream()
                .sorted(comparingByKey())
                .collect(
                        toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2,
                                LinkedHashMap::new));
        sortMap.put("secretKey", secretKey);

        StringBuilder sb = new StringBuilder();
        sortMap.forEach((key, value) -> {
            sb.append(key).append("=").append(value).append("&");
        });
        String result = sb.toString();
        if (result.length() > 2) {
            result = result.substring(0, result.length() - 1);
        }
        return result;
    }

    // 我的测试
    public String test() {
        Long id = 1826907441992253441L;
        String idStr = id + "";
        String url = StringUtils.replace(personalAuthorizationUrl, "id_str", idStr);
        return url;
    }
}