#include "tysy.h"

void tysy_init(tysy_t* tysy)
{
  assert(tysy);
  tysy->size = 0;

  // num
  {
    type_t* ty = malloc(sizeof(type_t));
    type_init(ty, TYPE_NUM);
    tysy_register_new_type(tysy, "num", ty);
  }

  // bool
  {
    type_t* ty = malloc(sizeof(type_t));
    type_init(ty, TYPE_BOOL);
    tysy_register_new_type(tysy, "bool", ty);
  }

  // str
  {
    type_t* ty = malloc(sizeof(type_t));
    type_init(ty, TYPE_STR);
    tysy_register_new_type(tysy, "str", ty);
  }

  // fun
  {
    type_t* ty = malloc(sizeof(type_t));
    type_init(ty, TYPE_FUN);
    tysy_register_new_type(tysy, "fun", ty);
  }

  // ref
  {
    type_t* ty = malloc(sizeof(type_t));
    type_init(ty, TYPE_REF);
    tysy_register_new_type(tysy, "ref", ty);
  }
}

void tysy_free(tysy_t* tysy)
{
  assert(tysy);

  for (size_t i=0; i<tysy->size; i++)
    {
      type_free(tysy->types[i]);
      free(tysy->types[i]);
      free(tysy->names[i]);
    }

  tysy->size = 0;
}

void tysy_register_new_type(tysy_t* tysy, char* name, type_t* type)
{
  assert(tysy);
  assert(name);
  assert(type);
  assert(tysy->size + 1 < RZ_MAX_TYPES);

  tysy->types[tysy->size] = type;
  tysy->names[tysy->size] = strdup(name);
  tysy->size++;
}

type_t* tysy_try_find_type(tysy_t* tysy, char* name)
{
  assert(tysy);
  assert(name);

  for (size_t i=0; i<tysy->size; i++)
    {
      if (strcmp(name, tysy->names[i]) == 0)
        {
          return tysy->types[i];
        }
    }

  return NULL;
}

value_t* tysy_new_num(tysy_t* tysy, double value, int line)
{
  assert(tysy);

  value_t* val = malloc(sizeof(value_t));
  value_init(val, tysy_try_find_type(tysy, "num"), line);
  val->value.num = value;

  return val;
}

value_t* tysy_new_bool(tysy_t* tysy, int value, int line)
{
  assert(tysy);

  value_t* val = malloc(sizeof(value_t));
  value_init(val, tysy_try_find_type(tysy, "bool"), line);
  val->value.bool = value;

  return val;
}

value_t* tysy_new_str(tysy_t* tysy, char* value, int line)
{
  assert(tysy);

  value_t* val = malloc(sizeof(value_t));
  value_init(val, tysy_try_find_type(tysy, "str"), line);
  val->value.str = strdup(value);

  return val;
}

value_t* tysy_new_fun(tysy_t* tysy, fun_t* fun, int line)
{
  assert(tysy);

  value_t* val = malloc(sizeof(value_t));
  value_init(val, tysy_try_find_type(tysy, "fun"), line);
  val->value.fun = fun;

  return val;
}

value_t* tysy_new_ref(tysy_t* tysy, size_t ref, int line)
{
  assert(tysy);

  value_t* val = malloc(sizeof(value_t));
  value_init(val, tysy_try_find_type(tysy, "ref"), line);
  val->value.ref = ref;

  return val;
}