#include <windows.h>
#include <assert.h>

#include "idmac/idmac.h"
#include "idmac/jvs.h"

#include "hook/table.h"
#include "hook/table.h"
#include "util/dprintf.h"

enum IDAMC_IOCTL {
    DMA_READ              = 0xC3502000,
    DMA_WRITE             = 0xC3502004,
    REGISTER_READ         = 0xC3502008,
    REGISTER_WRITE        = 0xC350200C,
    REGISTER_BUFFER_READ  = 0xC3502012,
    REGISTER_BUFFER_WRITE = 0xC3502016,
    MEMORY_READ           = 0xC3502018,
    MEMORY_WRITE          = 0xC350201C,
    MEMORY_READ_EXT       = 0xC3502080,
    MEMORY_WRITE_EXT      = 0xC3502084,
    MEMORY_BUFFER_READ    = 0xC3502020,
    MEMORY_BUFFER_WRITE   = 0xC3502024,
};

DWORD hook_iDmacDrvOpen(int dev_num, DWORD *dev_handle, DWORD *other_ptr);
DWORD hook_iDmacDrvClose(HANDLE a1, DWORD *lp);
int hook_iDmacDrvDmaRead(HANDLE a1, LPVOID lp, UINT_PTR ucb, unsigned int *a4);
int hook_iDmacDrvDmaWrite(HANDLE a1, void *lp, UINT_PTR ucb, unsigned int *a4);
int hook_iDmacDrvRegisterRead(HANDLE a1, DWORD register_id, DWORD* lp, unsigned int *a4);
int hook_iDmacDrvRegisterWrite(HANDLE a1, DWORD register_id, int a3, DWORD *lp);
int hook_iDmacDrvRegisterBufferRead(HANDLE a1, DWORD BytesReturned, LPVOID lp, UINT_PTR ucb, DWORD *a5);
int hook_iDmacDrvRegisterBufferWrite(HANDLE a1, DWORD BytesReturned, void *lp, UINT_PTR ucb, DWORD *a5);
int hook_iDmacDrvMemoryRead(HANDLE a1, DWORD BytesReturned, LPVOID lp, DWORD *a4);
int hook_iDmacDrvMemoryWrite(HANDLE a1, DWORD BytesReturned, int a3, DWORD *lp);
int hook_iDmacDrvMemoryBufferRead(HANDLE a1, DWORD BytesReturned, LPVOID lp, UINT_PTR ucb, DWORD *a5);
int hook_iDmacDrvMemoryBufferWrite(HANDLE a1, unsigned int a2, void *lp, UINT_PTR ucb, DWORD *a5);
int hook_iDmacDrvMemoryReadExt(HANDLE a1, DWORD BytesReturned, unsigned int a3, LPVOID lp, int nOutBufferSize, DWORD *a6);
int hook_iDmacDrvMemoryWriteExt(HANDLE a1, int a2, unsigned int a3, void *Source, rsize_t DestinationSize, unsigned int *lp);

DWORD (*next_iDmacDrvOpen)(int dev_num, DWORD *dev_handle, DWORD *other_ptr);
DWORD (*next_iDmacDrvClose)(HANDLE a1, DWORD *lp);
int (*next_iDmacDrvDmaRead)(HANDLE a1, LPVOID lp, UINT_PTR ucb, unsigned int *a4);
int (*next_iDmacDrvDmaWrite)(HANDLE a1, void *lp, UINT_PTR ucb, unsigned int *a4);
int (*next_iDmacDrvRegisterRead)(HANDLE a1, DWORD BytesReturned, LPVOID lp, unsigned int *a4);
int (*next_iDmacDrvRegisterWrite)(HANDLE a1, DWORD BytesReturned, int a3, DWORD *lp);
int (*next_iDmacDrvRegisterBufferRead)(HANDLE a1, DWORD BytesReturned, LPVOID lp, UINT_PTR ucb, DWORD *a5);
int (*next_iDmacDrvRegisterBufferWrite)(HANDLE a1, DWORD BytesReturned, void *lp, UINT_PTR ucb, DWORD *a5);
int (*next_iDmacDrvMemoryRead)(HANDLE a1, DWORD BytesReturned, LPVOID lp, DWORD *a4);
int (*next_iDmacDrvMemoryWrite)(HANDLE a1, DWORD BytesReturned, int a3, DWORD *lp);
int (*next_iDmacDrvMemoryBufferRead)(HANDLE a1, DWORD BytesReturned, LPVOID lp, UINT_PTR ucb, DWORD *a5);
int (*next_iDmacDrvMemoryBufferWrite)(HANDLE a1, unsigned int a2, void *lp, UINT_PTR ucb, DWORD *a5);
int (*next_iDmacDrvMemoryReadExt)(HANDLE a1, DWORD BytesReturned, unsigned int a3, LPVOID lp, int nOutBufferSize, DWORD *a6);
int (*next_iDmacDrvMemoryWriteExt)(HANDLE a1, int a2, unsigned int a3, void *Source, rsize_t DestinationSize, unsigned int *lp);

