#include <stdafx.h>
#include "ScriptAPI.h"
#include <Project64/UserInterface/Debugger/debugger.h>
#include <Project64/UserInterface/Debugger/DebugMMU.h>
#include <stdio.h>
#include <string>

#pragma warning(disable: 4702) // disable unreachable code warning

using namespace ScriptAPI;

static size_t MemTypeSize(MemType t);
static duk_ret_t ThrowMemoryError(duk_context* ctx, uint32_t address);

void ScriptAPI::Define_mem(duk_context *ctx)
{
    #define MEM_PROXY_FUNCS(T) js_mem__get<T>, js_mem__set<T>

    const DukPropListEntry props[] = {
        { "getblock",   DukCFunction(js_mem_getblock) },
        { "setblock",   DukCFunction(js_mem_setblock) },
        { "getstring",  DukCFunction(js_mem_getstring) },
        { "setstring",  DukCFunction(js_mem_setblock) },
        { "bindvar",    DukCFunction(js_mem_bindvar) },
        { "bindvars",   DukCFunction(js_mem_bindvars) },
        { "bindstruct", DukCFunction(js_mem_bindstruct) },
        { "typedef",    DukCFunction(js_mem_typedef) },
        { "ramSize",    DukGetter(js_mem__get_ramsize) },
        { "romSize",    DukGetter(js_mem__get_romsize) },
        { "ptr",        DukGetter(js_mem__get_ptr) },
        { "u32",        DukProxy(MEM_PROXY_FUNCS(uint32_t)) },
        { "u16",        DukProxy(MEM_PROXY_FUNCS(uint16_t)) },
        { "u8",         DukProxy(MEM_PROXY_FUNCS(uint8_t)) },
        { "s32",        DukProxy(MEM_PROXY_FUNCS(int32_t)) },
        { "s16",        DukProxy(MEM_PROXY_FUNCS(int16_t)) },
        { "s8",         DukProxy(MEM_PROXY_FUNCS(int8_t)) },
        { "f64",        DukProxy(MEM_PROXY_FUNCS(double)) },
        { "f32",        DukProxy(MEM_PROXY_FUNCS(float)) },
        { nullptr }
    };

    DefineGlobalInterface(ctx, "mem", props);
}

template <class T>
duk_ret_t ScriptAPI::js_mem__get(duk_context *ctx)
{
    CScriptInstance *inst = GetInstance(ctx);

    uint32_t addr = (uint32_t)duk_to_number(ctx, 1);
    
    T value;
    if(inst->Debugger()->DebugLoad_VAddr<T>(addr, value))
    {
        duk_push_number(ctx, value);
        return 1;
    }

    return ThrowMemoryError(ctx, addr);
}

template <class T>
duk_ret_t ScriptAPI::js_mem__set(duk_context *ctx)
{
    CScriptInstance *inst = GetInstance(ctx);

    uint32_t addr = (uint32_t)duk_to_number(ctx, 1);
    T value = (T)duk_to_number(ctx, 2);

    if(inst->Debugger()->DebugStore_VAddr<T>(addr, value))
    {
        duk_push_true(ctx);
        return 1;
    }

    return ThrowMemoryError(ctx, addr);
}

