#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <ctype.h>
#include <stdio.h>

#include "ant.h"
#include "errors.h"
#include "runtime.h"
#include "internal.h"
#include "common.h"
#include "descriptors.h"

#include "modules/blob.h"
#include "modules/buffer.h"
#include "modules/assert.h"
#include "modules/abort.h"
#include "modules/formdata.h"
#include "modules/headers.h"
#include "modules/multipart.h"
#include "modules/request.h"
#include "modules/symbol.h"
#include "modules/url.h"
#include "modules/json.h"
#include "streams/pipes.h"
#include "streams/readable.h"

ant_value_t g_request_proto = 0;

static request_data_t *get_data(ant_value_t obj) {
  ant_value_t slot = js_get_slot(obj, SLOT_DATA);
  if (vtype(slot) != T_NUM) return NULL;
  return (request_data_t *)(uintptr_t)(size_t)js_getnum(slot);
}

request_data_t *request_get_data(ant_value_t obj) {
  return get_data(obj);
}

ant_value_t request_get_headers(ant_value_t obj) {
  return js_get_slot(obj, SLOT_REQUEST_HEADERS);
}

ant_value_t request_get_signal(ant_t *js, ant_value_t obj) {
  ant_value_t signal = js_get_slot(obj, SLOT_REQUEST_SIGNAL);

  if (vtype(signal) != T_UNDEF) return signal;
  signal = abort_signal_create_dependent(js, js_mkundef());
  
  if (is_err(signal)) return signal;
  ant_value_t abort_reason = js_get_slot(obj, SLOT_REQUEST_ABORT_REASON);
  
  if (vtype(abort_reason) != T_UNDEF) signal_do_abort(js, signal, abort_reason);
  js_set_slot_wb(js, obj, SLOT_REQUEST_SIGNAL, signal);
  
  return signal;
}

static void data_free(request_data_t *d) {
  if (!d) return;
  free(d->method);
  url_state_clear(&d->url);
  free(d->referrer);
  free(d->referrer_policy);
  free(d->mode);
  free(d->credentials);
  free(d->cache);
  free(d->redirect);
  free(d->integrity);
  free(d->body_data);
  free(d->body_type);
  free(d);
}

static request_data_t *data_new_with(const char *method, const char *mode) {
  request_data_t *d = calloc(1, sizeof(request_data_t));
  if (!d) return NULL;

  d->method = strdup(method ? method : "GET");
  d->referrer = strdup("client");
  d->referrer_policy = strdup("");
  d->mode = strdup(mode);
  d->credentials = strdup("same-origin");
  d->cache = strdup("default");
  d->redirect = strdup("follow");
  d->integrity = strdup("");
  
  if (!d->method
    || !d->referrer
    || !d->referrer_policy
    || !d->mode
    || !d->credentials
    || !d->cache
    || !d->redirect
    || !d->integrity
  ) { data_free(d); return NULL; }

  return d;
}

static request_data_t *data_new(void) { return data_new_with("GET", "cors"); }
static request_data_t *data_new_server(const char *method) { return data_new_with(method, "same-origin"); }

static ant_value_t request_create_object(ant_t *js, request_data_t *req, ant_value_t headers_obj, bool create_signal) {
  ant_value_t obj = js_mkobj(js);
  ant_value_t hdrs = is_object_type(headers_obj)
    ? headers_obj
    : headers_create_empty(js);

  js_set_proto_init(obj, g_request_proto);
  js_set_slot(obj, SLOT_BRAND, js_mknum(BRAND_REQUEST));
  js_set_slot(obj, SLOT_DATA, ANT_PTR(req));

  headers_set_guard(hdrs,
    strcmp(req->mode, "no-cors") == 0
    ? HEADERS_GUARD_REQUEST_NO_CORS
    : HEADERS_GUARD_REQUEST
  );

  headers_apply_guard(hdrs);
  js_set_slot_wb(js, obj, SLOT_REQUEST_HEADERS, hdrs);
  js_set_slot(obj, SLOT_REQUEST_ABORT_REASON, js_mkundef());
  
  js_set_slot_wb(js, obj, SLOT_REQUEST_SIGNAL, create_signal 
    ? abort_signal_create_dependent(js, js_mkundef()) 
    : js_mkundef()
  );
  
  return obj;
}

static char *request_build_server_base_url(const char *host, const char *server_hostname, int server_port) {
  const char *authority = (host && host[0]) ? host : server_hostname;
  size_t authority_len = authority ? strlen(authority) : 0;
  bool include_port = (!host || !host[0]) && server_port > 0 && server_port != 80;
  size_t cap = sizeof("http://") - 1 + authority_len + 1 + 16 + 1;
  
  char *base = malloc(cap);
  int written = 0;

  if (!base) return NULL;
  if (include_port) written = snprintf(base, cap, "http://%s:%d/", authority ? authority : "", server_port);
  else written = snprintf(base, cap, "http://%s/", authority ? authority : "");
  
  if (written < 0 || (size_t)written >= cap) {
    free(base);
    return NULL;
  }

  return base;
}

static int request_parse_server_url(
  const char *target,
  bool absolute_target,
  const char *host,
  const char *server_hostname,
  int server_port,
  url_state_t *out
) {
  char *base = NULL;
  int rc = 0;

  if (absolute_target)
    return parse_url_to_state(target, NULL, out);

  base = request_build_server_base_url(host, server_hostname, server_port);
  if (!base) return -1;
  
  rc = parse_url_to_state(target, base, out);
  free(base);
  
  return rc;
}

static request_data_t *data_dup(const request_data_t *src) {
  request_data_t *d = calloc(1, sizeof(request_data_t));
  if (!d) return NULL;

#define DUP_STR(f) do { d->f = src->f ? strdup(src->f) : NULL; } while(0)
  DUP_STR(method);
  DUP_STR(referrer);
  DUP_STR(referrer_policy);
  DUP_STR(mode);
  DUP_STR(credentials);
  DUP_STR(cache);
  DUP_STR(redirect);
  DUP_STR(integrity);
  DUP_STR(body_type);
#undef DUP_STR
  url_state_t *su = (url_state_t *)&src->url;
  url_state_t *du = &d->url;
#define DUP_US(f) do { du->f = su->f ? strdup(su->f) : NULL; } while(0)
  DUP_US(protocol); DUP_US(username); DUP_US(password);
  DUP_US(hostname); DUP_US(port);     DUP_US(pathname);
  DUP_US(search);   DUP_US(hash);
#undef DUP_US
  d->keepalive         = src->keepalive;
  d->reload_navigation = src->reload_navigation;
  d->history_navigation = src->history_navigation;
  d->has_body          = src->has_body;
  d->body_is_stream    = src->body_is_stream;
  d->body_used         = src->body_used;
  d->body_size         = src->body_size;

  if (src->body_data && src->body_size > 0) {
    d->body_data = malloc(src->body_size);
    if (!d->body_data) { data_free(d); return NULL; }
    memcpy(d->body_data, src->body_data, src->body_size);
  }

  return d;
}

static bool is_token_char(unsigned char c) {
  if (c == 0 || c > 127) return false;
  static const char *delimiters = "(),/:;<=>?@[\\]{}\"";
  return c > 32 && !strchr(delimiters, (char)c);
}

