#include "runtime/interpreter.hpp"
#include "runtime/frameObject.hpp"
#include "runtime/universe.hpp"
#include "runtime/functionObject.hpp"
#include "runtime/stringTable.hpp"
#include "runtime/module.hpp"
#include "runtime/traceback.hpp"
#include "runtime/generator.hpp"
#include "runtime/cellObject.hpp"
#include "util/arrayList.hpp"
#include "util/map.hpp"
#include "util/handles.hpp"
#include "object/hiString.hpp"
#include "object/hiInteger.hpp"
#include "object/hiList.hpp"
#include "object/hiDict.hpp"
#include "memory/oopClosure.hpp"

#include <string.h>

#define PUSH(x)       _frame->stack()->append((x))
#define POP()         _frame->stack()->pop()
#define TOP()         _frame->stack()->top()
#define STACK_LEVEL() _frame->stack()->size()
#define PEEK(x)       _frame->stack()->get((x))
#define EMPTY()       (_frame->stack()->size() == 0)

#define HI_TRUE       Universe::HiTrue
#define HI_FALSE      Universe::HiFalse

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

Interpreter* Interpreter::_instance = NULL;

Interpreter* Interpreter::get_instance() {
    if (_instance == NULL) {
        _instance = new Interpreter();
    }

    return _instance;
}

Interpreter::Interpreter() {
    _frame = NULL;
    _exception_class = NULL;
    _pending_exception = NULL;
    _trace_back = NULL;
    _int_status = IS_OK;

    // prepare for import builtin, this should be created first
    _builtins = new ModuleObject(new HiDict());
    _builtins->put(new HiString("object"),   ObjectKlass::get_instance()->type_object());
    _builtins->put(new HiString("True"),     Universe::HiTrue);
    _builtins->put(new HiString("False"),    Universe::HiFalse);
    _builtins->put(new HiString("None"),     Universe::HiNone);

    _builtins->put(new HiString("len"),      new FunctionObject(len));
    _builtins->put(new HiString("iter"),      new FunctionObject(iter));
    _builtins->put(new HiString("type"),     new FunctionObject(type_of));
    _builtins->put(new HiString("isinstance"),new FunctionObject(isinstance));
    _builtins->put(new HiString("super"),    new FunctionObject(builtin_super));
    _builtins->put(new HiString("sysgc"),    new FunctionObject(sysgc));

    _builtins->put(new HiString("int"),      IntegerKlass::get_instance()->type_object());
    _builtins->put(new HiString("object"),   ObjectKlass::get_instance()->type_object());
    _builtins->put(new HiString("str"),      StringKlass::get_instance()->type_object());
    _builtins->put(new HiString("list"),     ListKlass::get_instance()->type_object());
    _builtins->put(new HiString("dict"),     DictKlass::get_instance()->type_object());
}

void Interpreter::initialize() {
    _builtins->extend(ModuleObject::import_module(new HiString("builtin")));
    Universe::stop_iteration = _builtins->get(new HiString("StopIteration"));

    _modules = new HiDict();
    _modules->put(new HiString("__builtins__"), _builtins);
}

void Interpreter::build_frame(HiObject* callable, ObjList args, int op_arg) {
    if (callable->klass() == NativeFunctionKlass::get_instance()) {
        PUSH(((FunctionObject*)callable)->call(args));
    }
    else if (callable->klass() == MethodKlass::get_instance()) {
        MethodObject* method = (MethodObject*) callable;
        // return value is ignored here, because they are handled
        // by other pathes.
        if (!args) {
            args = new ArrayList<HiObject*>(1);
        }
        args->insert(0, method->owner());
        build_frame(method->func(), args, op_arg + 1);
    }
    else if (MethodObject::is_yield_function(callable)) {
        Generator* gtor = new Generator((FunctionObject*) callable, args, op_arg);
        PUSH(gtor);
        return;
    }
    else if (callable->klass() == FunctionKlass::get_instance()) {
        FrameObject* frame = new FrameObject((FunctionObject*) callable, args, op_arg);
        frame->set_sender(_frame);
        _frame = frame;
    }
    else if (callable->klass() == TypeKlass::get_instance()) {
        HiObject* inst = ((HiTypeObject*)callable)->own_klass()->
            allocate_instance(callable, args); 
        PUSH(inst);
    }
    else {
        HiObject* m = callable->get_klass_attr(ST(call));
        if (m != Universe::HiNone)
            build_frame(m, args, op_arg);
        else {
            callable->print();
            printf("\nError : can not call a normal object.\n");
        }
    }
}

