#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "vm/Operation.h"
#include "vm/Script.h"

static void sError(Script* sc, const char* format, ...) {
    va_list args;
    va_start(args, format);
    vsnprintf(sc->error, SCRIPT_ERROR_SIZE, format, args);
    va_end(args);
}

static bool sPrinter(Object* o) {
    switch(o->type) {
        case OT_INT: printf("%d\n", o->as.intValue); return false;
        case OT_FLOAT: printf("%.2f\n", o->as.floatValue); return false;
        case OT_CONST_STRING: printf("%s\n", o->as.stringValue); return false;
        case OT_NULL: printf("null\n"); return false;
        case OT_BOOL:
            printf(o->as.intValue ? "true\n" : "false\n");
            return false;
        case OT_ARRAY: printf("array\n"); return false;
        default: return true;
    }
}

static ObjectPrinter printer = sPrinter;

static bool sRead(Script* sc, void* buffer, int length) {
    if(sc->readIndex + length > sc->code->length) {
        sError(sc, "cannot read expected %d bytes of data from bytecode");
        return true;
    }
    memcpy(buffer, sc->code->code + sc->readIndex, length);
    sc->readIndex += length;
    return false;
}

static Operation sReadOperation(Script* sc) {
    unsigned char c;
    if(sRead(sc, &c, 1)) {
        return OP_NOTHING;
    }
    return c;
}

static bool sReadInt(Script* sc, int* i) {
    return !sRead(sc, i, sizeof(int));
}

static bool sCheckType(Script* sc, Object* o, ObjectType ot) {
    if(o->type == ot) {
        return true;
    }
    sError(sc, "object is not of type %s", oGetName(ot));
    return false;
}

static bool sPush(Script* sc, Object* o) {
    if(sc->stackIndex >= SCRIPT_STACK_SIZE) {
        sError(sc, "stack overflow");
        return false;
    }
    sc->stack[sc->stackIndex++] = *o;
    return true;
}

static bool sPop(Script* sc, Object* o) {
    if(sc->stackIndex <= 0) {
        sError(sc, "stack underflow");
        return true;
    }
    *o = sc->stack[--sc->stackIndex];
    return false;
}

static void sPopEmpty(Script* sc) {
    Object o;
    sPop(sc, &o);
}

static Object* sPeek(Script* sc) {
    if(sc->stackIndex <= 0) {
        sError(sc, "stack underflow");
        return NULL;
    }
    return sc->stack + (sc->stackIndex - 1);
}

static bool sPushInt(Script* sc, int value) {
    Object o = {.type = OT_INT, .as.intValue = value};
    return sPush(sc, &o);
}

static void sPushFloat(Script* sc, float value) {
    Object o = {.type = OT_FLOAT, .as.floatValue = value};
    sPush(sc, &o);
}

static void sPushNull(Script* sc) {
    Object o = {.type = OT_NULL};
    sPush(sc, &o);
}

static void sPushBool(Script* sc, bool value) {
    Object o = {.type = OT_BOOL, .as.intValue = value};
    sPush(sc, &o);
}

static void sPushReference(Script* sc, int pointer, int index) {
    Object o = {.type = OT_REFERENCE,
                .as.reference.pointer = pointer,
                .as.reference.index = index};
    sPush(sc, &o);
}

static void sPushVars(Script* sc) {
    int vars = 0;
    int offset = 0;
    if(sReadInt(sc, &vars) && sReadInt(sc, &offset)) {
        int stackVarIndex = sc->stackVarIndex;
        sc->stackVarIndex = sc->stackIndex - offset;
        for(int i = 0; i < vars - offset; i++) {
            sPushNull(sc);
        }
        sPushInt(sc, stackVarIndex);
    }
}

static void sPopVars(Script* sc) {
    int value = 0;
    Object o;
    if(sReadInt(sc, &value) && !sPop(sc, &o) && sCheckType(sc, &o, OT_INT)) {
        sc->stackVarIndex = o.as.intValue;
        if(sc->stackIndex < value) {
            sError(sc, "stack underflow");
        } else {
            sc->stackIndex -= value;
        }
    }
}