static const struct hook_symbol idmac_hooks[] = {
    {
        .name    = "iDmacDrvOpen",
        .ordinal = 1,
        .patch   = hook_iDmacDrvOpen,
        .link    = (void **) &next_iDmacDrvOpen,
    },{
        .name    = "iDmacDrvClose",
        .ordinal = 2,
        .patch   = hook_iDmacDrvClose,
        .link    = (void **) &next_iDmacDrvClose,
    },{
        .name    = "iDmacDrvDmaRead",
        .ordinal = 3,
        .patch   = hook_iDmacDrvDmaRead,
        .link    = (void **) &next_iDmacDrvDmaRead,
    },{
        .name    = "iDmacDrvDmaWrite",
        .ordinal = 4,
        .patch   = hook_iDmacDrvDmaWrite,
        .link    = (void **) &next_iDmacDrvDmaWrite,
    },{
        .name    = "iDmacDrvRegisterRead",
        .ordinal = 5,
        .patch   = hook_iDmacDrvRegisterRead,
        .link    = (void **) &next_iDmacDrvRegisterRead,
    },{
        .name    = "iDmacDrvRegisterWrite",
        .ordinal = 6,
        .patch   = hook_iDmacDrvRegisterWrite,
        .link    = (void **) &next_iDmacDrvRegisterWrite,
    },{
        .name    = "iDmacDrvRegisterBufferRead",
        .ordinal = 7,
        .patch   = hook_iDmacDrvRegisterBufferRead,
        .link    = (void **) &next_iDmacDrvRegisterBufferRead,
    },{
        .name    = "iDmacDrvRegisterBufferWrite",
        .ordinal = 8,
        .patch   = hook_iDmacDrvRegisterBufferWrite,
        .link    = (void **) &next_iDmacDrvRegisterBufferWrite,
    },{
        .name    = "iDmacDrvMemoryRead",
        .ordinal = 9,
        .patch   = hook_iDmacDrvMemoryRead,
        .link    = (void **) &next_iDmacDrvMemoryRead,
    },{
        .name    = "iDmacDrvMemoryWrite",
        .ordinal = 10,
        .patch   = hook_iDmacDrvMemoryWrite,
        .link    = (void **) &next_iDmacDrvMemoryWrite,
    },{
        .name    = "iDmacDrvMemoryBufferRead",
        .ordinal = 11,
        .patch   = hook_iDmacDrvMemoryBufferRead,
        .link    = (void **) &next_iDmacDrvMemoryBufferRead,
    },{
        .name    = "iDmacDrvMemoryBufferWrite",
        .ordinal = 12,
        .patch   = hook_iDmacDrvMemoryBufferWrite,
        .link    = (void **) &next_iDmacDrvMemoryBufferWrite,
    },{
        .name    = "iDmacDrvMemoryReadExt",
        .ordinal = 13,
        .patch   = hook_iDmacDrvMemoryReadExt,
        .link    = (void **) &next_iDmacDrvMemoryReadExt,
    },{
        .name    = "iDmacDrvMemoryWriteExt",
        .ordinal = 14,
        .patch   = hook_iDmacDrvMemoryWriteExt,
        .link    = (void **) &next_iDmacDrvMemoryWriteExt,
    },
};

void idmac_hook_table_apply(HMODULE target)
{
    hook_table_apply(
        target,
        "iDmacDrv64.dll",
        idmac_hooks,
        _countof(idmac_hooks)
    );
    hook_table_apply(
        target,
        "iDmacDrv32.dll",
        idmac_hooks,
        _countof(idmac_hooks)
    );
}

