package com.nova.sankuai.controller.v2;

import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.nova.sankuai.domain.api.hengyidai.response.HyGetOrderStatusResponse;
import com.nova.sankuai.domain.api.zhongzan.RbResponse;
import com.nova.sankuai.domain.dto.zhongzan.BindCardSmsDTO;
import com.nova.sankuai.domain.entity.*;
import com.nova.sankuai.domain.enums.capitalInfo.CapitalApprovalResultEnum;
import com.nova.sankuai.infra.mapper.CustomerMapper;
import com.nova.sankuai.infra.utils.qinghuayoupin.QingHuaYouPinUtil;
import com.nova.sankuai.service.ICustomerCapitalResultService;
import com.nova.sankuai.service.IRepayRecord;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.validation.Valid;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Objects;

@RequestMapping("/api/v2/qingHua")
@Slf4j
@RestController
@Validated
@RequiredArgsConstructor
@Api(tags = "轻花优品接口")
public class QingHuaYouPinController {
    private final QingHuaYouPinUtil qingHuaYouPinUtil;
    private final ICustomerCapitalResultService customerCapitalResultService;
    private final HttpServletRequest request;
    private final CustomerMapper customerMapper;
    @Autowired
    private IRepayRecord repayRecord;
    @PostMapping("checkUser")
    @ApiOperation(value = "2.用户准入", notes = "此接口用于确认用户是否可以申请众攒方产品")
    ResponseEntity<RbResponse> checkUser(@RequestBody CapitalInfo capitalInfo, Customer customer, CustomerUser customerUser) {
        log.debug("2.用户准入接口测试");
        return ResponseEntity.ok(qingHuaYouPinUtil.checkUser(capitalInfo, customer, customerUser));
    }
    @PostMapping("getContract")
    @ApiOperation(value = "1.获取协议", notes = "可通过此接口可获取各场景需要展示的用户协议")
    ResponseEntity<RbResponse> getContract(@RequestBody @RequestParam(value = "type") Integer type, @RequestParam(value = "orderNo", required = false) String orderNo) {
        log.debug("获取协议接口测试");
        return ResponseEntity.ok(qingHuaYouPinUtil.getContract(type));
    }

