#ifndef __VIRTUALIZER_H
#define __VIRTUALIZER_H

#include "Code.h"
#include "VmCode.h"
#include "NativeCode.h"
#include "VMDefs.h"
#include "VirtualMachine.h"


#define VM_HANDLER_DESC_COUNT (VM_OPSIZE_COUNT * VM_OPSIZE_COUNT * VM_OPSIZE_COUNT)
typedef struct _VM_HANDLER_DESCRIPTOR
{
	PUCHAR Data;
	UINT DataSize;
}VM_HANDLER_DESCRIPTOR, * PVM_HANDLER_DESCRIPTOR;
typedef struct _VM_HANDLER
{
	VM_HANDLER_DESCRIPTOR Descriptors[VM_HANDLER_DESC_COUNT];
	inline _VM_HANDLER()
	{
		for (UINT i = 0; i < VM_HANDLER_DESC_COUNT; i++)
		{
			Descriptors[i].Data = NULL;
			Descriptors[i].DataSize = NULL;
		}
	}
	inline PVM_HANDLER_DESCRIPTOR Tripple(VM_OPERAND_SIZE_ENUM OpSize1, VM_OPERAND_SIZE_ENUM OpSize2, VM_OPERAND_SIZE_ENUM OpSize3)
	{
		return &Descriptors[(OpSize1 * (VM_OPSIZE_COUNT * VM_OPSIZE_COUNT)) + (OpSize2 * VM_OPSIZE_COUNT) + OpSize3];
	}
	inline PVM_HANDLER_DESCRIPTOR Double(VM_OPERAND_SIZE_ENUM OpSize1, VM_OPERAND_SIZE_ENUM OpSize2)
	{
		return Tripple(OpSize1, OpSize2, VM_OPSIZE_8);
	}
	inline PVM_HANDLER_DESCRIPTOR Single(VM_OPERAND_SIZE_ENUM OpSize1)
	{
		return Tripple(OpSize1, OpSize1, VM_OPSIZE_8);
	}
	inline PVM_HANDLER_DESCRIPTOR GetDesc(VM_OPERAND_SIZE_ENUM* OpSize)
	{
		return Tripple(OpSize[0], OpSize[1], OpSize[2]);
	}
}VM_HANDLER, * PVM_HANDLER;


typedef struct _VIRTUALIZER
{
	USHORT HandlerMap[VM_ICLASS_COUNT];
	STDVECTOR<PVM_HANDLER> Handlers;

	inline _VIRTUALIZER()
	{
		Handlers.clear();
		Handlers.push_back(NULL);

		for (UINT i = 0; i < VM_ICLASS_COUNT; i++)
			HandlerMap[i] = 0;
	}
}VIRTUALIZER, *PVIRTUALIZER;

PVM_HANDLER ViGetVmHandler(PVIRTUALIZER Virt, UINT Id);
CONST CHAR* ViIClassToString(UINT IClass);
BOOL ViCanHandleInst(PNATIVE_CODE_LINK Link);
BOOL ViValidateNativeCodeBlock(PVIRTUALIZER Virt, PNATIVE_CODE_BLOCK Block);
BOOL ViVirtualizeInst(PVIRTUALIZER Virt, XED_DECODED_INST* DecodedInst, PVM_CODE_BLOCK Block);

#endif