#include "stdafx.h"

#include "../OpInfo.h"
#include "ScriptAPI.h"

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

using namespace ScriptAPI;

static bool CbCond_PcBetween(JSAppCallback * cb, void * env);
static bool CbCond_ReadAddrBetween(JSAppCallback * cb, void * env);
static bool CbCond_WriteAddrBetween(JSAppCallback * cb, void * env);
static bool CbCond_PcBetween_OpcodeEquals(JSAppCallback * cb, void * env);
static bool CbCond_PcBetween_GprValueEquals(JSAppCallback * cb, void * env);

static duk_idx_t CbArgs_GenericEventObject(duk_context * ctx, void * env);
static duk_idx_t CbArgs_EmuStateChangeEventObject(duk_context * ctx, void * env);
static duk_idx_t CbArgs_ExecEventObject(duk_context * ctx, void * env);
static duk_idx_t CbArgs_ReadEventObject(duk_context * ctx, void * env);
static duk_idx_t CbArgs_WriteEventObject(duk_context * ctx, void * env);
static duk_idx_t CbArgs_OpcodeEventObject(duk_context * ctx, void * env);
static duk_idx_t CbArgs_RegValueEventObject(duk_context * ctx, void * env);
static duk_idx_t CbArgs_MouseEventObject(duk_context * ctx, void * env);
static duk_idx_t CbArgs_SPTaskEventObject(duk_context * ctx, void * env);
static duk_idx_t CbArgs_PIEventObject(duk_context * ctx, void * env);

static duk_ret_t RequireAddressOrAddressRange(duk_context * ctx, duk_idx_t idx, uint32_t * addrStart, uint32_t * addrEnd);
static duk_ret_t RequireInterpreterCPU(duk_context * ctx);

void ScriptAPI::Define_events(duk_context * ctx)
{
    const DukPropListEntry props[] = {
        {"onstatechange", DukCFunction(js_events_onstatechange)},
        {"onexec", DukCFunction(js_events_onexec)},
        {"onread", DukCFunction(js_events_onread)},
        {"onwrite", DukCFunction(js_events_onwrite)},
        {"ongprvalue", DukCFunction(js_events_ongprvalue)},
        {"onopcode", DukCFunction(js_events_onopcode)},
        {"onpifread", DukCFunction(js_events_onpifread)},
        {"onsptask", DukCFunction(js_events_onsptask)},
        {"onpidma", DukCFunction(js_events_onpidma)},
        {"onmouseup", DukCFunction(js_events_onmouseup)},
        {"onmousedown", DukCFunction(js_events_onmousedown)},
        {"onmousemove", DukCFunction(js_events_onmousemove)},
        {"remove", DukCFunction(js_events_remove)},
        { nullptr }
    };

    DefineGlobalInterface(ctx, "events", props);

    DefineGlobalClass(ctx, "GenericEvent", js_DummyConstructor);
    DefineGlobalClass(ctx, "EmuStateChangeEvent", js_DummyConstructor);
    DefineGlobalClass(ctx, "CPUExecEvent", js_DummyConstructor);
    DefineGlobalClass(ctx, "CPUReadWriteEvent", js_DummyConstructor);
    DefineGlobalClass(ctx, "CPUOpcodeEvent", js_DummyConstructor);
    DefineGlobalClass(ctx, "CPURegValueEvent", js_DummyConstructor);
    DefineGlobalClass(ctx, "SPTaskEvent", js_DummyConstructor);
    DefineGlobalClass(ctx, "PIEvent", js_DummyConstructor);
    DefineGlobalClass(ctx, "DrawEvent", js_DummyConstructor);

    const DukPropListEntry mouseEventStaticProps[] = {
        {"NONE", DukNumber(-1)},
        {"LEFT", DukNumber(0)},
        {"MIDDLE", DukNumber(1)},
        {"RIGHT", DukNumber(2)},
        {nullptr}
    };

    DefineGlobalClass(ctx, "MouseEvent", js_DummyConstructor, nullptr, mouseEventStaticProps);
}

