#include <compiler/tree_parser/tree_parser.h>
#include <stdlib.h>
#include <string.h>
#include <utils/file.h>
#include <utils/time.h>
#include <utils/types.h>
#include <vm/runner/runner.h>

#include "compiler/source_code/source_code.h"

Clock runWithPrint(SourceCode *code) {
  Clock sum = 0;
  Clock diff = 0;
  fprintf(stderr, "----code:\n%s\n----\n", code->codes[0]->code);
  Clock start = getTimeInNano();
  const Nodes nodes = lexer(code, 0);
  diff += getTimeInNano() - start;
  sum += diff;
  if (nodes.size != ERROR_SIZE) {
    printNodes(nodes);
    fprintf(stderr, "----lexing in %ldns\n", diff);
    start = getTimeInNano();
    ParsedNode *parsedNode = _parser(nodes, code);
    diff = getTimeInNano() - start;
    sum += diff;
    if (parsedNode != NULL) {
      printParsedNode(parsedNode);
      fprintf(stderr, "----node parsing in %ldns\n", diff);
      start = getTimeInNano();
      ParsedTree *parsedTree = _treeParser(parsedNode, code);
      diff = getTimeInNano() - start;
      sum += diff;
      if (parsedTree != NULL) {
        printParsedTreeNode(parsedTree);
        fprintf(stderr, "----tree parsing in %ldns\n", diff);
        start = getTimeInNano();
        Instructions instructions = _codeGenerator(parsedTree, code);
        diff = getTimeInNano() - start;
        sum += diff;
        if (instructions.size != ERROR_SIZE) {
          printInstructions(instructions);
          fprintf(stderr, "----code_generator in %ldns\n", diff);
          start = getTimeInNano();
          bool ranSuccess = _runner(instructions);
          diff = getTimeInNano() - start;
          sum += diff;
          fprintf(stderr, "----runner in %ldns\n", diff);
          fprintf(stderr, "ran sucessfully = %s\n",
                  ranSuccess ? "true" : "false");
          fprintf(stderr, "----sum %ldns\n", sum);
          deleteInstructions(instructions);
        } else {
          fprintf(stderr, "----returned error");
        }
        deleteParsedTree(parsedTree);
      } else {
        fprintf(stderr, "----returned error");
      }
      deleteParsedNode(parsedNode);
    } else {
      fprintf(stderr, "----returned error");
    }
  } else {
    fprintf(stderr, "----returned error");
  }
  deleteNodes(nodes);
  return sum;
}

int main(int argc, char *argv[]) {
  if (argc < 2) {
    fprintf(stderr, "no file");
    return 1;
  }
  SourceCode sourceCode = makeSourceCode();
  const char *const filePath = argv[1];

  Code *code;
  code = read_whole_file("std/builtins.felan");
  if (code == NULL) {
    goto RETURN_ERROR;
  }
  pushToSourceCode(&sourceCode, code);

  code = read_whole_file(filePath);
  if (code == NULL) {
    goto RETURN_ERROR;
  }
  pushToSourceCode(&sourceCode, code);

  if (!runner(&sourceCode)) {
    goto RETURN_ERROR;
  }

  deleteSourceCodeInners(sourceCode);
  return 0;

RETURN_ERROR:
  deleteSourceCodeInners(sourceCode);
  return 1;
}