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

import cn.hutool.core.util.IdUtil;
import cn.hutool.json.JSONObject;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.nova.sankuai.domain.api.zhongzan.RbResponse;
import com.nova.sankuai.domain.api.zhongzan.ZhongZanResponse;
import com.nova.sankuai.domain.dto.zhongzan.*;
import com.nova.sankuai.domain.entity.CapitalInfo;
import com.nova.sankuai.domain.entity.Customer;
import com.nova.sankuai.domain.entity.CustomerCapitalResult;
import com.nova.sankuai.domain.entity.CustomerUser;
import com.nova.sankuai.domain.enums.capitalInfo.CapitalApprovalResultEnum;
import com.nova.sankuai.domain.enums.capitalInfo.CapitalResultStatusEnum;
import com.nova.sankuai.infra.mapper.CustomerCapitalResultMapper;
import com.nova.sankuai.infra.utils.RbUtil;
import com.nova.sankuai.security.HttpClientUtil;
import com.nova.sankuai.service.ICapitalResultCommonService;
import lombok.RequiredArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.util.DigestUtils;

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 众攒对接
 */
@Component
@RequiredArgsConstructor
public class ZhongZanUtil {
    private static final Logger log = LoggerFactory.getLogger("capitalLogger");

    @Value("${rongbei.zhongzan.channel}")
    private String channel;

    @Value("${rongbei.channelSource}")
    private String channelSource;

    @Value("${rongbei.publicKey}")
    private String publicKey; // 到时换成众攒的公钥

    @Value("${rongbei.privateKey}")
    private String privateKey;

    @Value("${rongbei.zhongzan.basicUrl}")
    private String basicUrl;


    private void getZzResponse(RbResponse resp, String logNumber, String jsonData, String result, String trips) {
        ZhongZanResponse zz = JSON.parseObject(result, ZhongZanResponse.class);
        if ("0".equals(zz.getCode())) {
            resp.setCode(zz.getCode());
            String decryptStr = RbUtil.decrypt(resp, zz.getSign(), zz.getKey(), String.valueOf(resp.getData()), publicKey, privateKey);
            resp.setData(JSON.parseObject(decryptStr, JSONObject.class));
        } else {
            log.error("日志编号：{} 【众攒】{}失败：{}，jsonData：{}", logNumber, trips, result, jsonData);
        }
    }

    /**
     * 1.获取协议
     */
    public RbResponse getContract(Integer type, String orderNo) {
        RbResponse resp = new RbResponse();
        String logNumber = IdUtil.randomUUID();
        log.info("日志编号：" + logNumber + "【众攒】获取协议接口开始");
        JSONObject param = new JSONObject();
        param.putOpt("type", type);
        param.putOpt("orderNo", orderNo);

        String jsonData = RbUtil.encrypt(channel, System.currentTimeMillis(), String.valueOf(param), publicKey, privateKey);
        log.info("日志编号：" + logNumber + " 【众攒】获取协议接口参数:{}, data加密 {}", param, jsonData);
        String result = null;
        try {
            result = HttpClientUtil.getInstance().postJsonData(basicUrl + "getContract", jsonData);
        } catch (Exception ex) {
            log.error("日志编号：" + logNumber + "【众攒】获取协议接口推送失败，传参：{} ex：{}", jsonData, ex, "");
        }
        try {
            getZzResponse(resp, logNumber, jsonData, result, "获取协议接口");
        } catch (Exception ex) {
            log.error("日志编号：" + logNumber + " 【众攒】获取协议接口推送原始返回参数转换失败，jsonData：{} ex：{}", jsonData, ex, "");
        }
        return resp;
    }

