package com.nova.sankuai.controller.v2;

import cn.hutool.json.JSONUtil;
import com.nova.sankuai.domain.api.yangqianguan.MoneyPotResultJson;
import com.nova.sankuai.domain.api.yangqianguan.YqgResultCode;
import com.nova.sankuai.domain.api.yangqianguan.YqgUtil;
import com.nova.sankuai.domain.api.yangqianguan.dto.*;
import com.nova.sankuai.domain.api.yangqianguan.response.*;
import com.nova.sankuai.domain.api.yangqianguan.vo.VerifySignVo;
import com.nova.sankuai.infra.config.CommonException;
import com.nova.sankuai.infra.utils.ConstantsUtil;
import com.nova.sankuai.service.IMoneyPotService;
import io.swagger.annotations.Api;
import lombok.AllArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import javax.validation.Valid;
import java.io.IOException;

/**
 * @Description 洋钱罐对接
 * @Author CWR
 * @Date 2022/4/26 21:33
 */
@Api(tags = "洋钱罐对接V2")
@RestController
@Valid
@AllArgsConstructor
public class MoneyPotV2Controller {

    private final IMoneyPotService moneyPotService;

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

    private final YqgUtil yqgUtil;

    /**
     * 用户准入
     *
     * @return
     */
    @PostMapping("/yqg/api/v1/user/check")
    public MoneyPotResultJson<UserCheckResponse> userQualificationCheck(HttpServletRequest request) throws IOException {
        // 验签
        VerifySignVo verifySignVo = yqgUtil.verifyYqgSign(request);
        if (!verifySignVo.isVerify()) {
            return MoneyPotResultJson.error(YqgResultCode.SIGN_ERROR, "请求头或签名不正确");
        }
        try {
            UserCheckDto dto = JSONUtil.toBean(verifySignVo.getContent(), UserCheckDto.class);
            return moneyPotService.userQualificationCheck(dto);
        } catch (Exception e) {
            yqgLogger.error("洋钱罐用户准入异常", e);
            return MoneyPotResultJson.error(YqgResultCode.SERVER_ERROR, "内部错误，接口调用失败");
        }
    }

    /**
     * 授信申请
     *
     * @param request
     */
    @PostMapping("/yqg/api/v2/credit/apply")
    public MoneyPotResultJson<CreditApplyResponse> creditApply(HttpServletRequest request) throws IOException {
        // 验签
        VerifySignVo verifySignVo = yqgUtil.verifyYqgSign(request);
        if (!verifySignVo.isVerify()) {
            return MoneyPotResultJson.error(YqgResultCode.SIGN_ERROR, "请求头或签名不正确");
        }
        try {
            CreditApplyDto dto = JSONUtil.toBean(verifySignVo.getContent(), CreditApplyDto.class);
            return moneyPotService.creditApply(dto);
        } catch (Exception e) {
            yqgLogger.error("洋钱罐授信申请异常", e);
            return MoneyPotResultJson.error(YqgResultCode.SERVER_ERROR, "内部错误，接口调用失败");
        }
    }

    /**
     * 授信结果查询
     *
     * @param request
     */
    @PostMapping("/yqg/api/v2/credit/result")
    public MoneyPotResultJson<CreditResultResponse> creditResult(HttpServletRequest request) throws IOException {
        // 验签
        VerifySignVo verifySignVo = yqgUtil.verifyYqgSign(request);
        if (!verifySignVo.isVerify()) {
            return MoneyPotResultJson.error(YqgResultCode.SIGN_ERROR, "请求头或签名不正确");
        }
        try {
            CreditDto dto = JSONUtil.toBean(verifySignVo.getContent(), CreditDto.class);
            return moneyPotService.creditResult(dto);
        } catch (Exception e) {
            yqgLogger.error("洋钱罐授信结果查询异常", e);
            return MoneyPotResultJson.error(YqgResultCode.SERVER_ERROR, "内部错误，接口调用失败");
        }
    }

    /**
     * 授信额度查询
     *
     * @param request
     */
    @PostMapping("/yqg/api/v2/credit/limit")
    public MoneyPotResultJson<CreditLimitResponse> creditLimit(HttpServletRequest request) throws IOException {
        // 验签
        VerifySignVo verifySignVo = yqgUtil.verifyYqgSign(request);
        if (!verifySignVo.isVerify()) {
            return MoneyPotResultJson.error(YqgResultCode.SIGN_ERROR, "请求头或签名不正确");
        }
        try {
            CreditDto dto = JSONUtil.toBean(verifySignVo.getContent(), CreditDto.class);
            return moneyPotService.creditLimit(dto);
        } catch (Exception e) {
            yqgLogger.error("洋钱罐授信额度查询异常", e);
            return MoneyPotResultJson.error(YqgResultCode.SERVER_ERROR, "内部错误，接口调用失败");
        }
    }

