#include "object/hiObject.hpp"
#include "object/hiDict.hpp"
#include "object/hiString.hpp"
#include "runtime/universe.hpp"
#include "runtime/stringTable.hpp"
#include "runtime/functionObject.hpp"
#include "memory/heap.hpp"
#include "memory/oopClosure.hpp"

ObjectKlass* ObjectKlass::instance = NULL;

ObjectKlass::ObjectKlass() {
}

ObjectKlass* ObjectKlass::get_instance() {
 if (instance == NULL)
 instance = new ObjectKlass();

 return instance;
}

void HiObject::print() {
 klass()->print(this);
}

HiObject::HiObject() {
 _mark_word = 0;
 _obj_dict = NULL;
}

HiObject* HiObject::greater(HiObject * rhs) {
 return klass()->greater(this, rhs);
}

HiObject* HiObject::add(HiObject * rhs) {
 return klass()->add(this, rhs);
}

HiObject* HiObject::sub(HiObject * rhs) {
 return klass()->sub(this, rhs);
}

HiObject* HiObject::mul(HiObject * rhs) {
 return klass()->mul(this, rhs);
}

HiObject* HiObject::div(HiObject * rhs) {
 return klass()->div(this, rhs);
}

HiObject* HiObject::mod(HiObject * rhs) {
 return klass()->mod(this, rhs);
}

HiObject* HiObject::less(HiObject * rhs) {
 return klass()->less(this, rhs);
}

HiObject* HiObject::equal(HiObject * rhs) {
 return klass()->equal(this, rhs);
}

HiObject* HiObject::not_equal(HiObject * rhs) {
 return klass()->not_equal(this, rhs);
}

HiObject* HiObject::ge(HiObject * rhs) {
 return klass()->ge(this, rhs);
}

HiObject* HiObject::le(HiObject * rhs) {
 return klass()->le(this, rhs);
}

HiObject* HiObject::getattr(HiObject* x) {
 return klass()->getattr(this, x);
}

HiObject* HiObject::get_klass_attr(HiObject* x) {
 return klass()->get_klass_attr(this, x);
}

HiObject* HiObject::setattr(HiObject* x, HiObject* y) {
 return klass()->setattr(this, x, y);
 if (klass() == TypeKlass::get_instance()) {
 }
}

HiObject* HiObject::subscr(HiObject* x) {
 return klass()->subscr(this, x);
}

void HiObject::store_subscr(HiObject* x, HiObject* y) {
 klass()->store_subscr(this, x, y);
}

void HiObject::del_subscr(HiObject* x) {
 klass()->del_subscr(this, x);
}

HiObject* HiObject::contains(HiObject* x) {
 return klass()->contains(this, x);
}

HiObject* HiObject::iter() {
 return klass()->iter(this);
}

HiObject* HiObject::next() {
 return klass()->next(this);
}

HiObject* HiObject::len() {
 return klass()->len(this);
}

/*
 * TypeObject is a special object
 */
TypeKlass* TypeKlass::instance = NULL;

TypeKlass* TypeKlass::get_instance() {
 if (instance == NULL)
 instance = new TypeKlass();

 return instance;
}

void TypeKlass::print(HiObject* obj) {
 assert(obj->klass() == (Klass*) this);
 printf("<type ");
 Klass* own_klass = ((HiTypeObject*)obj)->own_klass();

 HiDict* attr_dict = own_klass->klass_dict();
 if (attr_dict) {
 HiObject* mod = attr_dict->get((HiObject*)
 StringTable::get_instance()->mod_str);
 if (mod != Universe::HiNone) {
 mod->print();
 printf(".");
 }
 }

 own_klass->name()->print();
 printf(">");
}

HiObject* TypeKlass::setattr(HiObject* x, HiObject* y, HiObject* z) {
 HiTypeObject* type_obj = (HiTypeObject*)x;
 type_obj->own_klass()->klass_dict()->put(y, z);
 return Universe::HiNone;
}

size_t TypeKlass::size() {
 return sizeof(HiTypeObject);
}

void TypeKlass::oops_do(OopClosure* f, HiObject* obj) {
 // do nothing since HiTypeObject refers no oop.
}

HiTypeObject::HiTypeObject() {
 set_klass(TypeKlass::get_instance());
}

void HiTypeObject::set_own_klass(Klass* k) {
 _own_klass = k; 
 k->set_type_object(this);
}

void HiObject::init_dict() {
 _obj_dict = new HiDict();
}

/*
 * Interfaces for GC.
 */
void HiObject::oops_do(OopClosure* closure) {
 // object does not know who to visit, klass knows
 closure->do_oop((HiObject**)&_obj_dict);
 klass()->oops_do(closure, this);
}

char* HiObject::new_address() {
 if ((_mark_word & 0x1) == 0x1)
 return (char*)(_mark_word & ((long)-8));

 return NULL;
}

void HiObject::set_new_address(char* addr) {
 if (!addr)
 return;

 _mark_word = ((long)addr) | 0x1;
}

void* HiObject::operator new(size_t size) {
 return Universe::heap->allocate(size);
}

size_t HiObject::size() {
 return klass()->size();
}