#include "include/main.h"
#include "include/doer.h"

#include "../test/include/test.h"

void test_tree_cpy() {
   tree_t* tree_block = tree_init(TREE_TYPE_BLOCK, NULL);
      tree_t* tree_lstr = tree_block->data.block.val = tree_init(TREE_TYPE_LSTR, tree_block);
         char* char_lstr = tree_lstr->data.lstr.val = calloc(12, sizeof(char));
         strcpy(char_lstr, "hello world");
         tree_lstr->data.lstr.len = 11;
      tree_t* tree_block2 = tree_block->data.block.nxt = tree_init(TREE_TYPE_BLOCK, tree_block);
         tree_t* tree_def = tree_block2->data.block.val = tree_init(TREE_TYPE_DEF, tree_block2);
            tree_t* tree_tag = tree_def->data.def.tag = tree_init(TREE_TYPE_TAG, tree_def);
               char* char_tag = tree_tag->data.tag.val = calloc(4, sizeof(char));
               strcpy(char_tag, "int");
               tree_tag->data.tag.nxt = NULL;
            tree_t* tree_darg = tree_def->data.def.arg = tree_init(TREE_TYPE_DARG, tree_def);
               tree_t* tree_tag2 = tree_darg->data.darg.tag = tree_init(TREE_TYPE_TAG, tree_darg);
                  char* char_tag2 = tree_tag2->data.tag.val = calloc(4, sizeof(char));
                  strcpy(char_tag2, "int");
                  tree_tag2->data.tag.nxt = NULL;
               tree_darg->data.darg.nxt = NULL;
            tree_t* tree_lint = tree_def->data.def.val = tree_init(TREE_TYPE_LINT, tree_def);
               tree_lint->data.lint.val = 42;
         tree_block2->data.block.nxt = NULL;

   tree_t* t2 = malloc(sizeof(tree_t));

   tree_cpy(&t2, tree_block);

   printf(tree_cmp(tree_block, t2)?"yes":"no");

   tree_print(tree_block, 0);
   tree_print(t2, 0);


   printf(&t2 != &tree_block ?"yes":"no");
}

/* FIXME: Segfaults ~30% of the time. No idea why. Thx future self <3. */
int main(int argc, char* argv[]) {
   test_tree_cpy();
   return 0;
   char* src;
   pp_t* pp;
   lexer_t* lexer;
   parser_t* parser;

   /* Get source. */
   src = source_get(argv[1]); 
   LOG_DBGF("Source: %s", src);

   /* Create pre-processor. */
   pp = pp_init(src);
   LOG_DBG("Preprocessor created.");

   /* Pre-process source. */
   pp_run(pp);
   free(src);
   src = pp->psrc;
   LOG_DBGF("pre-processed source: %s", pp->psrc);
   /* destroy pre-processor */
   pp_destroy(pp);
   LOG_DBG("preprocessor ran");

   /* create lexer */
   lexer = lexer_init(src);
   LOG_DBG("lexer created");

   /* run lexer */
   lexer_run(lexer);
   LOG_DBG("lexer ran");

   /* Print the lexer's tokens. */
   token_print(lexer->tokenl);

   /* Create the parser from the lexer's tokens. */
   parser = parser_init(lexer->tokenl);
   parser_run(parser);
#ifdef DBG
   tree_print(parser->tree, 0);
#endif

   doer_t* doer = doer_init(parser->tree);
   doer_do_block(doer);
   target_print(doer->targets);

   /* Clean up. */
   doer_destroy(doer);
   token_destroy(lexer->tokenl);
   lexer_destroy(lexer);
   tree_destroy(parser->tree);
   parser_destroy(parser);
   free(src);

   return 0;
}