    private final ICapitalResultCommonService capitalResultCommonService;
    /**
     * 2.用户准入
     */
    public RbResponse checkUser(CapitalInfo capitalInfo, Customer customer, CustomerUser customerUser) {
        String logNumber = IdUtil.randomUUID();
        RbResponse resp = new RbResponse();
        log.info("日志编号：" + logNumber + "【众攒】用户准入接口开始");
        CustomerCapitalResult capitalResult = CustomerCapitalResult.initResult(capitalInfo, customerUser.getId(), customer.getId());
        capitalResult.setStatus(CapitalResultStatusEnum.CHECK.getCode());
        CustomerCapitalResult filterResult = capitalResultCommonService.filterCustomer(customer, capitalInfo, capitalResult, logNumber);
        if (filterResult != null) {
            log.info("日志编号：{}{}撞库时不满足资方信息筛选条件，撞库失败", logNumber, capitalInfo.getName());
        }
        JSONObject param = new JSONObject();
        param.putOpt("idCardMd5", DigestUtils.md5DigestAsHex(customer.getIdCard().getBytes()));
        param.putOpt("mobileMd5", DigestUtils.md5DigestAsHex(customer.getPhone().getBytes()));
        param.putOpt("nameMd5", DigestUtils.md5DigestAsHex(customer.getName().getBytes()));

        String jsonData = RbUtil.encrypt(channel, System.currentTimeMillis(), String.valueOf(param), publicKey, privateKey);

        log.info("日志编号：" + logNumber + " 手机号为：{},【众攒】用户准入接口参数:{}, data加密 {}", customer.getPhone(), param, jsonData);
        String result = null;
        try {
            result = HttpClientUtil.getInstance().postJsonData(basicUrl + "checkUser", jsonData);
        } catch (Exception ex) {
            capitalResult.setCheckResult(CustomerCapitalResult.CHECK_FAIL);
            log.error("日志编号：{} 手机号为：{},【众攒】用户准入接口推送失败，传参：{} ex：{}", logNumber, customer.getPhone(), jsonData, ex.getMessage());
        }
        try {
            getZzResponse(resp, logNumber, jsonData, result, "用户准入接口");
            if (resp.getData().getInt("status") == 1) {//准入成功
                capitalResult.setCheckResult(CustomerCapitalResult.CHECK_SUCCESS);
            }else {
                capitalResult.setCheckResult(CustomerCapitalResult.CHECK_FAIL);
            }
        } catch (Exception ex) {
            capitalResult.setCheckResult(CustomerCapitalResult.CHECK_FAIL);
            log.error("日志编号：{} 手机号为：{},【众攒】用户准入接口推送原始返回参数转换失败，jsonData：{} ex：{}", logNumber, customer.getPhone(), jsonData, ex.getMessage());
        }
        capitalResultMapper.insert(capitalResult);
        return resp;
    }

    //private final IChannelInfoService channelInfoService;