duk_ret_t ScriptAPI::js_events_onstatechange(duk_context * ctx)
{
    CheckArgs(ctx, {Arg_Function});

    JSAppCallbackID callbackId = AddAppCallback(ctx, 0, JS_HOOK_EMUSTATECHANGE,
                                                CbArgs_EmuStateChangeEventObject);
    duk_push_uint(ctx, callbackId);
    return 1;
}

duk_ret_t ScriptAPI::js_events_onexec(duk_context * ctx)
{
    CheckArgs(ctx, {Arg_Any, Arg_Function});

    uint32_t addrStart, addrEnd;
    RequireAddressOrAddressRange(ctx, 0, &addrStart, &addrEnd);

    RequireInterpreterCPU(ctx);

    JSAppCallback cb(GetInstance(ctx), duk_get_heapptr(ctx, 1),
                     CbCond_PcBetween, CbArgs_ExecEventObject);
    cb.m_Params.addrStart = addrStart;
    cb.m_Params.addrEnd = addrEnd;

    JSAppCallbackID callbackId = AddAppCallback(ctx, JS_HOOK_CPU_EXEC, cb);

    duk_push_uint(ctx, callbackId);
    return 1;
}

duk_ret_t ScriptAPI::js_events_onread(duk_context * ctx)
{
    CheckArgs(ctx, {Arg_Any, Arg_Function});

    uint32_t addrStart, addrEnd;
    RequireAddressOrAddressRange(ctx, 0, &addrStart, &addrEnd);

    RequireInterpreterCPU(ctx);

    JSAppCallback cb(GetInstance(ctx), duk_get_heapptr(ctx, 1),
                     CbCond_ReadAddrBetween, CbArgs_ReadEventObject);
    cb.m_Params.addrStart = addrStart;
    cb.m_Params.addrEnd = addrEnd;

    JSAppCallbackID callbackId = AddAppCallback(ctx, JS_HOOK_CPU_READ, cb);

    duk_push_uint(ctx, callbackId);
    return 1;
}

duk_ret_t ScriptAPI::js_events_onwrite(duk_context * ctx)
{
    CheckArgs(ctx, {Arg_Any, Arg_Function});

    uint32_t addrStart, addrEnd;
    RequireAddressOrAddressRange(ctx, 0, &addrStart, &addrEnd);

    RequireInterpreterCPU(ctx);

    JSAppCallback cb(GetInstance(ctx), duk_get_heapptr(ctx, 1),
                     CbCond_WriteAddrBetween, CbArgs_WriteEventObject);
    cb.m_Params.addrStart = addrStart;
    cb.m_Params.addrEnd = addrEnd;

    JSAppCallbackID callbackId = AddAppCallback(ctx, JS_HOOK_CPU_WRITE, cb);

    duk_push_uint(ctx, callbackId);
    return 1;
}

duk_ret_t ScriptAPI::js_events_onopcode(duk_context * ctx)
{
    CheckArgs(ctx, {Arg_Any, Arg_Number, Arg_Number, Arg_Function});

    uint32_t addrStart, addrEnd;
    RequireAddressOrAddressRange(ctx, 0, &addrStart, &addrEnd);

    RequireInterpreterCPU(ctx);

    uint32_t opcode = duk_get_uint(ctx, 1);
    uint32_t mask = duk_get_uint(ctx, 2);

    JSAppCallback cb(GetInstance(ctx), duk_get_heapptr(ctx, 3),
                     CbCond_PcBetween_OpcodeEquals, CbArgs_OpcodeEventObject);
    cb.m_Params.addrStart = addrStart;
    cb.m_Params.addrEnd = addrEnd;
    cb.m_Params.opcode = opcode;
    cb.m_Params.opcodeMask = mask;

    JSAppCallbackID callbackId = AddAppCallback(ctx, JS_HOOK_CPU_EXEC, cb);

    duk_push_uint(ctx, callbackId);
    return 1;
}

