#include <compat.h> // IWYU pragma: keep

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>

#include "ant.h"
#include "errors.h"
#include "internal.h"

#include "modules/blob.h"
#include "modules/formdata.h"
#include "modules/multipart.h"
#include "modules/url.h"

static ant_value_t multipart_invalid(ant_t *js) {
  return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to parse body as FormData");
}

static bool ct_is_type(const char *ct, const char *type) {
  size_t type_len = 0;

  if (!ct || !type) return false;

  while (*ct == ' ' || *ct == '\t') ct++;
  type_len = strlen(type);
  if (strncasecmp(ct, type, type_len) != 0) return false;

  ct += type_len;
  return *ct == '\0' || *ct == ';' || *ct == ' ' || *ct == '\t';
}

static const char *ct_find_next_param(const char *p) {
scan:
  if (*p == '\0') return NULL;
  if (*p == ';') return p;
  if (*p != '"') {
    p++;
    goto scan;
  }

quoted:
  p++;
  if (*p == '\0') return NULL;
  if (*p == '\\') goto escaped;
  if (*p == '"') {
    p++;
    goto scan;
  }
  goto quoted;

escaped:
  p++;
  if (*p == '\0') return NULL;
  p++;
  goto quoted;
}

static char *ct_get_param_dup(const char *ct, const char *name) {
  const char *p = NULL;
  const char *param_name = NULL;
  const char *param_name_end = NULL;
  
  char *buf = NULL;
  size_t name_len = 0;
  size_t len = 0;
  size_t cap = 0;
  char ch = '\0';

  if (!ct || !name) return NULL;

  name_len = strlen(name);
  if (name_len == 0) return NULL;

  p = strchr(ct, ';');

next_param:
  if (!p) return NULL;
  p++;

  while (*p == ' ' || *p == '\t') p++;
  if (*p == '\0') return NULL;

  param_name = p;
  while (*p && *p != '=' && *p != ';') p++;
  param_name_end = p;

  while (
    param_name_end > param_name &&
    (param_name_end[-1] == ' ' || param_name_end[-1] == '\t')
  ) param_name_end--;

  if (*p != '=') goto skip_param;
  if ((size_t)(param_name_end - param_name) != name_len) goto skip_param;
  if (strncasecmp(param_name, name, name_len) != 0) goto skip_param;

  p++;
  while (*p == ' ' || *p == '\t') p++;
  if (*p == '\0') return strdup("");

  if (*p == '"') {
    p++;
    goto quoted;
  }

unquoted:
  if (*p == '\0' || *p == ';' || *p == ' ' || *p == '\t') {
    buf = malloc(len + 1);
    if (!buf) return NULL;
    if (len != 0) memcpy(buf, p - len, len);
    buf[len] = '\0';
    return buf;
  }
  p++;
  len++;
  goto unquoted;

quoted:
  if (*p == '\0') goto fail;
  if (*p == '"') goto done;
  if (*p == '\\') goto quoted_escape;
  ch = *p++;
  goto append;

quoted_escape:
  p++;
  if (*p == '\0') goto fail;
  ch = *p++;
  goto append;

append:
  if (len == cap) {
    size_t next_cap = cap ? cap * 2 : 32;
    char *next = realloc(buf, next_cap);
    if (!next) goto fail;
    buf = next;
    cap = next_cap;
  }
  buf[len++] = ch;
  goto quoted;

done:
  p++;
  if (len == cap) {
    size_t next_cap = cap ? cap + 1 : 1;
    char *next = realloc(buf, next_cap);
    if (!next) goto fail;
    buf = next;
    cap = next_cap;
  }
  buf[len] = '\0';
  return buf;

skip_param:
  p = ct_find_next_param(p);
  goto next_param;

fail:
  free(buf);
  return NULL;
}

