VALUE rugged_signature_new(const git_signature *sig, const char *encoding_name)
{
	VALUE rb_sig, rb_time;
	rb_encoding *encoding = rb_utf8_encoding();

	if (encoding_name != NULL)
		encoding = rb_enc_find(encoding_name);

	rb_sig = rb_hash_new();

	/* Allocate the time with a the given timezone */
	rb_time = rb_funcall(
		rb_time_new(sig->when.time, 0),
		rb_intern("getlocal"), 1,
		INT2FIX(sig->when.offset * 60)
	);

	rb_hash_aset(rb_sig, CSTR2SYM("name"),
		rb_enc_str_new(sig->name, strlen(sig->name), encoding));

	rb_hash_aset(rb_sig, CSTR2SYM("email"),
		rb_enc_str_new(sig->email, strlen(sig->email), encoding));

	rb_hash_aset(rb_sig, CSTR2SYM("time"), rb_time);

	return rb_sig;
}

static inline VALUE
get_user_from_path(wchar_t **wpath, int offset, UINT cp, UINT path_cp, rb_encoding *path_encoding)
{
    VALUE result, tmp;
    wchar_t *wuser = *wpath + offset;
    wchar_t *pos = wuser;
    char *user;
    size_t size;

    while (!IS_DIR_SEPARATOR_P(*pos) && *pos != '\0')
     pos++;

    *pos = '\0';
    convert_wchar_to_mb(wuser, &user, &size, cp);

    /* convert to VALUE and set the path encoding */
    if (path_cp == INVALID_CODE_PAGE) {
	tmp = rb_enc_str_new(user, size, rb_utf8_encoding());
	result = rb_str_encode(tmp, rb_enc_from_encoding(path_encoding), 0, Qnil);
	rb_str_resize(tmp, 0);
    }
    else {
	result = rb_enc_str_new(user, size, path_encoding);
    }

    if (user)
	xfree(user);

    return result;
}

void Init_request_parse(VALUE nyara) {
  str_accept = rb_enc_str_new("Accept", strlen("Accept"), u8_encoding);
  rb_gc_register_mark_object(str_accept);
  method_override_key = rb_enc_str_new("_method", strlen("_method"), u8_encoding);
  OBJ_FREEZE(method_override_key);
  rb_const_set(nyara, rb_intern("METHOD_OVERRIDE_KEY"), method_override_key);
  nyara_http_methods = rb_const_get(nyara, rb_intern("HTTP_METHODS"));
}

static int
cmp_1(const void *ap, const void *bp, void *dummy)
{
    struct sort_data *d = dummy;
    VALUE a = rb_enc_str_new(ap, d->elsize, d->enc);
    VALUE b = rb_enc_str_new(bp, d->elsize, d->enc);
    VALUE retval = rb_yield_values(2, a, b);
    return rb_cmpint(retval, a, b);
}

static VALUE
to_ruby_value(plruby_context_t *ctx, char type, void *arg, int pos)
{
    OCIString *str;
    OCINumber *num;
    double *d;
    char *cstr;
    ub4 size;
    double dbl;

    switch (type) {
    case ' ':
        trace(ctx, 1, "arg[%d]: nil", pos);
        return Qnil;
    case 'v':
        str = (OCIString *)arg;
        cstr = (char*)OCIStringPtr(ctx->envhp, str);
        size = OCIStringSize(ctx->envhp, str);
        trace(ctx, 1, "arg[%d]: %.*s", pos, size, cstr);
        return rb_enc_str_new(cstr, size, oracle_encoding);
    case 'n':
        num = (OCINumber *)arg;
        chk(OCINumberToReal(ctx->errhp, num, sizeof(dbl), &dbl));
        trace(ctx, 1, "arg[%d]: %f", pos, dbl);
        return rb_float_new(dbl);
    case 'd':
        d = (double *)arg;
        trace(ctx, 1, "arg[%d]: %f", pos, *d);
        return rb_float_new(*d);
    }
    rb_raise(rb_eRuntimeError, "Unsupported type %d", type);
}

static void
err_append(const char *s, rb_encoding *enc)
{
    rb_thread_t *th = GET_THREAD();
    VALUE err = th->errinfo;

    if (th->mild_compile_error) {
	if (!RTEST(err)) {
	    err = rb_exc_new3(rb_eSyntaxError,
			      rb_enc_str_new(s, strlen(s), enc));
	    th->errinfo = err;
	}
	else {
	    VALUE str = rb_obj_as_string(err);

	    rb_str_cat2(str, "\n");
	    rb_str_cat2(str, s);
	    th->errinfo = rb_exc_new3(rb_eSyntaxError, str);
	}
    }
    else {
	if (!RTEST(err)) {
	    err = rb_exc_new2(rb_eSyntaxError, "compile error");
	    th->errinfo = err;
	}
	rb_write_error(s);
	rb_write_error("\n");
    }
}

