#include "object/hiDict.hpp"
#include "object/hiList.hpp"
#include "object/hiInteger.hpp"
#include "object/hiString.hpp"
#include "runtime/functionObject.hpp"
#include "runtime/universe.hpp"
#include "runtime/stringTable.hpp"
#include "memory/oopClosure.hpp"
#include <assert.h>

DictKlass* DictKlass::instance = NULL;

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

 return instance;
}

DictKlass::DictKlass() {
}

void DictKlass::initialize() {
 HiDict* klass_dict = new HiDict();
 klass_dict->put(new HiString("setdefault"),
 new FunctionObject(dict_set_default));
 klass_dict->put(new HiString("remove"),
 new FunctionObject(dict_remove));
 klass_dict->put(new HiString("keys"),
 new FunctionObject(dict_keys));
 klass_dict->put(new HiString("values"),
 new FunctionObject(dict_values));
 klass_dict->put(new HiString("items"),
 new FunctionObject(dict_items));
 klass_dict->put(new HiString("iterkeys"),
 new FunctionObject(dict_iterkeys));
 klass_dict->put(new HiString("itervalues"),
 new FunctionObject(dict_itervalues));
 klass_dict->put(new HiString("iteritems"),
 new FunctionObject(dict_iteritems));
 set_klass_dict(klass_dict);
 set_name(new HiString("dict"));
 (new HiTypeObject())->set_own_klass(this);
 add_super(ObjectKlass::get_instance());
}

void DictKlass::print(HiObject* obj) {
 HiDict* dict_obj = (HiDict*) obj;
 assert(dict_obj && dict_obj->klass() == (Klass*) this);

 printf("{"); 
 int size = dict_obj->_map->size();
 if (size >= 1) {
 dict_obj->_map->entries()[0]._k->print();
 printf(":"); 
 dict_obj->_map->entries()[0]._v->print();
 }

 for (int i = 1; i < size; i++) {
 printf(", "); 
 dict_obj->_map->entries()[i]._k->print();
 printf(":"); 
 dict_obj->_map->entries()[i]._v->print();
 }

 printf("}");
}

HiObject* DictKlass::getattr(HiObject* obj, HiString* name) {
 assert(obj->klass() == (Klass*) this);
 return klass_dict()->get((HiObject*)name);
}

HiObject* DictKlass::subscr(HiObject* x, HiObject* y) {
 assert(x && x->klass() == (Klass*) this);
 return ((HiDict*)x)->map()->get(y);
}

void DictKlass::store_subscr(HiObject* x, HiObject*y, HiObject* z) {
 assert(x && x->klass() == (Klass*) this);
 ((HiDict*)x)->put(y, z);
}

HiObject* DictKlass::iter(HiObject* x) {
 HiObject* it = new DictIterator((HiDict*)x);
 it->set_klass(DictIteratorKlass<ITER_KEY>::get_instance());
 return it;
}

void DictKlass::del_subscr(HiObject* x, HiObject* y) {
 assert(x && x->klass() == (Klass*) this);
 ((HiDict*)x)->remove(y);
}

HiDict::HiDict() {
 _map = new Map<HiObject*, HiObject*>();
 set_klass(DictKlass::get_instance());
}

HiDict::HiDict(Map<HiObject*, HiObject*>* x) {
 _map = x;
 set_klass(DictKlass::get_instance());
}

void HiDict::update(HiDict* dict) {
 for (int i = 0; i < dict->size(); i++) {
 put(dict->map()->get_key(i), 
 dict->map()->get_value(i));
 }
}

/*
 * Iterations for dict object
 */
template<ITER_TYPE n>
DictIteratorKlass<n>* DictIteratorKlass<n>::instance = NULL;

template<ITER_TYPE n>
DictIteratorKlass<n>* DictIteratorKlass<n>::get_instance() {
 if (instance == NULL) {
 instance = new DictIteratorKlass<n>();
 }

 return instance;
}