static void sReferenceFromVar(Script* sc) {
    int value = 0;
    if(sReadInt(sc, &value)) {
        sPushReference(sc, -1, value + sc->stackVarIndex);
    }
}

static void sReferenceFromArray(Script* sc) {
    int value = 0;
    Object o;
    if(sReadInt(sc, &value) && !sPop(sc, &o) && sCheckType(sc, &o, OT_INT)) {
        sPushReference(sc, value, o.as.intValue);
    }
}

static Object* sDereference(Script* sc, Object* reference) {
    int pointer = reference->as.reference.pointer;
    int index = reference->as.reference.index;
    if(pointer == -1) {
        if(index < 0 || index >= sc->stackIndex) {
            sError(sc, "variable reference index exceeds stack");
            return NULL;
        }
        return sc->stack + index;
    } else {
        if(pointer < 0 || pointer >= sc->allocator.capacity) {
            sError(sc, "array reference pointer is out of range");
            return NULL;
        } else if(index < 0 || index >= sc->allocator.data[pointer].length) {
            sError(sc, "array reference index is out of bounds");
            return NULL;
        }
        return sc->allocator.data[pointer].data + index;
    }
}

static Object* sPopAndDereference(Script* sc) {
    Object o;
    if(!sPop(sc, &o) && sCheckType(sc, &o, OT_REFERENCE)) {
        return sDereference(sc, &o);
    }
    return NULL;
}

static void sDereferencePush(Script* sc) {
    Object* o = sPopAndDereference(sc);
    if(o != NULL) {
        sPush(sc, o);
    }
}

static void sSet(Script* sc) {
    Object value;
    if(sPop(sc, &value)) {
        return;
    }
    Object* o = sPopAndDereference(sc);
    if(o != NULL) {
        *o = value;
    }
}

static void sAllocateArray(Script* sc) {
    Object length;
    if(!sPop(sc, &length) && sCheckType(sc, &length, OT_INT)) {
        if(length.as.intValue < 0) {
            sError(sc, "negative array length");
            return;
        }
        Object o = {.type = OT_ARRAY,
                    .as.intValue =
                        aAllocate(&sc->allocator, length.as.intValue)};
        sPush(sc, &o);
    }
}

static void sArrayLength(Script* sc) {
    Object* o = sPopAndDereference(sc);
    if(o != NULL && sCheckType(sc, o, OT_ARRAY)) {
        int arrayPointer = o->as.intValue;
        if(arrayPointer < 0 || arrayPointer >= sc->allocator.capacity) {
            sError(sc, "array pointer is out of range");
            return;
        }
        sPushInt(sc, sc->allocator.data[arrayPointer].length);
    }
}

static void sPreChange(Script* sc, int change) {
    Object* o = sPopAndDereference(sc);
    if(o != NULL) {
        if(o->type == OT_INT) {
            o->as.intValue += change;
        } else if(o->type == OT_FLOAT) {
            o->as.floatValue += change;
        } else {
            sError(sc, "variable is '%s' not a number", oGetName(o->type));
            return;
        }
        sPush(sc, o);
    }
}

static void sPreIncrement(Script* sc) {
    sPreChange(sc, 1);
}

static void sPreDecrement(Script* sc) {
    sPreChange(sc, -1);
}

static void sPostChange(Script* sc, int change) {
    Object* o = sPopAndDereference(sc);
    if(o != NULL) {
        if(o->type == OT_INT) {
            sPush(sc, o);
            o->as.intValue += change;
        } else if(o->type == OT_FLOAT) {
            sPush(sc, o);
            o->as.floatValue += change;
        } else {
            sError(sc, "variable is '%s' not a number", oGetName(o->type));
        }
    }
}

static void sPostIncrement(Script* sc) {
    sPostChange(sc, 1);
}

static void sPostDecrement(Script* sc) {
    sPostChange(sc, -1);
}

