package christie.blockchain;

import org.bouncycastle.asn1.sec.SECNamedCurves;
import org.bouncycastle.asn1.x9.X9ECParameters;
import org.bouncycastle.crypto.params.ECDomainParameters;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.jce.spec.ECParameterSpec;
import org.bouncycastle.math.ec.ECPoint;

import java.math.BigInteger;
import java.security.*;
import java.security.interfaces.ECPublicKey;
import java.security.spec.ECGenParameterSpec;
import java.util.Arrays;


public class ECKey {

    public static final ECDomainParameters CURVE;
    public static final ECParameterSpec CURVE_SPEC;

    public static final BigInteger HALF_CURVE_ORDER;
    private static final SecureRandom secureRandom;

    private final PrivateKey privateKey;
    private final PublicKey publicKey;
    private final Provider provider;

    static {
        X9ECParameters params = SECNamedCurves.getByName("secp256k1");
        CURVE = new ECDomainParameters(params.getCurve(), params.getG(), params.getN(), params.getH());
        CURVE_SPEC = new ECParameterSpec(params.getCurve(), params.getG(), params.getN(), params.getH());
        HALF_CURVE_ORDER = params.getN().shiftRight(1);
        secureRandom = new SecureRandom();
    }

    public ECKey() {
        this(secureRandom);
    }

    public ECKey(SecureRandom secureRandom) {
        this(new BouncyCastleProvider(), secureRandom);
    }


    public ECKey(Provider provider, SecureRandom secureRandom) {
        this.provider = provider;

        KeyPairGenerator keyGen;
        try {
            keyGen = KeyPairGenerator.getInstance("EC");
            ECGenParameterSpec SECP256K1_CURVE = new ECGenParameterSpec("secp256k1");
            keyGen.initialize(SECP256K1_CURVE);
        } catch (NoSuchAlgorithmException ex) {
            throw new AssertionError(ex);
        } catch (InvalidAlgorithmParameterException ex) {
            throw new AssertionError(ex);
        }

        KeyPair keyPair = keyGen.generateKeyPair();

        this.privateKey = keyPair.getPrivate();
        this.publicKey = keyPair.getPublic();

    }

    private static ECPoint extractPublicKey(final ECPublicKey ecPublicKey) {
        final java.security.spec.ECPoint publicPointW = ecPublicKey.getW();
        final BigInteger xCoord = publicPointW.getAffineX();
        final BigInteger yCoord = publicPointW.getAffineY();

        return CURVE.getCurve().createPoint(xCoord, yCoord);
    }

    public byte[] applyECDSASig(PrivateKey privateKey, byte[] input) {
        Signature dsa;
        byte[] output;

        if (privateKey == null)
            throw new RuntimeException();
        try {
            dsa = Signature.getInstance("ECDSA","BC");
            dsa.initSign(privateKey);
            dsa.update(input);
            output = dsa.sign();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return output;
    }

    public boolean verifyECDSASig(PublicKey publicKey, byte[] data, byte[] signature) {
        try {
            Signature ecdsaVerify = Signature.getInstance("ECDSA", "BC");
            ecdsaVerify.initVerify(publicKey);
            ecdsaVerify.update(data);
            return ecdsaVerify.verify(signature);
        }catch(Exception e) {
            throw new RuntimeException(e);
        }
    }

    public PrivateKey getPrivateKey() {
        return privateKey;
    }

    public PublicKey getPublicKey() {
        return publicKey;
    }
}