static bool is_valid_method(const char *m) {
  if (!m || !*m) return false;
  for (const unsigned char *p = (const unsigned char *)m; *p; p++)
    if (!is_token_char(*p)) return false;
  return true;
}

static bool is_forbidden_method(const char *m) {
  return 
    strcasecmp(m, "CONNECT") == 0 ||
    strcasecmp(m, "TRACE")   == 0 ||
    strcasecmp(m, "TRACK")   == 0;
}

static bool is_cors_safelisted_method(const char *m) {
  return 
    strcasecmp(m, "GET")  == 0 ||
    strcasecmp(m, "HEAD") == 0 ||
    strcasecmp(m, "POST") == 0;
}

static void normalize_method(char *m) {
  static const char *norm[] = { 
    "DELETE","GET","HEAD","OPTIONS","POST","PUT" 
  };
  
  for (int i = 0; i < 6; i++) {
  if (strcasecmp(m, norm[i]) == 0) {
    strcpy(m, norm[i]);
    return;
  }}
}

static ant_value_t request_rejection_reason(ant_t *js, ant_value_t value) {
  if (!is_err(value)) return value;
  ant_value_t reason = js->thrown_exists ? js->thrown_value : value;
  js->thrown_exists = false;
  js->thrown_value = js_mkundef();
  js->thrown_stack = js_mkundef();
  return reason;
}

static const char *request_effective_body_type(ant_t *js, ant_value_t req_obj, request_data_t *d) {
  ant_value_t headers = js_get_slot(req_obj, SLOT_REQUEST_HEADERS);
  if (!headers_is_headers(headers)) return d ? d->body_type : NULL;
  ant_value_t ct = headers_get_value(js, headers, "content-type");
  if (vtype(ct) == T_STR) return js_getstr(js, ct, NULL);
  return d ? d->body_type : NULL;
}

static bool copy_body_bytes(
  ant_t *js, const uint8_t *src, size_t src_len,
  uint8_t **out_data, size_t *out_size, ant_value_t *err_out
) {
  uint8_t *buf = NULL;

  *out_data = NULL;
  *out_size = 0;
  if (src_len == 0) return true;

  buf = malloc(src_len);
  if (!buf) {
    *err_out = js_mkerr(js, "out of memory");
    return false;
  }

  memcpy(buf, src, src_len);
  *out_data = buf;
  *out_size = src_len;
  return true;
}

static bool extract_buffer_source_body(
  ant_t *js, ant_value_t body_val,
  uint8_t **out_data, size_t *out_size, ant_value_t *err_out
) {
  const uint8_t *src = NULL;
  size_t src_len = 0;

  if (!((
    vtype(body_val) == T_TYPEDARRAY || vtype(body_val) == T_OBJ) &&
    buffer_source_get_bytes(js, body_val, &src, &src_len))
  ) return false;

  return copy_body_bytes(js, src, src_len, out_data, out_size, err_out);
}

static bool extract_stream_body(
  ant_t *js, ant_value_t body_val,
  ant_value_t *out_stream, ant_value_t *err_out
) {
  if (!rs_is_stream(body_val)) return false;
  if (rs_stream_unusable(body_val)) {
    *err_out = js_mkerr_typed(js, JS_ERR_TYPE, "body stream is disturbed or locked");
    return false;
  }

  *out_stream = body_val;
  return true;
}

static bool extract_blob_body(
  ant_t *js, ant_value_t body_val,
  uint8_t **out_data, size_t *out_size, char **out_type, ant_value_t *err_out
) {
  blob_data_t *bd = blob_is_blob(js, body_val) ? blob_get_data(body_val) : NULL;
  if (!bd) return false;

  if (!copy_body_bytes(js, bd->data, bd->size, out_data, out_size, err_out)) return false;
  if (bd->type && bd->type[0]) *out_type = strdup(bd->type);
  
  return true;
}

static bool extract_urlsearchparams_body(
  ant_t *js, ant_value_t body_val,
  uint8_t **out_data, size_t *out_size, char **out_type
) {
  char *serialized = NULL;
  if (!usp_is_urlsearchparams(js, body_val)) return false;

  serialized = usp_serialize(js, body_val);
  if (serialized) {
    *out_data = (uint8_t *)serialized;
    *out_size = strlen(serialized);
    *out_type = strdup("application/x-www-form-urlencoded;charset=UTF-8");
  }
  
  return true;
}

static bool extract_formdata_body(
  ant_t *js, ant_value_t body_val,
  uint8_t **out_data, size_t *out_size, char **out_type, ant_value_t *err_out
) {
  char *boundary = NULL;
  char *content_type = NULL;
  size_t mp_size = 0;
  uint8_t *mp = NULL;

  if (!formdata_is_formdata(js, body_val)) return false;
  mp = formdata_serialize_multipart(js, body_val, &mp_size, &boundary);
  
  if (!mp) {
    *err_out = js_mkerr(js, "out of memory");
    return false;
  }

  if (mp_size > 0) *out_data = mp;
  else free(mp);

  *out_size = mp_size;
  if (boundary) {
    size_t ct_len = snprintf(NULL, 0, "multipart/form-data; boundary=%s", boundary);
    content_type = malloc(ct_len + 1);
    if (!content_type) {
      free(boundary);
      if (mp_size > 0) free(mp);
      *out_data = NULL;
      *out_size = 0;
      *err_out = js_mkerr(js, "out of memory");
      return false;
    }
    snprintf(content_type, ct_len + 1, "multipart/form-data; boundary=%s", boundary);
    free(boundary);
    *out_type = content_type;
  }

  return true;
}

static bool extract_string_body(
  ant_t *js, ant_value_t body_val,
  uint8_t **out_data, size_t *out_size, char **out_type, ant_value_t *err_out
) {
  size_t len = 0;
  const char *s = NULL;

  if (vtype(body_val) != T_STR) {
  body_val = js_tostring_val(js, body_val);
  if (is_err(body_val)) {
    *err_out = body_val;
    return false;
  }}

  s = js_getstr(js, body_val, &len);
  if (!copy_body_bytes(js, (const uint8_t *)s, len, out_data, out_size, err_out)) return false;
  *out_type = strdup("text/plain;charset=UTF-8");
  
  return true;
}

static bool extract_body(
  ant_t *js, ant_value_t body_val,
  uint8_t **out_data, size_t *out_size, char **out_type,
  ant_value_t *out_stream, ant_value_t *err_out
) {
  *out_data   = NULL;
  *out_size   = 0;
  *out_type   = NULL;
  *out_stream = js_mkundef();
  *err_out    = js_mkundef();

  if (vtype(body_val) == T_NULL || vtype(body_val) == T_UNDEF) return true;
  if (extract_buffer_source_body(js, body_val, out_data, out_size, err_out)) return true;
  if (vtype(body_val) == T_OBJ && rs_is_stream(body_val)) return extract_stream_body(js, body_val, out_stream, err_out);
  if (vtype(body_val) == T_OBJ && extract_blob_body(js, body_val, out_data, out_size, out_type, err_out)) return true;
  if (vtype(body_val) == T_OBJ && extract_urlsearchparams_body(js, body_val, out_data, out_size, out_type)) return true;
  if (vtype(body_val) == T_OBJ && extract_formdata_body(js, body_val, out_data, out_size, out_type, err_out)) return true;
  
  return extract_string_body(js, body_val, out_data, out_size, out_type, err_out);
}