    /**
     * 3.进件接口，1成功，0失败
     */
    public boolean pushProfile(Customer customer) {
        boolean isSucc = false;
        RbResponse resp = new RbResponse();
        String logNumber = IdUtil.randomUUID();
        log.info("日志编号：" + logNumber + "【众攒】进件接口开始");
        Random random = new Random();
        int[] values;

        UserProfile userProfile = new UserProfile();
//        userProfile.setOrderNo(ConstantsUtil.getCreditNo());
        // 张明于2024-9-18号修改
        userProfile.setOrderNo(customer.getCreditNo());
        userProfile.setChannelSource(customer.getAppName());
        userProfile.setMobile(customer.getPhone());
        userProfile.setUserName(customer.getName());
        userProfile.setIdCard(customer.getIdCard());
        // 照片 photos
        Photo photo = new Photo();
        photo.setIdCardFrontUrl(customer.getIdCardFrontPath());
        photo.setIdCardBackUrl(customer.getIdCardBackPath());
        photo.setFaceUrl(customer.getFacePhotoPath());
        photo.setFaceScore(customer.getVerifySimilarity());
        photo.setThresholds("");
        photo.setFaceSource(customer.getVerifySimilarityName());
        photo.setFaceTime("");
        photo.setName(customer.getName());
        photo.setIdCardNo(customer.getIdCard());
        photo.setIdDueTime(customer.getIdValidDateBegin() + "-" + ("1".equals(customer.getIdLongTerm()) ? "长期" : customer.getIdValidDateEnd()));
        photo.setIdCardAddress(customer.getIdAddress());
        photo.setSex(RbUtil.getGenderByIDCard(customer.getIdCard()));
        photo.setNation(customer.getNation());
        photo.setIdCardAuthority(customer.getSignOrganization());
        Map<String, String> idAddress = RbUtil.addressResolution(customer.getIdAddress());
        photo.setId_province(Objects.isNull(idAddress.get("province")) ? idAddress.get("province") : "");
        photo.setId_city(Objects.isNull(idAddress.get("city")) ? idAddress.get("city") : "");
        photo.setId_area(Objects.isNull(idAddress.get("area")) ? idAddress.get("area") : "");
        photo.setId_address(customer.getIdAddress());
        userProfile.setPhotos(photo);
        // 基础信息baseInfo
        BaseInfo baseInfo = new BaseInfo();
        /**
         * 学历
         * 5：博士及以上， 4：硕士， 3：本科， 2：专科， 1：高中/中专， 0：初中及以下
         */
        String eduction = customer.getEducation();
        if ("02".equals(eduction)) {
            eduction = "2";
        } else if ("03".equals(eduction)) {
            eduction = "3";
        } else if ("04".equals(eduction)) {
            values = new int[]{4, 5};
            eduction = String.valueOf(values[random.nextInt(values.length)]);
        } else {
            values = new int[]{0, 1};
            eduction = String.valueOf(values[random.nextInt(values.length)]);
        }
        baseInfo.setEducation(Integer.parseInt(eduction));

        /**
         * "0：未婚，
         * 1：已婚无子女，
         * 2：已婚有子女，
         * 3：离异，
         * 4：再婚，
         * 5：丧偶
         */
        String maritalStatus = customer.getMaritalStatus();
        int marriage = 1;
        if ("04".equals(maritalStatus)) {
            marriage = 5;
        } else if ("03".equals(maritalStatus)) {
            marriage = 3;
        } else if ("01".equals(maritalStatus)) {
            marriage = 0;
        } else {
            values = new int[]{1, 2, 4};
            marriage = values[random.nextInt(values.length)];
        }
        baseInfo.setMarriage(marriage);
        // 1：上班族， 3：企业主， 4：个体工商， 5：事业单位， 2：自由职业者
        Integer professionInfo = customer.getProfessionInfo();
        int career = Objects.isNull(professionInfo) ? 1 : professionInfo.intValue();
        if (career == 1) { //自由职业
            career = 2;
        } else if (career == 2) { // 企业主
            career = 3;
        } else if (career == 4) { //公务员
            career = 5;
        } else if (career == 0) { // 上班族
            career = 1;
        }
        baseInfo.setJob(career);
        baseInfo.setWorkUnitName(customer.getCompanyName());
        baseInfo.setWorkUnitAddress(customer.getCompanyAddress());
        baseInfo.setHomeAddress(customer.getAddress());
        String companyTrade = getcompanyTradeString(customer);
        baseInfo.setIndustry(Integer.parseInt(companyTrade));
        /**
         * ⽉收⼊
         * 1 0-3000
         * 2 3000-6000
         * 3 6000~10000
         * 4 10000~15000
         * 5 15000~20000
         * 6 20000以上
         */
        int monthlySalary = customer.getMonthlyIncome();
        if (monthlySalary == 3) { // 10000-30000
            values = new int[]{4, 5, 6}; // 指定的字符集合
            monthlySalary = values[random.nextInt(values.length)];
        } else if (monthlySalary == 4) { // 30000以上
            monthlySalary = 6;
        } else { // 10000以下
            values = new int[]{1, 2, 3}; // 指定的字符集合
            monthlySalary = values[random.nextInt(values.length)];
        }
        baseInfo.setMonthlyIncome(monthlySalary);
        baseInfo.setEmail(customer.getEmail());
        /**
         * 借款⽤途
         * 0：日常消费， 1：装修， 2：医疗， 3：教育， 4：旅游， 5：其他
         */
        String useOfLoan = customer.getUseOfLoan();
        if ("DEC".equals(useOfLoan)) { //装修
            useOfLoan = "1";
        } else if ("EDU".equals(useOfLoan)) { // 教育
            useOfLoan = "3";
        } else if ("OTH".equals(useOfLoan)) { // 教育
            useOfLoan = "5";
        } else {
            values = new int[]{0, 2, 4}; // 指定的字符集合
            // 随机选取一个字符
            useOfLoan = String.valueOf(values[random.nextInt(values.length)]);
        }
        baseInfo.setLoanPurpose(useOfLoan);
        userProfile.setBaseInfo(baseInfo);
        // 联系人 relations
        Relation relation = new Relation();
        List<Relation> relations = new ArrayList<>();
        relation.setName(customer.getRelationshipName());
        /**
         * 1：父亲、
         * 2：母亲、
         * 3：配偶、
         * 4：儿子、
         * 5：女儿、
         * 6：哥哥、
         * 7：弟弟、
         * 8：姐姐、
         * 9：妹妹
         * 01: 配偶, 02: 父母, 03: 子女, 04: 兄弟姐妹
         */
        String relationShip = customer.getRelationship();
        if ("01".equals(relationShip)) {
            relationShip = "3";
        } else if ("02".equals(relationShip)) {
            values = new int[]{2, 3}; // 指定的字符集合
            // 随机选取一个字符
            relationShip = String.valueOf(values[random.nextInt(values.length)]);
        } else if ("03".equals(relationShip)) {
            values = new int[]{4, 5}; // 指定的字符集合
            // 随机选取一个字符
            relationShip = String.valueOf(values[random.nextInt(values.length)]);
        } else {
            values = new int[]{6, 7, 8, 9}; // 指定的字符集合
            // 随机选取一个字符
            relationShip = String.valueOf(values[random.nextInt(values.length)]);
        }
        relation.setRelation(Integer.parseInt(relationShip));
        relation.setPhone(customer.getRelationshipPhone());
        relations.add(relation);
        relation = new Relation();
        /**
         * 紧急联系人
         * 10：同事，
         * 11：朋友，
         * 12：同学，
         * 13：其他
         */
        values = new int[]{10, 11, 12, 13}; // 指定的字符集合
        // 随机选取一个字符
        relation.setRelation(values[random.nextInt(values.length)]);
        relation.setName(customer.getRelationship1Name());
        relation.setPhone(customer.getRelationship1Phone());
        relations.add(relation);
        userProfile.setRelations(relations);

        // GPS
        Gps gps = new Gps();
        gps.setLatitude(customer.getLat());
        gps.setLongitude(customer.getLng());
        userProfile.setGps(gps);
        // 设备信息 deviceInfo
        DeviceInfo deviceInfo = new DeviceInfo();
        deviceInfo.setDeviceId(customer.getDeviceId());
        deviceInfo.setIdfa(customer.getIdfa());
        deviceInfo.setIdfv(customer.getIdfv());
        deviceInfo.setOsType(customer.getOs());
        deviceInfo.setAndroidId(customer.getAndroidId());
        deviceInfo.setImei(customer.getImei());
        deviceInfo.setIp(customer.getIpAddres());
        userProfile.setDeviceInfo(deviceInfo);
        JSONObject param = new JSONObject();
        BeanUtils.copyProperties(userProfile, param);
        String jsonData = RbUtil.encrypt(channel, System.currentTimeMillis(), String.valueOf(param), publicKey, privateKey);
        log.info("日志编号：" + logNumber + " 【众攒】进件接口参数:{}, data加密 {}", userProfile, jsonData);
        String result = null;
        try {
            result = HttpClientUtil.getInstance().postJsonData(basicUrl + "pushProfile", jsonData);
        } catch (Exception ex) {
            log.error("日志编号：" + logNumber + "【众攒】进件接口推送失败，传参：{} ex：{}", jsonData, ex, "");
        }
        try {
            getZzResponse(resp, logNumber, jsonData, result, "进件接口");
            isSucc = true;
            /*JSONObject data = resp.getData();
            data.putOpt("orderNo", userProfile.getOrderNo());
            resp.setData(data);*/
        } catch (Exception ex) {
            log.error("日志编号：" + logNumber + " 【众攒】进件接口推送原始返回参数转换失败，jsonData：{} ex：{}", jsonData, ex, "");
        }
        return isSucc;
    }

