package com.nova.sankuai.service.impl;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.nova.sankuai.domain.api.shantai.ShanTaiCheckVo;
import com.nova.sankuai.domain.api.yinsheng.enums.SignStatusEnum;
import com.nova.sankuai.domain.entity.Customer;
import com.nova.sankuai.domain.entity.ShanTaiSignRecord;
import com.nova.sankuai.domain.vo.huifubao.HuifubaoSignRecordVO;
import com.nova.sankuai.domain.entity.CustomerUser;
import com.nova.sankuai.domain.entity.HuifubaoSignRecord;
import com.nova.sankuai.domain.vo.huifubao.SignCallBackVo;
import com.nova.sankuai.infra.config.CommonException;
import com.nova.sankuai.infra.constants.ResultCode;
import com.nova.sankuai.infra.mapper.CustomerMapper;
import com.nova.sankuai.infra.utils.ResultJson;
import com.nova.sankuai.infra.utils.UserUtil;
import com.nova.sankuai.infra.utils.huifubao.common.*;
import com.nova.sankuai.infra.utils.huifubao.request.BaseRequest;
import com.nova.sankuai.infra.utils.huifubao.request.SignRequest;
import com.nova.sankuai.infra.utils.huifubao.respone.BaseResponse;
import com.nova.sankuai.infra.utils.huifubao.respone.SignResponse;
import com.nova.sankuai.security.UserDetail;
import com.nova.sankuai.service.ICustomerUserService;
import com.nova.sankuai.service.IHuifubaoSignRecordService;
import com.nova.sankuai.service.IHuiFuBaoSignService;
import lombok.SneakyThrows;
import org.bouncycastle.util.encoders.Base64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.text.SimpleDateFormat;
import java.util.*;

import static com.nova.sankuai.infra.constants.ResultCode.BAD_REQUEST;


@Service
public class HuiFuBaoSignServiceImpl implements IHuiFuBaoSignService {

    private static final Logger logger = LoggerFactory.getLogger("huibaofu-sign");

    private static final String SERVER_URL = "https://pay.Heepay.com/API/PageSign/Index.aspx";

    private static final String METHOD = "heepay.agreement.bank.sign.page";

    @Value("${huifubao.merchId}")
    private String merchId;

    @Value("${huifubao.domainUrl}")
    private String domainUrl;

    @Value("${huifubao.returnSignUrl}")
    private String returnSignUrl;

    @Resource
    private ICustomerUserService iCustomerUserService;

    @Resource
    private IHuifubaoSignRecordService iHuiFuBaoSignRecordService;

    @Resource
    private CustomerMapper customerMapper;