    @PostMapping("approval")
    @ApiOperation(value = "3.进件接口", notes = "调用此接口将用户资料传输给众攒方")
    ResponseEntity<RbResponse> pushProfile(@RequestBody Customer customer) {
        log.debug("3.进件接口测试");
        return ResponseEntity.ok(qingHuaYouPinUtil.pushProfile(customer));
    }
    @PostMapping("queryApproval")
    @ApiOperation(value = "4.查询进件结果", notes = "查询进件结果")
    ResponseEntity<RbResponse> queryApproval() {
        log.debug("4.查询申请结果");
        CustomerUser customerUser = this.customerCapitalResultService.checkUser(this.request);
        Customer customer = this.customerMapper.getLatestCustomerRecord(customerUser.getPhone());
        List<CustomerCapitalResult> capitalResultList = new ArrayList();
        if (customer != null) {
            capitalResultList = customerCapitalResultService.lambdaQuery()
                    .eq(CustomerCapitalResult::getCustomerUserId, customerUser.getId())
                    .eq(CustomerCapitalResult::getCustomerRecordId, customer.getId())
                    .eq(CustomerCapitalResult::getCapitalInfoId, 4l)
                    .list();
        }
        RbResponse result = new RbResponse();
        if (!(capitalResultList).isEmpty() ) {
            CustomerCapitalResult customerCapitalResult = capitalResultList.get(0);
            if (customerCapitalResult.getApprovalResult() != null && customerCapitalResult.getApprovalResult().equals(0)){
                result = this.qingHuaYouPinUtil.queryApproval(customerCapitalResult);
            }
        }
        return ResponseEntity.ok(result);
    }
    @PostMapping("getBankList")
    @ApiOperation(value = "5.支持银行列表接口", notes = "可通过此接口查询支持银行卡列表，展示在前端供用户绑卡时选择")
    ResponseEntity<RbResponse> getBankList() {
        log.debug("5.支持银行列表接口");
        return ResponseEntity.ok(qingHuaYouPinUtil.getBankList());
    }
    @PostMapping("getBankCardList")
    @ApiOperation(value = "6.用户已绑银行卡", notes = "贷前授信通过后，调用此接口获取用户已绑卡列表")
    ResponseEntity<RbResponse> getBankCardList(@RequestParam(value = "orderNo") String orderNo) {
        log.debug("6.银行卡信息查询");
        return ResponseEntity.ok(qingHuaYouPinUtil.getBankCardList(orderNo));
    }
    @PostMapping("bindCardApply")
    @ApiOperation(value = "7.绑卡申请", notes = "绑卡申请")
    ResponseEntity<RbResponse> bindCardApply(@RequestParam(value = "cardNo") String cardNo,@RequestParam(value = "phone") String phone,
                                             @RequestParam(value = "certNo") String certNo,@RequestParam(value = "bankCode") String bankCode,
                                             @RequestParam(value = "cardName") String cardName) {
        log.debug("7.绑卡申请");
        CustomerUser customerUser = this.customerCapitalResultService.checkUser(this.request);
        Customer customer = this.customerMapper.getLatestCustomerRecord(customerUser.getPhone());
        List<CustomerCapitalResult> capitalResultList = new ArrayList();
        if (customer != null) {
            capitalResultList = customerCapitalResultService.lambdaQuery()
                    .eq(CustomerCapitalResult::getCustomerUserId, customerUser.getId())
                    .eq(CustomerCapitalResult::getCustomerRecordId, customer.getId())
                    .eq(CustomerCapitalResult::getCapitalInfoId, 4l)
                    .list();
        }
        RbResponse result = new RbResponse();
        if (!(capitalResultList).isEmpty()) {
            CustomerCapitalResult customerCapitalResult = capitalResultList.get(0);
            result = this.qingHuaYouPinUtil.bindCardApply(cardNo, phone, certNo, bankCode, cardName, customerCapitalResult.getCreditNo());
            customer.setCardNo(cardNo);
            customer.setBankCardName(cardName);
            customer.setBankCode(bankCode);
            this.customerMapper.updateById(customer);
        } else {
            result.setMsg("绑卡申请失败");
            result.setCode("1");
        }

        return ResponseEntity.ok(result);
    }