    private static String getcompanyTradeString(Customer customer) {
        String companyTrade = customer.getCompanyTrade();
        /**
         * （0：批发/零售， 1：制造业， 2：金融/保险/证券， 3：住宿/餐饮/旅游， 4：商业服务/娱乐/艺术/体育， 5：计算机/互联网， 6：通讯电子， 7：建筑/房地产， 8：法律/咨询， 9：卫生/教育/社会服务， 10：公共事业/社会团体， 11：生物/制药， 12：广告/媒体， 13：能源， 14：贸易， 15：交通运输/仓储/物流， 16：农业/化工/金属冶炼， 17：其他行业）所属行业 --> 融呗（ (A：农、林、牧、渔业，B：采矿业，C：制造业，D：电力、热力、燃气及水生产和供应业，E：建筑业，F：批发和零售业，G：交通运输、仓储和邮储业，H：住宿和餐饮业，I：信息传输、软件和信息技术服务，J：金融业，K：房地产业，L：租赁和商务服务业，M：科学研究和技术服务业，N：水利、环境和公共设施管理业，O：居民服务、修理和其他服务业，P：教育，Q：卫生和社会工作，R：文化、体育和娱乐业，S：公共管理、社会保障和社会组织，T：国际组织，9：未知)）
         * 1. 建筑业 -->（E)
         * 2. 电力,热力,燃气及水生产和供应业 -->（D)
         * 3. 交通运输、仓储和邮政业 -->（G)
         * 4. 教育 -->（P)
         * 5. 房地产业 -->（K)
         * 6. 住宿和餐饮业 -->（H)
         * 7. 批发和零售业 -->（F)
         * 8. 租赁和商务服务业 -->（L)
         * 9. 信息传输、软件和信息技术服务业 -->（I)
         * 10. 金融业 -->（J)
         * 11. 文化、体育和娱乐业 -->（R)
         * 12. 制造业 -->（1)
         * 13. 水利、环境和公共设施管理业 -->（N)
         * 14. 采矿业 -->（B)
         * 15. 农、林、牧、渔业 -->（A)
         * 16. 居民服务、修理和其他服务业 -->（O)
         * 17. 卫生和社会工作 -->（Q)
         * 18. 科学研究和技术服务业 -->（M)
         * 19. 公共管理、社会保障和社会组织 -->（S)
         */
        if ("E".equals(companyTrade) || "K".equals(companyTrade)) { //建筑业
            companyTrade = "7";
        } else if ("G".equals(companyTrade)) { //交通运输、仓储和邮政业
            companyTrade = "15";
        } else if ("H".equals(companyTrade)) { //住宿和餐饮业
            companyTrade = "3";
        } else if ("F".equals(companyTrade)) { //批发和零售业
            companyTrade = "0";
        } else if ("I".equals(companyTrade)) { //信息传输、软件和信息技术服务业
            companyTrade = "5";
        } else if ("J".equals(companyTrade)) { //金融业
            companyTrade = "2";
        } else if ("R".equals(companyTrade)) { //文化、体育和娱乐业
            companyTrade = "4";
        } else if ("C".equals(companyTrade)) { //制造业
            companyTrade = "1";
        } else if ("A".equals(companyTrade) || "B".equals(companyTrade) || "D".equals(companyTrade) || "L".equals(companyTrade) || "M".equals(companyTrade) || "W".equals(companyTrade) || "O".equals(companyTrade) || "T".equals(companyTrade) || "9".equals(companyTrade)) {
            companyTrade = "17";
        } else if ("Q".equals(companyTrade) || "P".equals(companyTrade)) { //卫生和社会工作
            companyTrade = "9";
        } else if ("S".equals(companyTrade)) { //公共管理、社会保障和社会组织
            companyTrade = "10";
        }
        return companyTrade;
    }

