package cc.mrbird.febs.pay.service.impl;

import cc.mrbird.febs.common.properties.XcxProperties;
import cc.mrbird.febs.common.utils.AppContants;
import cc.mrbird.febs.common.utils.SpringContextHolder;
import cc.mrbird.febs.mall.entity.MallOrderInfo;
import cc.mrbird.febs.mall.mapper.MallOrderInfoMapper;
import cc.mrbird.febs.pay.model.HeaderDto;
import cc.mrbird.febs.pay.service.WxFaPiaoService;
import cc.mrbird.febs.pay.util.RandomStringGenerator;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.wechat.pay.contrib.apache.httpclient.auth.AutoUpdateCertificatesVerifier;
import com.wechat.pay.contrib.apache.httpclient.auth.PrivateKeySigner;
import com.wechat.pay.contrib.apache.httpclient.auth.WechatPay2Credentials;
import com.wechat.pay.contrib.apache.httpclient.notification.Notification;
import com.wechat.pay.contrib.apache.httpclient.notification.NotificationHandler;
import com.wechat.pay.contrib.apache.httpclient.notification.NotificationRequest;
import com.wechat.pay.contrib.apache.httpclient.util.AesUtil;
import lombok.RequiredArgsConstructor;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import okhttp3.HttpUrl;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpPatch;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.springframework.core.io.ClassPathResource;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.cert.X509Certificate;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@Slf4j
@Service
@RequiredArgsConstructor
public class WxFaPiaoServiceImpl implements WxFaPiaoService {

    private final MallOrderInfoMapper mallOrderInfoMapper;

    private final XcxProperties xcxProperties = SpringContextHolder.getBean(XcxProperties.class);

    @Override
    public String createAuthorization(String method, String canonicalUrl, String body, PrivateKey keyPair) throws UnsupportedEncodingException, NoSuchAlgorithmException {
        String nonceStr = RandomStringGenerator.getRandomStringByLength(32);//随机字符串
        long timestamp = System.currentTimeMillis() / 1000;//时间戳
        HttpUrl httpurl = HttpUrl.parse(canonicalUrl);
        String message = buildMessage(method, httpurl, timestamp, nonceStr, body);
        log.info("签名串：\n"+message);
        log.info("签名串长度：\n"+getWordCount(message));
        String signature = sign2(message.getBytes("utf-8"), keyPair);

        log.info("签名串sign：\n"+signature);
        log.info("签名串长度sign：\n"+getWordCount(signature));
//        String yourCertificateSerialNo = "221D49AEC4EA538A63941D1936709C8559EB05C5";
        return "mchid=\"" + xcxProperties.getWecharpayMchid() + "\","
                + "nonce_str=\"" + nonceStr + "\","
                + "timestamp=\"" + timestamp + "\","
                + "serial_no=\"" + AppContants.WX_CARD_NUM + "\","
                + "signature=\"" + signature + "\"";
    }

    public   int  getWordCount(String s)
    {
        int  length  =   0 ;
        for ( int  i  =   0 ; i  <  s.length(); i ++ )
        {
            int  ascii  =  Character.codePointAt(s, i);
            if (ascii  >=   0   &&  ascii  <= 255 )
                length ++ ;
            else
                length  +=   2 ;

        }
        return  length;

    }