duk_ret_t ScriptAPI::js_events_ongprvalue(duk_context * ctx)
{
    CheckArgs(ctx, {Arg_Any, Arg_Number, Arg_Number, Arg_Function});

    uint32_t addrStart, addrEnd;
    RequireAddressOrAddressRange(ctx, 0, &addrStart, &addrEnd);

    RequireInterpreterCPU(ctx);

    JSAppCallback cb(GetInstance(ctx), duk_get_heapptr(ctx, 3),
                     CbCond_PcBetween_GprValueEquals, CbArgs_RegValueEventObject);
    cb.m_Params.addrStart = addrStart;
    cb.m_Params.addrEnd = addrEnd;
    cb.m_Params.regIndices = duk_get_uint(ctx, 1);
    cb.m_Params.regValue = duk_get_uint(ctx, 2);

    JSAppCallbackID callbackId = AddAppCallback(ctx, JS_HOOK_CPU_EXEC, cb);

    duk_push_uint(ctx, callbackId);
    return 1;
}

duk_ret_t ScriptAPI::js_events_onpifread(duk_context * ctx)
{
    CheckArgs(ctx, {Arg_Function});

    JSAppCallbackID callbackId = AddAppCallback(ctx, 0, JS_HOOK_PIFREAD, CbArgs_GenericEventObject);
    duk_push_uint(ctx, callbackId);
    return 1;
}

duk_ret_t ScriptAPI::js_events_onsptask(duk_context * ctx)
{
    CheckArgs(ctx, {Arg_Function});

    JSAppCallbackID callbackId = AddAppCallback(ctx, 0, JS_HOOK_RSPTASK, CbArgs_SPTaskEventObject);
    duk_push_uint(ctx, callbackId);
    return 1;
}

duk_ret_t ScriptAPI::js_events_onpidma(duk_context * ctx)
{
    CheckArgs(ctx, {Arg_Function});

    JSAppCallbackID callbackId = AddAppCallback(ctx, 0, JS_HOOK_PIDMA, CbArgs_PIEventObject);
    duk_push_uint(ctx, callbackId);
    return 1;
}

duk_ret_t ScriptAPI::js_events_onmouseup(duk_context * ctx)
{
    CheckArgs(ctx, {Arg_Function});

    JSAppCallbackID callbackId = AddAppCallback(ctx, 0, JS_HOOK_MOUSEUP, CbArgs_MouseEventObject);
    duk_push_uint(ctx, callbackId);
    return 1;
}

duk_ret_t ScriptAPI::js_events_onmousedown(duk_context * ctx)
{
    CheckArgs(ctx, {Arg_Function});

    JSAppCallbackID callbackId = AddAppCallback(ctx, 0, JS_HOOK_MOUSEDOWN, CbArgs_MouseEventObject);
    duk_push_uint(ctx, callbackId);
    return 1;
}

duk_ret_t ScriptAPI::js_events_onmousemove(duk_context * ctx)
{
    CheckArgs(ctx, {Arg_Function});

    JSAppCallbackID callbackId = AddAppCallback(ctx, 0, JS_HOOK_MOUSEMOVE, CbArgs_MouseEventObject);
    duk_push_uint(ctx, callbackId);
    return 1;
}

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

    JSAppCallbackID callbackId = (JSAppCallbackID)duk_get_uint(ctx, 0);

    if (!RemoveAppCallback(ctx, callbackId))
    {
        duk_push_error_object(ctx, DUK_ERR_REFERENCE_ERROR, "invalid callback ID");
        return duk_throw(ctx);
    }

    return 0;
}

bool CbCond_ReadAddrBetween(JSAppCallback * cb, void * _env)
{
    JSHookCpuStepEnv * env = (JSHookCpuStepEnv *)_env;

    if (!env->opInfo.IsLoadCommand())
    {
        return false;
    }

    uint32_t addr = env->opInfo.GetLoadStoreAddress();

    return (addr >= cb->m_Params.addrStart &&
            addr <= cb->m_Params.addrEnd);
}

bool CbCond_WriteAddrBetween(JSAppCallback * cb, void * _env)
{
    JSHookCpuStepEnv * env = (JSHookCpuStepEnv *)_env;

    if (!env->opInfo.IsStoreCommand())
    {
        return false;
    }

    uint32_t addr = env->opInfo.GetLoadStoreAddress();

    return (addr >= cb->m_Params.addrStart &&
            addr <= cb->m_Params.addrEnd);
}