    /**
     * 4.查询申请结果
     */
    public RbResponse queryApplyResult(String orderNo) {
        RbResponse resp = new RbResponse();
        JSONObject param = new JSONObject();
        param.putOpt("orderNo", orderNo);
        String logNumber = IdUtil.randomUUID();
        log.info("日志编号：" + logNumber + "【众攒】查询申请结果接口开始");

        String jsonData = RbUtil.encrypt(channel, System.currentTimeMillis(), String.valueOf(param), publicKey, privateKey);
        log.info("日志编号：" + logNumber + " 【众攒】查询申请结果接口参数:{}, data加密 {}", param, jsonData);
        String result = null;
        try {
            result = HttpClientUtil.getInstance().postJsonData(basicUrl + "queryApplyResult", jsonData);
        } catch (Exception ex) {
            log.error("日志编号：" + logNumber + "【众攒】查询申请结果接口推送失败，传参：{} ex：{}", jsonData, ex, "");
        }
        try {
            getZzResponse(resp, logNumber, jsonData, result, "查询申请结果接口");
        } catch (Exception ex) {
            log.error("日志编号：" + logNumber + " 【众攒】查询申请结果接口推送原始返回参数转换失败，jsonData：{} ex：{}", jsonData, ex, "");
        }
        return resp;
    }

    private final CustomerCapitalResultMapper capitalResultMapper;
    /**
     * 5.审核结果推送
     */
    public RbResponse pushApproval(RequestDTO dto) {
        RbResponse resp = new RbResponse();
        String logNumber = IdUtil.randomUUID();
        log.info("日志编号：{}【众攒】审核结果推送开始", logNumber);
        // 验签并解密
        String decryptRequest = RbUtil.decryptRequest(dto, dto.getSign(), dto.getKey(), dto.getParams(), publicKey, privateKey);
        if (StringUtils.isNotEmpty(decryptRequest)) {
            JSONObject params = JSON.parseObject(decryptRequest, JSONObject.class);
            CustomerCapitalResult capitalResult = capitalResultMapper.selectOne(Wrappers.<CustomerCapitalResult>lambdaQuery()
                    .eq(CustomerCapitalResult::getCreditNo, params.getStr("orderNo")));
            if (capitalResult != null) {
                updateResultByAudit(capitalResult, params);
            }
        }
        resp.setCode("1");
        resp.setMsg("success");
        return resp;
    }

    private void updateResultByAudit(CustomerCapitalResult capitalResult, JSONObject params) {
        if (CapitalApprovalResultEnum.APPROVAL_WAIT.getCode().equals(capitalResult.getApprovalResult())) {
            LambdaUpdateWrapper<CustomerCapitalResult> wrapper = Wrappers.<CustomerCapitalResult>lambdaUpdate()
                    .set(CustomerCapitalResult::getLastUpdatedDate, new Date())
                    .set(CustomerCapitalResult::getCreditApplyTime, params.getStr("auditTime"))
                    .set(CustomerCapitalResult::getThirdOrderStatus, params.getInt("conclusion"))
                    .eq(CustomerCapitalResult::getId, capitalResult.getId());
            if (params.getInt("conclusion") == 10) {
                capitalResult.setApprovalResult(CapitalApprovalResultEnum.APPROVAL_SUCCESS.getCode());
                if (params.getInt("auditAmt") != null) {
                    Double amount = Double.valueOf(params.getInt("auditAmt")) / 100;
                    wrapper.set(CustomerCapitalResult::getTotalCredit, amount);
                }
                wrapper.set(CustomerCapitalResult::getAvailableAmount, params.getStr("availableAmount"));
                wrapper.set(CustomerCapitalResult::getMaxAmount, params.getStr("maxAmt"));
                wrapper.set(CustomerCapitalResult::getMinAmount, params.getStr("minAmt"));
                wrapper.set(CustomerCapitalResult::getSubExpDate, params.getStr("validEndDate"));
                wrapper.set(CustomerCapitalResult::getQuotaRate, params.getStr("yearRate"));
            } else if (params.getInt("conclusion") == 40) {
                capitalResult.setApprovalResult(CapitalApprovalResultEnum.APPROVAL_REFUSE.getCode());
                wrapper.set(CustomerCapitalResult::getFailedReason, params.getStr("failedReason"));
            }
            wrapper.set(CustomerCapitalResult::getApprovalResult, capitalResult.getApprovalResult());
            capitalResultMapper.update(null, wrapper);
        }
    }