void Interpreter::leave_frame() {
    destroy_frame();
    PUSH(_ret_value);
}

void Interpreter::destroy_frame() {
    FrameObject* temp = _frame;
    _frame = _frame->sender();

    delete temp;
}

HiObject* Interpreter::call_virtual(HiObject* func, ObjList args) {
    if (func->klass() == NativeFunctionKlass::get_instance()) {
        // we do not create a virtual frame, but native frame.
        return ((FunctionObject*)func)->call(args);
    }
    else if (func->klass() == MethodKlass::get_instance()) {
        MethodObject* method = (MethodObject*) func;
        if (!args) {
            args = new ArrayList<HiObject*>(1);
        }
        args->insert(0, method->owner());
        return call_virtual(method->func(), args);
    }
    else if (MethodObject::is_function(func)) {
        int size = args ? args->size() : 0;
        FrameObject* frame = new FrameObject((FunctionObject*) func, args, size);
        frame->set_entry_frame(true);
        enter_frame(frame);
        eval_frame();
        destroy_frame();
        return _ret_value;
    }

    return Universe::HiNone;
}

void Interpreter::enter_frame(FrameObject* frame) {
    frame->set_sender(_frame);
    _frame         = frame;
}

void Interpreter::run(CodeObject* codes) {
    _frame = new FrameObject(codes);
    _frame->locals()->put(ST(name), new HiString("__main__"));
    eval_frame();

    if (_int_status == IS_EXCEPTION) {
        _int_status = IS_OK;

        _trace_back->print();
        _pending_exception->print();
        printf("\n");

        _trace_back = NULL;
        _pending_exception = NULL;
        _exception_class = NULL;
    }

    destroy_frame();
}

HiDict* Interpreter::run_mod(CodeObject* codes, HiString* mod_name) {
    FrameObject* frame = new FrameObject(codes);
    frame->set_entry_frame(true);
    frame->locals()->put(ST(name), mod_name);

    enter_frame(frame);
    eval_frame();
    HiDict* result = frame->locals();
    destroy_frame();
    return result;
}