enum { 
  BODY_TEXT = 0,
  BODY_JSON,
  BODY_ARRAYBUFFER,
  BODY_BLOB,
  BODY_BYTES,
  BODY_FORMDATA
};

static void resolve_body_promise(
  ant_t *js, ant_value_t promise,
  const uint8_t *data, size_t size,
  const char *body_type, int mode, bool has_body
) {
  switch (mode) {
  case BODY_TEXT: {
    ant_value_t str = (data && size > 0)
      ? js_mkstr(js, (const char *)data, size)
      : js_mkstr(js, "", 0);
    js_resolve_promise(js, promise, str);
    break;
  }
  case BODY_JSON: {
    ant_value_t str = (data && size > 0)
      ? js_mkstr(js, (const char *)data, size)
      : js_mkstr(js, "", 0);
    ant_value_t parsed = json_parse_value(js, str);
    if (is_err(parsed)) js_reject_promise(js, promise, request_rejection_reason(js, parsed));
    else js_resolve_promise(js, promise, parsed);
    break;
  }
  case BODY_ARRAYBUFFER: {
    ArrayBufferData *ab = create_array_buffer_data(size);
    if (!ab) { js_reject_promise(js, promise, js_mkerr(js, "out of memory")); break; }
    if (data && size > 0) memcpy(ab->data, data, size);
    js_resolve_promise(js, promise, create_arraybuffer_obj(js, ab));
    break;
  }
  case BODY_BLOB: {
    const char *type = body_type ? body_type : "";
    js_resolve_promise(js, promise, blob_create(js, data, size, type));
    break;
  }
  case BODY_BYTES: {
    ArrayBufferData *ab = create_array_buffer_data(size);
    if (!ab) { js_reject_promise(js, promise, js_mkerr(js, "out of memory")); break; }
    if (data && size > 0) memcpy(ab->data, data, size);
    js_resolve_promise(js, promise,
      create_typed_array(js, TYPED_ARRAY_UINT8, ab, 0, size, "Uint8Array"));
    break;
  }
  case BODY_FORMDATA: {
    ant_value_t fd = formdata_parse_body(js, data, size, body_type, has_body);
    if (is_err(fd)) js_reject_promise(js, promise, request_rejection_reason(js, fd));
    else js_resolve_promise(js, promise, fd);
    break;
  }}
}

static uint8_t *concat_chunks(ant_t *js, ant_value_t chunks, size_t *out_size) {
  ant_offset_t n = js_arr_len(js, chunks);
  size_t total = 0;

  for (ant_offset_t i = 0; i < n; i++) {
  ant_value_t chunk = js_arr_get(js, chunks, i);
  if (vtype(chunk) == T_TYPEDARRAY) {
    TypedArrayData *ta = (TypedArrayData *)js_gettypedarray(chunk);
    if (ta && ta->buffer && !ta->buffer->is_detached) total += ta->byte_length;
  }}

  uint8_t *buf = total > 0 ? malloc(total) : NULL;
  if (total > 0 && !buf) return NULL;

  size_t pos = 0;
  for (ant_offset_t i = 0; i < n; i++) {
  ant_value_t chunk = js_arr_get(js, chunks, i);
  
  if (vtype(chunk) == T_TYPEDARRAY) {
  TypedArrayData *ta = (TypedArrayData *)js_gettypedarray(chunk);
  if (ta && ta->buffer && !ta->buffer->is_detached && ta->byte_length > 0) {
    memcpy(buf + pos, ta->buffer->data + ta->byte_offset, ta->byte_length);
    pos += ta->byte_length;
  }}}

  *out_size = pos;
  return buf;
}

static ant_value_t stream_body_read(ant_t *js, ant_value_t *args, int nargs);

static ant_value_t stream_body_rejected(ant_t *js, ant_value_t *args, int nargs) {
  ant_value_t state   = js_get_slot(js->current_func, SLOT_DATA);
  ant_value_t promise = js_get(js, state, "promise");
  ant_value_t reason  = (nargs > 0) ? args[0] : js_mkundef();
  js_reject_promise(js, promise, reason);
  return js_mkundef();
}

static void stream_schedule_next_read(ant_t *js, ant_value_t state, ant_value_t read_fn, ant_value_t reader) {
  ant_value_t next_p  = rs_default_reader_read(js, reader);
  ant_value_t fulfill = js_heavy_mkfun(js, stream_body_read, state);
  ant_value_t reject  = js_heavy_mkfun(js, stream_body_rejected, state);
  ant_value_t then_result = js_promise_then(js, next_p, fulfill, reject);
  promise_mark_handled(then_result);
}

static ant_value_t stream_body_read(ant_t *js, ant_value_t *args, int nargs) {
  ant_value_t state   = js_get_slot(js->current_func, SLOT_DATA);
  ant_value_t result  = (nargs > 0) ? args[0] : js_mkundef();
  ant_value_t promise = js_get(js, state, "promise");
  ant_value_t reader  = js_get(js, state, "reader");
  ant_value_t chunks  = js_get(js, state, "chunks");
  int mode            = (int)js_getnum(js_get(js, state, "mode"));

  ant_value_t done_val = js_get(js, result, "done");
  ant_value_t value    = js_get(js, result, "value");

  if (vtype(done_val) == T_BOOL && done_val == js_true) {
    size_t size = 0;
    uint8_t *data = concat_chunks(js, chunks, &size);
    ant_value_t type_v = js_get(js, state, "type");
    const char *body_type = (vtype(type_v) == T_STR) ? js_getstr(js, type_v, NULL) : NULL;
    resolve_body_promise(js, promise, data, size, body_type, mode, true);
    free(data);
    return js_mkundef();
  }

  if (vtype(value) != T_UNDEF && vtype(value) != T_NULL)
    js_arr_push(js, chunks, value);

  stream_schedule_next_read(js, state, js_mkundef(), reader);
  return js_mkundef();
}

static ant_value_t consume_body_from_stream(
  ant_t *js, ant_value_t stream,
  ant_value_t promise, int mode,
  const char *body_type
) {
  ant_value_t reader_args[1] = { stream };
  ant_value_t saved = js->new_target;
  
  js->new_target = g_reader_proto;
  ant_value_t reader = js_rs_reader_ctor(js, reader_args, 1);
  js->new_target = saved;
  
  if (is_err(reader)) { 
    js_reject_promise(js, promise, reader);
    return promise;
  }

  ant_value_t state = js_mkobj(js);
  js_set(js, state, "promise", promise);
  js_set(js, state, "reader",  reader);
  js_set(js, state, "chunks",  js_mkarr(js));
  js_set(js, state, "mode",    js_mknum(mode));
  js_set(js, state, "type",    body_type ? js_mkstr(js, body_type, strlen(body_type)) : js_mkundef());

  stream_schedule_next_read(js, state, js_mkundef(), reader);
  return promise;
}