    /**
     * 6.银行卡信息查询
     */
    public RbResponse getBankCardList(String orderNo) {
        RbResponse resp = new RbResponse();
        JSONObject param = new JSONObject();
        param.putOpt("orderNo", orderNo);
        String logNumber = IdUtil.randomUUID();
        log.info("日志编号：{}【众攒】银行卡信息查询接口开始", logNumber);
        String jsonData = RbUtil.encrypt(channel, System.currentTimeMillis(), String.valueOf(param), publicKey, privateKey);
        log.info("日志编号：{} 【众攒】银行卡信息查询接口参数:{}, data加密 {}", logNumber, param, jsonData);
        String result = null;
        try {
            result = HttpClientUtil.getInstance().postJsonData(basicUrl + "getBankCardList", jsonData);
        } catch (Exception ex) {
            log.error("日志编号：{}【众攒】银行卡信息查询接口推送失败，传参：{} ex：{}", logNumber, jsonData, ex.getMessage());
        }
        try {
            getZzResponse(resp, logNumber, jsonData, result, "银行卡信息查询接口");
        } catch (Exception ex) {
            log.error("日志编号：{} 【众攒】银行卡信息查询接口推送原始返回参数转换失败，jsonData：{} ex：{}", logNumber, jsonData, ex.getMessage());
        }
        return resp;
    }

    /**
     * 7.绑卡发验证码
     */
    public RbResponse sendBindCardSms(BindCardSmsDTO dto) {
        RbResponse resp = new RbResponse();
        JSONObject param = new JSONObject();
        param.putOpt("orderNo", dto.getOrderNo());
        param.putOpt("bankCard", dto.getBankCard());
        param.putOpt("bankCode", dto.getBankCode());
        param.putOpt("userName", dto.getUserName());
        param.putOpt("idCardNumber", dto.getIdCardNumber());
        param.putOpt("userMobile", dto.getUserMobile());
        String logNumber = IdUtil.randomUUID();
        log.info("日志编号：{}【众攒】绑卡发验证码接口开始", logNumber);
        String jsonData = RbUtil.encrypt(channel, System.currentTimeMillis(), String.valueOf(param), publicKey, privateKey);
        log.info("日志编号：{} 【众攒】绑卡发验证码接口参数:{}, data加密 {}", logNumber, param, jsonData);
        String result = null;
        try {
            result = HttpClientUtil.getInstance().postJsonData(basicUrl + "sendBindCardSms", jsonData);
        } catch (Exception ex) {
            log.error("日志编号：{}【众攒】绑卡发验证码接口推送失败，传参：{} ex：{}", logNumber, jsonData, ex.getMessage());
        }
        try {
            getZzResponse(resp, logNumber, jsonData, result, "绑卡发验证码接口");
        } catch (Exception ex) {
            log.error("日志编号：{} 【众攒】绑卡发验证码接口推送原始返回参数转换失败，jsonData：{} ex：{}", logNumber, jsonData, ex.getMessage());
        }
        return resp;
    }

    /**
     * 8.绑卡验证接口
     */
    public RbResponse verifyBindCardSms(String orderNo, String verifyCode,  String bindBankNo) {
        RbResponse resp = new RbResponse();
        JSONObject param = new JSONObject();
        param.putOpt("orderNo", orderNo);
        param.putOpt("verifyCode", verifyCode);
        param.putOpt("bindBankNo", bindBankNo);
        String logNumber = IdUtil.randomUUID();
        log.info("日志编号：{}【众攒】绑卡验证接口开始", logNumber);
        String jsonData = RbUtil.encrypt(channel, System.currentTimeMillis(), String.valueOf(param), publicKey, privateKey);
        log.info("日志编号：{} 【众攒】绑卡验证接口参数:{}, data加密 {}", logNumber, param, jsonData);
        String result = null;
        try {
            result = HttpClientUtil.getInstance().postJsonData(basicUrl + "verifyBindCardSms", jsonData);
        } catch (Exception ex) {
            log.error("日志编号：{}【众攒】绑卡验证接口推送失败，传参：{} ex：{}", logNumber, jsonData, ex.getMessage());
        }
        try {
            getZzResponse(resp, logNumber, jsonData, result, "绑卡验证接口");
        } catch (Exception ex) {
            log.error("日志编号：{} 【众攒】绑卡验证接口推送原始返回参数转换失败，jsonData：{} ex：{}", logNumber, jsonData, ex.getMessage());
        }
        return resp;
    }