bool CbCond_PcBetween(JSAppCallback * cb, void * _env)
{
    JSHookCpuStepEnv * env = (JSHookCpuStepEnv *)_env;
    return (env->pc >= cb->m_Params.addrStart &&
            env->pc <= cb->m_Params.addrEnd);
}

bool CbCond_PcBetween_OpcodeEquals(JSAppCallback * cb, void * _env)
{
    if (!CbCond_PcBetween(cb, _env))
    {
        return false;
    }

    JSHookCpuStepEnv * env = (JSHookCpuStepEnv *)_env;
    return cb->m_Params.opcode == (env->opInfo.m_OpCode.Value & cb->m_Params.opcodeMask);
}

static bool CbCond_PcBetween_GprValueEquals(JSAppCallback * cb, void * _env)
{
    if (!CbCond_PcBetween(cb, _env))
    {
        return false;
    }

    JSHookCpuStepEnv * env = (JSHookCpuStepEnv *)_env;

    for (int i = 0; i < 32; i++)
    {
        if (cb->m_Params.regIndices & (1 << i))
        {
            if (g_Reg->m_GPR[i].UW[0] == cb->m_Params.regValue)
            {
                env->outAffectedRegIndex = i;
                return true;
            }
        }
    }

    return false;
}

duk_idx_t CbArgs_EmuStateChangeEventObject(duk_context * ctx, void * _env)
{
    CScriptInstance * inst = GetInstance(ctx);
    JSHookEmuStateChangeEnv * env = (JSHookEmuStateChangeEnv *)_env;
    duk_push_object(ctx);
    SetDummyConstructor(ctx, -1, "EmuStateChangeEvent");

    const DukPropListEntry props[] = {
        {"callbackId", DukUInt(inst->CallbackId())},
        {"state", DukUInt(env->state)},
        { nullptr }
    };

    DukPutPropList(ctx, -1, props);
    duk_freeze(ctx, -1);
    return 1;
}

duk_idx_t CbArgs_GenericEventObject(duk_context * ctx, void * /*_env*/)
{
    CScriptInstance * inst = GetInstance(ctx);
    duk_push_object(ctx);
    SetDummyConstructor(ctx, -1, "GenericEvent");

    const DukPropListEntry props[] = {
        {"callbackId", DukUInt(inst->CallbackId())},
        { nullptr }
    };

    DukPutPropList(ctx, -1, props);
    duk_freeze(ctx, -1);
    return 1;
}

duk_idx_t CbArgs_ExecEventObject(duk_context * ctx, void * _env)
{
    CScriptInstance * inst = GetInstance(ctx);
    JSHookCpuStepEnv * env = (JSHookCpuStepEnv *)_env;
    duk_push_object(ctx);
    SetDummyConstructor(ctx, -1, "CPUExecEvent");

    const DukPropListEntry props[] = {
        {"callbackId", DukUInt(inst->CallbackId())},
        {"pc", DukUInt(env->pc)},
        { nullptr }
    };

    DukPutPropList(ctx, -1, props);
    duk_freeze(ctx, -1);
    return 1;
}

