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;
        EC_POINT* R = EC_POINT_new(group);
        scope (exit)
        {
            foreach (bn; [order, k, kinv, rp, Rx, Ry])
                bn.BN_free;
            EC_POINT_free(R);
            ECDSA_SIG_free(sig);
        }
        EC_GROUP_get_order(group, order, null);
        ECDSA_sign_setup(ec_key, null, &kinv, &rp);
        BN_mod_inverse(k, kinv, order, null);
        assert(EC_POINT_mul(group, R, k, null, null, null));
        EC_POINT_get_affine_coordinates_GFp(group, R, Rx, Ry, null);
        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 ECDSA_SIG_to(Result)(ECDSA_SIG* sig)
    {
        static if (is(Result == string))
        {
            auto rptr = BN_bn2hex(sig.r);
            auto sptr = BN_bn2hex(sig.s);
            auto result = rptr.to!string ~ BN_bn2hex(sig.s).to!string;
            scope (exit)
            {
                free(rptr);
                free(sptr);
            }
        }
        else static if (is(Result == bytes))
        {
            ubyte[32] r;
            ubyte[32] s;
            BN_bn2bin(sig.r, r.ptr);
            BN_bn2bin(sig.s, s.ptr);
            auto result = r[] ~ s[];
        }
        else static if (is(Result == Signature))
        {
            Signature result;

            auto group = ec_key.EC_KEY_get0_group;
            auto R = EC_POINT_new(group);
            EC_POINT_set_compressed_coordinates_GFp(group, R, sig.r, 0, null);
            auto x = BN_new(), y = BN_new();
            auto ctx = BN_CTX_new();
            scope (exit)
            {
                BN_free(x);
                BN_free(y);
                EC_POINT_free(R);
            }
            EC_POINT_get_affine_coordinates_GFp(group, R, x, y, null);
            y.BN_bn2dec.puts;
            y.BN_is_negative.writeln;
            EC_POINT_set_compressed_coordinates_GFp(group, R, sig.r, 1, null);
            EC_POINT_get_affine_coordinates_GFp(group, R, x, y, null);
            y.BN_bn2dec.puts;
            y.BN_is_negative.writeln;
            result.recid = BN_is_odd(y);
            BN_bn2bin(sig.r, result.r.ptr);
            BN_bn2bin(sig.s, result.s.ptr);
        }
        return result;
    }
}