void Interpreter::eval_frame() {
    Block* b;
    FunctionObject* fo;
    ArrayList<HiObject*>* args = NULL;
    HiObject *v, *w, *u;
    unsigned char op_code;
    bool has_argument;
    int op_arg;

    while (_frame->has_more_codes()) {
        if (_int_status != IS_OK)
            goto fast_handle_exception;

        op_code = _frame->get_op_code();
        has_argument = (op_code & 0xFF) >= ByteCode::HAVE_ARGUMENT;

        op_arg = -1;
        if (has_argument) {
            op_arg = _frame->get_op_arg();
        }

        switch (op_code) {
            case ByteCode::POP_TOP:
                POP();
                break;

            case ByteCode::ROT_TWO:
                v = POP();
                w = POP();
                PUSH(v);
                PUSH(w);
                break;

            case ByteCode::ROT_THREE:
                v = POP();
                w = POP();
                u = POP();
                PUSH(v);
                PUSH(u);
                PUSH(w);
                break;

            case ByteCode::DUP_TOP:
                PUSH(TOP());
                break;

            case ByteCode::LOAD_CONST:
                PUSH(_frame->consts()->get(op_arg));
                break;

            case ByteCode::LOAD_NAME:
                v = _frame->names()->get(op_arg);
                w = _frame->locals()->get(v);
                if (w != Universe::HiNone) {
                    PUSH(w);
                    break;
                }

                w = _frame->globals()->get(v);
                if (w != Universe::HiNone) {
                    PUSH(w);
                    break;
                }

                w = _builtins->get(v);
                if (w != Universe::HiNone) {
                    PUSH(w);
                    break;
                }

                PUSH(Universe::HiNone);
                break;

            case ByteCode::LOAD_FAST:
                PUSH(_frame->fast_locals()->get(op_arg));
                break;

            case ByteCode::LOAD_GLOBAL:
                v = _frame->names()->get(op_arg);
                w = _frame->globals()->get(v);
                if (w != Universe::HiNone) {
                    PUSH(w);
                    break;
                }

                w = _builtins->get(v);
                if (w != Universe::HiNone) {
                    PUSH(w);
                    break;
                }

                PUSH(Universe::HiNone);
                break;

            case ByteCode::LOAD_ATTR:
                v = POP();
                w = _frame->_names->get(op_arg);
                PUSH(v->getattr(w));
                break;

            case ByteCode::LOAD_LOCALS:
                PUSH(_frame->_locals);
                break;

            case ByteCode::LOAD_CLOSURE:
                v = _frame->closure()->get(op_arg);
                if (v == NULL) {
                    _frame->closure()->set(op_arg, (_frame->get_cell_from_parameter(op_arg)));
                }

                v = _frame->closure()->get(op_arg);
                if (v->klass() == CellKlass::get_instance()) {
                    PUSH(v);
                }
                else
                    PUSH(new CellObject(_frame->closure(), op_arg));

                break;

            case ByteCode::LOAD_DEREF:
                v = _frame->closure()->get(op_arg);
                if (v->klass() == CellKlass::get_instance()) {
                    v = ((CellObject*)v)->value();
                }
                PUSH(v);
                break;

            case ByteCode::STORE_NAME:
                v = _frame->names()->get(op_arg);
                _frame->locals()->put(v, POP());
                break;

            case ByteCode::STORE_FAST:
                _frame->_fast_locals->set(op_arg, POP());
                break;

            case ByteCode::STORE_GLOBAL:
                v = _frame->names()->get(op_arg);
                _frame->globals()->put(v, POP());
                break;

            case ByteCode::STORE_SUBSCR:
                u = POP();
                v = POP();
                w = POP();
                v->store_subscr(u, w);
                break;

            case ByteCode::STORE_MAP:
                w = POP();
                u = POP();
                v = TOP();
                ((HiDict*)v)->put(w, u);
                break;

            case ByteCode::STORE_ATTR:
                u = POP();
                v = _frame->_names->get(op_arg);
                w = POP();
                u->setattr(v, w);
                break;

            case ByteCode::STORE_DEREF:
                _frame->closure()->set(op_arg, POP());
                break;

            case ByteCode::BINARY_SUBSCR:
                v = POP();
                w = POP();
                PUSH(w->subscr(v));
                break;

            case ByteCode::PRINT_ITEM:
                v = POP();
                v->print();
                break;

            case ByteCode::PRINT_NEWLINE:
                printf("\n");
                break;

            case ByteCode::INPLACE_DIVIDE:
            case ByteCode::BINARY_DIVIDE:
                v = POP();
                w = POP();
                PUSH(w->div(v));
                break;

            case ByteCode::INPLACE_ADD:
            case ByteCode::BINARY_ADD:
                v = POP();
                w = POP();
                PUSH(w->add(v));
                break;

            case ByteCode::BINARY_SUBTRACT:
                v = POP();
                w = POP();
                PUSH(w->sub(v));
                break;

            case ByteCode::BINARY_MULTIPLY:
                v = POP();
                w = POP();
                PUSH(w->mul(v));
                break;

            case ByteCode::INPLACE_MODULO: // drop down
            case ByteCode::BINARY_MODULO:
                v = POP();
                w = POP();
                PUSH(w->mod(v));
                break;

            case ByteCode::MAKE_CLOSURE:
                v = POP();
                fo = new FunctionObject(v);
                fo->set_closure((HiList*)(POP()));
                fo->set_globals(_frame->globals());
                if (op_arg > 0) {
                    args = new ArrayList<HiObject*>(op_arg);
                    while (op_arg--) {
                        args->set(op_arg, POP());
                    }
                }
                fo->set_default(args);

                if (args != NULL) {
                    args = NULL;
                }

                PUSH(fo);
                break;

            case ByteCode::MAKE_FUNCTION:
                v = POP();
                fo = new FunctionObject(v);
                fo->set_globals(_frame->globals());
                if (op_arg > 0) {
                    args = new ArrayList<HiObject*>(op_arg);
                    while (op_arg--) {
                        args->set(op_arg, POP());
                    }
                }
                fo->set_default(args);

                if (args != NULL) {
                    args = NULL;
                }

                PUSH(fo);
                break;

            case ByteCode::CALL_FUNCTION:
                if (op_arg > 0) {
                    int na = op_arg & 0xff;
                    int nk = op_arg >> 8;
                    int arg_cnt = na + 2 * nk;
                    args = new ArrayList<HiObject*>(arg_cnt);
                    while (arg_cnt--) {
                        args->set(arg_cnt, POP());
                    }
                }

                build_frame(POP(), args, op_arg);

                if (args != NULL) {
                    args = NULL;
                }
                break;

            case ByteCode::RETURN_VALUE:
                _ret_value = POP();
                _int_status = IS_RETURN;
                break;

            case ByteCode::COMPARE_OP:
                w = POP();
                v = POP();

                switch(op_arg) {
                case ByteCode::GREATER:
                    PUSH(v->greater(w));
                    break;

                case ByteCode::LESS:
                    PUSH(v->less(w));
                    break;

                case ByteCode::EQUAL:
                    PUSH(v->equal(w));
                    break;

                case ByteCode::NOT_EQUAL:
                    PUSH(v->not_equal(w));
                    break;

                case ByteCode::GREATER_EQUAL:
                    PUSH(v->ge(w));
                    break;
               
                case ByteCode::LESS_EQUAL: 
                    PUSH(v->le(w));
                    break;

                case ByteCode::IN:
                    PUSH(w->contains(v));
                    break;

                case ByteCode::IS:
                    if (v == w)
                        PUSH(HI_TRUE);
                    else
                        PUSH(HI_FALSE);
                    break;

                case ByteCode::IS_NOT:
                    if (v == w)
                        PUSH(HI_TRUE);
                    else
                        PUSH(HI_FALSE);
                    break;

                case ByteCode::EXC_MATCH:
                {
                    bool found = false;
                    Klass* k = ((HiTypeObject*)v)->own_klass();

                    if (v == w)
                        found = true;
                    else {
                        for (int i = 0; i < k->mro()->size(); i++) {
                            if (v->klass()->mro()->get(i) == w) {
                                found = true;
                                break;
                            }
                        }
                    }

                    if (found)
                        PUSH(Universe::HiTrue);
                    else
                        PUSH(Universe::HiFalse);

                    break;
                }

                default:
                    printf("Error: Unrecognized compare op %d\n", op_arg);

                }
                break;

            case ByteCode::DELETE_SUBSCR:
                w = POP();
                v = POP();
                v->del_subscr(w);
                break;

            case ByteCode::POP_JUMP_IF_FALSE:
                v = POP();
                if (v == Universe::HiFalse)
                    _frame->set_pc(op_arg);
                break;

            case ByteCode::JUMP_FORWARD:
                _frame->set_pc(op_arg + _frame->get_pc());
                break;

            case ByteCode::JUMP_ABSOLUTE:
                _frame->set_pc(op_arg);
                break;

            case ByteCode::SETUP_FINALLY:
            case ByteCode::SETUP_EXCEPT:
            case ByteCode::SETUP_LOOP:
                _frame->loop_stack()->add(new Block(
                    op_code, _frame->get_pc() + op_arg,
                    STACK_LEVEL()));
                break;

            case ByteCode::POP_BLOCK:
                b = _frame->loop_stack()->pop();
                while (STACK_LEVEL() > b->_level) {
                    POP();
                }
                break;

            case ByteCode::BREAK_LOOP:
                _int_status = IS_BREAK;
                break;

            case ByteCode::CONTINUE_LOOP:
                _int_status = IS_CONTINUE;
                _ret_value = (HiObject*)((long)op_arg);
                break;

            case ByteCode::END_FINALLY:
                // TODO: restore exceptions
                v = POP();
                if (((long)v) & 0x1) {
                    _int_status = (Status)(((long)v) >> 1);
                    if (_int_status == IS_RETURN)
                        _ret_value = POP();
                    else if (_int_status == IS_CONTINUE)
                        _frame->_pc = (int)((long)(POP()));
                }
                else if (v != Universe::HiNone) {
                    _exception_class = v;
                    _pending_exception = POP();
                    _trace_back = POP();
                    _int_status = IS_EXCEPTION;
                }
                break;

            case ByteCode::BUILD_TUPLE: // drop down, we need this
            case ByteCode::BUILD_LIST:
                v = new HiList();
                while (op_arg--) {
                    ((HiList*)v)->set(op_arg, POP());
                }
                PUSH(v);
                break;

            case ByteCode::BUILD_MAP:
                v = new HiDict();
                PUSH(v);
                break;

            case ByteCode::BUILD_CLASS:
                v = POP();
                u = POP();
                w = POP();
                v = Klass::create_klass(v, u, w);
                PUSH(v);
                break;

            case ByteCode::GET_ITER:
                v = POP();
                PUSH(v->iter());
                break;

            case ByteCode::FOR_ITER:
                v = TOP();
                w = v->next();

                if (w == NULL) {
                    // we may encounter a StopIteration, ignore it.
                    //assert(_int_status == IS_EXCEPTION && _pending_exception != NULL);
                    _frame->_pc += op_arg;
                    _int_status = IS_OK;
                    _pending_exception = NULL;
                }
                else {
                    PUSH(w);
                }
                break;

            case ByteCode::UNPACK_SEQUENCE:
                v = POP();

                while (op_arg--) {
                    PUSH(v->subscr(new HiInteger(op_arg)));
                }
                break;

            case ByteCode::IMPORT_NAME:
                POP();
                POP();
                v = _frame->names()->get(op_arg);
                w = _modules->get(v);
                if (w != Universe::HiNone) {
                    PUSH(w);
                    break;
                }
                w = ModuleObject::import_module(v);
                _modules->put(v, w);
                PUSH(w);
                break;

            case ByteCode::IMPORT_FROM:
                v = _frame->names()->get(op_arg);
                w = TOP();
                u = ((ModuleObject*)w)->get(v);
                PUSH(u);
                break;

            case ByteCode::DUP_TOPX:
                for (int i = 0; i < op_arg; i++) {
                    int index = STACK_LEVEL() - op_arg;
                    PUSH(PEEK(index));
                }
                break;

            case ByteCode::CALL_FUNCTION_VAR:
                v = POP();
                if (op_arg > 0 || (v && ((HiList*)v)->size() > 0)) {
                    int na = op_arg & 0xff;
                    int nk = op_arg >> 8;
                    int arg_cnt = na + 2 * nk;
                    args = new ArrayList<HiObject*>();
                    while (arg_cnt--) {
                        args->set(arg_cnt, POP());
                    }

                    int s = ((HiList*)v)->size();
                    for (int i = 0; i < s; i++) {
                        args->add(((HiList*)v)->get(i));
                    }
                    na += s;
                    op_arg = (nk << 8) | na;
                }

                build_frame(POP(), args, op_arg);

                if (args != NULL) {
                    args = NULL;
                }
                break;

            case ByteCode::RAISE_VARARGS:
                w = v = u = NULL;
                switch (op_arg) {
                case 3:
                    u = POP();
                case 2:
                    v = POP();
                case 1:
                    w = POP();
                    break;
                }
                do_raise(w, v, u);

                break;

            case ByteCode::YIELD_VALUE:
                // we are assured that we're in the progress
                // of evalating generator.
                _int_status = IS_YIELD;
                _ret_value = TOP();
                return;

            default:
                printf("Error: Unrecognized byte code %d\n", op_code);
        }

fast_handle_exception:
        while (_int_status != IS_OK && _frame->_loop_stack->size() != 0) {
            b = _frame->_loop_stack->get(_frame->_loop_stack->size()-1);
            if (_int_status == IS_CONTINUE && b->_type == ByteCode::SETUP_LOOP) {
                _frame->_pc = (int)((long)_ret_value);
                _int_status = IS_OK;
                break;
            }

            b = _frame->_loop_stack->pop();
            while (STACK_LEVEL() > b->_level) {
                POP();
            }

            if (_int_status == IS_BREAK && b->_type == ByteCode::SETUP_LOOP) {
                _frame->_pc = b->_target;;
                _int_status = IS_OK;
            }
            else if (b->_type == ByteCode::SETUP_FINALLY || 
                    (_int_status == IS_EXCEPTION
                    && b->_type == ByteCode::SETUP_EXCEPT)) {
                if (_int_status == IS_EXCEPTION) {
                    // traceback, value, exception class
                    PUSH(_trace_back);
                    PUSH(_pending_exception);
                    PUSH(_exception_class);

                    _trace_back = NULL;
                    _pending_exception = NULL;
                    _exception_class = NULL;
                }
                else {
                    if (_int_status == IS_RETURN ||
                            _int_status == IS_CONTINUE)
                        PUSH(_ret_value);

                    PUSH((HiObject*)(((long)_int_status << 1) | 0x1));
                }
                _frame->_pc = b->_target;;
                _int_status = IS_OK;
            }
        }

        // has pending exception and no handler found, unwind stack.
        if (_int_status != IS_OK && _frame->_loop_stack->size() == 0) {
            if (_int_status == IS_EXCEPTION) {
                _ret_value = NULL;
                ((Traceback*)_trace_back)->record_frame(_frame);
            }

            if (_int_status == IS_RETURN)
                _int_status = IS_OK;

            if (_frame->is_first_frame() ||
                    _frame->is_entry_frame())
                return;
            leave_frame();
        }
    }
}