duk_idx_t CbArgs_ReadEventObject(duk_context * ctx, void * _env)
{
    CScriptInstance * inst = GetInstance(ctx);
    CDebuggerUI * debugger = inst->Debugger();
    JSHookCpuStepEnv * env = (JSHookCpuStepEnv *)_env;

    uint32_t address = env->opInfo.GetLoadStoreAddress();

    uint8_t op = env->opInfo.m_OpCode.op;
    uint8_t rt = env->opInfo.m_OpCode.rt;
    bool bFPU = (op == R4300i_LWC1 || op == R4300i_LDC1);

    duk_push_object(ctx);
    SetDummyConstructor(ctx, -1, "CPUReadWriteEvent");

    const DukPropListEntry props[] = {
        {"callbackId", DukUInt(inst->CallbackId())},
        {"pc", DukUInt(env->pc)},
        {"address", DukUInt(address)},
        {"reg", DukUInt(rt)},
        {"fpu", DukBoolean(bFPU)},
        { nullptr }
    };

    DukPutPropList(ctx, -1, props);

    union
    {
        uint8_t u8;
        int8_t s8;
        uint16_t u16;
        int16_t s16;
        uint32_t u32;
        int32_t s32;
        float f32;
        double f64;
        uint64_t u64;
    } value = {0};

    bool bNeedUpper32 = false;

    switch (env->opInfo.m_OpCode.op)
    {
    case R4300i_LB:
        debugger->DebugLoad_VAddr(address, value.s8);
        duk_push_int(ctx, value.s8);
        duk_push_int(ctx, S8);
        break;
    case R4300i_LBU:
        debugger->DebugLoad_VAddr(address, value.u8);
        duk_push_uint(ctx, value.u8);
        duk_push_int(ctx, U8);
        break;
    case R4300i_LH:
        debugger->DebugLoad_VAddr(address, value.s16);
        duk_push_int(ctx, value.s16);
        duk_push_int(ctx, S16);
        break;
    case R4300i_LHU:
        debugger->DebugLoad_VAddr(address, value.u16);
        duk_push_uint(ctx, value.u16);
        duk_push_int(ctx, U16);
        break;
    case R4300i_LL:
    case R4300i_LW:
        debugger->DebugLoad_VAddr(address, value.s32);
        duk_push_int(ctx, value.s32);
        duk_push_int(ctx, S32);
        break;
    case R4300i_LWU:
        debugger->DebugLoad_VAddr(address, value.u32);
        duk_push_uint(ctx, value.u32);
        duk_push_int(ctx, U32);
        break;
    case R4300i_LWC1:
        debugger->DebugLoad_VAddr(address, value.f32);
        duk_push_number(ctx, value.f32);
        duk_push_int(ctx, F32);
        break;
    case R4300i_LDC1:
        debugger->DebugLoad_VAddr(address, value.f64);
        duk_push_number(ctx, value.f64);
        duk_push_int(ctx, F64);
        break;
    case R4300i_LD:
        debugger->DebugLoad_VAddr(address, value.u64);
        duk_push_number(ctx, (duk_double_t)(value.u64 & 0xFFFFFFFF));
        duk_push_int(ctx, U64);
        bNeedUpper32 = true;
        break;
    case R4300i_LDL:
        {
        int shift = (address & 7) * 8;
        uint64_t mask = ~(((uint64_t)-1) << shift);
        debugger->DebugLoad_VAddr(address & ~7, value.u64);
        value.u64 = (g_Reg->m_GPR[rt].DW & mask) + (value.u64 << shift);
        duk_push_number(ctx, (duk_double_t)(value.u64 & 0xFFFFFFFF));
        duk_push_int(ctx, U64);
        bNeedUpper32 = true;
        }
        break;
    case R4300i_LDR:
        {
        int shift = 56 - ((address & 7) * 8);
        uint64_t mask = ~(((uint64_t)-1) >> shift);
        debugger->DebugLoad_VAddr(address & ~7, value.u64);
        value.u64 = (g_Reg->m_GPR[rt].DW & mask) + (value.u64 >> shift);
        duk_push_number(ctx, (duk_double_t)(value.u64 & 0xFFFFFFFF));
        duk_push_int(ctx, U64);
        bNeedUpper32 = true;
        }
        break;
    case R4300i_LWL:
        {
        int shift = (address & 3) * 8;
        uint32_t mask = ~(((uint32_t)-1) << shift);
        debugger->DebugLoad_VAddr(address & ~3, value.s32);
        value.s32 = (g_Reg->m_GPR[rt].W[0] & mask) + (value.s32 << shift);
        duk_push_number(ctx, value.s32);
        duk_push_int(ctx, S32);
        }
        break;
    case R4300i_LWR:
        {
        int shift = 24 - ((address & 3) * 8);
        uint32_t mask = ~(((uint32_t)-1) >> shift);
        debugger->DebugLoad_VAddr(address & ~3, value.s32);
        value.s32 = (g_Reg->m_GPR[rt].W[0] & mask) + (value.s32 >> shift);
        duk_push_number(ctx, value.s32);
        duk_push_int(ctx, S32);
        }
        break;
    default:
        duk_push_number(ctx, 0);
        duk_push_number(ctx, 0);
        break;
    }

    duk_put_prop_string(ctx, -3, "valueType");
    duk_put_prop_string(ctx, -2, "value");

    if (bNeedUpper32)
    {
        duk_push_number(ctx, (duk_double_t)(value.u64 >> 32));
        duk_put_prop_string(ctx, -2, "valueHi");
    }

    duk_freeze(ctx, -1);
    return 1;
}