VALUE typecast_detect(const char *data, size_t size, int type) {
    VALUE value;
    char *bytea;
    size_t bytea_len;
    switch (type) {
        case SWIFT_TYPE_INT:
            return rb_cstr2inum(data, 10);
        case SWIFT_TYPE_FLOAT:
            return rb_float_new(atof(data));
        case SWIFT_TYPE_NUMERIC:
            return rb_funcall(cBigDecimal, fnew, 1, rb_str_new(data, size));
        case SWIFT_TYPE_BOOLEAN:
            return (data && (data[0] =='t' || data[0] == '1')) ? Qtrue : Qfalse;
        case SWIFT_TYPE_BLOB:
            bytea = PQunescapeBytea(data, &bytea_len);
            value = rb_str_new(bytea, bytea_len);
            PQfreemem(bytea);
            return rb_funcall(cStringIO, fnew, 1, value);
        case SWIFT_TYPE_TIMESTAMP:
            return datetime_parse(cSwiftDateTime, data, size);
        case SWIFT_TYPE_DATE:
            return date_parse(cSwiftDateTime, data, size);
        default:
            return rb_enc_str_new(data, size, rb_utf8_encoding());
    }
}

/*
 *  call-seq:
 *    commit.header_field(field_name) -> str
 *
 *  Returns +commit+'s header field value.
 */
static VALUE rb_git_commit_header_field(VALUE self, VALUE rb_field)
{
	git_buf header_field = { 0 };
	git_commit *commit = NULL;

	const char *encoding_name;
	rb_encoding *encoding = rb_utf8_encoding();
	VALUE rb_result;

	int error;

	Check_Type(rb_field, T_STRING);
	Data_Get_Struct(self, git_commit, commit);

	error = git_commit_header_field(&header_field, commit, StringValueCStr(rb_field));

	if (error < 0) {
		git_buf_free(&header_field);
		if (error == GIT_ENOTFOUND)
			return Qnil;
		rugged_exception_check(error);
	}

	encoding_name = git_commit_message_encoding(commit);
	if (encoding_name != NULL)
		encoding = rb_enc_find(encoding_name);

	rb_result = rb_enc_str_new(header_field.ptr, header_field.size, encoding);
	git_buf_free(&header_field);
	return rb_result;
}

static void CheckOSStatusOrRaise(OSStatus err){
  if(err != 0){
    CFStringRef description = SecCopyErrorMessageString(err, NULL);

    CFIndex bufferSize = CFStringGetMaximumSizeForEncoding(CFStringGetLength(description), kCFStringEncodingUTF8);
    char *buffer = malloc(bufferSize + 1);
    CFStringGetCString(description, buffer, bufferSize + 1, kCFStringEncodingUTF8);
    CFRelease(description);

    VALUE exceptionString = rb_enc_str_new(buffer, strlen(buffer), rb_utf8_encoding());
    free(buffer);
    VALUE exception = Qnil;

    switch(err){
      case errSecAuthFailed:
        exception = rb_obj_alloc(rb_eKeychainAuthFailedError);
        break;
      case errSecNoSuchKeychain:
        exception = rb_obj_alloc(rb_eKeychainNoSuchKeychainError);
        break;
      case errSecDuplicateItem:
        exception = rb_obj_alloc(rb_eKeychainDuplicateItemError);
        break;
      default:
        exception = rb_obj_alloc(rb_eKeychainError);
    }
    rb_funcall(exception, rb_intern("initialize"), 2,exceptionString, INT2FIX(err));
    rb_exc_raise(exception);
  }
}

static VALUE decode(VALUE self, VALUE str)
{
  int rc;
  punycode_uint *ustr;
  size_t len;
  char *buf = NULL;
  VALUE retv;

  str = rb_check_convert_type(str, T_STRING, "String", "to_s");

  len = RSTRING_LEN(str);
  ustr = malloc(len * sizeof(punycode_uint));

  if (ustr == NULL) {
    rb_raise(rb_eNoMemError, "cannot allocate memory (%d bytes)", (uint32_t)len);
    return Qnil;
  }

  rc = punycode_decode(RSTRING_LEN(str), RSTRING_PTR(str),
                       &len, ustr, NULL);

  if (rc != PUNYCODE_SUCCESS) {
    xfree(ustr);
    rb_raise(ePunycodeError, "%s (%d)", punycode_strerror(rc), rc);
    return Qnil;
  }

  buf = stringprep_ucs4_to_utf8(ustr, len, NULL, &len);
  retv = rb_enc_str_new(buf, len, rb_utf8_encoding());
  xfree(ustr);
  xfree(buf);
  return retv;
}