static ant_value_t parse_formdata_urlencoded(ant_t *js, const uint8_t *data, size_t size) {
  ant_value_t fd = 0;
  char *body = NULL;
  char *cursor = NULL;

  fd = formdata_create_empty(js);
  if (is_err(fd)) return fd;
  if (!data || size == 0) return fd;

  body = strndup((const char *)data, size);
  if (!body) return js_mkerr(js, "out of memory");

  cursor = body;
  while (cursor) {
    ant_value_t r = 0;
    char *amp = strchr(cursor, '&');
    char *eq = NULL;
    char *raw_name = NULL;
    char *raw_value = NULL;
    char *name = NULL;
    char *value = NULL;

    if (amp) *amp = '\0';

    eq = strchr(cursor, '=');
    raw_name = cursor;
    raw_value = eq ? (eq + 1) : "";
    if (eq) *eq = '\0';

    name = form_urldecode(raw_name);
    value = form_urldecode(raw_value);
    if (!name || !value) {
      free(name);
      free(value);
      free(body);
      return js_mkerr(js, "out of memory");
    }

    r = formdata_append_string(
      js, fd,
      js_mkstr(js, name, strlen(name)),
      js_mkstr(js, value, strlen(value))
    );
    
    free(name);
    free(value);
    
    if (is_err(r)) {
      free(body);
      return r;
    }
    
    cursor = amp ? (amp + 1) : NULL;
  }

  free(body);
  return fd;
}

static const uint8_t *find_bytes(
  const uint8_t *haystack, size_t haystack_len,
  const uint8_t *needle, size_t needle_len
) {
  size_t i = 0;

  if (needle_len == 0) return haystack;
  if (haystack_len < needle_len) return NULL;

  for (i = 0; i + needle_len <= haystack_len; i++) {
    if (memcmp(haystack + i, needle, needle_len) == 0) return haystack + i;
  }
  
  return NULL;
}

typedef struct {
  char *name;
  char *filename;
  char *content_type;
} multipart_part_info_t;

static void multipart_part_info_clear(multipart_part_info_t *info) {
  if (!info) return;
  free(info->name);
  free(info->filename);
  free(info->content_type);
  info->name = NULL;
  info->filename = NULL;
  info->content_type = NULL;
}

static bool multipart_parse_headers(
  ant_t *js, char *headers, multipart_part_info_t *info, ant_value_t *err_out
) {
  char *saveptr = NULL;

  for (
    char *line = strtok_r(headers, "\r\n", &saveptr);
    line; line = strtok_r(NULL, "\r\n", &saveptr)
  ) {
    char *colon = strchr(line, ':');
    char *value = NULL;
    
    if (!colon) continue;
    *colon = '\0';
    
    value = colon + 1;
    while (*value == ' ' || *value == '\t') value++;
    
    if (strcasecmp(line, "Content-Disposition") == 0) {
      free(info->name);
      free(info->filename);
      
      info->name = ct_get_param_dup(value, "name");
      info->filename = ct_get_param_dup(value, "filename");
      
      continue;
    }
    
    if (strcasecmp(line, "Content-Type") == 0) {
    free(info->content_type);
    info->content_type = strdup(value);
    if (!info->content_type) {
      *err_out = js_mkerr(js, "out of memory");
      return false;
    }}
  }

  if (info->name) return true;
  *err_out = multipart_invalid(js);
  
  return false;
}

static const uint8_t *multipart_find_part_end(
  const uint8_t *p, const uint8_t *end, const char *delim, size_t delim_len
) {
  char *marker = malloc(delim_len + 3);
  const uint8_t *part_end = NULL;
  if (!marker) return NULL;

  snprintf(marker, delim_len + 3, "\r\n%s", delim);
  part_end = find_bytes(
    p, (size_t)(end - p), 
    (const uint8_t *)marker, delim_len + 2
  );
  
  free(marker);
  return part_end;
}

static ant_value_t multipart_append_part(
  ant_t *js, ant_value_t fd, const multipart_part_info_t *info,
  const uint8_t *data, size_t size
) {
  if (info->filename) {
    ant_value_t blob = blob_create(
      js, data, size, info->content_type 
      ? info->content_type : ""
    );
    
    if (is_err(blob)) return blob;
    
    return formdata_append_file(
      js, fd, js_mkstr(js, info->name, strlen(info->name)),
      blob, js_mkstr(js, info->filename, strlen(info->filename))
    );
  }

  return formdata_append_string(
    js, fd,
    js_mkstr(js, info->name, strlen(info->name)),
    js_mkstr(js, data, size)
  );
}