    /**
     * 9.支持银行列表接口
     */
    public RbResponse getBankList(String orderNo) {
        RbResponse resp = new RbResponse();
        JSONObject param = new JSONObject();
        param.putOpt("orderNo", orderNo);
        String logNumber = IdUtil.randomUUID();
        log.info("日志编号：{}【众攒】支持银行列表接口开始", logNumber);
        String jsonData = RbUtil.encrypt(channel, System.currentTimeMillis(), String.valueOf(param), publicKey, privateKey);
        log.info("日志编号：{} 【众攒】支持银行列表接口参数:{}, data加密 {}", logNumber, param, jsonData);
        String result = null;
        try {
            result = HttpClientUtil.getInstance().postJsonData(basicUrl + "getBankCardList", jsonData);
        } catch (Exception ex) {
            log.error("日志编号：{}【众攒】支持银行列表接口推送失败，传参：{} ex：{}", logNumber, jsonData, ex.getMessage());
        }
        try {
            getZzResponse(resp, logNumber, jsonData, result, "支持银行列表接口");
        } catch (Exception ex) {
            log.error("日志编号：{} 【众攒】支持银行列表接口推送原始返回参数转换失败，jsonData：{} ex：{}", logNumber, jsonData, ex.getMessage());
        }
        return resp;
    }

    /**
     * 10.借款试算
     */
    public RbResponse getTrialInfo(TrialInfoDTO dto) {
        RbResponse resp = new RbResponse();
        JSONObject param = new JSONObject();
        param.putOpt("orderNo", dto.getOrderNo());
        param.putOpt("loanAmt", dto.getLoanAmt());
        param.putOpt("loanNum", dto.getLoanNum());
        param.putOpt("repayType", dto.getRepayType());
        String logNumber = IdUtil.randomUUID();
        log.info("日志编号：{}【众攒】借款试算接口开始", logNumber);
        String jsonData = RbUtil.encrypt(channel, System.currentTimeMillis(), String.valueOf(param), publicKey, privateKey);
        log.info("日志编号：{} 【众攒】借款试算接口参数:{}, data加密 {}", logNumber, param, jsonData);
        String result = null;
        try {
            result = HttpClientUtil.getInstance().postJsonData(basicUrl + "getTrialInfo", jsonData);
        } catch (Exception ex) {
            log.error("日志编号：{}【众攒】借款试算接口推送失败，传参：{} ex：{}", logNumber, jsonData, ex.getMessage());
        }
        try {
            getZzResponse(resp, logNumber, jsonData, result, "借款试算接口");
        } catch (Exception ex) {
            log.error("日志编号：{} 【众攒】借款试算接口推送原始返回参数转换失败，jsonData：{} ex：{}", logNumber, jsonData, ex.getMessage());
        }
        return resp;
    }

    /**
     * 11.下单
     */
    public RbResponse confirmLoan(ConfirmLoanDTO dto) {
        RbResponse resp = new RbResponse();
        JSONObject param = new JSONObject();
        param.putOpt("orderNo", dto.getOrderNo());
        param.putOpt("loanNo", dto.getLoanNo());
        param.putOpt("applyAmt", dto.getApplyAmt());
        param.putOpt("bankCardNo", dto.getBankCardNo());
        param.putOpt("period", dto.getPeriod());
        String logNumber = IdUtil.randomUUID();
        log.info("日志编号：{}【众攒】下单结果接口开始", logNumber);
        String jsonData = RbUtil.encrypt(channel, System.currentTimeMillis(), String.valueOf(param), publicKey, privateKey);
        log.info("日志编号：{} 【众攒】下单接口参数:{}, data加密 {}", logNumber, param, jsonData);
        String result = null;
        try {
            result = HttpClientUtil.getInstance().postJsonData(basicUrl + "confirmLoan", jsonData);
        } catch (Exception ex) {
            log.error("日志编号：{}【众攒】下单接口推送失败，传参：{} ex：{}", logNumber, jsonData, ex.getMessage());
        }
        try {
            getZzResponse(resp, logNumber, jsonData, result, "下单接口");
        } catch (Exception ex) {
            log.error("日志编号：{} 【众攒】下单接口接推送原始返回参数转换失败，jsonData：{} ex：{}", logNumber, jsonData, ex.getMessage());
        }
        return resp;
    }