    @Override
    @Transactional(rollbackFor = Exception.class)
    public ResultJson signInfo(HuifubaoSignRecordVO vo, UserDetail userDetail) {
        if (userDetail == null){
            userDetail = new UserDetail();
        }
        LambdaQueryWrapper<CustomerUser> customerUserWrapper = new LambdaQueryWrapper<>();
        customerUserWrapper.eq(CustomerUser::getPhone, userDetail.getPhone()).eq(CustomerUser::getDeleteFlag, 0);
        List<CustomerUser> customerUserList = iCustomerUserService.list(customerUserWrapper);

        if (CollUtil.isEmpty(customerUserList)) {
            logger.error("手机查询用户不存在，手机号：{}", userDetail.getPhone());
//            throw new CommonException("用户不存在");
            return ResultJson.failure(BAD_REQUEST,"");
        }
        CustomerUser customerUser = customerUserList.stream().min(Comparator.comparing(CustomerUser::getCreationDate)).orElse(new CustomerUser());
        LambdaQueryWrapper<HuifubaoSignRecord> huiFuBaoSignRecordWrapper = Wrappers.lambdaQuery();
        huiFuBaoSignRecordWrapper.eq(HuifubaoSignRecord::getCustomerUserId,customerUser.getId());
        huiFuBaoSignRecordWrapper.eq(HuifubaoSignRecord::getSignResult,SignStatusEnum.SUCCESS.getValue());
        List<HuifubaoSignRecord> huifubaoSignRecordList = iHuiFuBaoSignRecordService.list(huiFuBaoSignRecordWrapper);
        if (CollUtil.isNotEmpty(huifubaoSignRecordList)){
            HuifubaoSignRecord huifubaoSignRecord = huifubaoSignRecordList.stream().distinct().findFirst().orElse(new HuifubaoSignRecord());
            logger.error("该用户已录入 录入用户id:{}，录入信息为：{}",customerUser.getId(),JSON.toJSONString(huifubaoSignRecord));
            throw new CommonException("该用户已录入");
        }

        if (StrUtil.isEmpty(vo.getSignIdNo()) || StrUtil.isEmpty(vo.getSignName())
                || StrUtil.isEmpty(vo.getSignPhone()) || StrUtil.isEmpty(vo.getSignCardNumber())){
            logger.error("录入参数不完整，请完善信息。vo：{}",JSON.toJSONString(vo));
            return ResultJson.failure(BAD_REQUEST,"录入参数不完整，请完善信息。");
        }

        SignRequest signRequest = new SignRequest();
        /**
         * 业务参数
         */
        BaseRequest baseRequest = new BaseRequest();
        SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
/*        子商户号,大商户子商户模式必传
        signRequest.setSub_merch_id("");*/

        signRequest.setNotify_url(domainUrl + "/api/v2/hfb/sign/callback");
        signRequest.setReturn_url(returnSignUrl);
        long tenDigitTimestamp = System.currentTimeMillis() / 1000;
        //商户签约单号，自定义
        String outTradeNo = String.valueOf(tenDigitTimestamp);
        signRequest.setOut_trade_no(outTradeNo);
        Date date = new Date();
        signRequest.setOut_trade_time(sd.format(date));
        //商户平台用户标识，自定义保证唯一
        signRequest.setMerch_user_id(String.valueOf(customerUser.getId()));
        //持卡人银行卡号,若传值页面自动代入
        signRequest.setBank_card_no(vo.getSignCardNumber());
        //持卡人姓名，若传值页面自动代入
        signRequest.setBank_user_name(vo.getSignName());
        //持卡人预留银行手机号，若传值页面自动代入
        signRequest.setMobile(vo.getSignPhone());
        //持卡人证据号码
        signRequest.setCert_no(vo.getSignIdNo());

        /**
         ** 公共请求参数
         */
        CertRequest certRequest = new CertRequest();
        //请求URL
        certRequest.setServerUrl(SERVER_URL);
        //商户编号，（汇付宝商户内码：七位整数数字）
        certRequest.setMerchantId(merchId);
//        certRequest.setMerchantId(signRequest.getSub_merch_id());
        //版本号：固定值 1.0
        certRequest.setVersion("1.0");
        //具体业务接口名称
        certRequest.setMethod(METHOD);
        baseRequest.setBiz_content(JSON.toJSONString(signRequest));
        //商户私钥
        certRequest.setPrivateKeyStr(MyKey.privateKeystr);
        //汇付宝公钥
        certRequest.setPublicKeyStr(MyKey.publicKeystr);
        baseRequest.setBiz_content(JSON.toJSONString(signRequest));
        //请求汇付宝演
        SignResponse response = doSignPost(baseRequest,certRequest);
        if (!Objects.equals(response.getCode(), "10000")) {
            String msg = response.getMsg();
            if (StrUtil.isEmpty(msg)){
                msg = SignStatusEnum.FAILED.getValue();
            }
            return ResultJson.failure(ResultCode.OPERATE_ERROR, msg);
        }
        //录入
        HuifubaoSignRecord huifubaoSignRecord = new HuifubaoSignRecord();
        BeanUtils.copyProperties(vo, huifubaoSignRecord);
        huifubaoSignRecord.setSignOrderNo(outTradeNo);
        huifubaoSignRecord.setCustomerUserId(customerUser.getId());
        huifubaoSignRecord.setSignResult(SignStatusEnum.WAIT_CONFIRM.getValue());
        huifubaoSignRecord.setCreationDate(date);
        huifubaoSignRecord.setLastUpdatedDate(date);
        iHuiFuBaoSignRecordService.saveOrUpdate(huifubaoSignRecord);
        return ResultJson.ok(response);
    }