static ant_value_t consume_body(ant_t *js, int mode) {
  ant_value_t this = js_getthis(js);
  request_data_t *d = get_data(this);
  ant_value_t promise = js_mkpromise(js);

  if (!d) {
    js_reject_promise(js, promise, request_rejection_reason(js,
      js_mkerr_typed(js, JS_ERR_TYPE, "Invalid Request object")));
    return promise;
  }
  
  if (!d->has_body) {
    resolve_body_promise(js, promise, NULL, 0, request_effective_body_type(js, this, d), mode, false);
    return promise;
  }
  
  if (d->body_used) {
    js_reject_promise(js, promise, request_rejection_reason(js,
      js_mkerr_typed(js, JS_ERR_TYPE, "body stream is disturbed or locked")));
    return promise;
  }
  
  d->body_used = true;
  ant_value_t stream = js_get_slot(this, SLOT_REQUEST_BODY_STREAM);
  if (rs_is_stream(stream) && d->body_is_stream)
    return consume_body_from_stream(js, stream, promise, mode, request_effective_body_type(js, this, d));
  resolve_body_promise(js, promise, d->body_data, d->body_size, request_effective_body_type(js, this, d), mode, true);
  
  return promise;
}

static ant_value_t js_req_text(ant_t *js, ant_value_t *args, int nargs) {
  return consume_body(js, BODY_TEXT);
}

static ant_value_t js_req_json(ant_t *js, ant_value_t *args, int nargs) {
  return consume_body(js, BODY_JSON);
}

static ant_value_t js_req_array_buffer(ant_t *js, ant_value_t *args, int nargs) {
  return consume_body(js, BODY_ARRAYBUFFER);
}

static ant_value_t js_req_blob(ant_t *js, ant_value_t *args, int nargs) {
  return consume_body(js, BODY_BLOB);
}

static ant_value_t js_req_bytes(ant_t *js, ant_value_t *args, int nargs) {
  return consume_body(js, BODY_BYTES);
}

static ant_value_t js_req_form_data(ant_t *js, ant_value_t *args, int nargs) {
  return consume_body(js, BODY_FORMDATA);
}

static ant_value_t request_set_extracted_body(
  ant_t *js, ant_value_t req_obj, ant_value_t headers, request_data_t *req,
  uint8_t *body_data, size_t body_size, char *body_type,
  ant_value_t body_stream, bool duplex_provided
) {
  free(req->body_data);
  free(req->body_type);

  req->body_data = body_data;
  req->body_size = body_size;
  req->body_type = body_type;
  req->body_is_stream = rs_is_stream(body_stream);
  req->has_body = true;

  if (!req->body_is_stream) {
    if (body_type && body_type[0]) headers_append_if_missing(headers, "content-type", body_type);
    return js_mkundef();
  }

  if (req->keepalive) {
    return js_mkerr_typed(js, JS_ERR_TYPE,
    "Failed to construct 'Request': keepalive cannot be used with a ReadableStream body");
  }
  if (!duplex_provided) {
    return js_mkerr_typed(js, JS_ERR_TYPE,
    "Failed to construct 'Request': duplex must be provided for a ReadableStream body");
  }

  js_set_slot_wb(js, req_obj, SLOT_REQUEST_BODY_STREAM, body_stream);
  if (body_type && body_type[0]) headers_append_if_missing(headers, "content-type", body_type);
  return js_mkundef();
}

static void request_clear_body(ant_t *js, ant_value_t req_obj, request_data_t *req) {
  free(req->body_data);
  free(req->body_type);
  req->body_data = NULL;
  req->body_size = 0;
  req->body_type = NULL;
  req->body_is_stream = false;
  req->has_body = false;
  js_set_slot_wb(js, req_obj, SLOT_REQUEST_BODY_STREAM, js_mkundef());
}

static ant_value_t request_copy_source_body(ant_t *js, ant_value_t req_obj, ant_value_t input, request_data_t *req, request_data_t *src) {
  ant_value_t src_stream = js_get_slot(input, SLOT_REQUEST_BODY_STREAM);

  if (src->body_used) {
    return js_mkerr_typed(js, JS_ERR_TYPE, "Cannot construct Request with unusable body");
  }

  if (rs_is_stream(src_stream) && rs_stream_unusable(src_stream)) {
    return js_mkerr_typed(js, JS_ERR_TYPE, "body stream is disturbed or locked");
  }

  if (!src->body_is_stream) {
    req->body_data = malloc(src->body_size);
    if (src->body_size > 0 && !req->body_data) return js_mkerr(js, "out of memory");
    if (src->body_size > 0) memcpy(req->body_data, src->body_data, src->body_size);
    req->body_size = src->body_size;
    req->body_type = src->body_type ? strdup(src->body_type) : NULL;
    req->body_is_stream = false;
    req->has_body = true;
    return js_mkundef();
  }

  if (!rs_is_stream(src_stream)) return js_mkundef();
  ant_value_t branches = readable_stream_tee(js, src_stream);
  
  if (is_err(branches)) return branches;
  if (vtype(branches) != T_ARR) {
    return js_mkerr_typed(js, JS_ERR_TYPE,
    "Failed to construct 'Request': tee() did not return branches");
  }

  js_set_slot_wb(js, req_obj, SLOT_REQUEST_BODY_STREAM, js_arr_get(js, branches, 1));
  req->body_is_stream = true;
  req->has_body = true;
  
  return js_mkundef();
}

#define REQ_GETTER_START(name)                                                    \
  static ant_value_t js_req_get_##name(ant_t *js, ant_value_t *args, int nargs) { \
    ant_value_t this = js_getthis(js);                                            \
    request_data_t *d = get_data(this);                                           \
    if (!d) return js_mkundef();

#define REQ_GETTER_END }

REQ_GETTER_START(method)
  return js_mkstr(js, d->method, strlen(d->method));
REQ_GETTER_END

REQ_GETTER_START(url)
  char *href = build_href(&d->url);
  if (!href) return js_mkstr(js, "", 0);
  ant_value_t ret = js_mkstr(js, href, strlen(href));
  free(href);
  return ret;
REQ_GETTER_END

REQ_GETTER_START(headers)
  return js_get_slot(this, SLOT_REQUEST_HEADERS);
REQ_GETTER_END

REQ_GETTER_START(destination)
  (void)d;
  return js_mkstr(js, "", 0);
REQ_GETTER_END

REQ_GETTER_START(referrer)
  if (!d->referrer || strcmp(d->referrer, "no-referrer") == 0)
    return js_mkstr(js, "", 0);
  if (strcmp(d->referrer, "client") == 0)
    return js_mkstr(js, "about:client", 12);
  return js_mkstr(js, d->referrer, strlen(d->referrer));
REQ_GETTER_END

REQ_GETTER_START(referrer_policy)
  const char *p = d->referrer_policy ? d->referrer_policy : "";
  return js_mkstr(js, p, strlen(p));
REQ_GETTER_END

REQ_GETTER_START(mode)
  return js_mkstr(js, d->mode, strlen(d->mode));
REQ_GETTER_END