    /**
     * 12.查询放款结果
     */
    public RbResponse queryLoan(String orderNo, String loanNo) {
        RbResponse resp = new RbResponse();
        JSONObject param = new JSONObject();
        param.putOpt("orderNo", orderNo);
        param.putOpt("loanNo", loanNo);
        String logNumber = IdUtil.randomUUID();
        log.info("日志编号：{}【众攒】查询放款结果接口开始", logNumber);
        String jsonData = RbUtil.encrypt(channel, System.currentTimeMillis(), String.valueOf(param), publicKey, privateKey);
        log.info("日志编号：{} 【众攒】查询放款结果接口参数:{}, data加密 {}", logNumber, param, jsonData);
        String result = null;
        try {
            result = HttpClientUtil.getInstance().postJsonData(basicUrl + "queryLoan", jsonData);
        } catch (Exception ex) {
            log.error("日志编号：{}【众攒】查询放款结果接口推送失败，传参：{} ex：{}", logNumber, jsonData, ex.getMessage());
        }
        try {
            getZzResponse(resp, logNumber, jsonData, result, "查询放款结果接口");
        } catch (Exception ex) {
            log.error("日志编号：{} 【众攒】查询放款结果接口推送原始返回参数转换失败，jsonData：{} ex：{}", logNumber, jsonData, ex.getMessage());
        }
        return resp;
    }

    /**
     * 13.放款结果推送
     */
    public JSONObject pushLoan(RequestDTO dto) {
        //RbResponse resp = new RbResponse();
        String logNumber = IdUtil.randomUUID();
        log.info("日志编号：{}【众攒】放款结果推送开始", logNumber);
        // 验签并解密
        //String decryptRequest = RbUtil.decryptRequest(dto, dto.getSign(), dto.getKey(), dto.getParams(), publicKey, privateKey);
        //resp.setCode("1");
        //resp.setMsg("success");
        //String encryptStr = RbUtil.encryptResponse("1", "success", null, publicKey, privateKey);
        return JSON.parseObject(RbUtil.encryptResponse("1", "success", "", publicKey, privateKey), JSONObject.class);
    }

    /**
     * 14。查询还款计划
     */
    public RbResponse queryRepayPlan(String orderNo, String loanNo) {
        RbResponse resp = new RbResponse();
        JSONObject param = new JSONObject();
        param.putOpt("orderNo", orderNo);
        param.putOpt("loanNo", loanNo);
        String logNumber = IdUtil.randomUUID();
        log.info("日志编号：{}【众攒】查询还款计划接口开始", logNumber);
        String jsonData = RbUtil.encrypt(channel, System.currentTimeMillis(), String.valueOf(param), publicKey, privateKey);
        log.info("日志编号：{} 【众攒】查询还款计划接口参数:{}, data加密 {}", logNumber, param, jsonData);
        String result = null;
        try {
            result = HttpClientUtil.getInstance().postJsonData(basicUrl + "queryRepayPlan", jsonData);
        } catch (Exception ex) {
            log.error("日志编号：{}【众攒】查询还款计划接口推送失败，传参：{} ex：{}", logNumber, jsonData, ex.getMessage());
        }
        try {
            getZzResponse(resp, logNumber, jsonData, result, "查询还款计划接口");
        } catch (Exception ex) {
            log.error("日志编号：{} 【众攒】查询还款计划接口推送原始返回参数转换失败，jsonData：{} ex：{}", logNumber, jsonData, ex.getMessage());
        }
        return resp;
    }

    /**15.还款结果推送*/
    public JSONObject pushRepayResult(RequestDTO dto) {
        String logNumber = IdUtil.randomUUID();
        log.info("日志编号：{}【众攒】还款结果推送开始", logNumber);
        // 验签并解密
        //String decryptRequest = RbUtil.decryptRequest(dto, dto.getSign(), dto.getKey(), dto.getParams(), publicKey, privateKey);
        return JSON.parseObject(RbUtil.encryptResponse("1", "success", "", publicKey, privateKey), JSONObject.class);
    }

    /**16.还款H5页面获取接口*/
    public RbResponse queryRepayUrl(RepayDTO dto) {
        RbResponse resp = new RbResponse();
        JSONObject param = new JSONObject();
        param.putOpt("orderNo", dto.getOrderNo());
        param.putOpt("loadNo", dto.getLoanNo());
        param.putOpt("type", dto.getType());
        param.putOpt("fromH5", dto.getFromH5());
        String logNumber = IdUtil.randomUUID();
        log.info("日志编号：{}【众攒】还款H5页面获取接口开始", logNumber);
        String jsonData = RbUtil.encrypt(channel, System.currentTimeMillis(), String.valueOf(param), publicKey, privateKey);
        log.info("日志编号：{} 【众攒】还款H5页面获取接口参数:{}, data加密 {}", logNumber, param, jsonData);
        String result = null;
        try {
            result = HttpClientUtil.getInstance().postJsonData(basicUrl + "queryRepayUrl", jsonData);
        } catch (Exception ex) {
            log.error("日志编号：{}【众攒】还款H5页面获取接口推送失败，传参：{} ex：{}", logNumber, jsonData, ex.getMessage());
        }
        try {
            getZzResponse(resp, logNumber, jsonData, result, "还款H5页面获取接口");
        } catch (Exception ex) {
            log.error("日志编号：{} 【众攒】还款H5页面获取接口原始返回参数转换失败，jsonData：{} ex：{}", logNumber, jsonData, ex.getMessage());
        }
        return resp;
    }
}