#include "ctl.h"

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

/* Heredoc args: `arg <key> <<TAG` ... a line equal to TAG.
 * The body is confirmed only by the terminator line, so no prefix of the
 * stream may ever produce CALL_READY. */

static int nfail;

#define EXPECT(cond, msg)                                                      \
  do {                                                                         \
    if (!(cond)) {                                                             \
      fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, msg);            \
      nfail++;                                                                 \
    }                                                                          \
  } while (0)

typedef struct {
  int ready;
  int nargs;
  char keys[CTL_MAX_ARGS][CTL_MAX_KEY];
  char *vals[CTL_MAX_ARGS];
  size_t lens[CTL_MAX_ARGS];
  char text[4096];
  size_t text_len;
} cap_t;

static void on_ev(const ctl_event_t *ev, void *ud) {
  cap_t *c = ud;
  if (ev->type == CTL_EV_TEXT && c->text_len + ev->text_len < sizeof(c->text)) {
    memcpy(c->text + c->text_len, ev->text, ev->text_len);
    c->text_len += ev->text_len;
  }
  if (ev->type != CTL_EV_CALL_READY)
    return;
  c->ready++;
  c->nargs = ev->call->nargs;
  for (int i = 0; i < ev->call->nargs; i++) {
    snprintf(c->keys[i], sizeof(c->keys[i]), "%s", ev->call->args[i].key);
    free(c->vals[i]);
    c->vals[i] = malloc(ev->call->args[i].value_len + 1);
    memcpy(c->vals[i], ev->call->args[i].value, ev->call->args[i].value_len);
    c->vals[i][ev->call->args[i].value_len] = 0;
    c->lens[i] = ev->call->args[i].value_len;
  }
}

static void cap_free(cap_t *c) {
  for (int i = 0; i < CTL_MAX_ARGS; i++)
    free(c->vals[i]);
  memset(c, 0, sizeof(*c));
}

/* feed in `chunk`-byte pieces; finish if asked */
static ctl_status_t run(const char *s, size_t n, size_t chunk, int finish,
                        cap_t *c, ctl_parser_stats_t *st) {
  memset(c, 0, sizeof(*c));
  ctl_parser_t *p = ctl_parser_create(on_ev, c);
  ctl_status_t rc = CTL_OK;
  for (size_t i = 0; i < n && rc == CTL_OK; i += chunk) {
    size_t k = n - i < chunk ? n - i : chunk;
    rc = ctl_parser_feed(p, s + i, k);
  }
  if (rc == CTL_OK && finish)
    rc = ctl_parser_finish(p);
  if (st)
    ctl_parser_stats(p, st);
  ctl_parser_destroy(p);
  return rc;
}

static const char *BODY = "all:\n"
                          "\tgcc -o app main.c\n"
                          "\n"
                          "end\n"
                          "call x y\n"
                          "arg path 3\n"
                          "```\n"
                          "  EOF\n"
                          "last line\n";

static const char *STREAM = "Writing the Makefile.\n"
                            "call w1 write_file\n"
                            "arg path Makefile\n"
                            "arg content <<EOF\n"
                            "all:\n"
                            "\tgcc -o app main.c\n"
                            "\n"
                            "end\n"
                            "call x y\n"
                            "arg path 3\n"
                            "```\n"
                            "  EOF\n"
                            "last line\n"
                            "EOF\n"
                            "end\n";

static void test_body_verbatim(void) {
  size_t chunks[] = {1, 2, 5, 64, 100000};
  for (size_t k = 0; k < sizeof(chunks) / sizeof(chunks[0]); k++) {
    cap_t c;
    ctl_parser_stats_t st;
    ctl_status_t rc = run(STREAM, strlen(STREAM), chunks[k], 1, &c, &st);
    EXPECT(rc == CTL_OK, "heredoc stream ok");
    EXPECT(c.ready == 1, "one call ready");
    EXPECT(c.nargs == 2, "two args");
    EXPECT(strcmp(c.keys[0], "path") == 0 && strcmp(c.vals[0], "Makefile") == 0,
           "inline path");
    EXPECT(strcmp(c.keys[1], "content") == 0, "content key");
    EXPECT(c.vals[1] && strcmp(c.vals[1], BODY) == 0,
           "body verbatim: tabs, blank lines, end/call/arg/fence lines, "
           "indented tag");
    EXPECT(st.args_heredoc == 1 && st.args_inline == 1, "stats per arg form");
    EXPECT(c.text_len == strlen("Writing the Makefile.\n"), "prose is text");
    cap_free(&c);
  }
}