duk_ret_t ScriptAPI::js_mem_getblock(duk_context *ctx)
{
    CheckArgs(ctx, { Arg_Number, Arg_Number });
    CScriptInstance *inst = GetInstance(ctx);

    duk_uint_t addr = duk_to_uint(ctx, 0);
    duk_uint_t length = duk_to_uint(ctx, 1);

    uint8_t *data = (uint8_t*)duk_push_fixed_buffer(ctx, length);
    duk_push_buffer_object(ctx, -1, 0, length, DUK_BUFOBJ_NODEJS_BUFFER);

    uint32_t paddr;
    uint8_t* memsrc = nullptr;
    uint32_t offsetStart = 0;

    if (addr < 0x80000000 || addr >= 0xC0000000)
    {
        if (!g_MMU || !g_MMU->TranslateVaddr(addr, paddr))
        {
            return ThrowMemoryError(ctx, addr);
        }
    }
    else
    {
        paddr = addr & 0x1FFFFFFF;
    }

    if (g_MMU && paddr >= 0x00000000 && (paddr + length) <= g_MMU->RdramSize())
    {
        memsrc = g_MMU->Rdram();
        offsetStart = paddr;
    }
    else if (g_Rom && paddr >= 0x10000000 &&
             ((paddr - 0x10000000) + length) <= g_Rom->GetRomSize())
    {
        memsrc = g_Rom->GetRomAddress();
        offsetStart = paddr - 0x10000000;
    }

    if (memsrc != nullptr)
    {
        uint32_t offsetEnd = offsetStart + length;
        uint32_t alignedOffsetStart = (offsetStart + 15) & ~15;
        uint32_t alignedOffsetEnd = offsetEnd & ~15;
        uint32_t prefixLen = alignedOffsetStart - offsetStart;
        uint32_t middleLen = alignedOffsetEnd - alignedOffsetStart;
        uint32_t suffixLen = offsetEnd - alignedOffsetEnd;

        uint32_t* middleDst = (uint32_t*)&data[0 + prefixLen];
        uint32_t* middleDstEnd = (uint32_t*)&data[0 + prefixLen + middleLen];
        uint32_t* middleSrc = (uint32_t*)&memsrc[alignedOffsetStart];

        for (size_t i = 0; i < prefixLen; i++)
        {
            data[i] = memsrc[(offsetStart + i) ^ 3];
        }

        while (middleDst < middleDstEnd)
        {
            *middleDst++ = _byteswap_ulong(*middleSrc++);
            *middleDst++ = _byteswap_ulong(*middleSrc++);
            *middleDst++ = _byteswap_ulong(*middleSrc++);
            *middleDst++ = _byteswap_ulong(*middleSrc++);
        }

        for (size_t i = 0; i < suffixLen; i++)
        {
            data[(length - suffixLen) + i] = memsrc[(alignedOffsetEnd + i) ^ 3];
        }
    }
    else
    {
        for (size_t i = 0; i < length; i++)
        {
            uint8_t byte;
            if (inst->Debugger()->DebugLoad_VAddr<uint8_t>(addr + i, byte))
            {
                data[i] = byte;
            }
            else
            {
                return ThrowMemoryError(ctx, addr + i);
            }
        }
    }

    return 1;
}

duk_ret_t ScriptAPI::js_mem_getstring(duk_context *ctx)
{
    CheckArgs(ctx, { Arg_Number, Arg_OptNumber });
    CScriptInstance *inst = GetInstance(ctx);

    duk_idx_t nargs = duk_get_top(ctx);

    duk_uint_t addr = duk_to_uint(ctx, 0);
    duk_uint_t maxLength = nargs > 1 ? duk_to_uint(ctx, 1) : 0xFFFFFFFF;
    size_t length = 0;

    for(size_t i = 0; i < maxLength; i++)
    {
        char c;
        if(!inst->Debugger()->DebugLoad_VAddr<char>(addr + i, c))
        {
            return ThrowMemoryError(ctx, addr);
        }

        if(c == 0)
        {
            break;
        }

        length++;
    }

    char *str = new char[length + 1];
    str[length] = '\0';

    for(size_t i = 0; i < length; i++)
    {
        if(!inst->Debugger()->DebugLoad_VAddr<char>(addr + i, str[i]))
        {
            delete[] str;
            return ThrowMemoryError(ctx, addr);
        }
    }

    duk_push_string(ctx, str);
    delete[] str;
    return 1;
}

duk_ret_t ScriptAPI::js_mem_setblock(duk_context *ctx)
{
    CheckArgs(ctx, { Arg_Number, Arg_Any, Arg_OptNumber });
    CScriptInstance *inst = GetInstance(ctx);
    CDebuggerUI *debugger = inst->Debugger();

    duk_idx_t nargs = duk_get_top(ctx);

    char* data;
    duk_size_t dataSize, length;

    uint32_t address = duk_get_uint(ctx, 0);

    if (duk_is_buffer_data(ctx, 1))
    {
        data = (char*)duk_get_buffer_data(ctx, 1, &dataSize);
    }
    else if(duk_is_string(ctx, 1))
    {
        data = (char*)duk_get_lstring(ctx, 1, &dataSize);
    }
    else
    {
        return ThrowInvalidArgsError(ctx);
    }

    if (nargs == 3)
    {
        duk_double_t l = duk_get_number(ctx, 2);

        if (l < 0 || l > dataSize)
        {
            return DUK_RET_RANGE_ERROR;
        }

        length = (duk_size_t)l;
    }
    else
    {
        length = dataSize;
    }

    for (size_t i = 0; i < length; i++)
    {
        if (!debugger->DebugStore_VAddr(address + i, data[i]))
        {
            return ThrowMemoryError(ctx, address + i);
        }
    }

    return 0;
}