    @PostMapping("bindCardConfirm")
    @ApiOperation(value = "8.绑卡确认", notes = "调用此接口可以让用户确定是否绑定卡")
    ResponseEntity<RbResponse> bindCardConfirm(@RequestParam(value = "confirmNo") String confirmNo,@RequestParam(value = "smsCode") String smsCode
                                              ) {
        CustomerUser customerUser = this.customerCapitalResultService.checkUser(this.request);
        Customer customer = this.customerMapper.getLatestCustomerRecord(customerUser.getPhone());
        List<CustomerCapitalResult> capitalResultList = new ArrayList();
        if (customer != null) {
            capitalResultList = customerCapitalResultService.lambdaQuery()
                    .eq(CustomerCapitalResult::getCustomerUserId, customerUser.getId())
                    .eq(CustomerCapitalResult::getCustomerRecordId, customer.getId())
                    .eq(CustomerCapitalResult::getCapitalInfoId, 4l)
                    .list();
        }
        log.debug("8.绑卡确认");
        RbResponse result = new RbResponse();
        if (!(capitalResultList).isEmpty()) {
            CustomerCapitalResult customerCapitalResult = capitalResultList.get(0);
            result = this.qingHuaYouPinUtil.bindCardConfirm(confirmNo, smsCode, customerCapitalResult.getCreditNo());
        } else {
            result.setMsg("绑卡确认失败");
            result.setCode("201");
        }

        return ResponseEntity.ok(result);
    }
    @PostMapping("getLoanUrl")
    @ApiOperation(value = "9.借款申请链接", notes = "调用此接口可以获取借款申请链接")
    ResponseEntity<RbResponse> getLoanUrl(@RequestParam(value = "redirectUrl") String redirectUrl,
                                               @RequestParam(value = "partnerOrderNo") String partnerOrderNo) {
        log.debug("9.借款申请链接");
        return ResponseEntity.ok(qingHuaYouPinUtil. getLoanUrl(redirectUrl,partnerOrderNo));
    }
    @PostMapping("getRepayUrl")
    @ApiOperation(value = "10.还款链接", notes = "调用此接口可以获取借款还款链接")
    ResponseEntity<RbResponse> getRepayUrl(@RequestParam(value = "redirectUrl") String redirectUrl,
                                          @RequestParam(value = "partnerOrderNo") String partnerOrderNo) {
        log.debug("10.还款链接");
        return ResponseEntity.ok(qingHuaYouPinUtil.getRepayUrl(redirectUrl,partnerOrderNo));
    }
    @PostMapping("trial")
    @ApiOperation(value = "11.要款试算", notes = "调用此接口可以获取要款试算结果")
    ResponseEntity<RbResponse> trial() {
        log.debug("11.要款试算");
        CustomerUser customerUser = this.customerCapitalResultService.checkUser(this.request);
        Customer customer = this.customerMapper.getLatestCustomerRecord(customerUser.getPhone());
        List<CustomerCapitalResult> capitalResultList = new ArrayList();
        RbResponse result = new RbResponse();
        if (customer != null) {
            capitalResultList = customerCapitalResultService.lambdaQuery()
                    .eq(CustomerCapitalResult::getCustomerUserId, customerUser.getId())
                    .eq(CustomerCapitalResult::getCustomerRecordId, customer.getId())
                    .eq(CustomerCapitalResult::getCapitalInfoId, 4l)
                    .list();
            if (!(capitalResultList).isEmpty()) {
                CustomerCapitalResult customerCapitalResult = capitalResultList.get(0);
                result = qingHuaYouPinUtil.trial(customerCapitalResult.getCreditNo());
            } else {
                result.setMsg("要款试算失败");
                result.setCode("201");
            }
        }
        return ResponseEntity.ok(result);
    }
    @PostMapping("submitLoan")
    @ApiOperation(value = "12.提交要款", notes = "调用此接口可以提交要款")
    ResponseEntity<RbResponse> submitLoan(@RequestParam(value = "rightsMarking") String rightsMarking) {
        log.debug("12.提交要款");
        CustomerUser customerUser = this.customerCapitalResultService.checkUser(this.request);
        Customer customer = this.customerMapper.getLatestCustomerRecord(customerUser.getPhone());
        List<CustomerCapitalResult> capitalResultList = new ArrayList();
        RbResponse result = new RbResponse();
        if (customer != null) {
            capitalResultList = customerCapitalResultService.lambdaQuery()
                    .eq(CustomerCapitalResult::getCustomerUserId, customerUser.getId())
                    .eq(CustomerCapitalResult::getCustomerRecordId, customer.getId())
                    .eq(CustomerCapitalResult::getCapitalInfoId, 4l)
                    .list();
            if (!(capitalResultList).isEmpty()) {
                CustomerCapitalResult customerCapitalResult = capitalResultList.get(0);
                result = qingHuaYouPinUtil.submitLoan(customerCapitalResult.getCreditNo(),rightsMarking);
            } else {
                result.setMsg("提交要款失败");
                result.setCode("201");
            }
        }
        return ResponseEntity.ok(result);
    }
    @PostMapping("queryLoan")
    @ApiOperation(value = "13.借款查询", notes = "调用此接口可以借款查询")
    ResponseEntity<RbResponse> queryLoan( ) {
        log.debug("13.借款查询");
        CustomerUser customerUser = this.customerCapitalResultService.checkUser(this.request);
        Customer customer = this.customerMapper.getLatestCustomerRecord(customerUser.getPhone());
        List<CustomerCapitalResult> capitalResultList = new ArrayList();
        RbResponse result = new RbResponse();
        if (customer != null) {
            capitalResultList = customerCapitalResultService.lambdaQuery()
                    .eq(CustomerCapitalResult::getCustomerUserId, customerUser.getId())
                    .eq(CustomerCapitalResult::getCustomerRecordId, customer.getId())
                    .eq(CustomerCapitalResult::getCapitalInfoId, 4l)
                    .list();
            if (!(capitalResultList).isEmpty()) {
                CustomerCapitalResult customerCapitalResult = capitalResultList.get(0);
                result = qingHuaYouPinUtil.queryLoan(customerCapitalResult.getCreditNo());
            } else {
                result.setMsg("借款查询失败");
                result.setCode("201");
            }
        }
        return ResponseEntity.ok(result);
    }
    @PostMapping("queryRepayPlan")
    @ApiOperation(value = "14.还款计划查询", notes = "调用此接口可以获取还款计划")
    ResponseEntity<RbResponse> queryRepayPlan( ) {
        log.debug("14.还款计划查询");
        CustomerUser customerUser = this.customerCapitalResultService.checkUser(this.request);
        Customer customer = this.customerMapper.getLatestCustomerRecord(customerUser.getPhone());
        List<CustomerCapitalResult> capitalResultList = new ArrayList();
        RbResponse result = new RbResponse();
        if (customer != null) {
            capitalResultList = customerCapitalResultService.lambdaQuery()
                    .eq(CustomerCapitalResult::getCustomerUserId, customerUser.getId())
                    .eq(CustomerCapitalResult::getCustomerRecordId, customer.getId())
                    .eq(CustomerCapitalResult::getCapitalInfoId, 4l)
                    .list();
            if (!(capitalResultList).isEmpty()) {
                CustomerCapitalResult customerCapitalResult = capitalResultList.get(0);
                result = qingHuaYouPinUtil.queryRepayPlan(customerCapitalResult.getCreditNo());
            } else {
                result.setMsg("还款计划查询失败");
                result.setCode("201");
            }
        }
        return ResponseEntity.ok(result);
    }
    @PostMapping("detail")
    @ApiOperation(value = "15.查询权益包详情", notes = "调用此接口可以获取查询权益包详情")
    ResponseEntity<RbResponse> detail() {
        log.debug("15.查询权益包详情");
        CustomerUser customerUser = this.customerCapitalResultService.checkUser(this.request);
        Customer customer = this.customerMapper.getLatestCustomerRecord(customerUser.getPhone());
        List<CustomerCapitalResult> capitalResultList = new ArrayList();
        RbResponse result = new RbResponse();
        if (customer != null) {
            capitalResultList = customerCapitalResultService.lambdaQuery()
                    .eq(CustomerCapitalResult::getCustomerUserId, customerUser.getId())
                    .eq(CustomerCapitalResult::getCustomerRecordId, customer.getId())
                    .eq(CustomerCapitalResult::getCapitalInfoId, 4l)
                    .list();
            if (!(capitalResultList).isEmpty()) {
                CustomerCapitalResult customerCapitalResult = capitalResultList.get(0);
                result = qingHuaYouPinUtil.detail(customerCapitalResult.getCreditNo());
            } else {
                result.setMsg("还款计划查询失败");
                result.setCode("201");
            }
        }
        return ResponseEntity.ok(result);
    }
    @PostMapping("benefitExchange")
    @ApiOperation(value = "15.获取权益兑换地址", notes = "调用此接口可以获取权益兑换地址")
    ResponseEntity<RbResponse> benefitExchange() {
        log.debug("15.获取权益兑换地址");
        CustomerUser customerUser = this.customerCapitalResultService.checkUser(this.request);
        Customer customer = this.customerMapper.getLatestCustomerRecord(customerUser.getPhone());
        List<CustomerCapitalResult> capitalResultList = new ArrayList();
        RbResponse result = new RbResponse();
        if (customer != null) {
            capitalResultList = customerCapitalResultService.lambdaQuery()
                    .eq(CustomerCapitalResult::getCustomerUserId, customerUser.getId())
                    .eq(CustomerCapitalResult::getCustomerRecordId, customer.getId())
                    .eq(CustomerCapitalResult::getCapitalInfoId, 4l)
                    .list();
            if (!(capitalResultList).isEmpty()) {
                CustomerCapitalResult customerCapitalResult = capitalResultList.get(0);
                result = qingHuaYouPinUtil.benefitExchange(customerCapitalResult.getCreditNo());
            } else {
                result.setMsg("获取权益兑换地址");
                result.setCode("201");
            }
        }
        return ResponseEntity.ok(result);
    }
    @PostMapping("deductionResult")
    @ApiOperation(value = "17.查询权益扣款结果", notes = "调用此接口可以查询权益扣款结果")
    ResponseEntity<RbResponse> repayTrial() {
        log.debug("17.查询权益扣款结果");
        CustomerUser customerUser = this.customerCapitalResultService.checkUser(this.request);
        Customer customer = this.customerMapper.getLatestCustomerRecord(customerUser.getPhone());
        List<CustomerCapitalResult> capitalResultList = new ArrayList();
        RbResponse result = new RbResponse();
        if (customer != null) {
            capitalResultList = customerCapitalResultService.lambdaQuery()
                    .eq(CustomerCapitalResult::getCustomerUserId, customerUser.getId())
                    .eq(CustomerCapitalResult::getCustomerRecordId, customer.getId())
                    .eq(CustomerCapitalResult::getCapitalInfoId, 4l)
                    .list();
            if (!(capitalResultList).isEmpty()) {
                CustomerCapitalResult customerCapitalResult = capitalResultList.get(0);
                result = qingHuaYouPinUtil.deductionResult(customerCapitalResult.getCreditNo());
            } else {
                result.setMsg("查询权益扣款结果失败");
                result.setCode("201");
            }
        }
        return ResponseEntity.ok(result);
    }
    @PostMapping("repayTrial")
    @ApiOperation(value = "18.还款试算", notes = "调用此接口可以获取还款结果查询")
    ResponseEntity<RbResponse> repayTrial(@RequestParam(value = "repayPurpose") String repayPurpose,
                                      @RequestParam(value = "period") String period) {
        log.debug("18.还款试算");
        CustomerUser customerUser = this.customerCapitalResultService.checkUser(this.request);
        Customer customer = this.customerMapper.getLatestCustomerRecord(customerUser.getPhone());
        List<CustomerCapitalResult> capitalResultList = new ArrayList();
        RbResponse result = new RbResponse();
        if (customer != null) {
            capitalResultList = customerCapitalResultService.lambdaQuery()
                    .eq(CustomerCapitalResult::getCustomerUserId, customerUser.getId())
                    .eq(CustomerCapitalResult::getCustomerRecordId, customer.getId())
                    .eq(CustomerCapitalResult::getCapitalInfoId, 4l)
                    .list();
            if (!(capitalResultList).isEmpty()) {
                CustomerCapitalResult customerCapitalResult = capitalResultList.get(0);
                result = qingHuaYouPinUtil.repayTrial(customerCapitalResult.getCreditNo(),repayPurpose,period);
            } else {
                result.setMsg("还款试算失败");
                result.setCode("201");
            }
        }
        return ResponseEntity.ok(result);
    }
    @PostMapping("repay")
    @ApiOperation(value = "19.提交还款", notes = "调用此接口可以获取提交还款结果")
    ResponseEntity<RbResponse> repay( @RequestParam(value = "repayPurpose") String repayPurpose,
                                      @RequestParam(value = "period") String period) {
        log.debug("19.提交还款");
        CustomerUser customerUser = this.customerCapitalResultService.checkUser(this.request);
        Customer customer = this.customerMapper.getLatestCustomerRecord(customerUser.getPhone());
        List<CustomerCapitalResult> capitalResultList = new ArrayList();
        RbResponse result = new RbResponse();
        if (customer != null) {
            capitalResultList = customerCapitalResultService.lambdaQuery()
                    .eq(CustomerCapitalResult::getCustomerUserId, customerUser.getId())
                    .eq(CustomerCapitalResult::getCustomerRecordId, customer.getId())
                    .eq(CustomerCapitalResult::getCapitalInfoId, 4l)
                    .list();
            if (!(capitalResultList).isEmpty()) {
                CustomerCapitalResult customerCapitalResult = capitalResultList.get(0);
                //流水号生成 qinghua+客户身份证后四位+年月日+时间（生成的时间，到分秒）+序号（"00"+还款期次）
                String idCardSub = customer.getIdCard().substring(14);
                String birthSub = customer.getIdCard().substring(6,14);
                String partnerRepayNo = "qinghua"+idCardSub+birthSub+System.currentTimeMillis()+"00"+period;
                result = qingHuaYouPinUtil.repay(customerCapitalResult.getCreditNo(),repayPurpose,period,partnerRepayNo);
                if ("200".equals(result.getCode())){//更新状态成还款中
                    customerCapitalResult.setApprovalResult(CapitalApprovalResultEnum.APPROVAL_REPAY.getCode());
                    customerCapitalResult.setThirdOrderStatus(HyGetOrderStatusResponse.STATUS_REPAY_FAIL);
                    customerCapitalResultService.updateById(customerCapitalResult);
                }
                LambdaQueryWrapper<RepayRecord> wrapper = new LambdaQueryWrapper<>();
                wrapper.eq(RepayRecord::getCapitalInfoId,"4");
                wrapper.eq(RepayRecord::getPeriod,period);
                wrapper.eq(RepayRecord::getPartnerOrderNo,customer.getCardNo());
                RepayRecord repayRecord1 = repayRecord.getOne(wrapper);
                //记录还款
                if (repayRecord1 == null){
                    RepayRecord saveRepayRecord = new RepayRecord();
                    saveRepayRecord.setCustomerId(customer.getId());
                    saveRepayRecord.setCreationDate(new Date());
                    saveRepayRecord.setCustomerName(customer.getName());
                    saveRepayRecord.setCapitalInfoId("4");
                    saveRepayRecord.setPeriod(period);
                    saveRepayRecord.setPartnerRepayNo(partnerRepayNo);
                    saveRepayRecord.setLastUpdatedDate(new Date());
                    saveRepayRecord.setPartnerOrderNo(customer.getCardNo());
                    repayRecord.save(saveRepayRecord);
                    log.info("提交还款完成新增还款记录"+partnerRepayNo);
                }else {
                    repayRecord1.setLastUpdatedDate(new Date());
                    repayRecord.updateById(repayRecord1);
                    log.info("提交还款完成，更新还款记录"+partnerRepayNo);
                }

            } else {
                result.setMsg("提交还款失败");
                result.setCode("201");
            }
        }
        return ResponseEntity.ok(result);
    }