VALUE
rb_readlink(VALUE path)
{
    ssize_t len;
    WCHAR *wpath, wbuf[MAX_PATH];
    rb_encoding *enc;
    UINT cp, path_cp;

    FilePathValue(path);
    enc = rb_enc_get(path);
    cp = path_cp = code_page(enc);
    if (cp == INVALID_CODE_PAGE) {
        path = fix_string_encoding(path, enc);
        cp = CP_UTF8;
    }
    wpath = mbstr_to_wstr(cp, RSTRING_PTR(path),
                          RSTRING_LEN(path)+rb_enc_mbminlen(enc), NULL);
    if (!wpath) rb_memerror();
    len = rb_w32_wreadlink(wpath, wbuf, numberof(wbuf));
    free(wpath);
    if (len < 0) rb_sys_fail_path(path);
    enc = rb_filesystem_encoding();
    cp = path_cp = code_page(enc);
    if (cp == INVALID_CODE_PAGE) cp = CP_UTF8;
    return append_wstr(rb_enc_str_new(0, 0, enc), wbuf, len, cp, path_cp, enc);
}

static OCIAnyData *
call_ruby(plruby_context_t *ctx)
{
    VALUE obj;

    trace(ctx, 1, "before encode to ('%s')", rb_enc_name(oracle_encoding));
    obj = rb_enc_str_new(ctx->obj, strlen(ctx->obj), oracle_encoding);
    trace(ctx, 1, "after encode to ('%s')", rb_enc_name(oracle_encoding));

    trace(ctx, 1, "before eval('%s')", ctx->obj);
    obj = rb_funcall(rb_cObject, rb_intern("eval"), 1, obj);
    trace(ctx, 1, "after eval('%s')", ctx->obj);
    if (ctx->meth != NULL) {
        VALUE args[MAX_ARG];
        int idx;

        for (idx = 0; idx < MAX_ARG && ctx->args[idx] != EMPTY; idx++) {
            trace(ctx, 2, "before to_ruby_value(ctx, ctx->args[%d], %d)", idx, idx);
            args[idx] = to_ruby_value(ctx, ctx->argtype[idx], ctx->args[idx], idx);
            trace(ctx, 2, "after to_ruby_value(ctx, ctx->args[%d], %d) => %p", idx, idx, args[idx]);
        }
        trace(ctx, 1, "before calling %s method", ctx->meth);
        obj = rb_funcall2(obj, rb_intern(ctx->meth), idx, args);
        trace(ctx, 1, "after calling %s method", ctx->meth);
    }
    return to_return_value(ctx, obj);
}

static VALUE to_utf8(UChar *ustr, int32_t ulen) {
    char buffer[BUF_SIZE];
    int32_t len = 0;
    UErrorCode status = U_ZERO_ERROR;

    /* Figure out the size of the buffer we need to allocate: */
    u_strToUTF8(buffer, 0, &len, ustr, ulen, &status);
    if (status == U_INVALID_CHAR_FOUND)
        len = 0;
    else if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR)
        return Qnil;

    /* Allocate the buffer and encode into it: */
    status = U_ZERO_ERROR;
    char *ptr = ALLOC_N(char, len);
    u_strToUTF8(ptr, len, &len, ustr, ulen, &status);
    if (U_FAILURE(status)) {
        xfree(ptr);
        return Qnil;
    }

    VALUE str = rb_enc_str_new(ptr, len, rb_utf8_encoding());
    xfree(ptr);
    return str;
;
}

VALUE wrap< wxString >(const wxString &st )
{
#ifdef HAVE_RUBY_ENCODING_H
	return rb_enc_str_new(st.c_str(),strlen(st.c_str()),rb_utf8_encoding());
#else
	return rb_str_new2(st.c_str());
#endif
}

VALUE rb_utf8_str_new(const char *str, long len)
{
#ifdef RUBY_ENCODING_H
    return rb_enc_str_new(str, len, rb_enc_find("UTF-8"));
#else
    return rb_str_new(str, len);
#endif
}