REQ_GETTER_START(credentials)
  return js_mkstr(js, d->credentials, strlen(d->credentials));
REQ_GETTER_END

REQ_GETTER_START(cache)
  return js_mkstr(js, d->cache, strlen(d->cache));
REQ_GETTER_END

REQ_GETTER_START(redirect)
  return js_mkstr(js, d->redirect, strlen(d->redirect));
REQ_GETTER_END

REQ_GETTER_START(integrity)
  const char *ig = d->integrity ? d->integrity : "";
  return js_mkstr(js, ig, strlen(ig));
REQ_GETTER_END

REQ_GETTER_START(keepalive)
  return js_bool(d->keepalive);
REQ_GETTER_END

REQ_GETTER_START(is_reload_navigation)
  return js_bool(d->reload_navigation);
REQ_GETTER_END

REQ_GETTER_START(is_history_navigation)
  return js_bool(d->history_navigation);
REQ_GETTER_END

REQ_GETTER_START(signal)
  return request_get_signal(js, this);
REQ_GETTER_END

REQ_GETTER_START(duplex)
  return js_mkstr(js, "half", 4);
REQ_GETTER_END

static ant_value_t req_body_pull(ant_t *js, ant_value_t *args, int nargs) {
  ant_value_t req_obj = js_get_slot(js->current_func, SLOT_DATA);
  request_data_t *d = get_data(req_obj);
  ant_value_t ctrl = (nargs > 0) ? args[0] : js_mkundef();

  if (d && d->body_data && d->body_size > 0) {
  ArrayBufferData *ab = create_array_buffer_data(d->body_size);
  if (ab) {
    memcpy(ab->data, d->body_data, d->body_size);
    rs_controller_enqueue(js, ctrl,
    create_typed_array(js, TYPED_ARRAY_UINT8, ab, 0, d->body_size, "Uint8Array"));
  }}
  
  rs_controller_close(js, ctrl);
  return js_mkundef();
}

REQ_GETTER_START(body)
  if (!d->has_body) return js_mknull();
  ant_value_t stored_stream = js_get_slot(this, SLOT_REQUEST_BODY_STREAM);
  if (rs_is_stream(stored_stream)) return stored_stream;
  if (d->body_used) return js_mknull();
  ant_value_t pull = js_heavy_mkfun(js, req_body_pull, this);
  ant_value_t stream = rs_create_stream(js, pull, js_mkundef(), 1.0);
  if (!is_err(stream)) js_set_slot_wb(js, this, SLOT_REQUEST_BODY_STREAM, stream);
  return stream;
REQ_GETTER_END

REQ_GETTER_START(body_used)
  return js_bool(d->body_used);
REQ_GETTER_END

#undef REQ_GETTER_START
#undef REQ_GETTER_END

static ant_value_t request_inspect_finish(ant_t *js, ant_value_t this_obj, ant_value_t body_obj) {
  ant_value_t tag_val = js_get_sym(js, this_obj, get_toStringTag_sym());
  const char *tag = vtype(tag_val) == T_STR ? js_getstr(js, tag_val, NULL) : "Request";

  js_inspect_builder_t builder;
  if (!js_inspect_builder_init_dynamic(&builder, js, 128)) {
    return js_mkerr(js, "out of memory");
  }

  bool ok = js_inspect_header_for(&builder, body_obj, "%s", tag);
  if (ok) ok = js_inspect_object_body(&builder, body_obj);
  if (ok) ok = js_inspect_close(&builder);

  if (!ok) {
    js_inspect_builder_dispose(&builder);
    return js_mkerr(js, "out of memory");
  }

  return js_inspect_builder_result(&builder);
}

// TODO: make dry
static bool request_inspect_set(
  ant_t *js, ant_value_t obj, const char *key, 
  ant_value_t value, ant_value_t *err_out
) {
  if (is_err(value)) {
    *err_out = value;
    return false;
  }

  js_set(js, obj, key, value);
  return true;
}

static ant_value_t request_inspect(ant_t *js, ant_value_t *args, int nargs) {
  ant_value_t this_obj = js_getthis(js);
  ant_value_t out = js_mkobj(js);
  ant_value_t err = 0;

  if (!request_inspect_set(js, out, "method", js_req_get_method(js, NULL, 0), &err)) return err;
  if (!request_inspect_set(js, out, "url", js_req_get_url(js, NULL, 0), &err)) return err;
  if (!request_inspect_set(js, out, "headers", js_req_get_headers(js, NULL, 0), &err)) return err;
  if (!request_inspect_set(js, out, "destination", js_req_get_destination(js, NULL, 0), &err)) return err;
  if (!request_inspect_set(js, out, "referrer", js_req_get_referrer(js, NULL, 0), &err)) return err;
  if (!request_inspect_set(js, out, "referrerPolicy", js_req_get_referrer_policy(js, NULL, 0), &err)) return err;
  if (!request_inspect_set(js, out, "mode", js_req_get_mode(js, NULL, 0), &err)) return err;
  if (!request_inspect_set(js, out, "credentials", js_req_get_credentials(js, NULL, 0), &err)) return err;
  if (!request_inspect_set(js, out, "cache", js_req_get_cache(js, NULL, 0), &err)) return err;
  if (!request_inspect_set(js, out, "redirect", js_req_get_redirect(js, NULL, 0), &err)) return err;
  if (!request_inspect_set(js, out, "integrity", js_req_get_integrity(js, NULL, 0), &err)) return err;
  if (!request_inspect_set(js, out, "keepalive", js_req_get_keepalive(js, NULL, 0), &err)) return err;
  if (!request_inspect_set(js, out, "isReloadNavigation", js_req_get_is_reload_navigation(js, NULL, 0), &err)) return err;
  if (!request_inspect_set(js, out, "isHistoryNavigation", js_req_get_is_history_navigation(js, NULL, 0), &err)) return err;
  if (!request_inspect_set(js, out, "signal", js_req_get_signal(js, NULL, 0), &err)) return err;

  return request_inspect_finish(js, this_obj, out);
}

