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

ListKlass* ListKlass::instance = NULL;

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

 return instance;
}

ListKlass::ListKlass() {
}

void ListKlass::initialize() {
 HiDict * klass_dict = new HiDict();
 klass_dict->put(new HiString("append"), 
 new FunctionObject(list_append));
 klass_dict->put(new HiString("pop"), 
 new FunctionObject(list_pop));
 klass_dict->put(new HiString("remove"), 
 new FunctionObject(list_remove));
 klass_dict->put(new HiString("reverse"), 
 new FunctionObject(list_reverse));
 klass_dict->put(new HiString("sort"), 
 new FunctionObject(list_sort));
 klass_dict->put(new HiString("extend"), 
 new FunctionObject(list_extend));
 klass_dict->put(new HiString("index"), 
 new FunctionObject(list_index));
 klass_dict->put(new HiString("__getitem__"), 
 new FunctionObject(list_getitem));
 set_klass_dict(klass_dict);

 (new HiTypeObject())->set_own_klass(this);
 set_name(new HiString("list"));
 add_super(ObjectKlass::get_instance());
}

HiObject* ListKlass::add(HiObject* x, HiObject* y) {
 HiList* lx = (HiList*)x;
 assert(lx && lx->klass() == (Klass*) this);
 HiList* ly = (HiList*)y;
 assert(ly && ly->klass() == (Klass*) this);

 HiList* z = new HiList();
 for (int i = 0; i < lx->size(); i++) {
 z->inner_list()->set(i, lx->inner_list()->get(i));
 }

 for (int i = 0; i < ly->size(); i++) {
 z->inner_list()->set(i + lx->size(),
 ly->inner_list()->get(i));
 }

 return z;
}

HiObject* ListKlass::mul(HiObject* x, HiObject* y) {
 HiList * lx = (HiList*)x;
 assert(lx && lx->klass() == (Klass*) this);
 HiInteger* iy = (HiInteger*)y;
 assert(iy && iy->klass() == IntegerKlass::get_instance());

 HiList* z = new HiList();
 for (int i = 0; i < iy->value(); i++) {
 for (int j = 0; j < lx->size(); j++) {
 z->inner_list()->set(i * lx->size() + j,
 lx->inner_list()->get(j));
 }
 }

 return z;
}

void ListKlass::print(HiObject* x) {
 HiList * lx = (HiList*)x;
 assert(lx && lx->klass() == (Klass*) this);

 printf("[");

 int size = lx->_inner_list->size();
 if (size >= 1)
 lx->_inner_list->get(0)->print();

 for (int i = 1; i < size; i++) {
 printf(", ");
 lx->_inner_list->get(i)->print();
 }
 printf("]");
}

HiObject* ListKlass::subscr(HiObject* x, HiObject* y) {
 assert(x && x->klass() == (Klass*) this);
 assert(y && y->klass() == (Klass*) IntegerKlass::get_instance());

 HiList * lx = (HiList*)x;
 HiInteger* iy = (HiInteger*)y;
 
 return lx->inner_list()->get(iy->value());
}

void ListKlass::store_subscr(HiObject* x, HiObject* y, HiObject* z) {
 assert(x && x->klass() == (Klass*) this);
 assert(y && y->klass() == IntegerKlass::get_instance());

 HiList * lx = (HiList*)x;
 HiInteger* iy = (HiInteger*)y;
 
 lx->inner_list()->set(iy->value(), z);
}

void ListKlass::del_subscr(HiObject* x, HiObject* y) {
 assert(x && x->klass() == (Klass*) this);
 assert(y && y->klass() == IntegerKlass::get_instance());

 HiList * lx = (HiList*)x;
 HiInteger* iy = (HiInteger*)y;
 
 lx->inner_list()->delete_index(iy->value());
}

HiObject* ListKlass::contains(HiObject* x, HiObject* y) {
 HiList * lx = (HiList*)x;
 assert(lx && lx->klass() == (Klass*) this);

 int size = lx->_inner_list->size();
 for (int i = 1; i < size; i++) {
 if (lx->_inner_list->get(i)->equal(y))
 return Universe::HiTrue;
 }

 return Universe::HiFalse;
}

HiObject* ListKlass::iter(HiObject* x) {
 assert(x && x->klass() == this);
 return new ListIterator((HiList*)x);
}

HiObject* ListKlass::less(HiObject* x, HiObject* y) {
 HiList * lx = (HiList*)x;
 assert(lx && lx->klass() == (Klass*) this);

 if (x->klass() != y->klass()) {
 if (Klass::compare_klass(x->klass(), y->klass()) < 0)
 return Universe::HiTrue;
 else
 return Universe::HiFalse;
 }

 HiList * ly = (HiList*)y;
 assert(ly && ly->klass() == (Klass*) this);

 int len = lx->size() < ly->size() ?
 lx->size() : ly->size();

 for (int i = 0; i < len; i++) {
 if (lx->get(i)->less(ly->get(i)) == Universe::HiTrue) {
 return Universe::HiTrue;
 }
 else if (lx->get(i)->equal(ly->get(i)) != Universe::HiTrue) {
 return Universe::HiFalse;
 }
 }

 if (lx->size() < ly->size())
 return Universe::HiTrue;

 return Universe::HiFalse;
}