static void sPushCodeInt(Script* sc) {
    int value = 0;
    if(sReadInt(sc, &value)) {
        sPushInt(sc, value);
    }
}

static void sPushCodeFloat(Script* sc) {
    float value = 0;
    if(sRead(sc, &value, sizeof(float))) {
        sError(sc, "cannot read a float from the bytecode");
        return;
    }
    sPushFloat(sc, value);
}

static void sPushCodeString(Script* sc) {
    int value = 0;
    if(sReadInt(sc, &value)) {
        char* s = (char*)(sc->code->code + sc->readIndex);
        sc->readIndex += value;
        Object o = {.type = OT_CONST_STRING, .as.stringValue = s};
        sPush(sc, &o);
    }
}

#define CHECKED_NUMBER_OP(check, op, typeA, typeB)                             \
    {                                                                          \
        Object o[2];                                                           \
        if(sPop(sc, o) || sPop(sc, o + 1)) {                                   \
            return;                                                            \
        } else if(o[0].type == OT_INT && o[1].type == OT_INT) {                \
            check sPush##typeA(sc, o[1].as.intValue op o[0].as.intValue);      \
        } else if(o[0].type == OT_INT && o[1].type == OT_FLOAT) {              \
            sPush##typeB(sc, o[1].as.floatValue op o[0].as.intValue);          \
        } else if(o[0].type == OT_FLOAT && o[1].type == OT_INT) {              \
            sPush##typeB(sc, o[1].as.intValue op o[0].as.floatValue);          \
        } else if(o[0].type == OT_FLOAT && o[1].type == OT_FLOAT) {            \
            sPush##typeB(sc, o[1].as.floatValue op o[0].as.floatValue);        \
        } else {                                                               \
            sError(sc, "object is not a number");                              \
        }                                                                      \
    }
#define NUMBER_NUMBER_OP(op) CHECKED_NUMBER_OP(, op, Int, Float)
#define NUMBER_BOOL_OP(op) CHECKED_NUMBER_OP(, op, Bool, Bool)
#define CHECKED_INT_OP(check, op)                                              \
    {                                                                          \
        Object o[2];                                                           \
        if(!sPop(sc, o) && !sPop(sc, o + 1) && sCheckType(sc, o, OT_INT) &&    \
           sCheckType(sc, o + 1, OT_INT)) {                                    \
            check sPushInt(sc, o[1].as.intValue op o[0].as.intValue);          \
        }                                                                      \
    }
#define INT_OP(op) CHECKED_INT_OP(, op)
#define ZERO_CHECK(op)                                                         \
    if(o[0].as.intValue == 0) {                                                \
        sError(sc, op " by 0");                                                \
        return;                                                                \
    }
#define DIVISION CHECKED_NUMBER_OP(ZERO_CHECK("division"), /, Int, Float)
#define MODULE CHECKED_INT_OP(ZERO_CHECK("module"), %);

static void sInvertSign(Script* sc) {
    Object* o = sPeek(sc);
    if(o == NULL) {
        return;
    } else if(o->type == OT_INT) {
        o->as.intValue = -o->as.intValue;
    } else if(o->type == OT_FLOAT) {
        o->as.floatValue = -o->as.floatValue;
    } else {
        sError(sc, "object is not a number");
    }
}

static void sEqual(Script* sc) {
    Object o[2];
    if(sPop(sc, o) || sPop(sc, o + 1)) {
        return;
    } else if(o[0].type == OT_INT && o[1].type == OT_INT) {
        sPushBool(sc, o[0].as.intValue == o[1].as.intValue);
    } else if(o[0].type == OT_INT && o[1].type == OT_FLOAT) {
        sPushBool(sc, o[0].as.intValue == o[1].as.floatValue);
    } else if(o[0].type == OT_FLOAT && o[1].type == OT_INT) {
        sPushBool(sc, o[0].as.floatValue == o[1].as.intValue);
    } else if(o[0].type == OT_FLOAT && o[1].type == OT_FLOAT) {
        sPushBool(sc, o[0].as.floatValue == o[1].as.floatValue);
    } else if(o[0].type == OT_BOOL && o[1].type == OT_BOOL) {
        sPushBool(sc, o[0].as.intValue == o[1].as.intValue);
    } else if(o[0].type == OT_NULL && o[1].type == OT_NULL) {
        sPushBool(sc, true);
    } else {
        sError(sc, "object types do not match");
    }
}

