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

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

int Klass::compare_klass(Klass* x, Klass* y) {
 if (x == y)
 return 0;

 if (x == IntegerKlass::get_instance())
 return -1;
 else if (y == IntegerKlass::get_instance())
 return 1;

 if (x->name()->less(y->name()) == (HiObject*)Universe::HiTrue)
 return -1;
 else
 return 1;
}

void Klass::print(HiObject* x) {
 HiObject* meth_repr = get_klass_attr(x, ST(repr));
 if (meth_repr != Universe::HiNone) {
 Interpreter::get_instance()->
 call_virtual(meth_repr, NULL)->
 print();

 return;
 }

 printf("<object of ");
 x->klass()->name()->print();
 printf(", at %p>", x);
}

HiObject* Klass::create_klass(HiObject* x, HiObject* supers, HiObject* name) {
 assert(x->klass() == (Klass*)DictKlass::get_instance());
 assert(supers->klass() == (Klass*)ListKlass::get_instance());
 assert(name->klass() == (Klass*)StringKlass::get_instance());

 Klass* new_klass = new Klass();
 HiDict* klass_dict = (HiDict*) x;
 HiList* supers_list = (HiList*) supers;
 new_klass->set_klass_dict(klass_dict);
 new_klass->set_name((HiString*)name);
 new_klass->set_super_list(supers_list);
 new_klass->order_supers();

 HiTypeObject* type_obj = new HiTypeObject();
 type_obj->set_own_klass(new_klass);
 
 return type_obj;
}

HiObject* Klass::allocate_instance(HiObject* callable, ArrayList<HiObject*>* args) {
 HiObject* inst = NULL;
 if (_mro->index(IntegerKlass::get_instance()->type_object()) >= 0)
 inst = new HiInteger(0);
 else if (_mro->index(StringKlass::get_instance()->type_object()) >= 0)
 inst = new HiString("");
 else if (_mro->index(ListKlass::get_instance()->type_object()) >= 0)
 inst = new HiList();
 else if (_mro->index(DictKlass::get_instance()->type_object()) >= 0)
 inst = new HiDict();
 else
 inst = new HiObject();

 inst->set_klass(((HiTypeObject*)callable)->own_klass());
 HiObject* constructor = inst->get_klass_attr(ST(init));
 if (constructor != Universe::HiNone) {
 Interpreter::get_instance()->call_virtual(constructor, args);
 }

 return inst;
}

HiObject* Klass::add(HiObject* lhs, HiObject* rhs) {
 ObjList args = new ArrayList<HiObject*>();
 args->add(rhs);
 return find_and_call(lhs, args, ST(add));
}

HiObject* Klass::find_and_call(HiObject* lhs, ObjList args, HiObject* func_name) {
 HiObject* func = lhs->get_klass_attr(func_name);
 if (func != Universe::HiNone) {
 return Interpreter::get_instance()->call_virtual(func, args);
 }

 printf("class ");
 lhs->klass()->name()->print();
 printf(" Error : unsupport operation for class ");
 assert(false);
 return Universe::HiNone;
}

HiObject* Klass::len(HiObject* x) {
 return find_and_call(x, NULL, ST(len));
}

HiObject* Klass::subscr(HiObject* x, HiObject* y) {
 ObjList args = new ArrayList<HiObject*>();
 args->add(y);
 return find_and_call(x, args, ST(getitem));
}

void Klass::store_subscr(HiObject* x, HiObject* y, HiObject* z) {
 ObjList args = new ArrayList<HiObject*>();
 args->add(y);
 args->add(z);
 find_and_call(x, args, ST(setitem));
}

HiObject* Klass::get_klass_attr(HiObject* x, HiObject* y) {
 HiObject* result = Universe::HiNone;

 result = find_in_parents(x, y);
 if (MethodObject::is_function(result)) {
 result = new MethodObject((FunctionObject*)result, x);
 }

 return result;
}