    @SneakyThrows
    @Override
    public ResponseEntity CallBack(SignCallBackVo vo) {
        String outTradeNo = vo.getOut_trade_no();
        String sign = vo.getSign();
        String signNo = vo.getSign_no();
        if (StrUtil.isEmpty(outTradeNo)){
            logger.error("商户签约单号不能为空");
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("商户签约单号不能为空");
        }

        if (StrUtil.isEmpty(sign)){
            logger.error("RSA签名结果不能为空");
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("RSA签名结果不能为空");
        }

        if (StrUtil.isEmpty(signNo)){
            logger.error("支付授权码不能为空");
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("支付授权码不能为空");
        }
        //查询是否存在签约单
        LambdaQueryWrapper<HuifubaoSignRecord> huifubaoSignRecordLambdaQueryWrapper = Wrappers.lambdaQuery();
        huifubaoSignRecordLambdaQueryWrapper.eq(HuifubaoSignRecord::getSignOrderNo,outTradeNo);
        HuifubaoSignRecord huifubaoSignRecord = iHuiFuBaoSignRecordService.getOne(huifubaoSignRecordLambdaQueryWrapper);
        if (huifubaoSignRecord == null){
            logger.error("系统中不存在当前商户签约单，单号：{}",outTradeNo);
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("系统中不存在当前商户签约单号：" + outTradeNo);
        }

        //decrypt为解密后的值
        String decrypt = getKeyPath(signNo,0,false);
        huifubaoSignRecord.setSignUniqueCode(decrypt);
        huifubaoSignRecord.setLastUpdatedDate(new Date());
        huifubaoSignRecord.setSignResult("签约成功");
        iHuiFuBaoSignRecordService.saveOrUpdate(huifubaoSignRecord);
        return ResponseEntity.ok("ok");
    }

    @Override
    public ResultJson querySignStatus(HuifubaoSignRecordVO vo, HttpServletRequest request) {
        String token = request.getHeader("Authorization");
        UserDetail user = UserUtil.getUser(token);
        if (Objects.isNull(user) || Objects.isNull(user.getId())) {
            logger.error("Token无效 当前token：{}",token);
            return ResultJson.failure(ResultCode.UNAUTHORIZED,"Token无效");
        }

        LambdaQueryWrapper<CustomerUser> customerUserWrapper = new LambdaQueryWrapper<>();
        customerUserWrapper.eq(CustomerUser::getPhone, user.getPhone()).eq(CustomerUser::getDeleteFlag, 0);
        List<CustomerUser> customerUserList = iCustomerUserService.list(customerUserWrapper);

        if (CollUtil.isEmpty(customerUserList)) {
            logger.error("手机查询用户不存在，手机号：{}", user.getPhone());
//            throw new CommonException("用户不存在");
            return ResultJson.failure(BAD_REQUEST,"");
        }
        CustomerUser customerUser = customerUserList.stream().min(Comparator.comparing(CustomerUser::getCreationDate)).orElse(new CustomerUser());
        //判断是否录入系统
        LambdaQueryWrapper<HuifubaoSignRecord> recordLambdaQueryWrapper = Wrappers.lambdaQuery();
        recordLambdaQueryWrapper.eq(HuifubaoSignRecord::getCustomerUserId,customerUser.getId());
        List<HuifubaoSignRecord> huifubaoSignRecordList = iHuiFuBaoSignRecordService.list(recordLambdaQueryWrapper);

        if (CollUtil.isEmpty(huifubaoSignRecordList)){
            logger.error("当前用户不存在 当前id：{}",user.getId());
            return ResultJson.failure(ResultCode.OPERATE_ERROR,"当前用户不存在");
        }
        HuifubaoSignRecord huifubaoSignRecord = huifubaoSignRecordList.stream().min(Comparator.comparing(HuifubaoSignRecord::getCreationDate)).orElse(new HuifubaoSignRecord());
        if (!Objects.equals(huifubaoSignRecord.getSignResult(), SignStatusEnum.SUCCESS.getValue())){
                //枚举值不存在 会导致报错 抛出捕获预防参数不一致
            logger.error("当前订单未成功签约，签约状态为：" + huifubaoSignRecord.getSignResult());
            return ResultJson.failure(ResultCode.OPERATE_ERROR,"当前订单未成功签约，签约状态为：" + huifubaoSignRecord.getSignResult());
        }
        return ResultJson.ok(huifubaoSignRecord);
    }