static ant_value_t js_request_clone(ant_t *js, ant_value_t *args, int nargs) {
  ant_value_t this = js_getthis(js);
  request_data_t *d = get_data(this);
  
  if (!d) return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid Request object");
  if (d->body_used)
    return js_mkerr_typed(js, JS_ERR_TYPE, "Cannot clone a Request whose body is unusable");

  request_data_t *nd = data_dup(d);
  if (!nd) return js_mkerr(js, "out of memory");

  ant_value_t src_headers = js_get_slot(this, SLOT_REQUEST_HEADERS);
  ant_value_t src_signal  = request_get_signal(js, this);

  ant_value_t new_headers = headers_create_empty(js);
  if (is_err(new_headers)) { data_free(nd); return new_headers; }
  
  headers_copy_from(js, new_headers, src_headers);
  headers_set_guard(new_headers,
    strcmp(nd->mode, "no-cors") == 0 
    ? HEADERS_GUARD_REQUEST_NO_CORS 
    : HEADERS_GUARD_REQUEST
  );
  headers_apply_guard(new_headers);

  ant_value_t new_signal = abort_signal_create_dependent(js, src_signal);
  if (is_err(new_signal)) { data_free(nd); return new_signal; }

  ant_value_t obj = js_mkobj(js);
  js_set_proto_init(obj, g_request_proto);
  js_set_slot(obj, SLOT_BRAND, js_mknum(BRAND_REQUEST));
  js_set_slot(obj, SLOT_DATA, ANT_PTR(nd));
  
  js_set_slot_wb(js, obj, SLOT_REQUEST_HEADERS, new_headers);
  js_set_slot(obj, SLOT_REQUEST_ABORT_REASON, js_mkundef());
  js_set_slot_wb(js, obj, SLOT_REQUEST_SIGNAL,  new_signal);

  ant_value_t src_stream = js_get_slot(this, SLOT_REQUEST_BODY_STREAM);
  if (rs_is_stream(src_stream)) {
  ant_value_t branches = readable_stream_tee(js, src_stream);
  if (!is_err(branches) && vtype(branches) == T_ARR) {
    ant_value_t b1 = js_arr_get(js, branches, 0);
    ant_value_t b2 = js_arr_get(js, branches, 1);
    js_set_slot_wb(js, this, SLOT_REQUEST_BODY_STREAM, b1);
    js_set_slot_wb(js, obj,  SLOT_REQUEST_BODY_STREAM, b2);
  }}

  return obj;
}

static const char *init_str(ant_t *js, ant_value_t init, const char *key, size_t klen, ant_value_t *err_out) {
  ant_value_t v = js_get(js, init, key);
  if (vtype(v) == T_UNDEF) return NULL;
  if (vtype(v) != T_STR) {
    v = js_tostring_val(js, v);
    if (is_err(v)) { *err_out = v; return NULL; }
  }
  return js_getstr(js, v, NULL);
}

static ant_value_t request_new_from_input(
  ant_t *js, ant_value_t input,
  request_data_t **out_req, request_data_t **out_src,
  ant_value_t *out_input_signal
) {
  request_data_t *req = NULL;
  request_data_t *src = NULL;

  *out_req = NULL;
  *out_src = NULL;
  *out_input_signal = js_mkundef();

  if (
    vtype(input) == T_OBJ && 
    js_check_brand(input, BRAND_REQUEST)
  ) src = get_data(input);

  if (!src) {
    size_t ulen = 0;
    const char *url_str = NULL;
    url_state_t parsed = {0};

    if (vtype(input) != T_STR) {
      input = js_tostring_val(js, input);
      if (is_err(input)) return input;
    }

    url_str = js_getstr(js, input, &ulen);
    if (parse_url_to_state(url_str, NULL, &parsed) != 0) {
      url_state_clear(&parsed);
      return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to construct 'Request': Invalid URL");
    }
    
    if ((parsed.username && parsed.username[0]) || (parsed.password && parsed.password[0])) {
      url_state_clear(&parsed);
      return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to construct 'Request': URL includes credentials");
    }

    req = data_new();
    if (!req) {
      url_state_clear(&parsed);
      return js_mkerr(js, "out of memory");
    }
    
    req->url = parsed;
  } else {
    req = data_dup(src);
    if (!req) return js_mkerr(js, "out of memory");
    req->body_used = false;
    *out_input_signal = request_get_signal(js, input);
  }

  *out_req = req;
  *out_src = src;
  return js_mkundef();
}

static ant_value_t request_apply_init_options(
  ant_t *js, ant_value_t init, request_data_t *req, ant_value_t *input_signal
) {
  ant_value_t err = js_mkundef();
  ant_value_t win = js_get(js, init, "window");
  
  const char *ref = NULL;
  const char *rp = NULL;
  const char *mode_val = NULL;
  const char *cred = NULL;
  const char *cache_val = NULL;
  const char *redir = NULL;
  const char *integ = NULL;
  const char *method_val = NULL;

  if (vtype(win) != T_UNDEF && vtype(win) != T_NULL) {
    return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to construct 'Request': 'window' must be null");
  }

  if (strcmp(req->mode, "navigate") == 0) {
    free(req->mode);
    req->mode = strdup("same-origin");
  }
  
  req->reload_navigation = false;
  req->history_navigation = false;
  free(req->referrer);
  req->referrer = strdup("client");
  free(req->referrer_policy);
  req->referrer_policy = strdup("");

  ref = init_str(js, init, "referrer", 8, &err);
  if (is_err(err)) return err;
  
  if (ref) {
  if (ref[0] == '\0') {
    free(req->referrer);
    req->referrer = strdup("no-referrer");
  } else {
    url_state_t rs = {0};
    if (parse_url_to_state(ref, NULL, &rs) != 0) {
      url_state_clear(&rs);
      return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to construct 'Request': Invalid referrer URL");
    }
    free(req->referrer);
    req->referrer = build_href(&rs);
    url_state_clear(&rs);
    if (!req->referrer) req->referrer = strdup("client");
  }}

  rp = init_str(js, init, "referrerPolicy", 14, &err);
  if (is_err(err)) return err;
  if (rp) {
    free(req->referrer_policy);
    req->referrer_policy = strdup(rp);
  }

  mode_val = init_str(js, init, "mode", 4, &err);
  if (is_err(err)) return err;
  if (mode_val) {
    if (strcmp(mode_val, "navigate") == 0) {
      return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to construct 'Request': mode 'navigate' is not allowed");
    }
    free(req->mode);
    req->mode = strdup(mode_val);
  }

  cred = init_str(js, init, "credentials", 11, &err);
  if (is_err(err)) return err;
  if (cred) {
    free(req->credentials);
    req->credentials = strdup(cred);
  }

  cache_val = init_str(js, init, "cache", 5, &err);
  if (is_err(err)) return err;
  
  if (cache_val) {
    free(req->cache);
    req->cache = strdup(cache_val);
    if (
      strcmp(req->cache, "only-if-cached") == 0 &&
      strcmp(req->mode, "same-origin") != 0
    ) return js_mkerr_typed(js, JS_ERR_TYPE,
      "Failed to construct 'Request': cache mode 'only-if-cached' requires mode 'same-origin'");
  }

  redir = init_str(js, init, "redirect", 8, &err);
  if (is_err(err)) return err;
  
  if (redir) {
    free(req->redirect);
    req->redirect = strdup(redir);
  }

  integ = init_str(js, init, "integrity", 9, &err);
  if (is_err(err)) return err;
  
  if (integ) {
    free(req->integrity);
    req->integrity = strdup(integ);
  }

  ant_value_t ka = js_get(js, init, "keepalive");
  if (vtype(ka) != T_UNDEF) req->keepalive = js_truthy(js, ka);

  method_val = init_str(js, init, "method", 6, &err);
  if (is_err(err)) return err;
  
  if (method_val) {
    if (!is_valid_method(method_val)) {
      return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to construct 'Request': Invalid method");
    }
    if (is_forbidden_method(method_val)) {
      return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to construct 'Request': Forbidden method");
    }
    
    free(req->method);
    req->method = strdup(method_val);
    normalize_method(req->method);
  }

  ant_value_t sig_val = js_get(js, init, "signal");
  if (vtype(sig_val) == T_UNDEF) return js_mkundef();
  
  if (vtype(sig_val) == T_NULL) {
    *input_signal = js_mkundef();
    return js_mkundef();
  }
  
  if (abort_signal_is_signal(sig_val)) {
    *input_signal = sig_val;
    return js_mkundef();
  }

  return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to construct 'Request': signal must be an AbortSignal");
}

