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

FunctionKlass* FunctionKlass::instance = NULL;

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

    return instance;
}

FunctionKlass::FunctionKlass() {
    add_super(ObjectKlass::get_instance());
    set_name(new HiString("function"));
    HiTypeObject* tp_obj = new HiTypeObject();
    tp_obj->set_own_klass(this);
}

void FunctionKlass::print(HiObject* obj) {
    printf("<function : ");
    FunctionObject* fo = static_cast<FunctionObject*>(obj);

    assert(fo && fo->klass() == (Klass*) this);
    fo->func_name()->print();
    printf(">");
}

size_t FunctionKlass::size() {
    return sizeof(FunctionObject);
}

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

    f->do_oop((HiObject**)&fo->_func_code);
    f->do_oop((HiObject**)&fo->_func_name);
    f->do_oop((HiObject**)&fo->_globals);
    f->do_oop((HiObject**)&fo->_closure);
    f->do_array_list(&fo->_defaults);
}

FunctionObject::FunctionObject(HiObject* code_object) {
    CodeObject* co = (CodeObject*) code_object;

    _func_code = co;
    _func_name = co->_co_name;
    _flags     = co->_flag;
    _globals   = NULL;
    _closure   = NULL;

    set_klass(FunctionKlass::get_instance());
}

FunctionObject::FunctionObject(NativeFuncPointer nfp) {
    _func_code = NULL;
    _func_name = NULL;
    _flags     = 0;
    _globals   = NULL;
    _closure   = NULL;
    _native_func = nfp;

    set_klass(NativeFunctionKlass::get_instance());
}

void FunctionObject::set_default(ArrayList<HiObject*>* defaults) {
    if (defaults == NULL) {
        _defaults = NULL;
        return;
    }

    _defaults = new ArrayList<HiObject*>(defaults->length());

    for (int i = 0; i < defaults->length(); i++) {
        _defaults->set(i, defaults->get(i));
    }
}

/*
 * Operations for native calls.
 */

NativeFunctionKlass* NativeFunctionKlass::instance = NULL;

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

    return instance;
}

NativeFunctionKlass::NativeFunctionKlass() {
    add_super(FunctionKlass::get_instance());
    set_name(new HiString("native function"));
    HiTypeObject* tp_obj = new HiTypeObject();
    tp_obj->set_own_klass(this);
}

HiObject* FunctionObject::call(ObjList args) {
    return (*_native_func)(args);
}

/*
 *  Operations for methods
 *  Method is a wrapper for function.
 */
MethodKlass* MethodKlass::instance = NULL;

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

    return instance;
}

MethodKlass::MethodKlass() {
    add_super(FunctionKlass::get_instance());
    set_name(new HiString("method"));
    HiTypeObject* tp_obj = new HiTypeObject();
    tp_obj->set_own_klass(this);
}

size_t MethodKlass::size() {
    return sizeof(MethodObject);
}

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

    f->do_oop((HiObject**)&mo->_owner);
    f->do_oop((HiObject**)&mo->_func);
}

HiObject* len(ObjList args) {
    return args->get(0)->len();
}

HiObject* string_upper(ObjList args) {
    HiObject* arg0 = args->get(0);
    assert(arg0->klass() == StringKlass::get_instance());

    HiString* str_obj = (HiString*)arg0;

    int length = str_obj->length();
    if (length <= 0)
        return Universe::HiNone;

    char* v = new char[length];
    char c;
    for (int i = 0; i < length; i++) {
        c = str_obj->value()[i];
        if (c >= 'a' && c <= 'z')
            v[i] = c - 0x20;
        else
            v[i] = c;
    }

    return new HiString(v, length);
}

HiObject* type_of(ObjList args) {
    HiObject* arg0 = args->get(0);

    return arg0->klass()->type_object();
}

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

    assert(y && y->klass() == TypeKlass::get_instance());

    Klass* k = x->klass();
    if (k->type_object() == y)
        return Universe::HiTrue;

    for (int i = 0; i < k->mro()->size(); i++) {
        if (k->mro()->get(i) == y) {
            return Universe::HiTrue;
        }
    }

    return Universe::HiFalse;
}

HiObject* builtin_super(ObjList args) {
    return NULL;
}

HiObject* sysgc(ObjList args) {
    Universe::heap->gc();
    return Universe::HiNone;
}

bool MethodObject::is_function(HiObject *x) {
    Klass* k = x->klass();
    if (k == (Klass*) FunctionKlass::get_instance())
        return true;

    if (k->mro() == NULL) 
        return false;

    for (int i = 0; i < k->mro()->size(); i++) {
        if (k->mro()->get(i) == 
                FunctionKlass::get_instance()->type_object()) {
            return true;
        }
    }

    return false;
}

bool MethodObject::is_yield_function(HiObject *x) {
    Klass* k = x->klass();
    if (k != (Klass*) FunctionKlass::get_instance())
        return false;

    FunctionObject* fo = (FunctionObject*)x;
    return ((fo->flags() & FunctionObject::CO_GENERATOR) != 0);
}

size_t NativeFunctionKlass::size() {
    return sizeof(FunctionObject);
}

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

    f->do_oop((HiObject**)&fo->_func_code);
    f->do_oop((HiObject**)&fo->_func_name);
    f->do_oop((HiObject**)&fo->_globals);
    f->do_oop((HiObject**)&fo->_closure);
    f->do_array_list(&fo->_defaults);
}

HiObject* iter(ObjList args) {
    return args->get(0)->iter();
}