template<ITER_TYPE iter_type>
DictIteratorKlass<iter_type>::DictIteratorKlass() {
 const char* klass_names[] = {
 "dictionary-keyiterator",
 "dictionary-valueiterator",
 "dictionary-itemiterator",
 };
 set_klass_dict(new HiDict());
 set_name(new HiString(klass_names[iter_type]));
}

DictIterator::DictIterator(HiDict* dict) {
 _owner = dict;
 _iter_cnt = 0;
}

HiObject* dict_set_default(ObjList args) {
 HiDict* dict = (HiDict*)(args->get(0));
 HiObject* key = args->get(1);
 HiObject* value = args->get(2);

 if (!dict->has_key(key))
 dict->put(key, value);

 return Universe::HiNone;
}

HiObject* dict_remove(ObjList args) {
 HiObject* x = args->get(0);
 HiObject* y = args->get(1);

 ((HiDict*)x)->remove(y);

 return Universe::HiNone;
}

HiObject* dict_keys(ObjList args) {
 HiDict* x = (HiDict*)(args->get(0));

 HiList* keys = new HiList();

 for (int i = 0; i < x->size(); i++) {
 keys->append(x->map()->get_key(i));
 }

 return keys;
}

HiObject* dict_values(ObjList args) {
 HiDict* x = (HiDict*)(args->get(0));

 HiList* values = new HiList();

 for (int i = 0; i < x->size(); i++) {
 values->append(x->map()->get_value(i));
 }

 return values;
}

HiObject* dict_items(ObjList args) {
 HiDict* x = (HiDict*)(args->get(0));

 HiList* items = new HiList();

 for (int i = 0; i < x->size(); i++) {
 HiList* item = new HiList();
 item->append(x->map()->get_key(i));
 item->append(x->map()->get_value(i));
 items->append(item);
 }

 return items;
}

HiObject* dict_iterkeys(ObjList args) {
 HiDict* x = (HiDict*)(args->get(0));
 HiObject* it = new DictIterator(x);
 it->set_klass(DictIteratorKlass<ITER_KEY>::get_instance());
 return it;
}

HiObject* dict_itervalues(ObjList args) {
 HiDict* x = (HiDict*)(args->get(0));
 HiObject* it = new DictIterator(x);
 it->set_klass(DictIteratorKlass<ITER_VALUE>::get_instance());
 return it;
}

HiObject* dict_iteritems(ObjList args) {
 HiDict* x = (HiDict*)(args->get(0));
 HiObject* it = new DictIterator(x);
 it->set_klass(DictIteratorKlass<ITER_ITEM>::get_instance());
 return it;
}

template<ITER_TYPE iter_type>
HiObject* DictIteratorKlass<iter_type>::next(HiObject* x) {
 DictIterator* iter = (DictIterator*)x;

 HiDict* adict = iter->owner();
 int iter_cnt = iter->iter_cnt();
 if (iter_cnt < adict->map()->size()) {
 HiObject* obj;
 if (iter_type == ITER_KEY)
 obj = adict->map()->get_key(iter_cnt);
 else if (iter_type == ITER_VALUE) {
 obj = adict->map()->get_value(iter_cnt);
 }
 else if (iter_type == ITER_ITEM) {
 HiList* lobj = new HiList();
 lobj->append(adict->map()->get_key(iter_cnt));
 lobj->append(adict->map()->get_value(iter_cnt));
 obj = lobj;
 }
 iter->inc_cnt();
 return obj;
 }
 else // TODO : we need Traceback here to mark iteration end
 return NULL;
}

HiObject* DictKlass::allocate_instance(HiObject* callable, 
 ArrayList<HiObject*>* args) {
 if (!args || args->length() == 0)
 return new HiDict();
 else
 return NULL;
}

size_t DictKlass::size() {
 return sizeof(HiDict);
}

void DictKlass::oops_do(OopClosure* f, HiObject* obj) {
 assert(obj->klass() == (Klass*)this);

 f->do_map(&((HiDict*)obj)->_map);
}