#include "time.h"
#include "../cnp.h"

UNUSED
static void
print_label6(pair6 label)
{
  printf("(%ld, %ld, %ld, %ld, %ld, %ld)\n",
         label.x, label.y, label.z, label.u, label.v, label.w);
}

#define TITO struct timespec tic, toc

#define TIC do { clock_gettime(CLOCK_MONOTONIC_RAW, &tic); } while (0)

#define TOC do {                                        \
    clock_gettime(CLOCK_MONOTONIC_RAW, &toc);           \
    printf("\nTotal time = %f seconds\n",               \
           (toc.tv_nsec - tic.tv_nsec) / 1000000000.0 + \
           toc.tv_sec - tic.tv_sec);                    \
  } while (0)

#define READ_INTO_CPA(N, U, L, I, VA, VI, CP) do {      \
    U = new_utf8(N, L);                                 \
    I = get_info((str *)U, 0);                          \
    VA = MYALLOC(NUM, 2);                               \
    VI = 0;                                             \
    for (NUM index = 0;                                 \
         I.value >= 0 && index < str_length((str *) U); \
         index += I.step, VI++) {                       \
      I = get_info((str *)U, index);                    \
      *(VA+VI) = I.value;                               \
    }                                                   \
    CP = MYALLOC(cpa, 1);                               \
    CP->array = VA;                                     \
    CP->size = VI;                                      \
    add_to_list(names, CP);                             \
    destroy_str((str *)U, 1);                           \
  } while (0)

#define READ_TNT_STRING(LEFT, FORMAT, LEN, ...) do {            \
    tnt_string = new_tnt_string(FORMAT, LEN, __VA_ARGS__);      \
    if (!tnt_string) {                                          \
      fleprintf("left = %d, f = %s, l = %d, "                   \
                "cannot create tnt string\n",                   \
                LEFT, FORMAT, LEN);                             \
      map_list(rules, destroy_rule_and_free_all);               \
      destroy_list(rules, 0);                                   \
      map_list(names, destroy_cpa_and_free_all);                \
      destroy_list(names, 0);                                   \
      return 1;                                                 \
    }                                                           \
    rule = new_rule(LEFT, tnt_string);                          \
    add_to_list(rules, rule);                                   \
  } while (0)

#define GRAMMAR 4