duk_ret_t ScriptAPI::js_mem__boundget(duk_context *ctx)
{
    CDebuggerUI *debugger = GetInstance(ctx)->Debugger();

    uint32_t addr = duk_get_uint(ctx, 0);
    duk_int_t type = duk_get_int(ctx, 1);

    union {
        uint8_t u8;
        uint16_t u16;
        uint32_t u32;
        int8_t s8;
        int16_t s16;
        int32_t s32;
        float f32;
        double f64;
    } retval;

    #define MEM_BOUNDGET_TRY(addr, T, result, dukpush) \
        if(debugger->DebugLoad_VAddr<T>(addr, result)) { dukpush(ctx, result); } \
        else { goto memory_error; }
    
    switch(type)
    {
    case U8:
        MEM_BOUNDGET_TRY(addr, uint8_t, retval.u8, duk_push_uint);
        return 1;
    case U16:
        MEM_BOUNDGET_TRY(addr, uint16_t, retval.u16, duk_push_uint);
        return 1;
    case U32:
        MEM_BOUNDGET_TRY(addr, uint32_t, retval.u32, duk_push_uint);
        return 1;
    case S8:
        MEM_BOUNDGET_TRY(addr, int8_t, retval.s8, duk_push_int);
        return 1;
    case S16:
        MEM_BOUNDGET_TRY(addr, int16_t, retval.s16, duk_push_int);
        return 1;
    case S32:
        MEM_BOUNDGET_TRY(addr, int32_t, retval.s32, duk_push_int);
        return 1;
    case F32:
        MEM_BOUNDGET_TRY(addr, float, retval.f32, duk_push_number);
        return 1;
    case F64:
        MEM_BOUNDGET_TRY(addr, double, retval.f64, duk_push_number);
        return 1;
    }

memory_error:
    return ThrowMemoryError(ctx, addr);
}

duk_ret_t ScriptAPI::js_mem__boundset(duk_context *ctx)
{
    CDebuggerUI *debugger = GetInstance(ctx)->Debugger();

    uint32_t addr = duk_get_uint(ctx, 0);
    duk_int_t type = duk_get_int(ctx, 1);

    #define MEM_BOUNDSET_TRY(addr, T, value) \
        if(debugger->DebugStore_VAddr<T>(addr, value)) { return 1; } \
        else { goto memory_error; }

    switch(type)
    {
    case U8:
        MEM_BOUNDSET_TRY(addr, uint8_t, duk_get_uint(ctx, 2) & 0xFF);
        break;
    case U16:
        MEM_BOUNDSET_TRY(addr, uint16_t, duk_get_uint(ctx, 2) & 0xFFFF);
        break;
    case U32:
        MEM_BOUNDSET_TRY(addr, uint32_t, duk_get_uint(ctx, 2));
        break;
    case S8:
        MEM_BOUNDSET_TRY(addr, int8_t, duk_get_int(ctx, 2) & 0xFF);
        break;
    case S16:
        MEM_BOUNDSET_TRY(addr, int16_t, duk_get_int(ctx, 2) & 0xFFFF);
        break;
    case S32:
        MEM_BOUNDSET_TRY(addr, int32_t, duk_get_int(ctx, 2));
        break;
    case F32:
        MEM_BOUNDSET_TRY(addr, float, (float)duk_get_number(ctx, 2));
        break;
    case F64:
        MEM_BOUNDSET_TRY(addr, double, duk_get_number(ctx, 2));
        break;
    }

    return 0;

memory_error:
    return ThrowMemoryError(ctx, addr);
}

duk_ret_t ScriptAPI::js_mem_bindvar(duk_context *ctx)
{
    CheckArgs(ctx, { Arg_Object, Arg_Number, Arg_String, Arg_Number });

    duk_uint_t addr = duk_get_uint(ctx, 1);
    const char* key = duk_get_string(ctx, 2);
    duk_int_t type = duk_get_int(ctx, 3);

    duk_push_string(ctx, key);

    // [ ... js_mem__boundget ] -> [ ... js_mem__boundget.bind(obj, addr, type) ]
    duk_push_c_function(ctx, js_mem__boundget, DUK_VARARGS);
    duk_push_string(ctx, "bind");
    duk_dup(ctx, 0);
    duk_push_uint(ctx, addr);
    duk_push_int(ctx, type);
    duk_call_prop(ctx, -5, 3);
    duk_remove(ctx, -2);

    duk_push_c_function(ctx, js_mem__boundset, DUK_VARARGS);
    duk_push_string(ctx, "bind");
    duk_dup(ctx, 0);
    duk_push_uint(ctx, addr);
    duk_push_int(ctx, type);
    duk_call_prop(ctx, -5, 3);
    duk_remove(ctx, -2);

    duk_def_prop(ctx, 0, DUK_DEFPROP_HAVE_GETTER | DUK_DEFPROP_HAVE_SETTER);

    return 0;
}