    @Override
    public boolean checkBeforePayment(Long id) {
        CustomerUser customerUser = iCustomerUserService.getById(id);
         //判断是否录入系统
        LambdaQueryWrapper<HuifubaoSignRecord> recordLambdaQueryWrapper = Wrappers.lambdaQuery();
        recordLambdaQueryWrapper.eq(HuifubaoSignRecord::getCustomerUserId,customerUser.getId());
        List<HuifubaoSignRecord> huifubaoSignRecordList = iHuiFuBaoSignRecordService.list(recordLambdaQueryWrapper);

        if (CollUtil.isEmpty(huifubaoSignRecordList)){
            logger.error("当前用户不存在 当前id：{}",customerUser.getId());
            return false;
        }
        HuifubaoSignRecord huifubaoSignRecord = huifubaoSignRecordList.stream().min(Comparator.comparing(HuifubaoSignRecord::getCreationDate)).orElse(new HuifubaoSignRecord());
        if (!Objects.equals(huifubaoSignRecord.getSignResult(), SignStatusEnum.SUCCESS.getValue())){
            //枚举值不存在 会导致报错 抛出捕获预防参数不一致
            logger.error("当前订单未成功签约，签约状态为：" + huifubaoSignRecord.getSignResult());
            return false;
        }
        return true;
    }

    @Override
    public ShanTaiCheckVo checkProtocolSignBySt(HttpServletRequest request) {
        String token = request.getHeader("Authorization");
        UserDetail user = UserUtil.getUser(token);
        if (user == null || user.getId() == null) {
            throw new CommonException("Token无效");
        }
        CustomerUser customerUser = iCustomerUserService.getById(user.getId());
        if (customerUser == null) {
            throw new CommonException("用户不存在");
        }
        ShanTaiCheckVo checkVo = new ShanTaiCheckVo();
        HuifubaoSignRecord signRecord = null;
        List<HuifubaoSignRecord> signRecords = iHuiFuBaoSignRecordService.list(Wrappers.lambdaQuery(HuifubaoSignRecord.class).
                eq(HuifubaoSignRecord::getCustomerUserId, customerUser.getId()).orderByDesc(HuifubaoSignRecord::getCreationDate));
        if (!signRecords.isEmpty()) {
            signRecord = signRecords.get(0);
        }
        if (signRecord != null && SignStatusEnum.SUCCESS.getValue().equals(signRecord.getSignResult())) {
            checkVo.setSign(true);
            checkVo.setSignCardNumber(signRecord.getSignCardNumber());
            checkVo.setSignIdNo(signRecord.getSignIdNo());
            checkVo.setSignName(signRecord.getSignName());
            checkVo.setSignPhone(signRecord.getSignPhone());
        } else {
            checkVo.setSign(false);
        }
        return checkVo;
    }