// This method should only be called in LOAD_ATTR
HiObject* Klass::getattr(HiObject* x, HiObject* y) {
 HiObject* func = find_in_parents(x, ST(getattr));
 if (func->klass() == FunctionKlass::get_instance()) {
 func = new MethodObject((FunctionObject*)func, x);
 ObjList args = new ArrayList<HiObject*>();
 args->add(y);
 return Interpreter::get_instance()->call_virtual(func, args);
 }

 HiObject* result = Universe::HiNone;

 if (x->obj_dict() != NULL) {
 result = x->obj_dict()->get(y);
 if (result != Universe::HiNone)
 return result;
 }

 return get_klass_attr(x, y);
}

HiObject* Klass::setattr(HiObject* x, HiObject* y, HiObject* z) {
 HiObject* func = x->klass()->klass_dict()->get(ST(setattr));
 if (func->klass() == FunctionKlass::get_instance()) {
 func = new MethodObject((FunctionObject*)func, x);
 ObjList args = new ArrayList<HiObject*>();
 args->add(y);
 args->add(z);
 return Interpreter::get_instance()->call_virtual(func, args);
 }

 if (x->obj_dict() == NULL) {
 x->init_dict();
 }

 x->obj_dict()->put(y, z);
 return Universe::HiNone;
}

void Klass::add_super(Klass* klass) {
 if (_super == NULL)
 _super = new HiList();

 _super->append(klass->type_object());
}

HiTypeObject* Klass::super() {
 if (_super == NULL)
 return NULL;

 if (_super->size() <= 0)
 return NULL;

 return (HiTypeObject*)_super->get(0);
}

Klass::Klass() {
 Universe::klasses->add(this);
 _klass_dict = NULL;
 _name = NULL;
 _super = NULL;
 _mro = NULL;
}

void Klass::order_supers() {
 if (_super == NULL)
 return;

 if (_mro == NULL)
 _mro = new HiList();

 int cur = -1;
 for (int i = 0; i < _super->size(); i++) {
 HiTypeObject* tp_obj = (HiTypeObject*)(_super->get(i));
 Klass* k = tp_obj->own_klass();
 _mro->append(tp_obj);
 if (k->mro() == NULL)
 continue;

 for (int j = 0; j < k->mro()->size(); j++) {
 HiTypeObject* tp_obj = (HiTypeObject*)(k->mro()->get(j));
 int index = _mro->index(tp_obj);
 if (index < cur) {
 printf("Error: method resolution order conflicts.\n");
 assert(false);
 }
 cur = index;

 if (index >= 0) {
 _mro->delete_index(index);
 }
 _mro->append(tp_obj);
 }
 }

 if (_mro == NULL)
 return;

 printf("%s's mro is ", _name->value());
 for (int i = 0; i < _mro->size(); i++) {
 HiTypeObject* tp_obj = (HiTypeObject*)(_mro->get(i));
 Klass* k = tp_obj->own_klass();
 printf("%s, ", k->name()->value());
 }
 printf("\n");
}

HiObject* Klass::find_in_parents(HiObject* x, HiObject* y) {
 HiObject* result = Universe::HiNone;
 result = x->klass()->klass_dict()->get(y);

 if (result != Universe::HiNone) {
 return result;
 }

 // find attribute in all parents.
 if (x->klass()->mro() == NULL)
 return result;

 for (int i = 0; i < x->klass()->mro()->size(); i++) {
 result = ((HiTypeObject*)(x->klass()->mro()->get(i)))
 ->own_klass()->klass_dict()->get(y);

 if (result != Universe::HiNone)
 break;
 }

 return result;
}

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

// this function will visit all children
void Klass::oops_do(OopClosure* closure, HiObject* obj) {
 printf("warning: klass oops_do for ");
 _name->print();
 printf("\n");
}

void Klass::oops_do(OopClosure* f) {
 f->do_oop((HiObject**)&_super);
 f->do_oop((HiObject**)&_mro);
 f->do_oop((HiObject**)&_name);
 f->do_oop((HiObject**)&_klass_dict);
 f->do_oop((HiObject**)&_type_object);
}

size_t Klass::size() {
 return sizeof(HiObject);
}

HiObject* Klass::iter(HiObject* x) {
 return find_and_call(x, NULL, ST(iter));
}

HiObject* Klass::next(HiObject* x) {
 return find_and_call(x, NULL, ST(next));
}