duk_ret_t ScriptAPI::js_mem_bindvars(duk_context *ctx)
{
    CheckArgs(ctx, { Arg_Object, Arg_Array });

    duk_size_t length = duk_get_length(ctx, 1);

    for(duk_uarridx_t i = 0; i < length; i++)
    {
        duk_get_prop_index(ctx, 1, i);
        if(!duk_is_array(ctx, -1) ||
           duk_get_length(ctx, -1) != 3)
        {
            return DUK_RET_TYPE_ERROR;
        }

        duk_push_c_function(ctx, js_mem_bindvar, 4);
        duk_dup(ctx, 0);
        duk_get_prop_index(ctx, -3, 0);
        duk_get_prop_index(ctx, -4, 1);
        duk_get_prop_index(ctx, -5, 2);

        if(duk_pcall(ctx, 4) != DUK_EXEC_SUCCESS)
        {
            return duk_throw(ctx);
        }

        duk_pop_n(ctx, 1);
    }

    duk_dup(ctx, 0);
    return 1;
}

duk_ret_t ScriptAPI::js_mem_bindstruct(duk_context *ctx)
{
    CheckArgs(ctx, { Arg_Object, Arg_Number, Arg_Object });

    uint32_t curAddr = duk_get_uint(ctx, 1);

    duk_enum(ctx, 2, DUK_ENUM_OWN_PROPERTIES_ONLY);

    while(duk_next(ctx, -1, 1))
    {
        MemType type = (MemType)duk_get_int(ctx, -1);

        duk_push_c_function(ctx, js_mem_bindvar, 4);
        duk_dup(ctx, 0);
        duk_push_uint(ctx, curAddr);
        duk_pull(ctx, -5);
        duk_pull(ctx, -5);

        if(duk_pcall(ctx, 4) != DUK_EXEC_SUCCESS)
        {
            return duk_throw(ctx);
        }

        duk_pop(ctx);

        curAddr += MemTypeSize(type);
    }

    duk_dup(ctx, 0);

    return 1;
}

duk_ret_t ScriptAPI::js_mem__type_constructor(duk_context* ctx)
{
    CheckArgs(ctx, { Arg_Object, Arg_Number });

    duk_push_c_function(ctx, js_mem_bindstruct, 3);
    duk_push_this(ctx);
    duk_pull(ctx, 1);
    duk_pull(ctx, 0);

    if(duk_pcall(ctx, 3) != DUK_EXEC_SUCCESS)
    {
        return duk_throw(ctx);
    }

    return 0;
}

duk_ret_t ScriptAPI::js_mem_typedef(duk_context* ctx)
{
    CheckArgs(ctx, { Arg_Object });

    duk_push_c_function(ctx, js_mem__type_constructor, DUK_VARARGS);
    duk_push_string(ctx, "bind");
    duk_push_null(ctx);
    duk_dup(ctx, 0);
    duk_call_prop(ctx, -4, 2);
    return 1;
}

duk_ret_t ScriptAPI::js_mem__get_ramsize(duk_context* ctx)
{
    duk_push_number(ctx, g_MMU ? g_MMU->RdramSize() : 0);
    return 1;
}

duk_ret_t ScriptAPI::js_mem__get_romsize(duk_context* ctx)
{
    duk_push_number(ctx, g_Rom ? g_Rom->GetRomSize() : 0);
    return 1;
}

duk_ret_t ScriptAPI::js_mem__get_ptr(duk_context* ctx)
{
    duk_push_pointer(ctx, g_MMU ? g_MMU->Rdram() : nullptr);
    return 1;
}

size_t MemTypeSize(MemType t)
{
    switch(t)
    {
    case U8:
    case S8:
        return 1;
    case U16:
    case S16:
        return 2;
    case U32:
    case S32:
    case F32:
        return 4;
    case F64:
        return 8;
    }
    return 0;
}

duk_ret_t ThrowMemoryError(duk_context* ctx, uint32_t address)
{
    duk_push_error_object(ctx, DUK_ERR_ERROR, "memory error (can't access 0x%08X)", address);
    return duk_throw(ctx);
}