class Blake2

# File lib/blake2.rb, line 10
def self.bytes(input, key = Blake2::Key.none, out_len = 32)
  check_if_valid!(input, key, out_len)
  Blake2.new(out_len, key).digest(input, :to_bytes)
end

# File lib/blake2.rb, line 5
def self.hex(input, key = Blake2::Key.none, out_len = 32)
  check_if_valid!(input, key, out_len)
  Blake2.new(out_len, key).digest(input, :to_hex)
end

VALUE m_blake2_initialize(VALUE self, VALUE _len, VALUE _key) {
  Blake2 *blake2;
  Data_Get_Struct(self, Blake2, blake2);
  int i;

  ID bytes_method  = rb_intern("bytes");
  blake2->to_hex   = ID2SYM(rb_intern("to_hex"));
  blake2->to_bytes = ID2SYM(rb_intern("to_bytes"));

  VALUE key_bytes_ary = rb_funcall(_key, bytes_method, 0);
  blake2->key_length  = RARRAY_LEN(key_bytes_ary);
  blake2->key_bytes   = (uint8_t*)malloc(blake2->key_length * sizeof(uint8_t));

  for(i = 0; i < blake2->key_length; i++) {
    VALUE byte           = rb_ary_entry(key_bytes_ary, i);
    blake2->key_bytes[i] = NUM2INT(byte);
  }

  blake2->output_length = NUM2INT(_len);
  blake2->output        = (uint8_t*)malloc(blake2->output_length * sizeof(uint8_t));

  return Qnil;
}

# File lib/blake2.rb, line 15
def self.check_if_valid!(input, key, out_len)
  unless input.is_a?(String)
    raise ArgumentError, 'input arg must be a String'
  end

  unless key.is_a?(Blake2::Key)
    raise ArgumentError, 'key arg must be a Blake2::Key'
  end

  unless out_len.is_a?(Integer) && out_len.between?(1, 32)
    raise ArgumentError, 'out_len arg must be an Integer between 1 and 32 inclusive'
  end
end

VALUE m_blake2_digest(VALUE self, VALUE _input, VALUE _representation) {
  Blake2 *blake2;

  char *input      = RSTRING_PTR(_input);
  int input_length = RSTRING_LEN(_input);
  int i;

  Data_Get_Struct(self, Blake2, blake2);

  blake2s(blake2->output, input, blake2->key_bytes,
      blake2->output_length, input_length, blake2->key_length);

  VALUE result;

  if(_representation == blake2->to_bytes) {
    result = rb_ary_new2(blake2->output_length);

    for(i = 0; i < blake2->output_length; i++) {
      rb_ary_push(result, INT2NUM(blake2->output[i]));
    }
  } else if(_representation == blake2->to_hex) {
    int ary_len = blake2->output_length * sizeof(char) * 2;
    char *c_str = (char*)malloc(ary_len + 1);

    for(i = 0; i < blake2->output_length; i++) {
      sprintf(c_str + (i * 2), "%02x", blake2->output[i]);
    }
    c_str[ary_len] = 0;

    result = rb_str_new(c_str, ary_len);

    if(RSTRING_LEN(result) != ary_len) {
      rb_raise(rb_eRuntimeError, "m_blake2_digest: sizes don't match. Ary: %d != %d", RSTRING_LEN(result), ary_len);
    }

    free(c_str);
  } else {
    rb_raise(rb_eArgError, "unknown representation :%"PRIsVALUE"", _representation);
  }

  return result;
}