HiList::HiList() {
 set_klass(ListKlass::get_instance());
 _inner_list = new ArrayList<HiObject*>();
}

HiList::HiList(ObjList ol) {
 set_klass(ListKlass::get_instance());
 _inner_list = ol;
}

HiObject* list_append(ObjList args) {
 ((HiList*)(args->get(0)))->append(args->get(1));
 return Universe::HiNone;
}

HiObject* list_sort(ObjList args) {
 HiList* list = (HiList*)(args->get(0));
 assert(list && list->klass() == ListKlass::get_instance());

 // bubble sort
 for (int i = 0; i < list->size(); i++) {
 for (int j = list->size() - 1; j > i; j--) {
 if (list->get(j)->less(list->get(j-1)) == Universe::HiTrue) {
 HiObject* t = list->get(j);
 list->set(j, list->get(j-1));
 list->set(j-1, t);
 }
 }
 }

 return Universe::HiNone;
}

HiObject* list_extend(ObjList args) {
 HiList* lx = (HiList*)(args->get(0));
 HiObject* obj = args->get(1);

 HiObject* next_func = obj->iter()->getattr(StringTable::get_instance()->next_str);
 assert(next_func != Universe::HiNone);

 HiObject* to;
 while ((to = Interpreter::get_instance()->call_virtual(next_func, NULL)) != NULL) {
 lx->append(to);
 }

 return Universe::HiNone;
}

HiObject* list_pop(ObjList args) {
 HiList* list = (HiList*)(args->get(0));
 assert(list && list->klass() == ListKlass::get_instance());
 return list->pop();
}

HiObject* list_remove(ObjList args) {
 HiList* list = (HiList*)(args->get(0));
 HiObject* target = (HiObject*)(args->get(1));

 assert(list && list->klass() == ListKlass::get_instance());

 for (int i = 0; i < list->inner_list()->size(); i++) {
 if (list->get(i)->equal(target) == (HiObject*)Universe::HiTrue) {
 list->inner_list()->delete_index(i);
 }
 }

 return Universe::HiNone;
}

HiObject* list_reverse(ObjList args) {
 HiList* list = (HiList*)(args->get(0));

 int i = 0;
 int j = list->size() - 1;
 while (i < j) {
 HiObject* t = list->get(i);
 list->set(i, list->get(j));
 list->set(j, t);

 i++;
 j--;
 }

 return Universe::HiNone;
}

int HiList::index(HiObject* t) {
 for (int i = 0; i < size(); i++) {
 if (get(i) == t) {
 return i;
 }
 }

 return -1;
}

HiObject* list_index(ObjList args) {
 HiList* list = (HiList*)(args->get(0));
 HiObject* target = (HiObject*)(args->get(1));

 assert(list && list->klass() == ListKlass::get_instance());

 for (int i = 0; i < list->inner_list()->size(); i++) {
 if (list->get(i)->equal(target) == (HiObject*)Universe::HiTrue) {
 return new HiInteger(i);
 }
 }

 return NULL;
}

HiObject* list_getitem(ObjList args) {
 HiList* list = (HiList*)(args->get(0));
 HiObject* y = (HiObject*)(args->get(1));

 HiInteger* iy = (HiInteger*)y;
 return list->inner_list()->get(iy->value());
}

/*
 * List Iterators
 */
ListIteratorKlass* ListIteratorKlass::instance = NULL;

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

 return instance;
}

ListIteratorKlass::ListIteratorKlass() {
 HiDict* klass_dict = new HiDict();
 klass_dict->put(new HiString("next"), 
 new FunctionObject(listiterator_next));
 set_klass_dict(klass_dict);
}

ListIterator::ListIterator(HiList* list) {
 _owner = list;
 _iter_cnt = 0;
 set_klass(ListIteratorKlass::get_instance());
}

HiObject* listiterator_next(ObjList args) {
 ListIterator* iter = (ListIterator*)(args->get(0));

 HiList* alist = iter->owner();
 int iter_cnt = iter->iter_cnt();
 if (iter_cnt < alist->inner_list()->size()) {
 HiObject* obj = alist->get(iter_cnt);
 iter->inc_cnt();
 return obj;
 }
 else // TODO : we need Traceback here to mark iteration end
 return NULL;
}

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

HiObject* ListKlass::len(HiObject* x) {
 assert(x->klass() == this);
 return new HiInteger(((HiList*)x)->size());
}

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

 f->do_array_list(&((HiList*)obj)->_inner_list);
}

size_t ListKlass::size() {
 return sizeof(HiList);
}