duk_idx_t CbArgs_WriteEventObject(duk_context * ctx, void * _env)
{
    CScriptInstance * inst = GetInstance(ctx);
    CDebuggerUI * debugger = inst->Debugger();
    JSHookCpuStepEnv * env = (JSHookCpuStepEnv *)_env;

    uint32_t address = env->opInfo.GetLoadStoreAddress();

    uint8_t op = env->opInfo.m_OpCode.op;
    uint8_t rt = env->opInfo.m_OpCode.rt;
    bool bFPU = (op == R4300i_SWC1 || op == R4300i_SDC1);

    duk_push_object(ctx);
    SetDummyConstructor(ctx, -1, "CPUReadWriteEvent");

    const DukPropListEntry props[] = {
        {"callbackId", DukUInt(inst->CallbackId())},
        {"pc", DukUInt(env->pc)},
        {"address", DukUInt(address)},
        {"reg", DukUInt(rt)},
        {"fpu", DukBoolean(bFPU)},
        { nullptr }
    };

    DukPutPropList(ctx, -1, props);

    bool bNeedUpper32 = false;
    uint64_t value64 = 0;

    switch (env->opInfo.m_OpCode.op)
    {
    case R4300i_SB:
        duk_push_int(ctx, g_Reg->m_GPR[rt].B[0]);
        duk_push_int(ctx, S8);
        break;
    case R4300i_SH:
        duk_push_int(ctx, g_Reg->m_GPR[rt].HW[0]);
        duk_push_int(ctx, S16);
        break;
    case R4300i_SW:
        duk_push_int(ctx, g_Reg->m_GPR[rt].W[0]);
        duk_push_int(ctx, S32);
        break;
    case R4300i_SWC1:
        duk_push_number(ctx, *g_Reg->m_FPR_S[rt]);
        duk_push_int(ctx, F32);
        break;
    case R4300i_SDC1:
        duk_push_number(ctx, *g_Reg->m_FPR_D[rt]);
        duk_push_int(ctx, F64);
        break;
    case R4300i_SD:
        duk_push_number(ctx, g_Reg->m_GPR[rt].UW[0]);
        duk_push_int(ctx, U64);
        bNeedUpper32 = true;
        break;
    case R4300i_SWL:
        {
        int shift = (address & 3) * 8;
        uint32_t mask = ~(((uint32_t)-1) >> shift);
        uint32_t value;
        debugger->DebugLoad_VAddr(address & ~3, value);
        value = (value & mask) + (g_Reg->m_GPR[rt].UW[0] >> shift);
        duk_push_number(ctx, value);
        duk_push_int(ctx, S32);
        }
        break;
    case R4300i_SWR:
        {
        int shift = 24 - ((address & 3) * 8);
        uint32_t mask = ~(((uint32_t)-1) << shift);
        uint32_t value;
        debugger->DebugLoad_VAddr(address & ~3, value);
        value = (value & mask) + (g_Reg->m_GPR[rt].UW[0] >> shift);
        duk_push_number(ctx, value);
        duk_push_int(ctx, S32);
        }
        break;
    case R4300i_SDL:
        {
        int shift = (address & 7) * 8;
        uint64_t mask = ~(((uint64_t)-1) >> shift);
        debugger->DebugLoad_VAddr(address & ~7, value64);
        value64 = (value64 & mask) + (g_Reg->m_GPR[rt].UDW >> shift);
        duk_push_number(ctx, (duk_double_t)(value64 & 0xFFFFFFFF));
        duk_push_int(ctx, U64);
        }
    case R4300i_SDR:
    {
        int shift = 56 - ((address & 7) * 8);
        uint64_t mask = ~(((uint64_t)-1) << shift);
        debugger->DebugLoad_VAddr(address & ~7, value64);
        value64 = (value64 & mask) + (g_Reg->m_GPR[rt].UDW >> shift);
        duk_push_number(ctx, (duk_double_t)(value64 & 0xFFFFFFFF));
        duk_push_int(ctx, U64);
    }
    default:
        duk_push_number(ctx, 0);
        duk_push_number(ctx, 0);
        break;
    }

    duk_put_prop_string(ctx, -3, "valueType");
    duk_put_prop_string(ctx, -2, "value");

    if (bNeedUpper32)
    {
        duk_push_number(ctx, (duk_double_t)(value64 >> 32));
        duk_put_prop_string(ctx, -2, "valueHi");
    }

    duk_freeze(ctx, -1);

    return 1;
}