static void test_never_premature(void) {
  size_t n = strlen(STREAM);
  int premature = 0;
  for (size_t cut = 0; cut < n; cut++) {
    cap_t c;
    run(STREAM, cut, 7, 0, &c, NULL);
    if (c.ready)
      premature++;
    cap_free(&c);
  }
  EXPECT(premature == 0, "no prefix of a heredoc call is executable");

  /* EOF inside the body: error, nothing executed */
  const char *mid = strstr(STREAM, "\tgcc");
  cap_t c;
  ctl_parser_stats_t st;
  ctl_status_t rc = run(STREAM, (size_t)(mid - STREAM), 3, 1, &c, &st);
  EXPECT(rc == CTL_ERR_CONTRACT && c.ready == 0, "EOF in heredoc rejected");
  EXPECT(st.error_kind == CTL_EK_HEREDOC_EOF, "error kind heredoc_eof");
  cap_free(&c);
}

static void test_tag_forms(void) {
  const char *quoted = "call q1 write_file\narg path a.txt\n"
                       "arg content <<'BODY_1'\nx\nBODY_1\nend\n";
  cap_t c;
  EXPECT(run(quoted, strlen(quoted), 1, 1, &c, NULL) == CTL_OK && c.ready == 1,
         "single-quoted tag");
  EXPECT(c.vals[1] && strcmp(c.vals[1], "x\n") == 0, "quoted tag body");
  cap_free(&c);

  const char *dq = "call q2 write_file\narg path a.txt\n"
                   "arg content << \"T\"\n\nT\nend\n";
  EXPECT(run(dq, strlen(dq), 4, 1, &c, NULL) == CTL_OK && c.ready == 1,
         "double-quoted tag with space");
  EXPECT(c.vals[1] && strcmp(c.vals[1], "\n") == 0, "single blank line body");
  cap_free(&c);

  const char *empty = "call q3 write_file\narg path a.txt\n"
                      "arg content <<E\nE\nend\n";
  EXPECT(run(empty, strlen(empty), 3, 1, &c, NULL) == CTL_OK && c.ready == 1 &&
             c.lens[1] == 0,
         "empty body");
  cap_free(&c);

  const char *bad = "call q4 write_file\narg content <<a-b\nx\na-b\nend\n";
  ctl_parser_stats_t st;
  EXPECT(run(bad, strlen(bad), 1, 1, &c, &st) == CTL_ERR_CONTRACT &&
             st.error_kind == CTL_EK_BAD_ARG && c.ready == 0,
         "invalid tag rejected");
  cap_free(&c);

  /* terminator on the last line without newline, implicit end at EOF */
  const char *eof = "call q5 write_file\narg path a.txt\narg content <<EOF\n"
                    "body\nEOF";
  EXPECT(run(eof, strlen(eof), 2, 1, &c, NULL) == CTL_OK && c.ready == 1,
         "tag at EOF accepted");
  EXPECT(c.vals[1] && strcmp(c.vals[1], "body\n") == 0, "tag at EOF body");
  cap_free(&c);

  /* mixing all three arg forms in one call */
  const char *mix = "call m1 apply_patch\narg note hello world\narg patch 4\n"
                    "ab\ncarg extra <<X\nq\nX\nend\n";
  EXPECT(run(mix, strlen(mix), 1, 1, &c, &st) == CTL_OK && c.ready == 1 &&
             c.nargs == 3,
         "inline + nbytes + heredoc in one call");
  EXPECT(c.vals[1] && strcmp(c.vals[1], "ab\nc") == 0, "nbytes body exact");
  EXPECT(st.args_inline == 1 && st.args_nbytes == 1 && st.args_heredoc == 1,
         "stats count each form");
  cap_free(&c);
}

int main(void) {
  test_body_verbatim();
  test_never_premature();
  test_tag_forms();
  if (nfail) {
    fprintf(stderr, "test_ctl_heredoc: %d failed\n", nfail);
    return 1;
  }
  printf("test_ctl_heredoc: OK\n");
  return 0;
}