static ant_value_t parse_formdata_multipart(
  ant_t *js, const uint8_t *data, size_t size, const char *body_type
) {
  ant_value_t fd = 0;
  char *boundary = NULL;
  char *delim = NULL;
  
  const uint8_t *p = data;
  const uint8_t *end = data + size;
  size_t delim_len = 0;

  if (!data || size == 0) return multipart_invalid(js);
  boundary = ct_get_param_dup(body_type, "boundary");
  if (!boundary || boundary[0] == '\0') goto invalid;

  fd = formdata_create_empty(js);
  if (is_err(fd)) goto done;

  delim_len = strlen(boundary) + 2;
  delim = malloc(delim_len + 1);
  if (!delim) {
    fd = js_mkerr(js, "out of memory");
    goto done;
  }
  snprintf(delim, delim_len + 1, "--%s", boundary);

  if ((size_t)(end - p) < delim_len || memcmp(p, delim, delim_len) != 0) goto invalid;
  p += delim_len;

next_part:
  if (p > end) goto done;
  if ((size_t)(end - p) >= 2 && memcmp(p, "--", 2) == 0) goto done;
  if ((size_t)(end - p) < 2 || memcmp(p, "\r\n", 2) != 0) goto invalid;
  p += 2;

  {
    ant_value_t r = 0;
    ant_value_t hdr_err = js_mkundef();
    const uint8_t *hdr_end = find_bytes(
      p, (size_t)(end - p), (const uint8_t *)"\r\n\r\n", 4
    );
    
    char *headers = NULL;
    multipart_part_info_t info = {0};
    const uint8_t *part_end = NULL;

    if (!hdr_end) goto invalid;

    headers = strndup((const char *)p, (size_t)(hdr_end - p));
    if (!headers) {
      fd = js_mkerr(js, "out of memory");
      goto done;
    }
    p = hdr_end + 4;

    if (!multipart_parse_headers(js, headers, &info, &hdr_err)) {
      free(headers);
      multipart_part_info_clear(&info);
      if (is_err(hdr_err)) { fd = hdr_err; goto done; }
      goto invalid;
    }
    free(headers);

    part_end = multipart_find_part_end(p, end, delim, delim_len);
    if (!part_end) {
      multipart_part_info_clear(&info);
      goto invalid;
    }

    r = multipart_append_part(js, fd, &info, p, (size_t)(part_end - p));
    multipart_part_info_clear(&info);
    if (is_err(r)) { fd = r; goto done; }

    p = part_end + 2 + delim_len;
    if ((size_t)(end - p) >= 2 && memcmp(p, "--", 2) == 0) goto done;
  }

  goto next_part;

invalid:
  fd = multipart_invalid(js);

done:
  free(boundary);
  free(delim);
  return fd;
}

ant_value_t formdata_parse_body(
  ant_t *js, const uint8_t *data, size_t size,
  const char *body_type, bool has_body
) {
  if (body_type && ct_is_type(body_type, "application/x-www-form-urlencoded")) {
    return parse_formdata_urlencoded(js, data, size);
  }

  if (body_type && ct_is_type(body_type, "multipart/form-data")) {
    if (!has_body || !data || size == 0) return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to parse body as FormData");
    return parse_formdata_multipart(js, data, size, body_type);
  }

  return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to parse body as FormData");
}

typedef struct {
  uint8_t *buf;
  size_t size;
  size_t cap;
} mp_buf_t;

static bool mp_grow(mp_buf_t *b, size_t need) {
  size_t nc = 0;
  uint8_t *nb = NULL;

  if (b->size + need <= b->cap) return true;

  nc = b->cap ? b->cap * 2 : 4096;
  while (nc < b->size + need) nc *= 2;

  nb = realloc(b->buf, nc);
  if (!nb) return false;
  b->buf = nb;
  b->cap = nc;
  return true;
}

static bool mp_append(mp_buf_t *b, const void *data, size_t len) {
  if (!mp_grow(b, len)) return false;
  memcpy(b->buf + b->size, data, len);
  b->size += len;
  return true;
}

