#include "object/hiDict.hpp"
#include "object/hiList.hpp"
#include "runtime/module.hpp"
#include "runtime/universe.hpp"
#include "runtime/interpreter.hpp"
#include "runtime/stringTable.hpp"
#include "util/bufferedInputStream.hpp"
#include "code/binaryFileParser.hpp"
#include "memory/oopClosure.hpp"
#include "inc/railgun.hpp"

#include <dlfcn.h>
#include <unistd.h>

#define ST(x) StringTable::get_instance()->STR(x)
#define STR(x) x##_str

ModuleKlass* ModuleKlass::_instance = NULL;

ModuleKlass* ModuleKlass::get_instance() {
 if (_instance == NULL)
 _instance = new ModuleKlass();

 return _instance;
}

ModuleKlass::ModuleKlass() {
}

void ModuleKlass::initialize() {
 HiDict* dict = new HiDict();
 set_klass_dict(dict);
 set_name(new HiString("module"));
 (new HiTypeObject())->set_own_klass(this);
 add_super(ObjectKlass::get_instance());
}

ModuleObject::ModuleObject(HiDict* dict) {
 set_obj_dict(dict);
 set_klass(ModuleKlass::get_instance());
}

ModuleObject* ModuleObject::import_module(HiObject* x) {
 HiString* mod_name = (HiString*)x;

 HiList* so_list = new HiList();
 so_list->append(ST(libdir_pre));
 so_list->append(mod_name);
 so_list->append(ST(so_suf));
 HiString* file_name = ST(empty)->join(so_list);
 
 if (access(file_name->value(), R_OK) == 0) {
 return import_so(mod_name);
 }

 file_name = (HiString*)(mod_name->add(ST(pyc_suf)));
 if (access(file_name->value(), R_OK) == -1) {
 HiList* pyc_list = new HiList();
 pyc_list->append(ST(libdir_pre));
 pyc_list->append(mod_name);
 pyc_list->append(ST(pyc_suf));
 file_name = ST(empty)->join(pyc_list);
 }

 assert(access(file_name->value(), R_OK) == 0);

 BufferedInputStream stream(file_name->value());
 BinaryFileParser parser(&stream);
 CodeObject* mod_code = parser.parse();
 HiDict* mod_dict = Interpreter::get_instance()->run_mod(mod_code, mod_name);
 return new ModuleObject(mod_dict);
}

void ModuleObject::put(HiObject* x, HiObject* y) {
 obj_dict()->put(x, y);
}

HiObject* ModuleObject::get(HiObject* x) {
 return obj_dict()->get(x);
}

void ModuleObject::extend(ModuleObject* mo) {
 obj_dict()->update(mo->obj_dict());
}

size_t ModuleKlass::size() {
 return sizeof(ModuleObject);
}

void ModuleKlass::oops_do(OopClosure* f, HiObject* obj) {
 void* temp = &(((ModuleObject*)obj)->_mod_name);
 f->do_oop((HiObject**)temp);
}

ModuleObject* ModuleObject::import_so(HiString* mod_name) {
 char* error_msg = NULL;

 HiString* prefix = new HiString("./lib/");
 HiString* so_suffix = new HiString(".so");

 HiString* file_name = (HiString*)(prefix->add(mod_name)->add(so_suffix));
 void* handle = dlopen(file_name->value(), RTLD_NOW);
 if (handle == NULL) {
 printf("error to open file: %s\n", dlerror());
 return NULL;
 }

 HiString* method_prefix = new HiString("init_");
 HiString* init_meth = (HiString*)(method_prefix->add(mod_name));
 INIT_FUNC init_func = (INIT_FUNC)dlsym(handle, init_meth->value());
 if ((error_msg = dlerror()) != NULL) {
 printf("Symbol init_methods not found: %s\n", error_msg);
 dlclose(handle);
 return NULL;
 }

 RGMethod* ml = init_func();
 ModuleObject* mod = new ModuleObject(new HiDict());
 for (; ml->meth_name != NULL; ml++) {
 mod->put(new HiString(ml->meth_name), 
 new FunctionObject(ml->meth));
 }

 return mod;
}