#include "Value.hpp"
#include "Type.hpp"
#include "Function.hpp"
#include "Code.hpp"

namespace jk
{
  /*static*/ std::shared_ptr<Value> Value::make_nil()
  {
    auto value = std::make_shared<Value>();
    value->m_type = std::make_shared<Type>(TYPE_NIL);
    return value;
  }

  /*static*/ std::shared_ptr<Value> Value::make_int(int val)
  {
    auto value = std::make_shared<Value>();
    value->m_type = std::make_shared<Type>(TYPE_INT);
    value->m_int_val = val;
    return value;
  }

  /*static*/ std::shared_ptr<Value>
  Value::make_function(std::shared_ptr<Function> val)
  {
    auto value = std::make_shared<Value>();
    value->m_type = std::make_shared<Type>(TYPE_FUNCTION);
    value->m_function_val = val;
    return value;
  }

  /*static*/ std::shared_ptr<Value>
  Value::make_code(std::shared_ptr<Code> val)
  {
    auto value = std::make_shared<Value>();
    value->m_type = std::make_shared<Type>(TYPE_CODE);
    value->m_code_val = val;
    return value;
  }

  /*static*/ std::shared_ptr<Value>
  Value::make_ref(size_t val)
  {
    auto value = std::make_shared<Value>();
    value->m_type = std::make_shared<Type>(TYPE_REF);
    value->m_ref_val = val;
    return value;
  }

  std::shared_ptr<Function> Value::as_function() const
  {
    return m_function_val;
  }

  std::shared_ptr<Code> Value::as_code() const
  {
    return m_code_val;
  }

  std::weak_ptr<Type> Value::type() const
  {
    return m_type;
  }

  std::string Value::string() const
  {
    switch (m_type->type())
      {
      case TYPE_NIL: return "<nil>";
      case TYPE_INT: return std::to_string(*m_int_val);

      default:
        std::cerr << "cannot stringify value '"
                  << TypeTypeStr[m_type->type()]
                  << "'"
                  << std::endl;
        abort();
      }
  }
}