static ant_value_t request_create_ctor_headers(ant_t *js, ant_value_t input) {
  ant_value_t headers = headers_create_empty(js);
  if (is_err(headers)) return headers;
  if (vtype(input) != T_OBJ) return headers;

  ant_value_t src_hdrs = js_get_slot(input, SLOT_REQUEST_HEADERS);
  headers_copy_from(js, headers, src_hdrs);
  return headers;
}

static ant_value_t request_apply_init_headers(ant_t *js, ant_value_t init, ant_value_t headers) {
  ant_value_t init_headers = js_get(js, init, "headers");
  if (vtype(init_headers) == T_UNDEF) return headers;
  return headers_create_from_init(js, init_headers);
}

static ant_value_t request_parse_duplex(ant_t *js, ant_value_t init, bool *out_duplex_provided) {
  ant_value_t duplex_val = js_get(js, init, "duplex");
  ant_value_t duplex_str_v = duplex_val;
  const char *duplex_str = NULL;

  *out_duplex_provided = vtype(duplex_val) != T_UNDEF;
  if (!*out_duplex_provided) return js_mkundef();

  if (vtype(duplex_str_v) != T_STR) {
    duplex_str_v = js_tostring_val(js, duplex_str_v);
    if (is_err(duplex_str_v)) return duplex_str_v;
  }

  duplex_str = js_getstr(js, duplex_str_v, NULL);
  if (duplex_str && strcmp(duplex_str, "half") == 0) return js_mkundef();

  return js_mkerr_typed(js, JS_ERR_TYPE,
    "Failed to construct 'Request': duplex must be 'half'");
}

static ant_value_t request_apply_ctor_body(
  ant_t *js, ant_value_t req_obj, ant_value_t input, ant_value_t init,
  bool init_provided, bool duplex_provided,
  request_data_t *req, request_data_t *src, ant_value_t headers
) {
  if (init_provided) {
    ant_value_t body_val = js_get(js, init, "body");
    bool init_body_present = vtype(body_val) != T_UNDEF;
    bool input_body_present = src && src->has_body;
    bool effective_body_present =
      (init_body_present && vtype(body_val) != T_NULL) ||
      (input_body_present && (!init_body_present || vtype(body_val) == T_NULL));

    if ((strcmp(req->method, "GET") == 0 || strcmp(req->method, "HEAD") == 0) && effective_body_present) {
      return js_mkerr_typed(js, JS_ERR_TYPE,
      "Failed to construct 'Request': Request with GET/HEAD method cannot have body");
    }

    if (vtype(body_val) == T_UNDEF) return js_mkundef();
    if (vtype(body_val) == T_NULL) {
      request_clear_body(js, req_obj, req);
      return js_mkundef();
    }

    request_data_t *init_req = get_data(init);
    ant_value_t body_err = js_mkundef();
    ant_value_t body_stream = js_mkundef();
    
    uint8_t *bd = NULL;
    size_t bs = 0;
    char *bt = NULL;
    
    if (init_req && !init_req->body_used && !init_req->body_is_stream && init_req->has_body) {
      bd = malloc(init_req->body_size);
      if (init_req->body_size > 0 && !bd) return js_mkerr(js, "out of memory");
      if (init_req->body_size > 0) memcpy(bd, init_req->body_data, init_req->body_size);
      bs = init_req->body_size;
      bt = init_req->body_type ? strdup(init_req->body_type) : NULL;
    } else if (!extract_body(js, body_val, &bd, &bs, &bt, &body_stream, &body_err)) 
      return is_err(body_err) ? body_err : js_mkerr(js, "Failed to extract body");
    
    return request_set_extracted_body(
      js, req_obj, headers, req, bd, 
      bs, bt, body_stream, duplex_provided
    );
  }

  if (!src) return js_mkundef();
  return request_copy_source_body(js, req_obj, input, req, src);
}

static ant_value_t js_request_ctor(ant_t *js, ant_value_t *args, int nargs) {
  ant_value_t init = (nargs >= 2 && vtype(args[1]) != T_UNDEF) ? args[1] : js_mkundef();

  if (vtype(js->new_target) == T_UNDEF)
    return js_mkerr_typed(js, JS_ERR_TYPE, "Request constructor requires 'new'");
  if (nargs < 1)
    return js_mkerr_typed(js, JS_ERR_TYPE, "Request constructor requires at least 1 argument");

  ant_value_t input  = args[0];
  ant_value_t obj = 0;
  ant_value_t proto = 0;
  bool init_provided = false;
  
  request_data_t *req = NULL;
  request_data_t *src = NULL;
  
  ant_value_t input_signal = js_mkundef();
  ant_value_t step = js_mkundef();
  ant_value_t signal = 0;
  ant_value_t headers = 0;
  
  bool duplex_provided = false;
  init_provided = (vtype(init) == T_OBJ || vtype(init) == T_ARR);
  
  step = request_new_from_input(js, input, &req, &src, &input_signal);
  if (is_err(step)) return step;

  if (init_provided) {
    step = request_apply_init_options(js, init, req, &input_signal);
    if (is_err(step)) { data_free(req); return step; }
  }

  if (
    strcmp(req->mode, "no-cors") == 0 &&
    !is_cors_safelisted_method(req->method)
  ) {
    data_free(req);
    return js_mkerr_typed(js, JS_ERR_TYPE,
    "Failed to construct 'Request': method must be one of GET, HEAD, POST for no-cors mode");
  }

  obj = js_mkobj(js);
  proto = js_instance_proto_from_new_target(js, g_request_proto);
  
  if (is_object_type(proto)) js_set_proto_init(obj, proto);
  else js_set_proto_init(obj, g_request_proto);
  
  js_set_slot(obj, SLOT_BRAND, js_mknum(BRAND_REQUEST));
  js_set_slot(obj, SLOT_DATA, ANT_PTR(req));
  js_set_slot(obj, SLOT_REQUEST_ABORT_REASON, js_mkundef());

  signal = abort_signal_create_dependent(js, input_signal);
  if (is_err(signal)) { data_free(req); return signal; }
  js_set_slot_wb(js, obj, SLOT_REQUEST_SIGNAL, signal);

  headers = request_create_ctor_headers(js, input);
  if (is_err(headers)) { data_free(req); return headers; }
  
  if (init_provided) {
    headers = request_apply_init_headers(js, init, headers);
    if (is_err(headers)) { data_free(req); return headers; }
  }

  headers_set_guard(headers,
    strcmp(req->mode, "no-cors") == 0
    ? HEADERS_GUARD_REQUEST_NO_CORS
    : HEADERS_GUARD_REQUEST
  );
  
  headers_apply_guard(headers);
  js_set_slot_wb(js, obj, SLOT_REQUEST_HEADERS, headers);

  if (init_provided) {
    step = request_parse_duplex(js, init, &duplex_provided);
    if (is_err(step)) { data_free(req); return step; }
  }

  step = request_apply_ctor_body(
    js, obj, input, init, init_provided,
    duplex_provided, req, src, headers
  );
  
  if (is_err(step)) {
    data_free(req);
    return step;
  }

  if (src && src->has_body && !src->body_used)
    src->body_used = true;

  return obj;
}