    @PostMapping("queryRepayResult")
    @ApiOperation(value = "20.还款结果查询", notes = "调用此接口可以获取还款结果")
    ResponseEntity<RbResponse> queryRepayResult( ) {
        log.debug("20.还款结果查询");
        CustomerUser customerUser = this.customerCapitalResultService.checkUser(this.request);
        Customer customer = this.customerMapper.getLatestCustomerRecord(customerUser.getPhone());
        List<CustomerCapitalResult> capitalResultList = new ArrayList();
        RbResponse result = new RbResponse();
        if (customer != null) {
            capitalResultList = customerCapitalResultService.lambdaQuery()
                    .eq(CustomerCapitalResult::getCustomerUserId, customerUser.getId())
                    .eq(CustomerCapitalResult::getCustomerRecordId, customer.getId())
                    .eq(CustomerCapitalResult::getCapitalInfoId, 4l)
                    .list();
            if (!(capitalResultList).isEmpty()) {
                CustomerCapitalResult customerCapitalResult = capitalResultList.get(0);
                result = qingHuaYouPinUtil.queryRepayResult(customerCapitalResult.getCreditNo());
            } else {
                result.setMsg("还款结果查询失败");
                result.setCode("201");
            }
        }
        return ResponseEntity.ok(result);
    }
    @PostMapping("orderStatusPush")
    @ApiOperation(value = "21.订单状态推送", notes = "调用此接口可以获取订单状态推送")
    ResponseEntity<RbResponse> orderStatusPush( @RequestParam(value = "partnerOrderNo") String partnerOrderNo) {
        log.debug("21.订单状态推送");

        return ResponseEntity.ok(qingHuaYouPinUtil.queryRepayResult(partnerOrderNo));
    }
//    @PostMapping("sendBindCardSms")
//    @ApiOperation(value = "8.绑卡发验证码", notes = "用户填写卡信息后，点击获取验证码，调用绑卡短信发送接口，众攒方会发送短信给用户")
//    ResponseEntity<RbResponse> sendBindCardSms(@RequestBody @Valid BindCardSmsDTO dto) {
//        log.debug("7.绑卡发验证码");
//        return ResponseEntity.ok(zhongZanUtil.sendBindCardSms(dto));
//
//    }