    @SneakyThrows
    private String getKeyPath(String value,Integer type,boolean isSign){
        String str = "";
        SignEncrypt signEncrypt = new SignEncrypt();
        // 使用类名和常量名来访问常量
        String publicKeystr = MyKey.publicKeystr;
        String privateKeystr = MyKey.privateKeystr;
        //密钥配置
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        byte[] publicKeyPath = Base64.decode(publicKeystr.getBytes());
        byte[] privateKeyPath = Base64.decode(privateKeystr.getBytes());
        PublicKey heepayPublicKey = keyFactory.generatePublic(new X509EncodedKeySpec(publicKeyPath));
        PrivateKey privateKey = keyFactory.generatePrivate(new PKCS8EncodedKeySpec(privateKeyPath));
        //是否是签约加密
        if (isSign){
            str = signEncrypt.sign(value,privateKey);
        }else if (type == 1){
            //RSA加密
            str = signEncrypt.encrypt(value, heepayPublicKey);
        }else {
            //RSA解密
            str = signEncrypt.decrypt(value, privateKey);
        }
        return str;
    }

    private SignResponse doSignPost(BaseRequest baseRequest,CertRequest certRequest){
        SignEncrypt signEncrypt = new SignEncrypt();
        HttpUtil httpUtil = new HttpUtil();
        // 使用类名和常量名来访问常量
        String publicKeystr = MyKey.publicKeystr;
        String privateKeystr = MyKey.privateKeystr;
        PublicKey heepayPublicKey = null;
        PrivateKey privateKey = null;
        SignResponse signResponse = new SignResponse();
        try {
            baseRequest.setMerch_id(certRequest.getMerchantId());
            baseRequest.setVersion(certRequest.getVersion());
            baseRequest.setMethod(certRequest.getMethod());
            //密钥配置
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            byte[] publicKeyPath = Base64.decode(publicKeystr.getBytes());
            byte[] privateKeyPath = Base64.decode(privateKeystr.getBytes());
            heepayPublicKey = keyFactory.generatePublic(new X509EncodedKeySpec(publicKeyPath));
            privateKey = keyFactory.generatePrivate(new PKCS8EncodedKeySpec(privateKeyPath));

            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            baseRequest.setTimestamp(df.format(new Date()));
            Map<String, String> map = Utils.convertBeanNoneEmpty(baseRequest);
            String bizJson = Utils.coverMap2String(map);
            logger.info("待签名：{}",bizJson);
            //签名
            String sign = signEncrypt.sign(bizJson, privateKey);
            logger.info("签名后：{}",sign);
            baseRequest.setSign(sign);


            //bizContent加密
            String content = signEncrypt.encrypt(baseRequest.getBiz_content(), heepayPublicKey);
            logger.info("加密后：{}",content);
            baseRequest.setBiz_content(content);

            String res = httpUtil.sendJsonHttpPost(SERVER_URL, JSON.toJSONString(baseRequest));
            logger.info("resq：{}",JSON.toJSONString(baseRequest));
            logger.info("resp：{}",res);

            //解析response 取到data并解密
            ObjectMapper objectMapper = new ObjectMapper();
            JsonNode jsonNode = objectMapper.readTree(res.toString());
            String data = jsonNode.get("data").asText();
            //decrypt为解密后的值
            String decrypt = signEncrypt.decrypt(data, privateKey);
            //继续解析解密后的值拿到sign_url
            JsonNode jsonNode1 = objectMapper.readTree(decrypt.toString());
            String sign_url = jsonNode1.get("sign_url").asText();
            logger.info("sign_url：{}",sign_url);

            if (StrUtil.isEmpty(res)) {
                return new SignResponse();
            }
            BaseResponse response = JSONObject.parseObject(res, BaseResponse.class);
            signResponse = JSON.parseObject(decrypt, SignResponse.class);
            signResponse.setCode(response.getCode());
            signResponse.setMsg(response.getMsg());
            signResponse.setSub_code(response.getSub_code());
            signResponse.setSub_msg(response.getSub_msg());
            signResponse.setData(response.getData());
            signResponse.setSign(response.getSign());
        }catch (Exception e){
            e.printStackTrace();
            logger.error("签约状态异常，请求参数：{}",baseRequest);
            throw new RuntimeException("签约异常");
        }
        return signResponse;
    }
}