static void sNot(Script* sc) {
    Object* o = sPeek(sc);
    if(o != NULL && sCheckType(sc, o, OT_BOOL)) {
        o->as.intValue = !o->as.intValue;
    }
}

static void sBitNot(Script* sc) {
    Object* o = sPeek(sc);
    if(o != NULL && sCheckType(sc, o, OT_INT)) {
        o->as.intValue = ~o->as.intValue;
    }
}

static void sAnd(Script* sc) {
    Object o[2];
    if(!sPop(sc, o) && !sPop(sc, o + 1) && sCheckType(sc, o, OT_BOOL) &&
       sCheckType(sc, o + 1, OT_BOOL)) {
        sPushBool(sc, o[0].as.intValue && o[1].as.intValue);
    }
}

static void sOr(Script* sc) {
    Object o[2];
    if(!sPop(sc, o) && !sPop(sc, o + 1) && sCheckType(sc, o, OT_BOOL) &&
       sCheckType(sc, o + 1, OT_BOOL)) {
        sPushBool(sc, o[0].as.intValue || o[1].as.intValue);
    }
}

static void sPrint(Script* sc) {
    Object o;
    if(!sPop(sc, &o) && printer(&o)) {
        sError(sc, "cannot print given object");
    }
}

static void sLine(Script* sc) {
    if(sRead(sc, &sc->line, 2)) {
        sError(sc, "line operation without a line");
    }
}

static void sGoTo(Script* sc) {
    int gotoIndex;
    if(sReadInt(sc, &gotoIndex)) {
        sc->readIndex = gotoIndex;
    }
}

static void sGoSub(Script* sc) {
    int gotoIndex;
    int arguments;
    if(sReadInt(sc, &gotoIndex) && sReadInt(sc, &arguments)) {
        int returnStackIndex = sc->stackIndex - arguments - 1;
        if(returnStackIndex < 0 || sc->stack[returnStackIndex].type != OT_INT) {
            sError(sc, "cannot find return address on stack");
            return;
        }
        sc->stack[returnStackIndex].as.intValue = sc->readIndex;
        sc->readIndex = gotoIndex;
    }
}

static void sIfGoTo(Script* sc) {
    int gotoIndex;
    Object o;
    if(sReadInt(sc, &gotoIndex) && !sPop(sc, &o) &&
       sCheckType(sc, &o, OT_BOOL) && !o.as.intValue) {
        sc->readIndex = gotoIndex;
    }
}

static void sSetReturn(Script* sc) {
    sPop(sc, &sc->returnValue);
}

static void sReturn(Script* sc) {
    Object o;
    if(!sPop(sc, &o) && sCheckType(sc, &o, OT_INT)) {
        sc->readIndex = o.as.intValue;
        if(sc->returnValue.type != OT_VOID) {
            sPush(sc, &sc->returnValue);
            sc->returnValue.type = OT_VOID;
        }
    }
}

static void sDuplicate(Script* sc) {
    Object* o = sPeek(sc);
    if(o != NULL) {
        sPush(sc, o);
    }
}