ant_value_t request_create_from_input_init(ant_t *js, ant_value_t input, ant_value_t init) {
  bool init_provided = (vtype(init) == T_OBJ || vtype(init) == T_ARR);
  
  request_data_t *req = NULL;
  request_data_t *src = NULL;
  
  ant_value_t input_signal = js_mkundef();
  ant_value_t step = js_mkundef();
  ant_value_t obj = 0;
  ant_value_t signal = 0;
  ant_value_t headers = 0;
  
  bool duplex_provided = false;
  step = request_new_from_input(js, input, &req, &src, &input_signal);
  if (is_err(step)) return step;

  if (init_provided) {
    step = request_apply_init_options(js, init, req, &input_signal);
    if (is_err(step)) { data_free(req); return step; }
  }

  if (
    strcmp(req->mode, "no-cors") == 0 &&
    !is_cors_safelisted_method(req->method)
  ) {
    data_free(req);
    return js_mkerr_typed(js, JS_ERR_TYPE,
    "Failed to construct 'Request': method must be one of GET, HEAD, POST for no-cors mode");
  }

  obj = js_mkobj(js);
  js_set_proto_init(obj, g_request_proto);
  js_set_slot(obj, SLOT_BRAND, js_mknum(BRAND_REQUEST));
  js_set_slot(obj, SLOT_DATA, ANT_PTR(req));
  js_set_slot(obj, SLOT_REQUEST_ABORT_REASON, js_mkundef());

  signal = abort_signal_create_dependent(js, input_signal);
  if (is_err(signal)) { data_free(req); return signal; }
  js_set_slot_wb(js, obj, SLOT_REQUEST_SIGNAL, signal);

  headers = request_create_ctor_headers(js, input);
  if (is_err(headers)) { data_free(req); return headers; }
  
  if (init_provided) {
    headers = request_apply_init_headers(js, init, headers);
    if (is_err(headers)) { data_free(req); return headers; }
  }

  headers_set_guard(headers,
    strcmp(req->mode, "no-cors") == 0 
    ? HEADERS_GUARD_REQUEST_NO_CORS 
    : HEADERS_GUARD_REQUEST
  );
  headers_apply_guard(headers);
  js_set_slot_wb(js, obj, SLOT_REQUEST_HEADERS, headers);

  if (init_provided) {
    step = request_parse_duplex(js, init, &duplex_provided);
    if (is_err(step)) { data_free(req); return step; }
  }

  step = request_apply_ctor_body(js, obj, input, init, init_provided, duplex_provided, req, src, headers);
  if (is_err(step)) {
    data_free(req);
    return step;
  }

  if (src && src->has_body && !src->body_used)
    src->body_used = true;

  return obj;
}

ant_value_t request_create(ant_t *js,
    const char *method, const char *url,
    ant_value_t headers_obj, const uint8_t *body, size_t body_len,
    const char *body_type) {
  request_data_t *req = data_new();
  if (!req) return js_mkerr(js, "out of memory");

  free(req->method);
  req->method = strdup(method ? method : "GET");
  free(req->mode);
  req->mode = strdup("same-origin");

  url_state_t parsed = {0};
  if (url && parse_url_to_state(url, NULL, &parsed) == 0) req->url = parsed;
  else url_state_clear(&parsed);

  if (body) req->has_body = true;
  
  if (body && body_len > 0) {
    req->body_data = malloc(body_len);
    if (!req->body_data) { data_free(req); return js_mkerr(js, "out of memory"); }
    memcpy(req->body_data, body, body_len);
    req->body_size = body_len;
    req->body_type = body_type ? strdup(body_type) : NULL;
  }
  req->body_is_stream = false;
  return request_create_object(js, req, headers_obj, true);
}

ant_value_t request_create_server(
  ant_t *js,
  const char *method,
  const char *target,
  bool absolute_target,
  const char *host,
  const char *server_hostname,
  int server_port,
  ant_value_t headers_obj,
  const uint8_t *body,
  size_t body_len,
  const char *body_type
) {
  request_data_t *req = data_new_server(method);
  if (!req) return js_mkerr(js, "out of memory");

  if (target && request_parse_server_url(target, absolute_target, host, server_hostname, server_port, &req->url) != 0)
    url_state_clear(&req->url);

  if (body) req->has_body = true;

  if (body && body_len > 0) {
    req->body_data = malloc(body_len);
    if (!req->body_data) { data_free(req); return js_mkerr(js, "out of memory"); }
    memcpy(req->body_data, body, body_len);
    req->body_size = body_len;
    req->body_type = body_type ? strdup(body_type) : NULL;
  }
  req->body_is_stream = false;

  return request_create_object(js, req, headers_obj, false);
}

void init_request_module(void) {
  ant_t *js = rt->js;
  ant_value_t g = js_glob(js);
  g_request_proto = js_mkobj(js);

  js_set(js, g_request_proto, "text", js_mkfun(js_req_text));
  js_set(js, g_request_proto, "json", js_mkfun(js_req_json));
  js_set(js, g_request_proto, "arrayBuffer", js_mkfun(js_req_array_buffer));
  js_set(js, g_request_proto, "blob", js_mkfun(js_req_blob));
  js_set(js, g_request_proto, "formData", js_mkfun(js_req_form_data));
  js_set(js, g_request_proto, "bytes", js_mkfun(js_req_bytes));
  js_set(js, g_request_proto, "clone", js_mkfun(js_request_clone));

#define GETTER(prop, fn) \
  js_set_getter_desc(js, g_request_proto, prop, sizeof(prop)-1, js_mkfun(js_req_get_##fn), JS_DESC_C)
  GETTER("method",            method);
  GETTER("url",               url);
  GETTER("headers",           headers);
  GETTER("destination",       destination);
  GETTER("referrer",          referrer);
  GETTER("referrerPolicy",    referrer_policy);
  GETTER("mode",              mode);
  GETTER("credentials",       credentials);
  GETTER("cache",             cache);
  GETTER("redirect",          redirect);
  GETTER("integrity",         integrity);
  GETTER("keepalive",         keepalive);
  GETTER("isReloadNavigation",is_reload_navigation);
  GETTER("isHistoryNavigation",is_history_navigation);
  GETTER("signal",            signal);
  GETTER("duplex",            duplex);
  GETTER("body",              body);
  GETTER("bodyUsed",          body_used);
#undef GETTER

  js_set_sym(js, g_request_proto, get_inspect_sym(), js_mkfun(request_inspect));
  js_set_sym(js, g_request_proto, get_toStringTag_sym(), js_mkstr(js, "Request", 7));
  ant_value_t ctor = js_make_ctor(js, js_request_ctor, g_request_proto, "Request", 7);
  
  js_set(js, g, "Request", ctor);
  js_set_descriptor(js, g, "Request", 7, JS_DESC_W | JS_DESC_C);
}