    /**
     * 借款试算
     *
     * @param request
     */
    @PostMapping("/yqg/api/v2/loan/trial")
    public MoneyPotResultJson<LoanTrialResponse> loanTrial(HttpServletRequest request) throws IOException {
        // 验签
        VerifySignVo verifySignVo = yqgUtil.verifyYqgSign(request);
        if (!verifySignVo.isVerify()) {
            return MoneyPotResultJson.error(YqgResultCode.SIGN_ERROR, "请求头或签名不正确");
        }
        try {
            LoanTrialDto dto = JSONUtil.toBean(verifySignVo.getContent(), LoanTrialDto.class);
            return moneyPotService.loanTrial(dto);
        } catch (Exception e) {
            yqgLogger.error("洋钱罐借款试算异常", e);
            return MoneyPotResultJson.error(YqgResultCode.SERVER_ERROR, "内部错误，接口调用失败");
        }
    }


    /**
     * 借款确认
     *
     * @param request
     */
    @PostMapping("/yqg/api/v2/loan/confirm")
    public MoneyPotResultJson<LoanConfirmResponse> loanConfirm(HttpServletRequest request) throws IOException {
        // 验签
        VerifySignVo verifySignVo = yqgUtil.verifyYqgSign(request);
        if (!verifySignVo.isVerify()) {
            return MoneyPotResultJson.error(YqgResultCode.SIGN_ERROR, "请求头或签名不正确");
        }
        try {
            LoanConfirmDto dto = JSONUtil.toBean(verifySignVo.getContent(), LoanConfirmDto.class);
            return moneyPotService.loanConfirm(dto);
        } catch (Exception e) {
            yqgLogger.error("洋钱罐借款确认异常", e);
            return MoneyPotResultJson.error(YqgResultCode.SERVER_ERROR, "内部错误，接口调用失败");
        }
    }


    /**
     * 还款计划查询
     *
     * @param request
     */
    @PostMapping("/yqg/api/v1/repayment/getRepayPlan")
    public MoneyPotResultJson<RepayPlanResponse> repayPlan(HttpServletRequest request) throws IOException {
        // 验签
        VerifySignVo verifySignVo = yqgUtil.verifyYqgSign(request);
        if (!verifySignVo.isVerify()) {
            return MoneyPotResultJson.error(YqgResultCode.SIGN_ERROR, "请求头或签名不正确");
        }
        try {
            RepayPlanDto dto = JSONUtil.toBean(verifySignVo.getContent(), RepayPlanDto.class);
            return moneyPotService.getRepayPlan(dto);
        } catch (Exception e) {
            yqgLogger.error("洋钱罐还款计划查询异常", e);
            return MoneyPotResultJson.error(YqgResultCode.SERVER_ERROR, "内部错误，接口调用失败");
        }
    }

    /**
     * 还款试算
     *
     * @param request
     */
    @PostMapping("/yqg/api/v1/repayment/getRepayDetail")
    public MoneyPotResultJson<RepayDetailResponse> repayDetail(HttpServletRequest request) throws IOException {
        // 验签
        VerifySignVo verifySignVo = yqgUtil.verifyYqgSign(request);
        if (!verifySignVo.isVerify()) {
            return MoneyPotResultJson.error(YqgResultCode.SIGN_ERROR, "请求头或签名不正确");
        }
        try {
            RepayDetailDto dto = JSONUtil.toBean(verifySignVo.getContent(), RepayDetailDto.class);
            return moneyPotService.getRepayDetail(dto);
        } catch (Exception e) {
            yqgLogger.error("洋钱罐还款试算异常", e);
            return MoneyPotResultJson.error(YqgResultCode.SERVER_ERROR, "内部错误，接口调用失败");
        }
    }

