import lombok.extern.slf4j.Slf4j;
import org.apache.xml.security.exceptions.XMLSecurityException;
import org.apache.xml.security.signature.XMLSignature;
import org.apache.xml.security.transforms.Transform;
import org.apache.xml.security.transforms.TransformationException;
import org.apache.xml.security.transforms.Transforms;
import org.apache.xml.security.utils.XMLUtils;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import ru.CryptoPro.JCP.JCP;
import ru.sirius.smev.server.smev.SmevTransformSpi;
import sun.security.x509.X509CertImpl;

import java.lang.reflect.Field;
import java.security.AccessController;
import java.security.Key;
import java.security.KeyStore;
import java.security.PrivilegedExceptionAction;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

@Slf4j
public class SignatureManager {

    private static final String CANONICALIZATION_METHOD = "http://www.w3.org/2001/10/xml-exc-c14n#";
    private static final String GRID = "#";
    private static final String SIG_ID = "sigID";
    private static final String XMLDSIG_MORE_GOSTR34102001_GOSTR3411 = "urn:ietf:params:xml:ns:cpxmlsec:algorithms:gostr34102012-gostr34112012-256";
    private static final String XMLDSIG_MORE_GOSTR3411 = "urn:ietf:params:xml:ns:cpxmlsec:algorithms:gostr34112012-256";
    private static final String xmlElementName = "CallerInformationSystemSignature";
    private static final String xmlElementID = "SIGNED_BY_CONSUMER";

    public static SignatureManager getInstance() {
        try {
            Transform.register(SmevTransformSpi.ALGORITHM_URN, SmevTransformSpi.class.getName());
            AccessController.doPrivileged((PrivilegedExceptionAction<Boolean>) () -> {
                Field f = XMLUtils.class.getDeclaredField("ignoreLineBreaks");
                f.setAccessible(true);
                f.set(null, true);
                return false;
            });

        } catch (Exception e) {
            log.info(e.getMessage());
        }
        return new SignatureManager();
    }

    public void sign(Document doc) {
        X509Certificate certificate = certificate();
        Key privateKey = privateKey();
        signDocument(doc, certificate, privateKey);
        validateSignature(doc);
    }

    private X509Certificate certificate() {
        try {
            ClassLoader classloader = Thread.currentThread().getContextClassLoader();
            return new X509CertImpl(classloader.getResourceAsStream("3oytfx3t.cer"));
        } catch (CertificateException e) {
            throw new RuntimeException(e);
        }
    }

    private Key privateKey() {
        KeyStore keyStore;
        try {
            keyStore = KeyStore.getInstance(JCP.HD_STORE_NAME);
            keyStore.load(null, "".toCharArray());
            return keyStore.getKey("3oytfx3t", "z5cn3723".toCharArray());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    private void signDocument(Document doc, X509Certificate certificate, Key privateKey) {
        try {
            XMLSignature sig = new XMLSignature(doc, "", XMLDSIG_MORE_GOSTR34102001_GOSTR3411, CANONICALIZATION_METHOD);
            sig.setId(SIG_ID);
            sig.addDocument(GRID + xmlElementID, transforms(doc), XMLDSIG_MORE_GOSTR3411);
            sig.addKeyInfo(certificate);
            sig.sign(privateKey);
            appendElement(doc, sig);
        } catch (XMLSecurityException e) {
            throw new RuntimeException(e);
        }
    }

    private void appendElement(Document doc, XMLSignature sig) {
        NodeList nodeList = doc.getElementsByTagNameNS("*", xmlElementName);
        Element anElement = (Element) nodeList.item(0);
        if (anElement != null) {
            anElement.appendChild(sig.getElement());
        } else {
            throw new RuntimeException("Could not find xml element with name " + xmlElementName);
        }
    }

    private Transforms transforms(Document doc) {
        Transforms transforms = new Transforms(doc);
        try {
            transforms.addTransform(Transforms.TRANSFORM_C14N_EXCL_OMIT_COMMENTS);
        } catch (TransformationException e) {
            throw new RuntimeException(e);
        }
        return transforms;
    }

    private void validateSignature(Document doc) {
        boolean validate = SignatureValidator.validate(doc);
        if (!validate) {
            throw new RuntimeException("Signature is invalid");
        }
    }
}

    @PostConstruct
    public void init() {
        try {
            org.apache.xml.security.Init.init();
            santuarioIgnoreLineBreaks(true);
            BouncyCastleProvider bcProvider = new BouncyCastleProvider();
            providerName = bcProvider.getName();
            Security.removeProvider(providerName);
            Security.addProvider(bcProvider);
            SignatureAlgorithm.register(GOST3411WITHECGOST3410_2012_256,
                    SignatureGostR341X.SignatureGostR34102012GostR3411.class);
            JCEMapper.register(GOST3411WITHECGOST3410_2012_256,
                    new JCEMapper.Algorithm("", "ECGOST3410-2012-256", /*"GOST3411WITHECGOST3410-2012-256", */"Signature"));
            JCEMapper.register(GOST34112012_256,
                    new JCEMapper.Algorithm("", "GOST3411-2012-256", "MessageDigest"));
            Transform.register(SmevTransformSpi.ALGORITHM_URN, SmevTransformSpi.class);
        } catch (AlgorithmAlreadyRegisteredException
                | ClassNotFoundException
                | XMLSignatureException
                | InvalidTransformException e) {
            e.printStackTrace();
        }
    }