#include "runner.h"

#include <compiler/code_generator/code_generator.h>
#include <stdio.h>
#include <stdlib.h>
#include <utils/memory/memory.h>
#include <utils/types.h>

const BuiltinFunction BUILTIN_FUNCTIONS[] = {
    print,
};
const char *BUILTIN_FUNCTION_NAMES[] = {
    "print",
};
const size_t BUILTIN_FUNCTIONS_SIZE =
    sizeof(BUILTIN_FUNCTIONS) / sizeof(BuiltinFunction);

bool runner(Instructions instructions) {
  size_t stack_size = 0;
  void **stack = a404m_malloc(stack_size * sizeof(void *));
  size_t stack_inserted = 0;

  for (size_t i = 0; i < instructions.size; ++i) {
    if (!runInstruction(instructions.instructions[i], &stack, &stack_size,
                        &stack_inserted)) {
      goto RETURN_ERROR;
    }
  }

  free(stack);
  return true;

RETURN_ERROR:
  free(stack);
  return false;
}

BuiltinFunction getBuiltinFunction(SizedString string) {
  for (size_t i = 0; i < BUILTIN_FUNCTIONS_SIZE; ++i) {
    const char *search = BUILTIN_FUNCTION_NAMES[i];
    // faster than strlen+strncpy
    for (size_t j = 0;; ++j) {
      const char searchChar = search[j];
      if (j == string.size) {
        if (searchChar == '\0') {
          return BUILTIN_FUNCTIONS[i];
        } else {
          break;
        }
      } else if (searchChar == '\0') {
        break;
      } else if (searchChar != string.str[j]) {
        break;
      }
    }
  }
  return NULL;
}

bool runInstruction(Instruction instruction, void ***restrict stack,
                    size_t *restrict stack_size,
                    size_t *restrict stack_inserted) {
  switch (instruction.command) {
    case COMMAND_PUSH_STRING: {
      SizedString *string = instruction.operand;
      if (*stack_inserted == *stack_size) {
        *stack_size += *stack_size / 2 + 1;
        *stack = a404m_realloc(*stack, *stack_size * sizeof(void *));
      }
      (*stack)[*stack_inserted] = string;
      ++*stack_inserted;
      return true;
    }
    case COMMAND_CALL_FUNCTION: {
      SizedString *functionName = instruction.operand;
      BuiltinFunction function = getBuiltinFunction(*functionName);
      if (function == NULL) {
        fprintf(stderr, "function '%.*s' not found\n", (int)functionName->size,
                functionName->str);
        return false;
      }
      function(stack, stack_inserted);
      return true;
    }
    case COMMAND_NONE:
  }
  fprintf(stderr, "unknown command '%d'\n", instruction.command);
  return false;
}

void print(void ***restrict stack, size_t *restrict stack_inserted) {
  const SizedString *string = (*stack)[--*stack_inserted];
  printf("%.*s", (int)string->size, string->str);
}