package com.ydtech.modules.ins.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectReader;
import com.ydtech.core.page.HttpResult;
import com.ydtech.modules.admin.model.SysCbitError;
import com.ydtech.modules.admin.model.SysCbitLog;
import com.ydtech.modules.ins.controller.InsCBITController;
import com.ydtech.modules.ins.model.cbit.*;
import com.ydtech.modules.ins.service.InsCBITService;
import com.ydtech.modules.ins.service.SysCbitErrorService;
import com.ydtech.modules.ins.service.SysCbitLogService;
import com.ydtech.modules.ins.model.vo.CarModelQryVo;
import com.ydtech.modules.ins.model.vo.KingInfoVo;
import com.ydtech.utils.HttpsPostUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.io.IOException;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * @author gws
 * @description：TODO
 * @date 2021-11-30 16:33
 */
@Service
public class InsCBITServiceImpl implements InsCBITService {
    Logger logger = LoggerFactory.getLogger(InsCBITController.class);
    @Autowired
    Environment environment;
    @Autowired
    SysCbitLogService sysCbitLogService;
    @Autowired
    SysCbitErrorService sysCbitErrorService;
    //接口域名
    @Value("${cbit.url_pre}")
    String url_pre = "";
    //中介机构编码
    @Value("${cbit.franchiserId}")
    String franchiserId = "";
    //ip
    @Value("${cbit.ip}")
    String franchiserIp = "";
    //中介平台-加解密秘钥对  私钥+公钥
    @Value("${cbit.ZJPT_PUBLIC_KEY}")
    private String ZJPT_PUBLIC_KEY = "";
    //合作伙伴-加解密秘钥对  私钥+公钥
    @Value("${cbit.HZHB_PRIVATE_KEY}")
    private String HZHB_PRIVATE_KEY = "";


    /**
     * 3.2初始化参数获取接口
     * insurerId 保险公司id
     * insurerBranchCode 二级机构编码
     * franchiserChannelId 传中介网点代码
     */
    @Override
    public InitResultData initParamAPI(CBITBaseparam req_baseparam) {
        String url = url_pre + environment.getProperty("cbit.api2");
        String req_desc = "3.2初始化参数获取接口";
        InitResultData initResultData = null;
        try {
            checkBaseparam(req_baseparam);
            String reqno = geneReqNo();//请求流水号
            String reqtype = "Z00001";
            logger.info(req_desc + "--请求接口地址-->" + url);
            //1.生成初始化参数
            //CBITBaseparam baseparam=new CBITBaseparam(req_baseparam.getInsurerId(),reqno,"Z00001",req_baseparam.getInsurerBranchCode(),req_baseparam.getFranchiserChannel().getFranchiserChannelId());
            req_baseparam.setRequestNo(reqno);
            req_baseparam.setRequestType(reqtype);
            CBITReqParam reqParam = geneReqParam(req_baseparam);
            //2.调用保信接口
            String req_json = JSON.toJSONString(reqParam);
            logger.info(req_desc + "--请求参数-->" + req_json);
            String resp_json = HttpsPostUtil.sendCBITPost(url, req_json, ZJPT_PUBLIC_KEY, HZHB_PRIVATE_KEY);
            logger.info(req_desc + "--返回结果-->" + resp_json);
            //3.插入调保信接口日志表
            insertCbitLog(url, req_desc, reqno, req_json, resp_json);
            //4.处理保信接口返回数据
            ObjectMapper objectMapper = new ObjectMapper();
            ObjectReader reader = objectMapper.readerFor(CBITResponse.class);
            CBITResponse res;
            try {
                res = reader.readValue(resp_json);
            } catch (IOException e) {
                res = null;
                logger.error("反序列化失败", e);
            }
            if (res == null) {
                throw new Exception("反序列化失败");
            }
            if (!"Z00001".equals(res.getStatus())) {
                throw new Exception("保信接口返回错误：" + res.getMsg());
            } else {//5.接口交互成功，返回数据处理
                initResultData = JSON.parseObject(JSON.toJSONString(res.getData()), InitResultData.class);
            }
        } catch (Exception e) {
            e.printStackTrace();
            HttpResult.error(e.getMessage());
        }
        return initResultData;
    }


