module secp256k1;

import std.stdio;
import std.exception : enforce;
import std.conv : to;

import core.stdc.stdlib : free;
import keccak : keccak_256;
import deimos.openssl.ec;
import deimos.openssl.evp;
import deimos.openssl.pem;
import deimos.openssl.ecdsa;
import deimos.openssl.bn;
import deimos.openssl.obj_mac : NID_secp256k1;

alias bytes = ubyte[];
unittest
{
    writeln("Elliptic Curve example");
    auto pk = new ubyte[32];
    pk[0 .. $] = [
        50, 93, 176, 197, 179, 11, 107, 161, 16, 47, 114, 191, 181, 146, 4, 60,
        66, 29, 253, 65, 237, 252, 116, 78, 218, 69, 204, 32, 73, 168, 217, 123
    ];
    auto ec = new secp256k1(pk);
    ec.writeln;
    ec.address.writeln(" --  address");
    ec.sign("abababa").writeln;
    ec.sign("abababa").writeln;
    ec.sign("abababa").writeln;
    ec.sign("abababa").writeln;
}

struct Signature
{
    int recid;
    ubyte[32] r;
    ubyte[32] s;
}

class secp256k1
{
    EC_KEY* ec_key;

    this(ubyte[] pk = null)
    {
        ec_key = EC_KEY_new_by_curve_name(NID_secp256k1);
        if (pk == null)
        {
            EC_KEY_generate_key(ec_key);
        }
        else
        {
            auto bn_pk = BN_bin2bn(pk.ptr, cast(int) pk.length, null);
            EC_KEY_set_private_key(ec_key, bn_pk);
            auto group = EC_KEY_get0_group(ec_key);
            auto pub_key = EC_POINT_new(group);
            auto ctx = BN_CTX_new();
            scope (exit)
            {
                BN_free(bn_pk);
                BN_CTX_free(ctx);
                EC_POINT_free(pub_key);
            }
            EC_POINT_mul(group, pub_key, bn_pk, null, null, ctx);
            EC_KEY_set_public_key(ec_key, pub_key);
        }
    }

    auto sign(Result = Signature, Input)(Input data)
    {
        ubyte[] _data = cast(ubyte[]) data.dup;
        auto group = ec_key.EC_KEY_get0_group;
        BIGNUM* kinv, rp, k = BN_new, Rx = BN_new, Ry = BN_new, order = BN_new;
        ECDSA_SIG* sig;
        auto ctx = BN_CTX_new;
        EC_POINT* R = EC_POINT_new(group);
        scope (exit)
        {
            foreach (bn; [order, k, kinv, rp, Rx, Ry])
                bn.BN_free;
            ctx.BN_CTX_free;
            EC_POINT_free(R);
            ECDSA_SIG_free(sig);
        }
        handleErr!EC_GROUP_get_order(group, order, ctx);
        handleErr!ECDSA_sign_setup(ec_key, null, &kinv, &rp);
        handleErr!BN_mod_inverse(k, kinv, order, ctx);
        assert(EC_POINT_mul(group, R, k, null, null, ctx));
        handleErr!EC_POINT_get_affine_coordinates_GFp(group, R, Rx, Ry, ctx);
        sig = ECDSA_do_sign_ex(_data.ptr, cast(int) _data.length, kinv, rp, ec_key);

        assert(ECDSA_do_verify(_data.ptr, cast(int) _data.length, sig, ec_key), "Check signature");
        assert(0 == BN_cmp(sig.r, Rx), "Rx == r");

        Signature result;
        result.recid = BN_is_odd(Ry);
        BN_bn2bin(sig.r, result.r.ptr);
        BN_bn2bin(sig.s, result.s.ptr);
        return result;
    }

    override string toString()
    {
        auto pkBN = EC_KEY_get0_private_key(ec_key);
        auto cptr = BN_bn2hex(pkBN);
        ubyte[32] pkBytes;
        BN_bn2bin(pkBN, pkBytes.ptr);
        string result = cptr.to!string ~ pkBytes.to!string ~ " Can sign: " ~ EC_KEY_check_key(ec_key)
            .to!string;
        OPENSSL_free(cptr);
        return result;
    }

    ~this()
    {
        EC_KEY_free(ec_key);
    }

    auto publicKey()
    {
        auto pubKey = EC_POINT_point2bn(ec_key.EC_KEY_get0_group, ec_key.EC_KEY_get0_public_key,
                point_conversion_form_t.POINT_CONVERSION_UNCOMPRESSED, null, null);
        ubyte[65] data;
        BN_bn2bin(pubKey, data.ptr);

        scope (exit)
        {
            BN_free(pubKey);
        }
        return data;
    }

    ubyte[20] address()
    {
        ubyte[32] hash;
        auto pubKey = publicKey[1 .. $] ~ [];
        keccak_256(hash.ptr, hash.length, pubKey.ptr, pubKey.length);
        return hash[12 .. $];
    }

}

private auto handleErr(alias f, ARGS...)(ARGS argv)
{
    import std.traits : fullyQualifiedName;

    enforce(f(argv), fullyQualifiedName!f ~ " crashed");
}