int
main(int UNUSED argc, char ** UNUSED argv)
{
  /* have a grammar for testing */
  List *tnt_string = NULL;
  Rule *rule = NULL;
  List *rules = new_list();
  List *names = new_list();

  char *name = MYALLOC(char, 2);
  utf8* uname = NULL;

  str_info info = EMPTY_STR_INFO;

  NUM *varray = NULL;
  NUM vindex = 0;
  cpa *cpap = NULL;

  switch (GRAMMAR) {
  case 1:
    *(name+1) = 0;
    *name = 'S';

    READ_INTO_CPA(name, uname, 1, info, varray, vindex, cpap);

    name = MYALLOC(char, 3);
    *(name+1) = 0;
    *name = 'A';

    READ_INTO_CPA(name, uname, 1, info, varray, vindex, cpap);

    name = MYALLOC(char, 2);
    *(name+1) = 0;
    *name = 'B';

    READ_INTO_CPA(name, uname, 1, info, varray, vindex, cpap);

    READ_TNT_STRING(0, "tnn", 3, (T) 'a', (NT) 1, (NT) 2);
    READ_TNT_STRING(0, "tnt", 3, (T) 'a', (NT) 1, (T) 'b');

    READ_TNT_STRING(1, "t", 1, (T) 'a');
    READ_TNT_STRING(1, "t", 1, (T) 'c');
    rule = new_rule(1, new_list());
    add_to_list(rules, rule);

    READ_TNT_STRING(2, "t", 1, (T) 'b');
    READ_TNT_STRING(2, "nt", 2, (NT) 2, (T) 'c');
    rule = new_rule(2, new_list());
    add_to_list(rules, rule);
    break;
  case 2:
    *(name+1) = 0;
    *name = 'B';

    READ_INTO_CPA(name, uname, 1, info, varray, vindex, cpap);

    name = MYALLOC(char, 2);
    *(name+1) = 0;
    *name = 'U';

    READ_INTO_CPA(name, uname, 1, info, varray, vindex, cpap);

    READ_TNT_STRING(0, "nn", 2, (NT) 1, (NT) 0);
    rule = new_rule(0, new_list());
    add_to_list(rules, rule);

    READ_TNT_STRING(1, "t", 1, (T) '>');
    READ_TNT_STRING(1, "t", 1, (T) '<');
    READ_TNT_STRING(1, "t", 1, (T) '+');
    READ_TNT_STRING(1, "t", 1, (T) '-');
    READ_TNT_STRING(1, "t", 1, (T) ',');
    READ_TNT_STRING(1, "t", 1, (T) '.');
    READ_TNT_STRING(1, "tnt", 3, (T) '[', (NT) 0, (T) ']');
    break;
  case 3:
    *(name+1) = 0;
    *name = 'S';
    READ_INTO_CPA(name, uname, 1, info, varray, vindex, cpap);

    READ_TNT_STRING(0, "t", 1, (T) 'b');
    READ_TNT_STRING(0, "nn", 2, (NT) 0, (NT) 0);
    READ_TNT_STRING(0, "nnn", 3, (NT) 0, (NT) 0, (NT) 0);
    break;
  case 4:
    *(name+1) = 0;
    *name = 'S';
    READ_INTO_CPA(name, uname, 1, info, varray, vindex, cpap);

    name = MYALLOC(char, 2);
    *(name+1) = 0;
    *name = 'T';
    READ_INTO_CPA(name, uname, 1, info, varray, vindex, cpap);

    name = MYALLOC(char, 2);
    *(name+1) = 0;
    *name = 'U';
    READ_INTO_CPA(name, uname, 1, info, varray, vindex, cpap);

    READ_TNT_STRING(0, "nnn", 3, (NT) 0, (NT) 1, (NT) 2);
    READ_TNT_STRING(1, "nnn", 3, (NT) 1, (NT) 2, (NT) 0);
    READ_TNT_STRING(2, "nnn", 3, (NT) 2, (NT) 0, (NT) 1);
    rule = new_rule(0, new_list());
    add_to_list(rules, rule);
    rule = new_rule(1, new_list());
    add_to_list(rules, rule);
    rule = new_rule(2, new_list());
    add_to_list(rules, rule);
    READ_TNT_STRING(0, "t", 1, (T) 'a');
    break;
  default:
    fleprintf0("Forgot to assign grammar!\n");
    break;
  }

  Grammar *g = new_grammar();

  build_grammar(g, rules, names, NULL);

  print_grammar(g);

  utf8 *string = NULL;

  switch (GRAMMAR) {
  case 1:
    string = new_utf8("aab", 3);
    break;
  case 2:
    string = new_utf8("[[[[[[[[[[[[[[[[[[[[[[[++[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--]]]]]]]]]]]]]]]]]]]]]]]", 204);
    break;
  case 3:
    string = new_utf8("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", 100);
    break;
  case 4:
    string = new_utf8("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 48);
    break;
  default:
    fleprintf0("Forgot to assign input!\n");
    break;
  }

  printf("\nPrinting the input...\n%s\n", get_data((str *) string));

  TITO;

  TIC;

  Environment *env = cnp_parse(g, (str *) string);

  TOC;

  if (env) {
    if (!(env_error_p(env))) {
      BOOL result = bsr_lookup
        (env_bsrp(env), 0, 0, str_length((str *) string));

      if (result) {
        printf("\nSuccessfully parsed the input!\n");
      } else {
        printf("\nThe input does not parse!\n");
      }

      printf("\nAll BSRs follow:\n\n");
      if (argc == 1)
        bsr_print(env_bsrp(env), env_grammar(env), 1);
    } else {
      printf("There are errors!\n");
    }

    destroy_env(env);
  }

  destroy_grammar(g, 1);

  destroy_list(rules, 1);

  free(string);

  return 0;
}