    @PostMapping("/to/woLaiDai/bindCardApply")
    @ApiOperation(value = "7.1 绑卡申请", notes = "我来贷绑卡申请")
    ResponseEntity<RbResponse> bindCardApplyToWoLaiDai(@RequestParam(value = "cardNo") String cardNo,@RequestParam(value = "phone") String phone,
                                             @RequestParam(value = "certNo") String certNo,@RequestParam(value = "bankCode") String bankCode,
                                             @RequestParam(value = "cardName") String cardName,@RequestParam(value = "partnerOrderNo") String partnerOrderNo) {

        return qingHuaYouPinUtil.bindCardApplyToWoLaiDai(cardNo, phone, certNo, bankCode, cardName, partnerOrderNo);
    }

    @PostMapping("/to/woLaiDai/bindCardConfirm")
    @ApiOperation(value = "8.1 绑卡确认", notes = "我来贷调用此接口可以让用户确定是否绑定卡")
    ResponseEntity<RbResponse> bindCardConfirmToWoLaiDai(@RequestParam(value = "partnerOrderNo") String partnerOrderNo,
                                                         @RequestParam(value = "confirmNo") String confirmNo,@RequestParam(value = "smsCode") String smsCode) {
        return qingHuaYouPinUtil.bindCardConfirmToWoLaiDai(confirmNo, smsCode, partnerOrderNo);
    }

