module keccak;

static const ubyte[24] rho = [
    1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 2, 14, 27, 41, 56, 8, 25, 43, 62, 18, 39,
    61, 20, 44
];
static const ubyte[24] pi = [
    10, 7, 11, 17, 18, 3, 5, 16, 8, 21, 24, 4, 15, 23, 19, 13, 12, 2, 20, 14, 22,
    9, 6, 1
];
static const ulong[24] RC = [
    1, 0x8082, 0x800000000000808a, 0x8000000080008000, 0x808b, 0x80000001,
    0x8000000080008081, 0x8000000000008009, 0x8a, 0x88, 0x80008009,
    0x8000000a, 0x8000808b, 0x800000000000008b, 0x8000000000008089,
    0x8000000000008003, 0x8000000000008002, 0x8000000000000080, 0x800a,
    0x800000008000000a, 0x8000000080008081, 0x8000000000008080, 0x80000001,
    0x8000000080008008
];

enum PLEN = 200;

auto rol(T)(T x, T s)
{
    return ((x) << s) | ((x) >> (64 - s));
}

/*** Keccak-f[1600] ***/
static void keccakf(void* state)
{
    ulong* a = cast(ulong*) state;
    ulong[5] b;
    ulong t = 0;
    ubyte x, y;
    static foreach (i; 0 .. 24)
    {
        // Theta
        x = 0;
        static foreach (_; 0 .. 5)
        {
            b[x] = 0;
            y = 0;
            static foreach (_; 0 .. 5)
            {
                b[x] ^= a[x + y];
                y += 5;
            }
            x++;
        }
        x = 0;
        static foreach (_; 0 .. 5)
        {
            y = 0;
            static foreach (_; 0 .. 5)
            {
                a[y + x] ^= b[(x + 4) % 5] ^ rol(b[(x + 1) % 5], 1);
                y += 5;
            }
            x++;
        }
        // Rho and pi
        t = a[1];
        x = 0;
        static foreach (_; 0 .. 24)
        {
            b[0] = a[pi[x]];
            a[pi[x]] = rol(t, rho[x]);
            t = b[0];
            x++;
        }
        // Chi
        y = 0;
        static foreach (_; 0 .. 5)
        {
            x = 0;
            static foreach (_; 0 .. 5)
            {
                b[x] = a[y + x];
                x++;
            }
            x = 0;
            static foreach (_; 0 .. 5)
            {
                a[y + x] = b[x] ^ ((~b[(x + 1) % 5]) & b[(x + 2) % 5]);
                x++;
            }
            y += 5;
        }
        // Iota
        a[0] ^= RC[i];
    }
}

static void xorin(ubyte* dst, const ubyte* src, ulong len)
{
    foreach (i; 0 .. len)
    {
        dst[i] ^= src[i];
    }
}

static int hash(ubyte delim, ulong bits, bool checkSize = true)(ubyte* dst,
        ulong outlen, ubyte* src, ulong inlen)
{
    static immutable rate = PLEN - (bits / 4);
    import core.stdc.string : memset, strncpy;

    static if (checkSize)
    {
        if (outlen > (bits / 8))
        {
            return -1;
        }
    }
    static assert(rate < PLEN, "Rate should be less than 200");
    if ((dst == null) || ((src == null) && inlen != 0))
    {
        return -1;
    }
    ubyte[PLEN] a;
    // Absorb input.
    while (inlen >= rate)
    {
        xorin(a.ptr, src, rate);
        keccakf(a.ptr);
        src += rate;
        inlen -= rate;
    }
    // Xor in the DS and pad frame.
    a[inlen] ^= delim;
    a[rate - 1] ^= 0x80;
    // Xor in the last block.
    xorin(a.ptr, src, inlen);
    // Apply P
    keccakf(a.ptr);
    // Squeeze output.
    while (outlen >= rate)
    {
        strncpy(cast(char*) dst, cast(char*) a.ptr, rate);
        keccakf(a.ptr);
        dst += rate;
        outlen -= rate;
    }
    strncpy(cast(char*) dst, cast(char*) a.ptr, outlen);
    memset(a.ptr, 0, PLEN);
    return 0;
}

alias keccak(ulong SIZE) = hash!(0x01, SIZE);

alias keccak_256 = keccak!256;
alias keccak_224 = keccak!224;
alias keccak_384 = keccak!384;
alias keccak_512 = keccak!512;

auto keccakD(ulong SIZE)(ubyte[] data)
{
    ubyte[SIZE / 8] hash;
    keccak!SIZE(hash.ptr, hash.length, data.ptr, data.length);
    return hash;
}

alias keccak256 = keccakD!256;
alias keccak224 = keccakD!224;
alias keccak384 = keccakD!384;
alias keccak512 = keccakD!512;

unittest
{
    import std;

    "keccak test started".writeln;

    ubyte[] a = cast(ubyte[]) "hello".to!(char[]);
    ubyte[4] b;

    assert(keccak_224(b.ptr, b.length, a.ptr, a.length) != -1);
    auto hash = b[].map!(e => e.to!string(16)).join;
    assert("45524EC4" == hash);

    assert(keccak_256(b.ptr, b.length, a.ptr, a.length) != -1);
    hash = b[].map!(e => e.to!string(16)).join;
    assert("1C8AFF95" == hash);

    assert(keccak_384(b.ptr, b.length, a.ptr, a.length) != -1);
    hash = b[].map!(e => e.to!string(16)).join;
    assert("DCEF6FB7" == hash);

    assert(keccak_512(b.ptr, b.length, a.ptr, a.length) != -1);
    hash = b[].map!(e => e.to!string(16)).join;
    assert("52FA8066" == hash);
}

unittest
{
    import std;

    "keccak test started".writeln;

    ubyte[] a = cast(ubyte[]) "hello".to!(char[]);
    {
        auto b = keccak224(a);

        auto hash = b[0 .. 4].map!(e => e.to!string(16)).join;
        assert("45524EC4" == hash);
    }
    {
        auto b = keccak256(a);

        auto hash = b[0 .. 4].map!(e => e.to!string(16)).join;
        assert("1C8AFF95" == hash);
    }
    {
        auto b = keccak384(a);

        auto hash = b[0 .. 4].map!(e => e.to!string(16)).join;
        assert("DCEF6FB7" == hash);
    }
    {
        auto b = keccak512(a);

        auto hash = b[0 .. 4].map!(e => e.to!string(16)).join;
        assert("52FA8066" == hash);
    }
}

unittest
{
    import std.datetime.stopwatch : benchmark;
    import std : uniform;
    import std : writeln;

    string t = import(`testText.txt`);

    benchmark!({
        ubyte[32] o;
        keccak_256(o.ptr, o.length, cast(ubyte*) t.ptr, t.length);
    })(1).writeln;
    benchmark!({
        ubyte[32] o;
        immutable s = uniform(0, cast(long) t.length - 600);
        auto slice = t[s .. s + 600];
        keccak_256(o.ptr, o.length, cast(ubyte*) slice.ptr, slice.length);
    })(10_000).writeln;
}