#include <stdio.h>
#include <stdint.h>
#include <stddef.h>
#include "blake2b.h"

#ifndef ROTR64
#define ROTR64(x, y) (((x) >> (y)) ^ ((x) << (64 - (y))))
#endif
// Little-endian byte access.
#define B2B_GET64(p) \
(((uint64_t) ((uint8_t *) (p))[0]) ^ \
(((uint64_t) ((uint8_t *) (p))[1]) << 8) ^ \
(((uint64_t) ((uint8_t *) (p))[2]) << 16) ^ \
(((uint64_t) ((uint8_t *) (p))[3]) << 24) ^ \
(((uint64_t) ((uint8_t *) (p))[4]) << 32) ^ \
(((uint64_t) ((uint8_t *) (p))[5]) << 40) ^ \
(((uint64_t) ((uint8_t *) (p))[6]) << 48) ^ \
(((uint64_t) ((uint8_t *) (p))[7]) << 56))
// G Mixing function.
#define B2B_G(a, b, c, d, x, y) { \
v[a] = v[a] + v[b] + x; \
v[d] = ROTR64(v[d] ^ v[a], 32); \
v[c] = v[c] + v[d]; \
v[b] = ROTR64(v[b] ^ v[c], 24); \
v[a] = v[a] + v[b] + y; \
v[d] = ROTR64(v[d] ^ v[a], 16); \
v[c] = v[c] + v[d]; \
v[b] = ROTR64(v[b] ^ v[c], 63); \
}
// Initialization Vector.
static const uint64_t blake2b_iv[8] = {
       0x6A09E667F3BCC908, 0xBB67AE8584CAA73B,
       0x3C6EF372FE94F82B, 0xA54FF53A5F1D36F1,
       0x510E527FADE682D1, 0x9B05688C2B3E6C1F,
       0x1F83D9ABFB41BD6B, 0x5BE0CD19137E2179
};

unsigned int be32toh(unsigned int x)
{
    return (((x & 0xff000000U) >> 24) | ((x & 0x00ff0000U) >>  8) |
            ((x & 0x0000ff00U) <<  8) | ((x & 0x000000ffU) << 24));
}