    @PostMapping("/to/woLaiDai/trial")
    @ApiOperation(value = "11.要款试算", notes = "我来贷调用此接口可以获取要款试算结果")
    ResponseEntity<RbResponse> trialToWoLaiDai(@RequestParam(value = "partnerOrderNo") String partnerOrderNo) {
        log.debug("11.1 要款试算");
        RbResponse resp = qingHuaYouPinUtil.trial(partnerOrderNo);
        if(!Objects.equals(resp.getCode(),"200")) {
            resp.setMsg("要款试算失败");
            resp.setCode("201");
        }
        return ResponseEntity.ok(resp);
    }

    @PostMapping("/to/woLaiDai/submitLoan")
    @ApiOperation(value = "12.1 提交要款", notes = "我来贷调用此接口可以提交要款")
    ResponseEntity<RbResponse> submitLoanToWoLaiDai(@RequestParam(value = "partnerOrderNo") String partnerOrderNo) {
        log.debug("12.1 提交要款");
        return qingHuaYouPinUtil.submitLoanToWoLaiDai(partnerOrderNo);
    }


    @PostMapping("/to/woLaiDai/queryLoan")
    @ApiOperation(value = "13.1 借款查询", notes = "调用此接口可以借款查询")
    ResponseEntity<RbResponse> queryLoanToWolaidai(@RequestParam(value = "partnerOrderNo") String partnerOrderNo) {
        log.debug("13.1 借款查询");
        return qingHuaYouPinUtil.queryLoanToWolaidai(partnerOrderNo);
    }
}