#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);
}