static void blake2b_compress(blake2b_ctx *ctx, int last)
{
   const uint8_t sigma[12][16] = {
      { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
      { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
      { 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
      { 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
      { 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
      { 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 },
      { 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 },
      { 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 },
      { 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 },
      { 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0 },
      { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
      { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 }
   };
int i;
uint64_t v[16], m[16];
//long int v15;
for (i = 0; i < 8; i++) { // init work variables
    v[i] = ctx->h[i];
    v[i + 8] = blake2b_iv[i];
}
//v15= v[15];
//printf("the v15=%02lx\n" ,v15);  

v[12] ^= ctx->t[0]; // low 64 bits of offset
v[13] ^= ctx->t[1]; // high 64 bits

//printf("ctx->t[0]= %016llx\n",ctx->t[0]);
//printf("ctx->t[1]= %016llx\n",ctx->t[1]);

if (last) // last block flag set ?
   v[14] = ~v[14];

for (i = 0; i < 16; i++) // get little-endian words
   m[i] = B2B_GET64(&ctx->b[8 * i]);

//for (int i = 0; i < 16; ++i) printf("v[%0d]=%016llx\n", i,v[i]);
//for (int i = 0; i < 16; ++i) printf("m[%0d]=%016llx\n", i,m[i]);

for (i = 0; i < 12; i++) { // twelve rounds for (i = 0; i < 12; i++) { // twelve rounds
    //printf("i=%0d\n",i);
    //for (int i = 0; i < 16; ++i) printf("v[%0d]=%016llx\n", i,v[i]);
    //for (int i = 0; i < 16; ++i) printf("m[%0d]=%016llx\n", i,m[i]);

     B2B_G( 0, 4, 8,  12, m[sigma[i][ 0]], m[sigma[i][ 1]]);
     B2B_G( 1, 5, 9,  13, m[sigma[i][ 2]], m[sigma[i][ 3]]);
     B2B_G( 2, 6, 10, 14, m[sigma[i][ 4]], m[sigma[i][ 5]]);
     B2B_G( 3, 7, 11, 15, m[sigma[i][ 6]], m[sigma[i][ 7]]);
     B2B_G( 0, 5, 10, 15, m[sigma[i][ 8]], m[sigma[i][ 9]]);
     B2B_G( 1, 6, 11, 12, m[sigma[i][10]], m[sigma[i][11]]);
     B2B_G( 2, 7, 8,  13, m[sigma[i][12]], m[sigma[i][13]]);
     B2B_G( 3, 4, 9,  14, m[sigma[i][14]], m[sigma[i][15]]);

   }
   //for (int i = 0; i < 16; ++i) printf("v[%0d]=%016llx\n", i,v[i]);
//v15= v[15];
//printf("the v15=%02lx\n" ,v15);  
for( i = 0; i < 8; ++i )
  ctx->h[i] ^= v[i] ^ v[i + 8];
//v15= v[15];
//printf("the v15=%02lx\n" ,v15);  
}

void blake2b_update(blake2b_ctx *ctx, const void *in, size_t inlen) // data bytes
{
size_t i;
for (i = 0; i < inlen; i++) {
    if (ctx->c == 128) { // buffer full ?
        ctx->t[0] += ctx->c; // add counters
       if (ctx->t[0] < ctx->c) // carry overflow ?
           ctx->t[1]++; // high word
       blake2b_compress(ctx, 0); // compress (not last)
       ctx->c = 0; // counter to zero
       //for (int i = 0; i < 8; ++i) printf("ctx->h[%0d]=%016llx\n",i,ctx->h[i]);
      }
     ctx->b[ctx->c++] = ((const uint8_t *) in)[i];
  }
/*
int t0,t1;
t0 = ctx->t[0];
t1 = ctx->t[1]; 
printf("the t[0]=%02x,the t[1]=%02x\n", t0,t1);  
*/
  //printf("the t[0]=%02x,the t[1]=%02x\n", ctx->t[0],ctx->t[1]);  
}

int blake2b_init(blake2b_ctx *ctx, size_t outlen) // (keylen=0: no key)
{
//size_t i;

//if (outlen == 0 || outlen > 64 || keylen > 64)
//   return -1; // illegal parameters
//
//for (i = 0; i < 8; i++) // state, "param block"
//   ctx->h[i]  = blake2b_iv[i];
//
// ctx->h[0] ^= 0x01010000 ^ (keylen << 8) ^ outlen;
// ctx->t[0]  = 0; // input count low word
// ctx->t[1]  = 0; // input count high word
// ctx->c     = 0; // pointer within buffer
// ctx->outlen = outlen;
//
//for (i = keylen; i < 128; i++) // zero input block
//    ctx->b[i] = 0;
//if (keylen > 0) {
//   blake2b_update(ctx, key, keylen);
//   ctx->c = 128; // at the end
//   }
ctx->h[0]= 0x6a09e667f2bdc93a;
ctx->h[1]= 0xbb67ae8584caa73b;
ctx->h[2]= 0x3c6ef372fe94f82b;
ctx->h[3]= 0xa54ff53a5f1d36f1;
ctx->h[4]= 0x510e527fade682d1;
ctx->h[5]= 0x9b05688c2b3e6c1f;
ctx->h[6]= 0x48ec89c38820de31;
ctx->h[7]= 0x5be0cd10137e21b1;
ctx->t[0]  = 0; // input count low word
ctx->t[1]  = 0; // input count high word
ctx->c     = 0; // pointer within buffer
ctx->outlen = outlen;
return 0;
}

void blake2b_final(blake2b_ctx *ctx, void *out)
{
size_t i;
ctx->t[0] += ctx->c; // mark last block offset
if (ctx->t[0] < ctx->c) // carry overflow
   ctx->t[1]++; // high word
while (ctx->c < 128) // fill up with zeros
   ctx->b[ctx->c++] = 0;
//printf("the msg is :\n");
//for (int i = 0; i < 128; ++i) printf("%02x",ctx->b[i]);
//printf("\n");
blake2b_compress(ctx, 1); // final block flag = 1
// little endian convert and store
/*
int t0,t1;
t0 = ctx->t[0];
t1 = ctx->t[1];
printf("the t[0]=%02x,the t[1]=%02x\n", t0,t1);
*/
//for (i = 0; i < 128; i++)
//    ((uint8_t *) msg_s1)[i] = ctx->b[i];
//for (int i = 0; i < 8; ++i) printf("ctx->h[%0d]=%016llx\n",i,ctx->h[i]);
//printf("ctx->outlen= %0d\n",ctx->outlen );
for (i = 0; i < ctx->outlen; i++) {
    ((uint8_t *) out)[i] = (ctx->h[i >> 3] >> (8 * (i & 7))) & 0xFF;
}
}

/*
int blake2b(void *out, size_t outlen,const void *key, size_t keylen,const void *in, size_t inlen,void *msg_s1)
{
 blake2b_ctx ctx;
 if (blake2b_init(&ctx, outlen, key, keylen))
   return -1;
 blake2b_update(&ctx, in, inlen);
 blake2b_final(&ctx, out);
 return 0;
}

int main(int argc, char** argv) {
int i,j;
uint8_t md[50];
uint8_t msg_s1[128];

uint8_t in[140+4] = {
        0x04,0x00,0x00,0x00,
        0xe5,0x4c,0x27,0x54,0x40,0x50,0x66,0x8f,0x27,0x2e,0xc3,0xb4,0x60,0xe1,0xcd,0xe7,
        0x45,0xc6,0xb2,0x12,0x39,0xa8,0x1d,0xae,0x63,0x7f,0xde,0x47,0x04,0x00,0x00,0x00,
        0x84,0x4b,0xc0,0xc5,0x56,0x96,0xef,0x99,0x20,0xee,0xda,0x11,0xc1,0xeb,0x41,0xb0,
        0xc2,0xe7,0x32,0x4b,0x46,0xcc,0x2e,0x7a,0xa0,0xc2,0xaa,0x77,0x36,0x44,0x8d,0x7a,
        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        0x68,0x24,0x1a,0x58,
        0x7e,0x7e,0x06,0x1d,
        0x25,0x0e,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        0x01,0x00,0x00,0x00
    };

blake2b(md, 50, NULL, 0, in, sizeof(in), msg_s1);

printf("the hash out is \n");  
for (i=0; i < sizeof(md); ++i) {
  printf("%02x",md[i]);
}
printf("\n");
return 0;
}
*/