static VALUE cfstring_to_rb_string(CFStringRef s){
  if(CFStringGetTypeID() != CFGetTypeID(s)){
    rb_raise(rb_eTypeError, "Non cfstring passed to cfstring_to_rb_string");
  }
  const char * fastBuffer = CFStringGetCStringPtr(s, kCFStringEncodingUTF8);
  if(fastBuffer){
    return rb_enc_str_new(fastBuffer, strlen(fastBuffer), rb_utf8_encoding());
  }else{
    CFIndex bufferLength = CFStringGetMaximumSizeForEncoding(CFStringGetLength(s),kCFStringEncodingUTF8);
    char * buffer = malloc(bufferLength);
    CFIndex used = 0;
    CFStringGetBytes(s,CFRangeMake(0, CFStringGetLength(s)), kCFStringEncodingUTF8, 0, false, (UInt8*)buffer, bufferLength, &used);
    VALUE rb_string = rb_enc_str_new(buffer, used, rb_utf8_encoding());
    free(buffer);
    return rb_string;
  }
}

/*
 *  call-seq:
 *    commit.to_mbox(options = {}) -> str
 *
 *  Returns +commit+'s contents formatted to resemble UNIX mailbox format.
 *
 *  Does not (yet) support merge commits.
 *
 *  The following options can be passed in the +options+ Hash:
 *
 *  :patch_no ::
 *    Number for this patch in the series. Defaults to +1+.
 *
 *  :total_patches ::
 *    Total number of patches in the series. Defaults to +1+.
 *
 *  :exclude_subject_patch_marker ::
 *    If set to true, no "[PATCH]" marker will be
 *    added to the beginning of the subject line.
 *
 *  Additionally, you can also pass the same options as for Rugged::Tree#diff.
 */
static VALUE rb_git_commit_to_mbox(int argc, VALUE *argv, VALUE self)
{
	git_buf email_patch = { NULL };
	git_repository *repo;
	git_commit *commit;
	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
	git_diff_format_email_flags_t flags = GIT_DIFF_FORMAT_EMAIL_NONE;

	VALUE rb_repo = rugged_owner(self), rb_email_patch = Qnil, rb_val, rb_options;

	int error;
	size_t patch_no = 1, total_patches = 1;

	rb_scan_args(argc, argv, ":", &rb_options);

	rugged_check_repo(rb_repo);
	Data_Get_Struct(rb_repo, git_repository, repo);

	Data_Get_Struct(self, git_commit, commit);

	if (!NIL_P(rb_options)) {
		Check_Type(rb_options, T_HASH);

		rb_val = rb_hash_aref(rb_options, CSTR2SYM("patch_no"));
		if (!NIL_P(rb_val))
			patch_no = NUM2INT(rb_val);

		rb_val = rb_hash_aref(rb_options, CSTR2SYM("total_patches"));
		if (!NIL_P(rb_val))
			total_patches = NUM2INT(rb_val);

		if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("exclude_subject_patch_marker"))))
			flags |= GIT_DIFF_FORMAT_EMAIL_EXCLUDE_SUBJECT_PATCH_MARKER;

		rugged_parse_diff_options(&opts, rb_options);
	}

	error = git_diff_commit_as_email(
		&email_patch,
		repo,
		commit,
		patch_no,
		total_patches,
		flags,
		&opts);

	if (error) goto cleanup;

	rb_email_patch = rb_enc_str_new(email_patch.ptr, email_patch.size, rb_utf8_encoding());

	cleanup:

	xfree(opts.pathspec.strings);
	git_buf_free(&email_patch);
	rugged_exception_check(error);

	return rb_email_patch;
}

// s, len is the raw kv string
static void _cookie_kv(VALUE output, const char* s, long len) {
  // strip
  for (; len > 0; len--, s++) {
    if (!isspace(*s)) {
      break;
    }
  }
  for (; len > 0; len--) {
    if (!isspace(s[len - 1])) {
      break;
    }
  }
  if (len > 0) {
    volatile VALUE key = rb_enc_str_new("", 0, u8_encoding);
    volatile VALUE value = rb_enc_str_new("", 0, u8_encoding);
    nyara_decode_uri_kv(key, value, s, len);
    rb_hash_aset(output, key, value);
  }
}

static VALUE rb_keychain_path(VALUE self){
  SecKeychainRef keychain=NULL;
  Data_Get_Struct(self, struct OpaqueSecKeychainRef, keychain);
  UInt32 pathLength = PATH_MAX;
  char path[PATH_MAX];
  OSStatus result = SecKeychainGetPath(keychain, &pathLength, path);

  CheckOSStatusOrRaise(result);
  return rb_enc_str_new(path, pathLength, rb_utf8_encoding());
}

static int on_header_field(http_parser* parser, const char* s, size_t len) {
  Request* p = (Request*)parser;
  if (p->last_field == Qnil) {
    p->last_field = rb_enc_str_new(s, len, u8_encoding);
    p->last_value = Qnil;
  } else {
    rb_str_cat(p->last_field, s, len);
  }
  return 0;
}