    public String sign2(byte[] message,PrivateKey keyPair) throws NoSuchAlgorithmException {
        Signature sign = Signature.getInstance("SHA256withRSA");
        String s = null;
        try {
            sign.initSign(keyPair);
            sign.update(message);
            s = Base64.getEncoder().encodeToString(sign.sign());
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (SignatureException e) {
            e.printStackTrace();
        }
        return s;
    }

    public String buildMessage(String method, HttpUrl url, long timestamp, String nonceStr, String body) {
        String canonicalUrl = url.encodedPath();
        if (url.encodedQuery() != null) {
            canonicalUrl += "?" + url.encodedQuery();
        }
        return method + "\n"
                + canonicalUrl + "\n"
                + timestamp + "\n"
                + nonceStr + "\n"
                + body + "\n";
    }

    @Override
    public PrivateKey getPrivateKeyV3() throws IOException {
        InputStream inputStream = new ClassPathResource("wxP12/apiclient_key.pem")
                .getInputStream();

        String content = new BufferedReader(new InputStreamReader(inputStream))
                .lines().collect(Collectors.joining(System.lineSeparator()));
        try {
            String privateKey = content.replace("-----BEGIN PRIVATE KEY-----", "")
                    .replace("-----END PRIVATE KEY-----", "")
                    .replaceAll("\\s+", "");

            KeyFactory kf = KeyFactory.getInstance("RSA");
            return kf.generatePrivate(
                    new PKCS8EncodedKeySpec(Base64.getDecoder().decode(privateKey)));
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("当前Java环境不支持RSA", e);
        } catch (InvalidKeySpecException e) {
            throw new RuntimeException("无效的密钥格式");
        }
    }

    @Override
    public String sendPatch(String url, String params, String token) {
        String result = "";
        CloseableHttpClient httpClient = HttpClients.createDefault();
        HttpPatch httpPatch = new HttpPatch(url);
        httpPatch.setHeader("Content-type", "application/json");
        httpPatch.setHeader("Charset", "utf-8");
        httpPatch.setHeader("Accept", "application/json");
        httpPatch.setHeader("Accept-Charset", "utf-8");
        httpPatch.setHeader("Authorization", token);
        try {
            StringEntity data = new StringEntity(params, "utf-8");
            httpPatch.setEntity(data);
            HttpResponse response = httpClient.execute(httpPatch);
            HttpEntity entity = response.getEntity();
            result = EntityUtils.toString(entity);
        } catch (Exception e) {
            result = "{\"status\":\"1\",\"error\":\"" + e.getMessage() + "\"}";
        }
        return result;
    }

    @Override
    public String sendPost(String url, String params, String token) {
        String result = "";
        int err = 0;
        while (true) {
            CloseableHttpClient client = HttpClients.createDefault();
            HttpPost httpPost = new HttpPost(url);
            try {
                httpPost.addHeader("Content-type", "application/json");
                httpPost.addHeader("Charset", "utf-8");
                httpPost.addHeader("Accept", "application/json");
                httpPost.addHeader("Accept-Charset", "utf-8");
                httpPost.addHeader("Authorization", token);

                StringEntity data = new StringEntity(params, "utf-8");
                httpPost.setEntity(data);
                HttpResponse response = client.execute(httpPost);
                HttpEntity resEntity = response.getEntity();
                result = EntityUtils.toString(resEntity);
                return result;
            } catch (IOException e) {
                result = "{\"status\":\"1\",\"errors\":\"" + e.getMessage() + "\"}";
                if (err++ > 2) {
                    break;
                }
                try {
                    Thread.sleep((err + 2) * 1000);
                } catch (InterruptedException e1) {
                    result = "{\"status\":\"1\",\"errors\":\"" + e1.getMessage() + "\"}";
                }
            }
        }
        return result;
    }

    @Override
    public Map<String, Object> fapiaoCallBack(HttpServletResponse response, HttpServletRequest request) {
        log.info("微信电子发票回调接口....");
        Map<String,Object> map = new HashMap<>();
        try {
            BufferedReader br = request.getReader();
            String str = null;
            StringBuilder sb = new StringBuilder();
            while ((str = br.readLine())!=null) {
                sb.append(str);
            }
            // 构建request，传入必要参数
            NotificationRequest requests = new NotificationRequest.Builder()
                    .withSerialNumber(request.getHeader("Wechatpay-Serial"))
                    .withNonce(request.getHeader("Wechatpay-Nonce"))
                    .withTimestamp(request.getHeader("Wechatpay-Timestamp"))
                    .withSignature(request.getHeader("Wechatpay-Signature"))
                    .withBody(String.valueOf(sb))
                    .build();
            //验签
            NotificationHandler handler = new NotificationHandler(getVerifier(AppContants.WX_CARD_NUM), xcxProperties.getWecharpaySecretV3().getBytes(StandardCharsets.UTF_8));
            //解析请求体
            Notification notification = handler.parse(requests);
            log.info("微信电子发票回调接口....解析请求体:"+notification.toString());
            String decryptData = notification.getDecryptData();//可能是支付业务的回调数据
            log.info("微信电子发票回调接口....decryptData:"+notification.toString());
            Notification.Resource resource = notification.getResource();//电子发票的回调加密数据
            log.info("微信电子发票回调接口....resource:"+notification.toString());

            if ("FAPIAO.USER_APPLIED".equals(notification.getEventType())//用户发票抬头填写完成类型：FAPIAO.USER_APPLIED
            && !"encryptresource".equals(notification.getResourceType())) {//通知的资源数据类型，确认成功通知为encryptresource。
                //解密
                AesUtil aesUtil = new AesUtil(xcxProperties.getWecharpaySecretV3().getBytes("utf-8"));
                String decryptToString = aesUtil.decryptToString(
                        resource.getAssociatedData().getBytes("utf-8"),
                        resource.getNonce().getBytes("utf-8"),
                        resource.getCiphertext());
                log.info("微信电子发票回调接口....resource解密:"+decryptToString);

                JSONObject parseObj = JSONUtil.parseObj(decryptToString);

                log.info("微信电子发票回调接口....resource解密-JSONObject:"+parseObj);

                String mchid = String.valueOf(parseObj.get("mchid"));
                String fapiao_apply_id = String.valueOf(parseObj.get("fapiao_apply_id"));
                String apply_time = String.valueOf(parseObj.get("apply_time"));
                MallOrderInfo mallOrderInfo = mallOrderInfoMapper.selectByOrderNo(fapiao_apply_id);
                if(ObjectUtil.isNotEmpty(mallOrderInfo)){
                    //省略查询订单
                    //此处处理业务
                    map.put("code","SUCCESS");
                    map.put("message","成功");
                    //消息推送成功
                    return map;
                }
            }
            map.put("code","RESOURCE_NOT_EXISTS");
            map.put("message", "订单不存在");
            return map;
        }catch (Exception e) {
            e.printStackTrace();
        }
        map.put("code","FAIL");
        map.put("message", "失败");
        return map;
    }

    /**
     * 功能描述: 验证签名
     * 注意：使用微信支付平台公钥验签
     * Wechatpay-Signature 微信返签名
     * Wechatpay-Serial 微信平台证书序列号
     *
     * @return java.lang.String
     * @author 影子
     */
    @SneakyThrows
    public boolean verifySign(HttpServletRequest request,String body) {
        boolean verify = false;
        try {
            String wechatPaySignature = request.getHeader("Wechatpay-Signature");
            String wechatPayTimestamp = request.getHeader("Wechatpay-Timestamp");
            String wechatPayNonce = request.getHeader("Wechatpay-Nonce");
            String wechatPaySerial = request.getHeader("Wechatpay-Serial");
            //组装签名串
            String signStr = Stream.of(wechatPayTimestamp, wechatPayNonce, body)
                    .collect(Collectors.joining("\n", "", "\n"));
            //获取平台证书
            AutoUpdateCertificatesVerifier verifier = getVerifier(wechatPaySerial);
            //获取失败 验证失败
            if (verifier != null) {
                Signature signature = Signature.getInstance("SHA256withRSA");
                signature.initVerify(verifier.getValidCertificate());
                //放入签名串
                signature.update(signStr.getBytes(StandardCharsets.UTF_8));
                verify = signature.verify(Base64.getDecoder().decode(wechatPaySignature.getBytes()));
            }
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return verify;
    }

    /**
     * 保存微信平台证书
     */
    private static final ConcurrentHashMap<String, AutoUpdateCertificatesVerifier> verifierMap = new ConcurrentHashMap<>();

    /**
     * 功能描述:获取平台证书，自动更新
     * 注意：这个方法内置了平台证书的获取和返回值解密
     */
    public AutoUpdateCertificatesVerifier getVerifier(String mchSerialNo) {
        AutoUpdateCertificatesVerifier verifier = null;
        if (verifierMap.isEmpty() || !verifierMap.containsKey(mchSerialNo)) {
            verifierMap.clear();
            try {
                //传入证书
                PrivateKey privateKey = getPrivateKeyV3();
                //刷新
                PrivateKeySigner signer = new PrivateKeySigner(mchSerialNo, privateKey);
                WechatPay2Credentials credentials = new WechatPay2Credentials(xcxProperties.getWecharpayMchid(), signer);
                verifier = new AutoUpdateCertificatesVerifier(credentials
                        , xcxProperties.getWecharpaySecretV3().getBytes("utf-8"));
                verifierMap.put(verifier.getValidCertificate().getSerialNumber()+"", verifier);
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            verifier = verifierMap.get(mchSerialNo);
        }
        return verifier;
    }


    /**
     * 获取公私钥.通过证书
     */
    private KeyStore store;
    private final Object lock = new Object();
    public KeyPair createPKCS12(String keyAlias, String keyPass) {
//        ClassPathResource resource = new ClassPathResource(xcxProperties.getCertLocalPath());
        ClassPathResource resource = new ClassPathResource("wxP12/apiclient_cert.p12");
//        File file = new File("src/main/resources/wxP12/apiclient_cert.p12");
        char[] pem = keyPass.toCharArray();
        try {
            synchronized (lock) {
                if (store == null) {
                    synchronized (lock) {
                        store = KeyStore.getInstance("PKCS12");
                        store.load(resource.getInputStream(), pem);
//                        store.load(new FileInputStream(file), pem);
                    }
                }
            }
            X509Certificate certificate = (X509Certificate) store.getCertificate(keyAlias);
            certificate.checkValidity();
            // 证书的序列号 也有用 50F37206347BCC9E6AC9860DAACE52AC035F7C24
            String serialNumber = certificate.getSerialNumber().toString(16).toUpperCase();
            // 证书的 公钥
            PublicKey publicKey = certificate.getPublicKey();
            // 证书的私钥
            PrivateKey storeKey = (PrivateKey) store.getKey(keyAlias, pem);
            return new KeyPair(publicKey, storeKey);
        } catch (Exception e) {
            throw new IllegalStateException("Cannot load keys from store: " , e);
        }
    }

    public static void main(String[] args) {
        HeaderDto headerDto = new HeaderDto();
        headerDto.setCallback_url("https://api.blnka.cn/api/xcxPay/fapiaoCallBack");
        headerDto.setShow_fapiao_cell(true);
        String parseObj = JSONUtil.parseObj(headerDto).toString();
            System.out.println(parseObj);
    }

}