    /**
     * 3.3订单号生成接口
     */
    @Override
    public HttpResult geneOrder(CBITBaseparam req_baseparam) {
        String url = url_pre + environment.getProperty("cbit.api3");
        String req_desc = "3.3订单号生成接口";
        String orderNo = "";
        try {
            checkBaseparam(req_baseparam);
            String reqno = geneReqNo();//请求流水号
            String reqtype = "Z00002";

            //1.生成初始化参数
            //CBITBaseparam baseparam=new CBITBaseparam(req_baseparam.getInsurerId(),reqno,reqtype,req_baseparam.getInsurerBranchCode(),req_baseparam.getFranchiserChannel().getFranchiserChannelId());
            req_baseparam.setRequestNo(reqno);
            req_baseparam.setRequestType(reqtype);
            CBITReqParam reqParam = geneReqParam(req_baseparam);
            //2.调用保信接口
            String req_json = JSON.toJSONString(reqParam);
            logger.info(req_desc + "--请求参数-->" + req_json);
            String resp_json = HttpsPostUtil.sendCBITPost(url, req_json, ZJPT_PUBLIC_KEY, HZHB_PRIVATE_KEY);
            logger.info(req_desc + "--返回结果-->" + resp_json);
            //3.插入调保信接口日志表
            insertCbitLog(url, req_desc, reqno, req_json, resp_json);
            //4.处理保信接口返回数据
            ObjectMapper objectMapper = new ObjectMapper();
            ObjectReader reader = objectMapper.readerFor(CBITResponse.class);
            CBITResponse res;
            try {
                res = reader.readValue(resp_json);
            } catch (IOException e) {
                res = null;
                logger.error("反序列化失败", e);
            }
            if (res == null) {
                throw new Exception("反序列化失败");
            }
            if (!"Z00001".equals(res.getStatus())) {
                return HttpResult.error("订单号生成错误，错误信息：" + res.getMsg());
            } else {//5.接口交互成功，返回数据处理
                JSONObject data = res.getData();
                orderNo = data.getString("orderNo");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return HttpResult.error(e.getMessage());
        }
        return HttpResult.ok("订单号生成成功", orderNo);
    }

    /**
     * 3.5车型查询接口
     */
    @Override
    public HttpResult queryModel(CarModelQryVo carModelQryVo) {
        String url = url_pre + environment.getProperty("cbit.api5");
        String req_desc = "3.5车型查询接口";
        CBITModelInfo cbitModelInfo = null;
        try {
            String reqno = geneReqNo();//请求流水号
            CBITBaseparam baseparam = carModelQryVo.getBaseParam();
            String insurerId = baseparam.getInsurerId();//
            String reqtype = "Z00004";
            baseparam.setRequestNo(reqno);
            baseparam.setRequestType(reqtype);
            String insurerBranchCode = baseparam.getInsurerBranchCode();
            String franchiserChannelId = baseparam.getFranchiserChannel().getFranchiserChannelId();
            if (StringUtils.isEmpty(franchiserChannelId)//中介网点代码
                    || StringUtils.isEmpty(insurerId)//保险公司
                    || StringUtils.isEmpty(insurerBranchCode)//二级机构编码
            ) {
                throw new Exception("insurerId/insurerBranchCode/franchiserChannelId,不能为空！");
            }
            if (StringUtils.isEmpty(baseparam.getOrderNo())
                    || StringUtils.isEmpty(carModelQryVo.getModelCName())//车辆型号
                    || StringUtils.isEmpty(carModelQryVo.getEngineNo())//发动机号
                    || StringUtils.isEmpty(carModelQryVo.getVin())//车架号
                    || StringUtils.isEmpty(carModelQryVo.getNewVehicleFlag())//0：非新车，1：新车
            ) {
                throw new Exception("orderNo/modelCName/engineNo/vin/newVehicleFlag,不能为空！");
            }
            //1.生成初始化参数
            CBITReqParam reqParam = geneReqParam(baseparam);
            reqParam.setVehicleBrandModelKey(carModelQryVo.getModelCName());//车辆型号
            reqParam.setEngineNo(carModelQryVo.getEngineNo());//发动机号
            reqParam.setVin(carModelQryVo.getVin());//车架号
            reqParam.setNewVehicleFlag(carModelQryVo.getNewVehicleFlag());//0：非新车，1：新车
            //2.调用保信接口
            String req_json = JSON.toJSONString(reqParam);
            logger.info(req_desc + "--请求参数-->" + req_json);
            String resp_json = HttpsPostUtil.sendCBITPost(url, req_json, ZJPT_PUBLIC_KEY, HZHB_PRIVATE_KEY);
            logger.info(req_desc + "--返回结果-->" + resp_json);
            //3.插入调保信接口日志表
            insertCbitLog(url, req_desc, reqno, req_json, resp_json);
            //4.处理保信接口返回数据
            ObjectMapper objectMapper = new ObjectMapper();
            ObjectReader reader = objectMapper.readerFor(CBITResponse.class);
            CBITResponse res;
            try {
                res = reader.readValue(resp_json);
            } catch (IOException e) {
                res = null;
                logger.error("反序列化失败", e);
            }
            if (res == null) {
                throw new Exception("反序列化失败");
            }
            if (!"Z00001".equals(res.getStatus())) {
                return HttpResult.error(req_desc + "返回错误，错误信息：" + res.getMsg());
            } else {//5.接口交互成功，返回数据处理
                cbitModelInfo = JSON.parseObject(JSON.toJSONString(res.getData()), CBITModelInfo.class);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return HttpResult.error(e.getMessage());
        }
        return HttpResult.ok(cbitModelInfo);
    }

    /**
     * 3.6车辆确认接口
     *
     * @param reqParam_in
     * @return
     */
    @Override
    public HttpResult confirmVehicle(CBITReqParam reqParam_in) {
        String url = url_pre + environment.getProperty("cbit.api6");
        String req_desc = "3.6车辆确认接口";
        ConfirmVehicleResqData confirmVehicleResqData = null;
        try {
            String reqno = geneReqNo();//请求流水号
            CBITBaseparam baseparam = reqParam_in.getBaseParam();
            checkBaseparam(baseparam);
            String reqtype = "Z00005";
            baseparam.setRequestNo(reqno);
            baseparam.setRequestType(reqtype);

            //1.生成初始化参数
            CBITReqParam reqParam = geneReqParam(baseparam);
            reqParam.setCarOwner(reqParam_in.getCarOwner());
            reqParam.setHolder(reqParam_in.getHolder());
            reqParam.setInsureder(reqParam_in.getInsureder());
            reqParam.setVehicle(reqParam_in.getVehicle());

            //2.调用保信接口
            String req_json = JSON.toJSONString(reqParam);
            logger.info(req_desc + "--请求参数-->" + req_json);
            String resp_json = HttpsPostUtil.sendCBITPost(url, req_json, ZJPT_PUBLIC_KEY, HZHB_PRIVATE_KEY);
            logger.info(req_desc + "--返回结果-->" + resp_json);
            //3.插入调保信接口日志表
            insertCbitLog(url, req_desc, reqno, req_json, resp_json);
            //4.处理保信接口返回数据
            ObjectMapper objectMapper = new ObjectMapper();
            ObjectReader reader = objectMapper.readerFor(CBITResponse.class);
            CBITResponse res;
            try {
                res = reader.readValue(resp_json);
            } catch (IOException e) {
                res = null;
                logger.error("反序列化失败", e);
            }
            if (res == null) {
                throw new Exception("反序列化失败");
            }
            if ("Z00002".equals(res.getStatus())) {//二次车型确认
                ConfirmVehicleResqData confirmVehicleResqData2 = JSON.parseObject(JSON.toJSONString(res.getData()), ConfirmVehicleResqData.class);
                String reqno2 = geneReqNo();
                CBITBaseparam baseparam2 = reqParam.getBaseParam();
                baseparam2.setRequestNo(reqno2);
                CBITReqParam reqParam2 = geneReqParam(baseparam2);
                reqParam2.setCarOwner(reqParam.getCarOwner());
                reqParam2.setHolder(reqParam.getHolder());
                reqParam2.setInsureder(reqParam.getInsureder());
                Vehicle vehicle = reqParam.getVehicle();
                vehicle.setPurchasePrice(confirmVehicleResqData2.getVehicleModels().get(0).getPurchasePrice());
                vehicle.setVehicleModelCode(confirmVehicleResqData2.getVehicleModels().get(0).getVehicleModelCode());
                reqParam2.setVehicle(vehicle);
                String req_json2 = JSON.toJSONString(reqParam2);
                logger.info(req_desc + "--二次车型请求参数-->" + req_json2);
                String resp_json2 = HttpsPostUtil.sendCBITPost(url, req_json2, ZJPT_PUBLIC_KEY, HZHB_PRIVATE_KEY);
                logger.info(req_desc + "--二次车型返回结果-->" + resp_json2);
                //3.插入调保信接口日志表
                insertCbitLog(url, req_desc, reqno2, req_json2, resp_json2);
                //4.处理保信接口返回数据
                ObjectMapper objectMapper2 = new ObjectMapper();
                ObjectReader reader2 = objectMapper2.readerFor(CBITResponse.class);
                CBITResponse res2;
                try {
                    res2 = reader2.readValue(resp_json2);
                } catch (IOException e) {
                    res2 = null;
                    logger.error("反序列化失败", e);
                }
                if (res2 == null) {
                    throw new Exception("反序列化失败");
                }
                if (!"Z00001".equals(res2.getStatus())) {
                    return HttpResult.error(req_desc + "错误，错误信息：" + res2.getMsg());
                } else {//5.接口交互成功，返回数据处理
                    confirmVehicleResqData = JSON.parseObject(JSON.toJSONString(res2.getData()), ConfirmVehicleResqData.class);
                }
            } else if (!"Z00001".equals(res.getStatus())) {
                return HttpResult.error(req_desc + "错误，错误信息：" + res.getMsg());
            } else {//5.接口交互成功，返回数据处理
                confirmVehicleResqData = JSON.parseObject(JSON.toJSONString(res.getData()), ConfirmVehicleResqData.class);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return HttpResult.error(e.getMessage());
        }
        return HttpResult.ok(confirmVehicleResqData);
    }

    /**
     * 3.7报价
     *
     * @param quoteInfo
     * @return
     */
    @Override
    public QuoteRespData quote(CBITQuoteInfoVo quoteInfo) throws Exception {
        String url = url_pre + environment.getProperty("cbit.api7");
        String req_desc = "3.7报价";
        QuoteRespData quoteRespData = null;
        try {
            String reqno = geneReqNo();//请求流水号
            String reqtype = "Z00006";

            CBITBaseparam baseparam = quoteInfo.getBaseParam();
            checkBaseparam(baseparam);
            baseparam.setRequestNo(reqno);
            baseparam.setRequestType(reqtype);
            if (StringUtils.isEmpty(baseparam.getOrderNo())//订单号
            ) {
                throw new Exception("orderNo,不能为空！");
            }
            if (quoteInfo.getRiskList() == null || quoteInfo.getRiskList().size() == 0) {
                throw new Exception("riskList,不能为空！");
            }
            //1.生成初始化参数
            CBITReqParam reqParam = geneReqParam(baseparam);
            List<CBITRiskInfoVo> riskList = quoteInfo.getRiskList();

            //交强商业险加工
            TrafficPolicy trafficPolicy = null;
            BusinessPolicy businessPolicy = null;
            List<KingInfoVo> kindList_n = new ArrayList<>();
            Date startdate_sy = new Date();
            SimpleDateFormat sdfm = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

            for (int i = 0; i < riskList.size(); i++) {
                //商业险
                if (riskList.get(i).getRiskCode().equals("0510")) {
                    kindList_n = geneKindInfo(quoteInfo);
                    startdate_sy = sdfm.parse(riskList.get(i).getStartDate());
                    businessPolicy = new BusinessPolicy(startdate_sy, kindList_n);
                }
                //交强险
                if (riskList.get(i).getRiskCode().equals("0507")) {
                    trafficPolicy = new TrafficPolicy(sdfm.parse(riskList.get(i).getStartDate()), "T", "0");
                }
            }

            reqParam.setTrafficPolicy(trafficPolicy);//需修改
            reqParam.setBusinessPolicy(businessPolicy);//需修改
            reqParam.setArgueSolution("1");
            reqParam.setCarVin(quoteInfo.getCarInfo().getVinNo());

            //2.调用保信接口
            String req_json = JSON.toJSONString(reqParam);
            logger.info(req_desc + "--请求参数-->" + req_json);
            String resp_json = HttpsPostUtil.sendCBITPost(url, req_json, ZJPT_PUBLIC_KEY, HZHB_PRIVATE_KEY);
            logger.info(req_desc + "--返回结果-->" + resp_json);
            //3.插入调保信接口日志表
            insertCbitLog(url, req_desc, reqno, req_json, resp_json);
            //4.处理保信接口返回数据
            ObjectMapper objectMapper = new ObjectMapper();
            ObjectReader reader = objectMapper.readerFor(CBITResponse.class);
            CBITResponse res;
            try {
                res = reader.readValue(resp_json);
            } catch (IOException e) {
                res = null;
                logger.error("反序列化失败", e);
            }
            if (res == null) {
                throw new Exception("反序列化失败");
            }
            if (!"Z00001".equals(res.getStatus())) {
                throw new Exception(req_desc + "错误，错误信息：" + res.getMsg());
            } else {//5.接口交互成功，返回数据处理
                quoteRespData = JSON.parseObject(JSON.toJSONString(res.getData()), QuoteRespData.class);
            }
        } catch (Exception e) {
            //e.printStackTrace();
            throw e;
        }
        return quoteRespData;
    }

    private List<KingInfoVo> geneKindInfo(CBITQuoteInfoVo quoteInfo) {
        List<KingInfoVo> kindList = quoteInfo.getKindList();
        List<KingInfoVo> kindList_n = new ArrayList<>();
        for (int j = 0; j < kindList.size(); j++) {

            KingInfoVo kindInfoVo = kindList.get(j);
            String deductibleRate = kindInfoVo.getDeductibleRate();
            BigDecimal setScale = null;
            if (deductibleRate != null) {
                BigDecimal b1 = new BigDecimal(Double.parseDouble(deductibleRate));
                BigDecimal b2 = b1.divide(new BigDecimal(-1d));
                setScale = b2.setScale(4, 4);
            }
            //扩展属性
            //seat： 乘客数(机动车车上人员责任保险-乘客)
            //repairFactorRate： 指定修理厂费率(指定专修厂险，国产车：车损险基准纯风险保费的10%~30%之间，选择国产默认10%；进口车：车损险基准纯风险保费的15%~60%之间，选择进口默认20%。)
            //importFlag：是否国产 0：国产 1：进口';
            //claimLimitPerDay： 每日赔付限额 (修理期间赔付险)
            //maxClaimDays： 最大赔付天数(修理期间赔付险)
            //damageCardeductibles： 绝对免赔额(车辆损失险)
            //damageCarDeductiblesNoClaimRate： 车损险绝对免赔率
            //serviceTimes： 服务次数
            //(道路救援服务特约险\车辆安全检测特约险\代为驾驶服务特约险\代为送检服务特约险需传送)
            //serviceGrade： 服务款别

            //第三者责任险
            if (kindList.get(j).getKindCode().equals("B")) {
                KingInfoVo kindInfo = new KingInfoVo();
                kindInfo.setKindCode("0301600");
                kindInfo.setAmount(kindList.get(j).getAmount());
                kindList_n.add(kindInfo);
            }
            //乘客责任险
            if (kindList.get(j).getKindCode().equals("D4")) {
                KingInfoVo kindInfo = new KingInfoVo();
                kindInfo.setKindCode("0301702");
                kindInfo.setAmount(kindList.get(j).getUnitAmount());
                Map<String, String> extendInfos = new HashMap<String, String>();
                extendInfos.put("seat", String.valueOf(Integer.valueOf(quoteInfo.getVehicleModel_QueRen().getSeatCount()) - 1));
                kindInfo.setExtendInfos(extendInfos);
                kindList_n.add(kindInfo);
            }
            //机动车损失险
            if (kindList.get(j).getKindCode().equals("A")) {
                KingInfoVo kindInfo = new KingInfoVo();
                kindInfo.setKindCode("0301200");
                kindInfo.setAmount(quoteInfo.getVehicleModel_QueRen().getCurrentValue().doubleValue());
                Map<String, String> extendInfos = new HashMap<String, String>();
                extendInfos.put("damageCardeductibles", "0");
                kindInfo.setExtendInfos(extendInfos);
                kindList_n.add(kindInfo);
            }
            //司机责任险
            if (kindList.get(j).getKindCode().equals("D3")) {
                KingInfoVo kindInfo = new KingInfoVo();
                kindInfo.setKindCode("0301701");
                kindInfo.setAmount(kindList.get(j).getAmount());
                /*Map<String, String> extendInfos =new HashMap<String, String>();
                extendInfos.put("damageCardeductibles","0");
                kindInfo.setExtendInfos(extendInfos);*/
                kindList_n.add(kindInfo);
            }
            //附加绝对免赔率特约条款（车损）
            if (kindList.get(j).getKindCode().equals("MJ1")) {
                KingInfoVo kindInfo = new KingInfoVo();
                kindInfo.setKindCode("0301007");
                kindInfo.setAmount(kindList.get(j).getAmount());
                Map<String, String> extendInfos = new HashMap<String, String>();
                extendInfos.put("damageCarDeductiblesNoClaimRate", setScale.toString());
                kindInfo.setExtendInfos(extendInfos);
                kindList_n.add(kindInfo);

            }
            //绝对免赔率特约险（三者）
            if (kindList.get(j).getKindCode().equals("MJ2")) {
                KingInfoVo kindInfo = new KingInfoVo();
                kindInfo.setKindCode("0301008");
                kindInfo.setAmount(kindList.get(j).getAmount());
                Map<String, String> extendInfos = new HashMap<String, String>();
                extendInfos.put("damageCarDeductiblesNoClaimRate", setScale.toString());
                kindInfo.setExtendInfos(extendInfos);
                kindList_n.add(kindInfo);
            }
            //绝对免赔率特约险（司机）
            if (kindList.get(j).getKindCode().equals("MJ3")) {
                KingInfoVo kindInfo = new KingInfoVo();
                kindInfo.setKindCode("0301009");
                kindInfo.setAmount(kindList.get(j).getAmount());
                Map<String, String> extendInfos = new HashMap<String, String>();
                extendInfos.put("damageCarDeductiblesNoClaimRate", setScale.toString());
                kindInfo.setExtendInfos(extendInfos);
                kindList_n.add(kindInfo);

            }
            //绝对免赔率特约险（乘客）
            if (kindList.get(j).getKindCode().equals("MJ4")) {
                KingInfoVo kindInfo = new KingInfoVo();
                kindInfo.setKindCode("0301010");
                kindInfo.setAmount(kindList.get(j).getAmount());
                Map<String, String> extendInfos = new HashMap<String, String>();
                extendInfos.put("damageCarDeductiblesNoClaimRate", setScale.toString());
                kindInfo.setExtendInfos(extendInfos);
                kindList_n.add(kindInfo);

            }
            //车身划痕险
            if (kindList.get(j).getKindCode().equals("L")) {
                KingInfoVo kindInfo = new KingInfoVo();
                kindInfo.setKindCode("0301210");
                kindInfo.setAmount(kindList.get(j).getAmount());
                kindList_n.add(kindInfo);
            }
            //法定节假日限额翻倍险
            if (kindList.get(j).getKindCode().equals("BD")) {
                KingInfoVo kindInfo = new KingInfoVo();
                kindInfo.setKindCode("0301604");
                kindInfo.setAmount(kindList.get(j).getAmount());
                kindList_n.add(kindInfo);
            }
        }
        return kindList_n;
    }

    /**
     * 3.8核保接口
     *
     * @param reqParam_in
     * @return
     */
    @Override
    public HttpResult submitAudit(CBITReqParam reqParam_in, CBITQuoteInfoVo quoteInfo) {
        String url = url_pre + environment.getProperty("cbit.api8");
        String req_desc = "3.8核保接口";
        String reqno = geneReqNo();//请求流水号
        String reqtype = "Z00007";
        AuditRespData auditRespData = null;
        try {
            CBITBaseparam baseparam = reqParam_in.getBaseParam();
            checkBaseparam(baseparam);
            baseparam.setRequestNo(reqno);
            baseparam.setRequestType(reqtype);
            if (StringUtils.isEmpty(baseparam.getOrderNo())//订单号
            ) {
                throw new Exception("orderNo,不能为空！");
            }
            if (quoteInfo.getRiskList() == null || quoteInfo.getRiskList().size() == 0) {
                throw new Exception("riskList,不能为空！");
            }
            //1.生成初始化参数
            CBITReqParam reqParam = geneReqParam(baseparam);
            List<CBITRiskInfoVo> riskList = quoteInfo.getRiskList();

            //交强商业险加工
            TrafficPolicy trafficPolicy = null;
            BusinessPolicy businessPolicy = null;
            List<KingInfoVo> kindList_n = new ArrayList<>();
            Date startdate_sy = new Date();
            SimpleDateFormat sdfm = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

            for (int i = 0; i < riskList.size(); i++) {
                //商业险
                if (riskList.get(i).getRiskCode().equals("0510")) {
                    kindList_n = geneKindInfo(quoteInfo);
                    startdate_sy = sdfm.parse(riskList.get(i).getStartDate());
                }
                //交强险
                if (riskList.get(i).getRiskCode().equals("0507")) {
                    trafficPolicy = new TrafficPolicy(sdfm.parse(riskList.get(i).getStartDate()), "T", "0");
                }
            }
            businessPolicy = new BusinessPolicy(startdate_sy, kindList_n);

            reqParam.setTrafficPolicy(trafficPolicy);
            reqParam.setBusinessPolicy(businessPolicy);

            //2.调用保信接口
            String req_json = JSON.toJSONString(reqParam);
            logger.info(req_desc + "--请求参数-->" + req_json);
            String resp_json = HttpsPostUtil.sendCBITPost(url, req_json, ZJPT_PUBLIC_KEY, HZHB_PRIVATE_KEY);
            logger.info(req_desc + "--返回结果-->" + resp_json);
            //3.插入调保信接口日志表
            insertCbitLog(url, req_desc, reqno, req_json, resp_json);
            //4.处理保信接口返回数据
            ObjectMapper objectMapper = new ObjectMapper();
            ObjectReader reader = objectMapper.readerFor(CBITResponse.class);
            CBITResponse res;
            try {
                res = reader.readValue(resp_json);
            } catch (IOException e) {
                res = null;
                logger.error("反序列化失败", e);
            }
            if (res == null) {
                throw new Exception("反序列化失败");
            }
            if (!"Z00001".equals(res.getStatus())) {
                return HttpResult.error(req_desc + "错误，错误信息：" + res.getMsg());
            } else {//5.接口交互成功，返回数据处理
                auditRespData = JSON.parseObject(JSON.toJSONString(res.getData()), AuditRespData.class);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return HttpResult.error(e.getMessage());
        }
        return HttpResult.ok(auditRespData);
    }

    /**
     * 3.14电子签名支付接口
     *
     * @return
     */
    @Override
    public HttpResult pay_eleSign(CBITBaseparam req_baseparam) {
        String url = url_pre + environment.getProperty("cbit.api14");
        String req_desc = "3.14电子签名支付接口";
        String reqno = geneReqNo();//请求流水号
        String reqtype = "Z00013";
        SignPayResqData signPayResqData = null;
        try {
            checkBaseparam(req_baseparam);
            if (StringUtils.isEmpty(req_baseparam.getOrderNo())//订单号
            ) {
                throw new Exception("orderNo,不能为空！");
            }
            //1.生成初始化参数
            req_baseparam.setRequestNo(reqno);
            req_baseparam.setRequestType(reqtype);
            CBITReqParam reqParam = geneReqParam(req_baseparam);
            //2.调用保信接口
            String req_json = JSON.toJSONString(reqParam);
            logger.info(req_desc + "--请求参数-->" + req_json);
            String resp_json = HttpsPostUtil.sendCBITPost(url, req_json, ZJPT_PUBLIC_KEY, HZHB_PRIVATE_KEY);
            logger.info(req_desc + "--返回结果-->" + resp_json);
            //3.插入调保信接口日志表
            insertCbitLog(url, req_desc, reqno, req_json, resp_json);
            //4.处理保信接口返回数据
            ObjectMapper objectMapper = new ObjectMapper();
            ObjectReader reader = objectMapper.readerFor(CBITResponse.class);
            CBITResponse res;
            try {
                res = reader.readValue(resp_json);
            } catch (IOException e) {
                res = null;
                logger.error("反序列化失败", e);
            }
            if (res == null) {
                throw new Exception("反序列化失败");
            }
            if (!"Z00001".equals(res.getStatus())) {
                return HttpResult.error(req_desc + "错误，错误信息：" + res.getMsg());
            } else {//5.接口交互成功，返回数据处理
                signPayResqData = JSON.parseObject(JSON.toJSONString(res.getData()), SignPayResqData.class);

            }
        } catch (Exception e) {
            e.printStackTrace();
            return HttpResult.error(e.getMessage());
        }
        return HttpResult.ok(signPayResqData);
    }

    /**
     * 3.17投保单继续支付接口
     *
     * @return
     */
    @Override
    public HttpResult pay_application(CBITBaseparam req_baseparam) {
        String url = url_pre + environment.getProperty("cbit.api17");
        String req_desc = "3.17投保单继续支付接口";
        String reqno = geneReqNo();//请求流水号
        String reqtype = "Z00016";
        String data = "";
        String pay_url = "";
        try {
            checkBaseparam(req_baseparam);
            if (StringUtils.isEmpty(req_baseparam.getOrderNo())//订单号
            ) {
                throw new Exception("orderNo,不能为空！");
            }
            //1.生成初始化参数
            req_baseparam.setRequestNo(reqno);
            req_baseparam.setRequestType(reqtype);
            CBITReqParam reqParam = geneReqParam(req_baseparam);
            //2.调用保信接口
            String req_json = JSON.toJSONString(reqParam);
            logger.info(req_desc + "--请求参数-->" + req_json);
            String resp_json = HttpsPostUtil.sendCBITPost(url, req_json, ZJPT_PUBLIC_KEY, HZHB_PRIVATE_KEY);
            logger.info(req_desc + "--返回结果-->" + resp_json);
            //3.插入调保信接口日志表
            insertCbitLog(url, req_desc, reqno, req_json, resp_json);
            //4.处理保信接口返回数据
            JSONObject resultMap = JSON.parseObject(resp_json.toString());
            String status = resultMap.getString("status");
            if (!"Z00001".equals(status)) {
                return HttpResult.error(req_desc + "错误，错误信息：" + resultMap.getString("msg"));
            } else {//5.接口交互成功，返回数据处理
                data = resultMap.getString("data");
                /*//生成html，并返回前端url
                String filePath = "/usr/local/apache-tomcat-7.0.93/webapps/html/template.html";
                String replaceStr =data;
                String disrPath = "/usr/local/apache-tomcat-7.0.93/webapps/html";
                String fileName = reqno;
                CreateHtmlUtils.MakeHtml(filePath,replaceStr,disrPath,fileName);
                pay_url ="http://10.23.69.89/html/"+reqno+".html";*/

            }
        } catch (Exception e) {
            e.printStackTrace();
            return HttpResult.error(e.getMessage());
        }
        return HttpResult.ok("", data);
    }

    /**
     * 3.11获取短信验证码接口(手机认证)
     *
     * @param req_baseparam
     * @return
     */
    @Override
    public HttpResult pay_duanxin(CBITBaseparam req_baseparam) {
        String url = url_pre + environment.getProperty("cbit.api11");
        String req_desc = "3.11获取短信验证码接口(手机认证)";
        String reqno = geneReqNo();//请求流水号
        String reqtype = "Z00010";
        String data = "";
        String pay_url = "";
        try {
            checkBaseparam(req_baseparam);
            if (StringUtils.isEmpty(req_baseparam.getOrderNo())//订单号
            ) {
                throw new Exception("orderNo,不能为空！");
            }
            //1.生成初始化参数
            req_baseparam.setRequestNo(reqno);
            req_baseparam.setRequestType(reqtype);
            CBITReqParam reqParam = geneReqParam(req_baseparam);
            reqParam.setSmsType("SMDX");
            //2.调用保信接口
            String req_json = JSON.toJSONString(reqParam);
            logger.info(req_desc + "--请求参数-->" + req_json);
            String resp_json = HttpsPostUtil.sendCBITPost(url, req_json, ZJPT_PUBLIC_KEY, HZHB_PRIVATE_KEY);
            logger.info(req_desc + "--返回结果-->" + resp_json);
            //3.插入调保信接口日志表
            insertCbitLog(url, req_desc, reqno, req_json, resp_json);
            //4.处理保信接口返回数据
            JSONObject resultMap = JSON.parseObject(resp_json.toString());
            String status = resultMap.getString("status");
            if (!"Z00001".equals(status)) {
                return HttpResult.error(req_desc + "错误，错误信息：" + resultMap.getString("msg"));
            } else {//5.接口交互成功，返回数据处理
                data = resultMap.getString("data");
                /*//生成html，并返回前端url
                String filePath = "/usr/local/apache-tomcat-7.0.93/webapps/html/template.html";
                String replaceStr =data;
                String disrPath = "/usr/local/apache-tomcat-7.0.93/webapps/html";
                String fileName = reqno;
                CreateHtmlUtils.MakeHtml(filePath,replaceStr,disrPath,fileName);
                pay_url ="http://10.23.69.89/html/"+reqno+".html";*/

            }
        } catch (Exception e) {
            e.printStackTrace();
            return HttpResult.error(e.getMessage());
        }
        return HttpResult.ok("", data);
    }

    /**
     * 3.12回收短信验证码接口(手机认证)
     *
     * @param req_baseparam
     * @return
     */
    @Override
    public HttpResult pay_duanxin_back(CBITBaseparam req_baseparam, String issueCode) {
        String url = url_pre + environment.getProperty("cbit.api12");
        String req_desc = "3.12回收短信验证码接口(手机认证)";
        String reqno = geneReqNo();//请求流水号
        String reqtype = "Z00011";
        String data = "";
        String pay_url = "";
        try {
            checkBaseparam(req_baseparam);

            //1.生成初始化参数
            req_baseparam.setRequestNo(reqno);
            req_baseparam.setRequestType(reqtype);
            CBITReqParam reqParam = geneReqParam(req_baseparam);
            logger.info("验证码issueCode：" + issueCode);
            reqParam.setIssueCode(issueCode);
            //2.调用保信接口
            String req_json = JSON.toJSONString(reqParam);
            logger.info(req_desc + "--请求参数-->" + req_json);
            String resp_json = HttpsPostUtil.sendCBITPost(url, req_json, ZJPT_PUBLIC_KEY, HZHB_PRIVATE_KEY);
            logger.info(req_desc + "--返回结果-->" + resp_json);
            //3.插入调保信接口日志表
            insertCbitLog(url, req_desc, reqno, req_json, resp_json);
            //4.处理保信接口返回数据
            JSONObject resultMap = JSON.parseObject(resp_json.toString());
            String status = resultMap.getString("status");
            if (!"Z00001".equals(status)) {
                return HttpResult.error(req_desc + "错误，错误信息：" + resultMap.getString("msg"));
            } else {//5.接口交互成功，返回数据处理
                data = resultMap.getString("data");
                /*//生成html，并返回前端url
                String filePath = "/usr/local/apache-tomcat-7.0.93/webapps/html/template.html";
                String replaceStr =data;
                String disrPath = "/usr/local/apache-tomcat-7.0.93/webapps/html";
                String fileName = reqno;
                CreateHtmlUtils.MakeHtml(filePath,replaceStr,disrPath,fileName);
                pay_url ="http://10.23.69.89/html/"+reqno+".html";*/

            }
        } catch (Exception e) {
            e.printStackTrace();
            return HttpResult.error(e.getMessage());
        }
        return HttpResult.ok("", data);
    }

    /**
     * 3.9支付申请接口
     *
     * @return
     */
    @Override
    public HttpResult pay_duanxin_pay(CBITBaseparam req_baseparam) {
        String url = url_pre + environment.getProperty("cbit.api9");
        String req_desc = "3.9支付申请接口";
        String reqno = geneReqNo();//请求流水号
        String reqtype = "Z00008";
        String data = "";
        String pay_url = "";
        try {
            checkBaseparam(req_baseparam);

            //1.生成初始化参数
            req_baseparam.setRequestNo(reqno);
            req_baseparam.setRequestType(reqtype);
            CBITReqParam reqParam = geneReqParam(req_baseparam);
            reqParam.setPayWay("Z000005");//太平 "payWayCode": "Z000005"
            //2.调用保信接口
            String req_json = JSON.toJSONString(reqParam);
            logger.info(req_desc + "--请求参数-->" + req_json);
            String resp_json = HttpsPostUtil.sendCBITPost(url, req_json, ZJPT_PUBLIC_KEY, HZHB_PRIVATE_KEY);
            logger.info(req_desc + "--返回结果-->" + resp_json);
            //3.插入调保信接口日志表
            insertCbitLog(url, req_desc, reqno, req_json, resp_json);
            //4.处理保信接口返回数据
            JSONObject resultMap = JSON.parseObject(resp_json.toString());
            String status = resultMap.getString("status");
            if (!"Z00001".equals(status)) {
                return HttpResult.error(req_desc + "错误，错误信息：" + resultMap.getString("msg"));
            } else {//5.接口交互成功，返回数据处理
                data = resultMap.getString("data");
                /*//生成html，并返回前端url
                String filePath = "/usr/local/apache-tomcat-7.0.93/webapps/html/template.html";
                String replaceStr =data;
                String disrPath = "/usr/local/apache-tomcat-7.0.93/webapps/html";
                String fileName = reqno;
                CreateHtmlUtils.MakeHtml(filePath,replaceStr,disrPath,fileName);
                pay_url ="http://10.23.69.89/html/"+reqno+".html";*/

            }
        } catch (Exception e) {
            e.printStackTrace();
            return HttpResult.error(e.getMessage());
        }
        return HttpResult.ok("", data);
    }

    private void insertCbitLog(String url, String req_desc, String reqno, String req_json, String resp_json) {
        SysCbitLog cbitLog = new SysCbitLog();
        cbitLog.setReqNo(reqno);
        cbitLog.setUsercode("");
//        cbitLog.setUsercode(SecurityUtils.getUsername());
        cbitLog.setReqUrl(url);
        cbitLog.setDescription(req_desc);
        cbitLog.setReqParam(req_json);
        cbitLog.setResponse(resp_json);
        cbitLog.setCreatetime(new Date());
        sysCbitLogService.insert(cbitLog);
    }

    private String geneReqNo() {
        //中介机构id+UUID，每次请求需生成一个不重复的流水号，响应时原样返回
        return franchiserId + UUID.randomUUID();
    }

    private CBITReqParam geneReqParam(CBITBaseparam baseparam) throws Exception {
        CBITReqParam CBITReqParam = new CBITReqParam();
        //不能为空校验
        //String insurerId,String reqno,String reqtype,String insurerBranchCode,String franchiserChannelId
        if (StringUtils.isEmpty(baseparam.getInsurerId()) || StringUtils.isEmpty(baseparam.getRequestNo()) || StringUtils.isEmpty(baseparam.getRequestType()) ||
                StringUtils.isEmpty(baseparam.getInsurerBranchCode()) || StringUtils.isEmpty(baseparam.getFranchiserChannel().getFranchiserChannelId())) {
            throw new Exception("insurerId, reqno, reqtype, insurerBranchCode, franchiserChannelId 这些参数不能为空！");
        }
        CBITBaseparam reqParam = new CBITBaseparam();
        reqParam.setFranchiserId(franchiserId);
        reqParam.setInsurerId(baseparam.getInsurerId());
        reqParam.setOrderNo(StringUtils.isEmpty(baseparam.getOrderNo()) ? "" : baseparam.getOrderNo());
        reqParam.setRequestNo(baseparam.getRequestNo());
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
        reqParam.setRequestTime(df.format(new Date()));
        reqParam.setRequestType(baseparam.getRequestType());
        reqParam.setIp(franchiserIp);
        reqParam.setInsurerBranchCode(baseparam.getInsurerBranchCode());
        reqParam.setPjOrderSourceCode(StringUtils.isEmpty(baseparam.getPjOrderSourceCode()) ? "" : baseparam.getPjOrderSourceCode());
        reqParam.setSysProductVersion(StringUtils.isEmpty(baseparam.getSysProductVersion()) ? "" : baseparam.getSysProductVersion());
        reqParam.setSysVersion(StringUtils.isEmpty(baseparam.getSysVersion()) ? "" : baseparam.getSysVersion());
        reqParam.setFranchiserInstitutionCode(StringUtils.isEmpty(baseparam.getFranchiserInstitutionCode()) ? "" : baseparam.getFranchiserInstitutionCode());
        reqParam.setFranchiserChannel(baseparam.getFranchiserChannel());
        CBITReqParam.setBaseParam(reqParam);
        return CBITReqParam;
    }

    private void checkBaseparam(CBITBaseparam baseparam) throws Exception {
        if (baseparam == null
                || StringUtils.isEmpty(baseparam.getFranchiserChannel().getFranchiserChannelId())//中介网点代码
                || StringUtils.isEmpty(baseparam.getInsurerId())//保险公司
                || StringUtils.isEmpty(baseparam.getInsurerBranchCode())//二级机构编码
        ) {
            throw new Exception("insurerId/insurerBranchCode/franchiserChannelId,不能为空！");
        }

    }

    private void insertCbitError(CBITReqParam reqParam_cbit, String api_url, String errorinfo) {
        SysCbitError sysCbitError = new SysCbitError();
        sysCbitError.setReqno(reqParam_cbit.getBaseParam().getRequestNo());
        sysCbitError.setRequrl(api_url);
        sysCbitError.setReqparam(JSON.toJSONString(reqParam_cbit));
        sysCbitError.setErrorinfo(errorinfo);
        sysCbitErrorService.insert(sysCbitError);
    }
}