static void sConsumeInstruction(Script* sc) {
    switch(sReadOperation(sc)) {
        case OP_NOTHING: break;
        case OP_PUSH_INT: sPushCodeInt(sc); break;
        case OP_PUSH_FLOAT: sPushCodeFloat(sc); break;
        case OP_PUSH_CONST_STRING: sPushCodeString(sc); break;
        case OP_PUSH_NULL: sPushNull(sc); break;
        case OP_PUSH_TRUE: sPushBool(sc, true); break;
        case OP_PUSH_FALSE: sPushBool(sc, false); break;
        case OP_PUSH_VARS: sPushVars(sc); break;
        case OP_POP_VARS: sPopVars(sc); break;
        case OP_POP: sPopEmpty(sc); break;
        case OP_SET: sSet(sc); break;
        case OP_PRE_INCREMENT: sPreIncrement(sc); break;
        case OP_POST_INCREMENT: sPostIncrement(sc); break;
        case OP_PRE_DECREMENT: sPreDecrement(sc); break;
        case OP_POST_DECREMENT: sPostDecrement(sc); break;
        case OP_ADD: NUMBER_NUMBER_OP(+); break;
        case OP_SUB: NUMBER_NUMBER_OP(-); break;
        case OP_MUL: NUMBER_NUMBER_OP(*); break;
        case OP_DIV: DIVISION; break;
        case OP_MOD: MODULE; break;
        case OP_INVERT_SIGN: sInvertSign(sc); break;
        case OP_LESS: NUMBER_BOOL_OP(<); break;
        case OP_GREATER: NUMBER_BOOL_OP(>); break;
        case OP_EQUAL: sEqual(sc); break;
        case OP_NOT: sNot(sc); break;
        case OP_AND: sAnd(sc); break;
        case OP_OR: sOr(sc); break;
        case OP_BIT_NOT: sBitNot(sc); break;
        case OP_BIT_AND: INT_OP(&); break;
        case OP_BIT_OR: INT_OP(|); break;
        case OP_BIT_XOR: INT_OP(^); break;
        case OP_LEFT_SHIFT: INT_OP(<<); break;
        case OP_RIGHT_SHIFT: INT_OP(>>); break;
        case OP_PRINT: sPrint(sc); break;
        case OP_LINE: sLine(sc); break;
        case OP_GOTO: sGoTo(sc); break;
        case OP_GOSUB: sGoSub(sc); break;
        case OP_IF_GOTO: sIfGoTo(sc); break;
        case OP_SET_RETURN: sSetReturn(sc); break;
        case OP_RETURN: sReturn(sc); break;
        case OP_DUPLICATE: sDuplicate(sc); break;
        case OP_ALLOCATE_ARRAY: sAllocateArray(sc); break;
        case OP_ARRAY_LENGTH: sArrayLength(sc); break;
        case OP_REFERENCE_FROM_VAR: sReferenceFromVar(sc); break;
        case OP_REFERENCE_FROM_ARRAY: sReferenceFromArray(sc); break;
        case OP_DEREFERENCE: sDereferencePush(sc); break;
    }
    sCollectGarbage(sc);
}

static bool sHasData(Script* sc) {
    return sc->readIndex < sc->code->length;
}

Script* sInit(ByteCode* code) {
    Script* sc = malloc(sizeof(Script));
    sc->error[0] = '\0';
    sc->code = code;
    sc->readIndex = 0;
    sc->returnValue.type = OT_VOID;
    sc->stackIndex = 0;
    sc->stackVarIndex = 0;
    sc->line = 0;
    aInit(&sc->allocator);
    return sc;
}

void sDelete(Script* sc) {
    bcDelete(sc->code);
    aDelete(&sc->allocator);
    free(sc);
}

void sRun(Script* sc) {
    while(sHasData(sc)) {
        sConsumeInstruction(sc);
        if(sc->error[0] != '\0') {
            puts("error:");
            printf(" - info: %s\n", sc->error);
            printf(" - line: %d\n", sc->line);
            return;
        }
    }
}

void sSetPrinter(ObjectPrinter p) {
    printer = p;
}

static void sMark(Script* sc, Object* o) {
    if(o->type == OT_ARRAY) {
        Array* a = sc->allocator.data + o->as.intValue;
        a->marked = true;
        for(int i = 0; i < a->length; i++) {
            sMark(sc, a->data + i);
        }
    }
}

void sCollectGarbage(Script* sc) {
    aClearMarker(&sc->allocator);
    for(int i = 0; i < sc->stackIndex; i++) {
        sMark(sc, sc->stack + i);
    }
    aRemoveUnmarked(&sc->allocator);
}