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, 121
    ];
    auto ec = new secp256k1(pk);
    ec.writeln;
    ec.address.writeln(" --  address");
    ec.sign!string("abababa").writeln;
    ec.sign!string("abababa").writeln;
}

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, Input)(Input data)
    {
        ubyte[] _data = cast(ubyte[]) data.dup;
        auto sig = ECDSA_do_sign(_data.ptr, cast(int) _data.length, ec_key);
        assert(ECDSA_do_verify(_data.ptr, cast(int) _data.length, sig, ec_key), "Check signature");
        auto result = sig.ECDSA_SIG_to!Result;
        ECDSA_SIG_free(sig);
        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);
    }

    int parity()
    {
        auto point = EC_KEY_get0_public_key(ec_key);
        auto group = EC_KEY_get0_group(ec_key);
        auto x = BN_new(), y = BN_new();
        auto ctx = BN_CTX_new();
        scope (exit)
        {
            BN_CTX_free(ctx);
            BN_free(x);
            BN_free(y);
        }
        EC_POINT_get_affine_coordinates_GFp(group, point, x, y, ctx);
        return BN_is_odd(y);
    }

    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 .. $];
    }
}

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
    {
        ubyte[32] r;
        ubyte[32] s;
        BN_bn2bin(sig.r, r.ptr);
        BN_bn2bin(sig.s, s.ptr);
        auto result = r[] ~ s[];
    }
    return result;
}