duk_idx_t CbArgs_OpcodeEventObject(duk_context * ctx, void * _env)
{
    CScriptInstance * inst = GetInstance(ctx);
    JSHookCpuStepEnv * env = (JSHookCpuStepEnv *)_env;
    duk_push_object(ctx);
    SetDummyConstructor(ctx, -1, "CPUOpcodeEvent");

    const DukPropListEntry props[] = {
        {"callbackId", DukUInt(inst->CallbackId())},
        {"pc", DukUInt(env->pc)},
        {"opcode", DukUInt(env->opInfo.m_OpCode.Value)},
        { nullptr }
    };

    DukPutPropList(ctx, -1, props);
    duk_freeze(ctx, -1);
    return 1;
}

duk_idx_t CbArgs_RegValueEventObject(duk_context * ctx, void * _env)
{
    CScriptInstance * inst = GetInstance(ctx);
    JSHookCpuStepEnv * env = (JSHookCpuStepEnv *)_env;
    duk_push_object(ctx);
    SetDummyConstructor(ctx, -1, "CPURegValueEvent");

    const DukPropListEntry props[] = {
        {"callbackId", DukUInt(inst->CallbackId())},
        {"pc", DukUInt(env->pc)},
        {"value", DukUInt(g_Reg->m_GPR[env->outAffectedRegIndex].UW[0])},
        {"reg", DukUInt(env->outAffectedRegIndex)},
        { nullptr }
    };

    DukPutPropList(ctx, -1, props);
    duk_freeze(ctx, -1);
    return 1;
}

static duk_idx_t CbArgs_MouseEventObject(duk_context * ctx, void * _env)
{
    CScriptInstance * inst = GetInstance(ctx);
    JSHookMouseEnv * env = (JSHookMouseEnv *)_env;
    duk_push_object(ctx);
    SetDummyConstructor(ctx, -1, "MouseEvent");

    const DukPropListEntry props[] = {
        {"callbackId", DukUInt(inst->CallbackId())},
        {"button", DukInt(env->button)},
        {"x", DukInt(env->x)},
        {"y", DukInt(env->y)},
        { nullptr }
    };
    
    DukPutPropList(ctx, -1, props);
    duk_freeze(ctx, -1);
    return 1;
}

static duk_idx_t CbArgs_SPTaskEventObject(duk_context * ctx, void * _env)
{
    CScriptInstance * inst = GetInstance(ctx);
    JSHookSpTaskEnv * env = (JSHookSpTaskEnv *)_env;
    duk_push_object(ctx);
    SetDummyConstructor(ctx, -1, "SPTaskEvent");

    const DukPropListEntry props[] = {
        {"callbackId", DukUInt(inst->CallbackId())},
        {"taskType", DukUInt(env->taskType)},
        {"taskFlags", DukUInt(env->taskFlags)},
        {"ucodeBootAddress", DukUInt(env->ucodeBootAddress | 0x80000000)},
        {"ucodeBootSize", DukUInt(env->ucodeBootSize)},
        {"ucodeAddress", DukUInt(env->ucodeAddress | 0x80000000)},
        {"ucodeSize", DukUInt(env->ucodeSize)},
        {"ucodeDataAddress", DukUInt(env->ucodeDataAddress | 0x80000000)},
        {"ucodeDataSize", DukUInt(env->ucodeDataSize)},
        {"dramStackAddress", DukUInt(env->dramStackAddress | 0x80000000)},
        {"dramStackSize", DukUInt(env->dramStackSize)},
        {"outputBuffAddress", DukUInt(env->outputBuffAddress | 0x80000000)},
        {"outputBuffSize", DukUInt(env->outputBuffSize)},
        {"dataAddress", DukUInt(env->dataAddress | 0x80000000)},
        {"dataSize", DukUInt(env->dataSize)},
        {"yieldDataAddress", DukUInt(env->yieldDataAddress | 0x80000000)},
        {"yieldDataSize", DukUInt(env->yieldDataSize)},
        { nullptr }
    };

    DukPutPropList(ctx, -1, props);
    duk_freeze(ctx, -1);
    return 1;
}

