package net.lulli.certsigner.util;

import org.bouncycastle.openssl.PEMParser;
import org.bouncycastle.pkcs.PKCS10CertificationRequest;

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.*;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

public class Serde {
    private Serde() {
    }

    public static void toFile(PublicKey key, String fileName) {
        try {
            var pem = toPem(key);
            Files.write(Paths.get(fileName), pem.getBytes());
        } catch (Exception e) {
            throw new IllegalStateException(e.getMessage());
        }
    }

    public static void toFile(PrivateKey key, String fileName) {
        try {
            var pem = toPem(key);
            Files.write(Paths.get(fileName), pem.getBytes());
        } catch (Exception e) {
            throw new IllegalStateException(e.getMessage());
        }
    }

    public static X509Certificate certificateFromFile(String fileName) {
        try {
            var keyContent = Files.readString(Paths.get(fileName));
            return readX509Certificate(keyContent);
        } catch (Exception e) {
            throw new IllegalStateException(e.getMessage());
        }
    }

    public static PublicKey publicKeyFromFile(String fileName) {
        try {
            var keyContent = Files.readString(Paths.get(fileName));
            return readX509PublicKey(keyContent);
        } catch (Exception e) {
            throw new IllegalStateException(e.getMessage());
        }
    }

    public static PrivateKey privateKeyFromFile(String fileName) {
        try {
            var keyContent = Files.readString(Paths.get(fileName));
            return readPKCS8PrivateKey(keyContent);
        } catch (Exception e) {
            throw new IllegalStateException(e.getMessage());
        }
    }

    public static String toPem(PrivateKey privateKey) {
        try {
            Writer out = new StringWriter();
            out.write("-----BEGIN RSA PRIVATE KEY-----\n");
            writeBase64(out, privateKey);
            out.write("-----END RSA PRIVATE KEY-----\n");

            return out.toString();
        } catch (Exception e) {
            return null;
        }
    }

    public static String toPem(PublicKey publicKey) {
        try {
            Writer out = new StringWriter();
            out.write("-----BEGIN RSA PUBLIC KEY-----\n");
            writeBase64(out, publicKey);
            out.write("-----END RSA PUBLIC KEY-----\n");

            return out.toString();
        } catch (Exception e) {
            return null;
        }
    }

    static private void writeBase64(Writer out, Key key) throws java.io.IOException {
        byte[] buf = key.getEncoded();
        out.write(Base64.getEncoder().encodeToString(buf));
        out.write("\n");
    }


    public static X509Certificate readX509Certificate(String certificate) throws Exception {
        InputStream targetStream = new ByteArrayInputStream(certificate.getBytes());
        return (X509Certificate) CertificateFactory
                .getInstance("X509")
                .generateCertificate(targetStream);
    }

    public static RSAPublicKey readX509PublicKey(String key) throws Exception {
        String publicKeyPEM = key
                .replace("-----BEGIN PUBLIC KEY-----", "")
                .replaceAll(System.lineSeparator(), "")
                .replace("-----END PUBLIC KEY-----", "");

        byte[] encoded = Base64.getDecoder().decode(publicKeyPEM);

        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(encoded);
        return (RSAPublicKey) keyFactory.generatePublic(keySpec);
    }

    public static RSAPrivateKey readPKCS8PrivateKey(String key) throws Exception {
        String privateKeyPEM = key
                .replace("-----BEGIN RSA PRIVATE KEY-----", "")
                .replaceAll(System.lineSeparator(), "")
                .replace("-----END RSA PRIVATE KEY-----", "");

        byte[] encoded = Base64.getDecoder().decode(privateKeyPEM);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(encoded);
        return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
    }

    public static PKCS10CertificationRequest pemToCsr(String pem) {
        Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
        PKCS10CertificationRequest csr = null;
        ByteArrayInputStream pemStream = null;
        try {
            pemStream = new ByteArrayInputStream(pem.getBytes("UTF-8"));
        } catch (Exception ex) {
            throw new IllegalStateException(ex);
        }

        Reader pemReader = new BufferedReader(new InputStreamReader(pemStream));
        PEMParser pemParser = new PEMParser(pemReader);

        try {
            Object parsedObj = pemParser.readObject();
            if (parsedObj instanceof PKCS10CertificationRequest) {
                csr = (PKCS10CertificationRequest) parsedObj;
            }
        } catch (Exception ex) {
            throw new IllegalStateException(ex);
        }
        return csr;
    }
}