    /**
     * 用户主动还款
     *
     * @param request
     */
    @PostMapping("/yqg/api/v2/repay")
    public MoneyPotResultJson<UserRepayResponse> userRepay(HttpServletRequest request) throws IOException {
        // 验签
        VerifySignVo verifySignVo = yqgUtil.verifyYqgSign(request);
        if (!verifySignVo.isVerify()) {
            return MoneyPotResultJson.error(YqgResultCode.SIGN_ERROR, "请求头或签名不正确");
        }
        try {
            UserRepayDto dto = JSONUtil.toBean(verifySignVo.getContent(), UserRepayDto.class);
            return moneyPotService.userRepay(dto);
        } catch (CommonException e) {
            yqgLogger.error("洋钱罐用户主动还款异常", e);
            return MoneyPotResultJson.error(YqgResultCode.SERVER_ERROR, e.getMessage());
        } catch (Exception e) {
            yqgLogger.error("洋钱罐用户主动还款异常", e);
            return MoneyPotResultJson.error(YqgResultCode.SERVER_ERROR, "内部错误，接口调用失败");
        }
    }

    /**
     * 还款结果查询
     *
     * @param request
     */
    @PostMapping("/yqg/api/v2/repay/result")
    public MoneyPotResultJson<RepayResultReturnDto> repayResult(HttpServletRequest request) throws IOException {
        // 验签
        VerifySignVo verifySignVo = yqgUtil.verifyYqgSign(request);
        if (!verifySignVo.isVerify()) {
            return MoneyPotResultJson.error(YqgResultCode.SIGN_ERROR, "请求头或签名不正确");
        }
        try {
            RepayResultDto dto = JSONUtil.toBean(verifySignVo.getContent(), RepayResultDto.class);
            return moneyPotService.queryRepayResult(dto);
        } catch (Exception e) {
            yqgLogger.error("洋钱罐还款结果查询异常", e);
            return MoneyPotResultJson.error(YqgResultCode.SERVER_ERROR, "内部错误，接口调用失败");
        }
    }

    /**
     * 支持的银行列表查询
     *
     * @param request
     */
    @PostMapping("/yqg/api/v2/bank/support")
    public MoneyPotResultJson<BankSupportResponse> bankSupport(HttpServletRequest request) throws IOException {
        // 验签
        VerifySignVo verifySignVo = yqgUtil.verifyYqgSign(request);
        if (!verifySignVo.isVerify()) {
            return MoneyPotResultJson.error(YqgResultCode.SIGN_ERROR, "请求头或签名不正确");
        }
        try {
            BankSupportDto dto = JSONUtil.toBean(verifySignVo.getContent(), BankSupportDto.class);
            return moneyPotService.bankSupport(dto);
        } catch (Exception e) {
            yqgLogger.error("洋钱罐支持的银行列表查询异常", e);
            return MoneyPotResultJson.error(YqgResultCode.SERVER_ERROR, "内部错误，接口调用失败");
        }
    }

    /**
     * 绑定银行卡
     *
     * @param request
     */
    @PostMapping("/yqg/api/v2/bank/bind")
    public MoneyPotResultJson<CodeSendResponse> bankBind(HttpServletRequest request) throws IOException {
        VerifySignVo verifySignVo = yqgUtil.verifyYqgSign(request);
        if (!verifySignVo.isVerify()) {
            return MoneyPotResultJson.error(YqgResultCode.SIGN_ERROR, "请求头或签名不正确");
        }
        try {
            BankBindDto dto = JSONUtil.toBean(verifySignVo.getContent(), BankBindDto.class);
            return moneyPotService.bankBind(dto);
        } catch (Exception e) {
            yqgLogger.error("洋钱罐绑定银行卡异常", e);
            return MoneyPotResultJson.error(YqgResultCode.SERVER_ERROR, "内部错误，接口调用失败");
        }
    }

    /**
     * 协议查询
     *
     * @param request
     */
    @PostMapping("/yqg/api/v2/contract")
    public MoneyPotResultJson<ContractResponse> contract(HttpServletRequest request) throws IOException {
        // 验签
        VerifySignVo verifySignVo = yqgUtil.verifyYqgSign(request);
        if (!verifySignVo.isVerify()) {
            return MoneyPotResultJson.error(YqgResultCode.SIGN_ERROR, "请求头或签名不正确");
        }
        try {
            ContractDto dto = JSONUtil.toBean(verifySignVo.getContent(), ContractDto.class);
            return moneyPotService.getContractList(dto);
        } catch (Exception e) {
            yqgLogger.error("洋钱罐协议查询异常", e);
            return MoneyPotResultJson.error(YqgResultCode.SERVER_ERROR, "内部错误，接口调用失败");
        }
    }