HRESULT idmac_hook_init(const struct idmac_config *cfg, jvs_provider_t jvs)
{
    HRESULT hr;

    assert(cfg != NULL);

    dprintf("iDmac: Init\n");

    hr = jvs_hook_init(&cfg->jvs, jvs);

    if (FAILED(hr)) {
        return hr;
    }

    idmac_hook_table_apply(NULL);

    return S_OK;
}

DWORD hook_iDmacDrvOpen(int dev_num, DWORD *dev_handle, DWORD *other_ptr) 
{
    dprintf("hook_iDmacDrvOpen: Open device #%X\n", dev_num);
    return 0;
}

DWORD hook_iDmacDrvClose(HANDLE dev_handle, DWORD *lp)
{
    dprintf("hook_iDmacDrvClose: Close handle %p\n", dev_handle);
    return 0;
}

int hook_iDmacDrvDmaRead(HANDLE a1, LPVOID lp, UINT_PTR ucb, unsigned int *a4)
{
    //dprintf("hook_iDmacDrvDmaRead: This code should not run!\n");
    return 0;
}

int hook_iDmacDrvDmaWrite(HANDLE a1, void *lp, UINT_PTR ucb, unsigned int *a4)
{
    //dprintf("hook_iDmacDrvDmaWrite: This code should not run!\n");
    return 0;
}

int hook_iDmacDrvRegisterRead(HANDLE a1, DWORD register_id, DWORD* lp, unsigned int *a4)
{
    //dprintf("hook_iDmacDrvRegisterRead: This code should not run!\n");
    if (register_id == 0x4140) { // get coin slot 1
        *lp = 0;
    }
    if (register_id == 0x4144) { // get coin slot 2
        *lp = 0;
    }
    if (register_id == 0x4120 && (GetAsyncKeyState(VK_DELETE) & 0x8000)) { // get keys
        *lp = 0x40;
    }
    return 0;
}

int hook_iDmacDrvRegisterWrite(HANDLE a1, DWORD register_id, int a3, DWORD *lp)
{
    //dprintf("hook_iDmacDrvRegisterWrite: This code should not run!\n");
    return 0;
}

int hook_iDmacDrvRegisterBufferRead(HANDLE a1, DWORD BytesReturned, LPVOID lp, UINT_PTR ucb, DWORD *a5)
{
    //dprintf("hook_iDmacDrvRegisterBufferRead: This code should not run!\n");
    return 0;
}

int hook_iDmacDrvRegisterBufferWrite(HANDLE a1, DWORD BytesReturned, void *lp, UINT_PTR ucb, DWORD *a5)
{
    //dprintf("hook_iDmacDrvRegisterBufferWrite: This code should not run!\n");
    return 0;
}

int hook_iDmacDrvMemoryRead(HANDLE a1, DWORD BytesReturned, LPVOID lp, DWORD *a4)
{
    //dprintf("hook_iDmacDrvMemoryRead: This code should not run!\n");
    return 0;
}

int hook_iDmacDrvMemoryWrite(HANDLE a1, DWORD BytesReturned, int a3, DWORD *lp)
{
    //dprintf("hook_iDmacDrvMemoryWrite: This code should not run!\n");
    return 0;
}

int hook_iDmacDrvMemoryBufferRead(HANDLE a1, DWORD BytesReturned, LPVOID lp, UINT_PTR ucb, DWORD *a5)
{
    //dprintf("hook_iDmacDrvMemoryBufferRead: This code should not run!\n");
    return 0;
}

int hook_iDmacDrvMemoryBufferWrite(HANDLE a1, unsigned int a2, void *lp, UINT_PTR ucb, DWORD *a5)
{
    //dprintf("hook_iDmacDrvMemoryBufferWrite: This code should not run!\n");
    return 0;
}

int hook_iDmacDrvMemoryReadExt(HANDLE a1, DWORD BytesReturned, unsigned int a3, LPVOID lp, int nOutBufferSize, DWORD *a6)
{
    //dprintf("hook_iDmacDrvMemoryReadExt: This code should not run!\n");
    return 0;
}

int hook_iDmacDrvMemoryWriteExt(HANDLE a1, int a2, unsigned int a3, void *Source, rsize_t DestinationSize, unsigned int *lp)
{
    //dprintf("hook_iDmacDrvMemoryWriteExt: This code should not run!\n");
    return 0;
}