static bool mp_append_str(mp_buf_t *b, const char *s) {
  return mp_append(b, s, strlen(s));
}

static bool mp_append_quoted(mp_buf_t *b, const char *s) {
  const char *p = s ? s : "";
  if (!mp_append_str(b, "\"")) return false;
  
  while (*p) {
    if (*p == '"' || *p == '\\') if (!mp_append(b, "\\", 1)) return false;
    if (!mp_append(b, p, 1)) return false;
    p++;
  }
  
  return mp_append_str(b, "\"");
}

static bool mp_append_boundary(mp_buf_t *b, const char *boundary, bool closing) {
  if (!mp_append_str(b, "--")) return false;
  if (!mp_append_str(b, boundary)) return false;
  return mp_append_str(b, closing ? "--\r\n" : "\r\n");
}

static bool mp_append_text_part(mp_buf_t *b, const fd_entry_t *e) {
  const char *val = e->str_value ? e->str_value : "";

  if (!mp_append_str(b, "Content-Disposition: form-data; name=")) return false;
  if (!mp_append_quoted(b, e->name ? e->name : "")) return false;
  if (!mp_append_str(b, "\r\n\r\n")) return false;
  
  return mp_append_str(b, val);
}

static bool mp_append_file_part(ant_t *js, mp_buf_t *b, ant_value_t values_arr, const fd_entry_t *e) {
  ant_value_t file_val = js_arr_get(js, values_arr, (ant_offset_t)e->val_idx);
  blob_data_t *bd = blob_get_data(file_val);
  
  const char *filename = (bd && bd->name) ? bd->name : "blob";
  const char *mime = (bd && bd->type && bd->type[0])
    ? bd->type
    : "application/octet-stream";
  
  if (!mp_append_str(b, "Content-Disposition: form-data; name=")) return false;
  if (!mp_append_quoted(b, e->name ? e->name : "")) return false;
  if (!mp_append_str(b, "; filename=")) return false;
  if (!mp_append_quoted(b, filename)) return false;
  if (!mp_append_str(b, "\r\nContent-Type: ")) return false;
  if (!mp_append_str(b, mime)) return false;
  if (!mp_append_str(b, "\r\n\r\n")) return false;
  if (!bd || !bd->data || bd->size == 0) return true;
  
  return mp_append(b, bd->data, bd->size);
}

uint8_t *formdata_serialize_multipart(
  ant_t *js, ant_value_t fd, size_t *out_size, char **out_boundary
) {
  ant_value_t values_arr = js_get_slot(fd, SLOT_ENTRIES);
  ant_value_t data_slot = js_get_slot(fd, SLOT_DATA);
  char boundary[49];
  
  mp_buf_t b = {NULL, 0, 0};
  fd_data_t *d = NULL;
  
  if (vtype(data_slot) != T_NUM) return NULL;
  d = (fd_data_t *)(uintptr_t)(size_t)js_getnum(data_slot);
  if (!d) return NULL;

  snprintf(
    boundary, sizeof(boundary),
    "----AntFormBoundary%08x%08x", (unsigned)rand(), (unsigned)rand()
  );

  if (d->count == 0) {
    uint8_t *empty = malloc(1);
    if (!empty) return NULL;
    
    *out_size = 0;
    *out_boundary = strdup(boundary);
    
    if (!*out_boundary) {
      free(empty);
      return NULL;
    }
    
    return empty;
  }

  for (fd_entry_t *e = d->head; e; e = e->next) {
    if (!mp_append_boundary(&b, boundary, false)) goto oom;
    if (!e->is_file && !mp_append_text_part(&b, e)) goto oom;
    if (e->is_file && !mp_append_file_part(js, &b, values_arr, e)) goto oom;
    if (!mp_append_str(&b, "\r\n")) goto oom;
  }

  if (!mp_append_boundary(&b, boundary, true)) goto oom;

  *out_size = b.size;
  *out_boundary = strdup(boundary);
  
  if (!*out_boundary) goto oom;
  return b.buf;

oom:
  free(b.buf);
  return NULL;
}