void Interpreter::oops_do(OopClosure* f) {
    f->do_oop((HiObject**)&_builtins);
    f->do_oop((HiObject**)&_modules);
    f->do_oop((HiObject**)&_ret_value);
    f->do_oop((HiObject**)&_exception_class);
    f->do_oop((HiObject**)&_pending_exception);
    f->do_oop((HiObject**)&_trace_back);

    if (_frame)
        _frame->oops_do(f);
}

Interpreter::Status Interpreter::do_raise(HiObject* exc, HiObject* val, HiObject* tb) {
    assert(exc != NULL);

    _int_status = IS_EXCEPTION;

    if (tb == NULL) {
        tb = new Traceback();
    }

    if (val != NULL) {
        _exception_class = exc;
        _pending_exception = val;
        _trace_back = tb;
        return IS_EXCEPTION;
    }

    if (exc->klass() == TypeKlass::get_instance()) {
        _pending_exception = call_virtual(exc, NULL);
        _exception_class = exc;
    }
    else {
        _pending_exception = exc;
        _exception_class = _pending_exception->klass()->type_object();
    }
    _trace_back = tb;
    return IS_EXCEPTION;
}

HiObject* Interpreter::eval_generator(Generator* g) {
    Handle handle(g);
    enter_frame(g->frame());
    g->frame()->set_entry_frame(true);
    eval_frame();

    if (_int_status != IS_YIELD) {
        _int_status = IS_OK;
        leave_frame();
        ((Generator*)handle())->set_frame(NULL);
        return NULL;
    }

    _int_status = IS_OK;
    _frame = _frame->sender();

    return _ret_value;
}