static duk_idx_t CbArgs_PIEventObject(duk_context * ctx, void * _env)
{
    CScriptInstance * inst = GetInstance(ctx);
    JSHookPiDmaEnv * env = (JSHookPiDmaEnv *)_env;
    duk_push_object(ctx);
    SetDummyConstructor(ctx, -1, "PIEvent");

    const DukPropListEntry props[] = {
        {"callbackId", DukUInt(inst->CallbackId())},
        {"direction", DukUInt(env->direction)},
        {"dramAddress", DukUInt(env->dramAddress | 0x80000000)},
        {"cartAddress", DukUInt(env->cartAddress | 0xA0000000)},
        {"length", DukUInt(env->length + 1)},
        { nullptr }
    };

    DukPutPropList(ctx, -1, props);
    duk_freeze(ctx, -1);
    return 1;
}

duk_ret_t RequireAddressOrAddressRange(duk_context * ctx, duk_idx_t idx, uint32_t * addrStart, uint32_t * addrEnd)
{
    if (duk_is_number(ctx, idx))
    {
        if (abs(duk_get_number(ctx, idx)) > 0xFFFFFFFF)
        {
            duk_push_error_object(ctx, DUK_ERR_RANGE_ERROR,
                                  "address is out of range");
            return duk_throw(ctx);
        }

        uint32_t addr = duk_get_uint(ctx, idx);
        *addrStart = addr;
        *addrEnd = addr;
        return 0;
    }

    if (duk_is_object(ctx, idx))
    {
        if (!duk_has_prop_string(ctx, idx, "start") ||
            !duk_has_prop_string(ctx, idx, "end"))
        {
            duk_push_error_object(ctx, DUK_ERR_REFERENCE_ERROR,
                                  "object is missing 'start' or 'end' property");
            return duk_throw(ctx);
        }

        duk_get_prop_string(ctx, idx, "start");
        duk_get_prop_string(ctx, idx, "end");

        if (!duk_is_number(ctx, -2) ||
            !duk_is_number(ctx, -1))
        {
            duk_pop_n(ctx, 2);
            duk_push_error_object(ctx, DUK_ERR_REFERENCE_ERROR,
                                  "'start' and 'end' properties must be numbers");
            return duk_throw(ctx);
        }

        if (abs(duk_get_number(ctx, -2)) > 0xFFFFFFFF ||
            abs(duk_get_number(ctx, -1)) > 0xFFFFFFFF)
        {
            duk_push_error_object(ctx, DUK_ERR_RANGE_ERROR,
                                  "'start' or 'end' property out of range");
            return duk_throw(ctx);
        }

        *addrStart = duk_get_uint(ctx, -2);
        *addrEnd = duk_get_uint(ctx, -1);
        duk_pop_n(ctx, 2);
        return 0;
    }

    duk_push_error_object(ctx, DUK_ERR_TYPE_ERROR,
                          "argument %d invalid; expected number or object", idx);
    return duk_throw(ctx);
}

duk_ret_t RequireInterpreterCPU(duk_context * ctx)
{
    if (!g_Settings->LoadBool(Setting_ForceInterpreterCPU) &&
        (CPU_TYPE)g_Settings->LoadDword(Game_CpuType) != CPU_Interpreter)
    {
        duk_push_error_object(ctx, DUK_ERR_ERROR,
                              "this feature requires the interpreter core");
        return duk_throw(ctx);
    }

    return 0;
}