#include "erl_nif.h"
#include <stdlib.h>
#include <time.h>
#include <stdio.h>
    
static int
load(ErlNifEnv* env, void** priv, ERL_NIF_TERM load_info)
{
  return 0;
}

static int
reload(ErlNifEnv* env, void** priv, ERL_NIF_TERM load_info)
{
  return 0;
}

static int
upgrade(ErlNifEnv* env, void** priv, void** old_priv,
	ERL_NIF_TERM load_info)
{
  return 0;
}

static void
unload(ErlNifEnv* env, void* priv)
{
  return;
}


// Function to generate binary
// Right now we are only constructing one binary and returns that. 
static ERL_NIF_TERM
generate_binary(ErlNifEnv* env, int argc, const ERL_NIF_TERM *argv)
{
  
  ErlNifPid to_pid;
  ErlNifBinary bin;
  int SIZE, i;

  //ErlNifEnv *env = enif_alloc_env();
  
  
  enif_get_int(env, argv[0], &SIZE);
  fprintf(stderr, "Value of argv[0]: %d\n", SIZE);
  
  
  enif_get_local_pid(env, argv[1], &to_pid);
  
  // Allocate memory for the binary
  enif_alloc_binary(SIZE, &bin);


  srand( (unsigned int) time(NULL));
  
  fprintf(stderr, "SIZE = %d\n", SIZE);
  
  // This is just random data right now. We might want to generate something more useful
  for(i = 0; i < SIZE; i++)
    {
      fprintf(stderr, "Iteration %d\n", i);
      bin.data[i] = (i % 26) + 'a';
    }
  
  // Create a enviroment
  ErlNifEnv *tmp_env = enif_alloc_env();
  
  // Make a NIF_TERM out of our binary
  ERL_NIF_TERM msg = enif_make_binary(tmp_env, &bin);
  
  // We send a message to the PID we have in the argumentlist
  if(enif_send(NULL, &to_pid, tmp_env, msg))
    {
      fprintf(stderr, "Sent message");
    } else {
    fprintf(stderr, "Could not send message");
  }
  
 
  return enif_make_string(env, "Hello world", ERL_NIF_LATIN1);

}


static ERL_NIF_TERM
generate_buffer(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) 
{
  ErlNifTid thread;
  ErlNifThreadOpts *thread_opts;
  
  thread_opts = enif_thread_opts_create("thread_opts");
  

  

  
  int size, buffers_per_batch;
  ErlNifPid pid;
  
  // Extract the arguments 
  if (!enif_get_int(env, argv[0], &size)) {
    fprintf(stderr, "Argument 1 not an int: %d\n", size);
    return enif_make_badarg(env);
  }


  if (!enif_get_int(env, argv[2], &buffers_per_batch)) {
    fprintf(stderr, "Argument 3 not an int: %d\n", buffers_per_batch);
    return enif_make_badarg(env);
  }

  if (!enif_get_local_pid(env, argv[1], &pid)) {
    fprintf(stderr, "Argument 2 not a pid\n");
    return enif_make_badarg(env);
  }
  ERL_NIF_TERM *arguments = (ERL_NIF_TERM *)malloc(sizeof(ERL_NIF_TERM)*5);
  
  arguments[0] = enif_make_int(env, size);
  arguments[1] = enif_make_pid(env, &pid);
  arguments[2] = enif_make_int(env, buffers_per_batch);


  enif_thread_create("data_generation", &thread, (void *)generate_binary, &arguments, NULL);

  
  
  return enif_make_string(env, "Hello World",ERL_NIF_LATIN1);
}

static ErlNifFunc mynif_funcs[] =
  {
    {"generate_binary", 3, generate_binary},
    {"generate_buffer", 3, generate_buffer}
  };


ERL_NIF_INIT(ctr_in_fg_nif,mynif_funcs,NULL,NULL,NULL,NULL);