class Namespace

static VALUE
rb_namespace_s_current(VALUE recv)
{
    const rb_namespace_t *ns;

    if (!rb_namespace_available())
        return Qnil;

    ns = rb_vm_current_namespace(GET_EC());
    VM_ASSERT(ns && ns->ns_object);
    return ns->ns_object;
}

static VALUE
rb_namespace_s_getenabled(VALUE recv)
{
    return RBOOL(rb_namespace_available());
}

static VALUE
namespace_initialize(VALUE namespace)
{
    rb_namespace_t *ns;
    rb_classext_t *object_classext;
    VALUE entry;
    ID id_namespace_entry;
    CONST_ID(id_namespace_entry, "__namespace_entry__");

    if (!rb_namespace_available()) {
        rb_raise(rb_eRuntimeError, "Namespace is disabled. Set RUBY_NAMESPACE=1 environment variable to use Namespace.");
    }

    entry = rb_class_new_instance_pass_kw(0, NULL, rb_cNamespaceEntry);
    ns = get_namespace_struct_internal(entry);

    ns->ns_object = namespace;
    ns->ns_id = namespace_generate_id();
    rb_define_singleton_method(ns->load_path, "resolve_feature_path", rb_resolve_feature_path, 1);

    // Set the Namespace object unique/consistent from any namespaces to have just single
    // constant table from any view of every (including main) namespace.
    // If a code in the namespace adds a constant, the constant will be visible even from root/main.
    RCLASS_SET_PRIME_CLASSEXT_WRITABLE(namespace, true);

    // Get a clean constant table of Object even by writable one
    // because ns was just created, so it has not touched any constants yet.
    object_classext = RCLASS_EXT_WRITABLE_IN_NS(rb_cObject, ns);
    RCLASS_SET_CONST_TBL(namespace, RCLASSEXT_CONST_TBL(object_classext), true);

    rb_ivar_set(namespace, id_namespace_entry, entry);

    return namespace;
}

static VALUE
rb_namespace_eval(VALUE namespace, VALUE str)
{
    const rb_iseq_t *iseq;
    const rb_namespace_t *ns;

    StringValue(str);

    iseq = rb_iseq_compile_iseq(str, rb_str_new_cstr("eval"));
    VM_ASSERT(iseq);

    ns = (const rb_namespace_t *)rb_get_namespace_t(namespace);

    return rb_iseq_eval(iseq, ns);
}

static VALUE
rb_namespace_inspect(VALUE obj)
{
    rb_namespace_t *ns;
    VALUE r;
    if (obj == Qfalse) {
        r = rb_str_new_cstr("#<Namespace:root>");
        return r;
    }
    ns = rb_get_namespace_t(obj);
    r = rb_str_new_cstr("#<Namespace:");
    rb_str_concat(r, rb_funcall(LONG2NUM(ns->ns_id), rb_intern("to_s"), 0));
    if (NAMESPACE_ROOT_P(ns)) {
        rb_str_cat_cstr(r, ",root");
    }
    if (NAMESPACE_USER_P(ns)) {
        rb_str_cat_cstr(r, ",user");
    }
    if (NAMESPACE_MAIN_P(ns)) {
        rb_str_cat_cstr(r, ",main");
    }
    else if (NAMESPACE_OPTIONAL_P(ns)) {
        rb_str_cat_cstr(r, ",optional");
    }
    rb_str_cat_cstr(r, ">");
    return r;
}

static VALUE
rb_namespace_load(int argc, VALUE *argv, VALUE namespace)
{
    VALUE fname, wrap;
    rb_scan_args(argc, argv, "11", &fname, &wrap);

    rb_vm_frame_flag_set_ns_require(GET_EC());

    VALUE args = rb_ary_new_from_args(2, fname, wrap);
    return rb_load_entrypoint(args);
}

static VALUE
rb_namespace_load_path(VALUE namespace)
{
    VM_ASSERT(NAMESPACE_OBJ_P(namespace));
    return rb_get_namespace_t(namespace)->load_path;
}

static VALUE
rb_namespace_require(VALUE namespace, VALUE fname)
{
    rb_vm_frame_flag_set_ns_require(GET_EC());

    return rb_require_string(fname);
}

static VALUE
rb_namespace_require_relative(VALUE namespace, VALUE fname)
{
    rb_vm_frame_flag_set_ns_require(GET_EC());

    return rb_require_relative_entrypoint(fname);
}