    /**
     * 订单状态查询
     *
     * @param
     */
    @PostMapping("/yqg/api/v1/order/getOrderStatus")
    public MoneyPotResultJson<OrderStatusResponse> orderStatus(HttpServletRequest request) throws IOException {
        // 验签
        VerifySignVo verifySignVo = yqgUtil.verifyYqgSign(request);
        if (!verifySignVo.isVerify()) {
            return MoneyPotResultJson.error(YqgResultCode.SIGN_ERROR, "请求头或签名不正确");
        }
        try {
            OrderStatusDto dto = JSONUtil.toBean(verifySignVo.getContent(), OrderStatusDto.class);
            return moneyPotService.getOrderStatus(dto);
        } catch (Exception e) {
            yqgLogger.error("洋钱罐订单状态查询异常", e);
            return MoneyPotResultJson.error(YqgResultCode.SERVER_ERROR, "内部错误，接口调用失败");
        }
    }

    /**
     * 短信验证码校验
     *
     * @param
     */
    @PostMapping("/yqg/api/v2/code/verify")
    public MoneyPotResultJson<CodeVerifyResponse> codeVerify(HttpServletRequest request) throws IOException {
        // 验签
        VerifySignVo verifySignVo = yqgUtil.verifyYqgSign(request);
        if (!verifySignVo.isVerify()) {
            return MoneyPotResultJson.error(YqgResultCode.SIGN_ERROR, "请求头或签名不正确");
        }
        try {
            CodeVerifyDto dto = JSONUtil.toBean(verifySignVo.getContent(), CodeVerifyDto.class);
            return moneyPotService.codeVerify(dto);
        } catch (Exception e) {
            yqgLogger.error("洋钱罐短信验证码校验异常", e);
            return MoneyPotResultJson.error(YqgResultCode.SERVER_ERROR, "内部错误，接口调用失败");
        }
    }

    /**
     * 是否需要绑定银行卡查询
     *
     * @param
     */
    @PostMapping("/yqg/api/v2/bank/bind/require")
    public MoneyPotResultJson<BankBindRequireResponse> bindRequire(HttpServletRequest request) throws IOException {
        // 验签
        VerifySignVo verifySignVo = yqgUtil.verifyYqgSign(request);
        if (!verifySignVo.isVerify()) {
            return MoneyPotResultJson.error(YqgResultCode.SIGN_ERROR, "请求头或签名不正确");
        }
        try {
            BankBindRequireDto dto = JSONUtil.toBean(verifySignVo.getContent(), BankBindRequireDto.class);
            return moneyPotService.queryBankCardBind(dto);
        } catch (Exception e) {
            yqgLogger.error("洋钱罐是否需要绑定银行卡查询异常", e);
            return MoneyPotResultJson.error(YqgResultCode.SERVER_ERROR, "内部错误，接口调用失败");
        }
    }

    /**
     * 获取用户已绑银行卡列表
     *
     * @param
     */
    @PostMapping("/yqg/api/v2/bank/cardList")
    public MoneyPotResultJson<BankCardListResponse> bankCardList(HttpServletRequest request) throws IOException {
        // 验签
        VerifySignVo verifySignVo = yqgUtil.verifyYqgSign(request);
        if (!verifySignVo.isVerify()) {
            return MoneyPotResultJson.error(YqgResultCode.SIGN_ERROR, "请求头或签名不正确");
        }
        try {
            BankCardListDto dto = JSONUtil.toBean(verifySignVo.getContent(), BankCardListDto.class);
            return moneyPotService.getUserBankCardList(dto);
        } catch (Exception e) {
            yqgLogger.error("洋钱罐获取用户已绑银行卡列表异常", e);
            return MoneyPotResultJson.error(YqgResultCode.SERVER_ERROR, "内部错误，接口调用失败");
        }
    }

    /**
     * 获取用户的权益卡信息
     *
     * @param
     */
    @PostMapping("/yqg/api/v2/rights/card")
    public MoneyPotResultJson<RightsCardResponse> getRightsCard(HttpServletRequest request) throws IOException {
        // 验签
        VerifySignVo verifySignVo = yqgUtil.verifyYqgSign(request);
        if (!verifySignVo.isVerify()) {
            return MoneyPotResultJson.error(YqgResultCode.SIGN_ERROR, "请求头或签名不正确");
        }
        try {
            RightsCardDto dto = JSONUtil.toBean(verifySignVo.getContent(), RightsCardDto.class);
            String hostUrl = ConstantsUtil.getHostUrl(request);
            return moneyPotService.getRightsCard(dto, hostUrl);
        } catch (Exception e) {
            yqgLogger.error("洋钱罐获取用户的权益卡信息异常", e);
            return MoneyPotResultJson.error(YqgResultCode.SERVER_ERROR, "内部错误，接口调用失败");
        }
    }
}