#ifndef KX_MEMORY_CHUNK_H
#define KX_MEMORY_CHUNK_H

#include <windows.h>
#include <DbgHelp.h>
#include <vector>
#include <string>

// SymCleanup()
typedef BOOL (__stdcall *tSC)( IN HANDLE hProcess );

// SymFunctionTableAccess()
typedef PVOID (__stdcall *tSFTA)( HANDLE hProcess, DWORD AddrBase );

// SymGetLineFromAddr()
typedef BOOL (__stdcall *tSGLFA)( IN HANDLE hProcess, IN DWORD dwAddr, OUT PDWORD pdwDisplacement, OUT PIMAGEHLP_LINE Line );

// SymGetModuleBase()
typedef DWORD (__stdcall *tSGMB)( IN HANDLE hProcess, IN DWORD dwAddr );

// SymGetModuleInfo()
typedef BOOL (__stdcall *tSGMI)( IN HANDLE hProcess, IN DWORD dwAddr, OUT PIMAGEHLP_MODULE ModuleInfo );

// SymGetOptions()
typedef DWORD (__stdcall *tSGO)( VOID );

// SymGetSymFromAddr()
typedef BOOL (__stdcall *tSGSFA)( IN HANDLE hProcess, IN DWORD dwAddr,	OUT PDWORD pdwDisplacement, OUT PIMAGEHLP_SYMBOL Symbol );

// SymInitialize()
typedef BOOL (__stdcall *tSI)( IN HANDLE hProcess, IN PSTR UserSearchPath, IN BOOL fInvadeProcess );

// SymLoadModule()
typedef DWORD (__stdcall *tSLM)( IN HANDLE hProcess, IN HANDLE hFile, IN PSTR ImageName, IN PSTR ModuleName, IN DWORD BaseOfDll, IN DWORD SizeOfDll );

// SymSetOptions()
typedef DWORD (__stdcall *tSSO)( IN DWORD SymOptions );

// StackWalk()
typedef BOOL (__stdcall *tSW)( DWORD MachineType, HANDLE hProcess,
										HANDLE hThread, LPSTACKFRAME StackFrame, PVOID ContextRecord,
										PREAD_PROCESS_MEMORY_ROUTINE ReadMemoryRoutine,
										PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine,
										PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine,
										PTRANSLATE_ADDRESS_ROUTINE TranslateAddress );
// UnDecorateSymbolName()
typedef DWORD (__stdcall WINAPI *tUDSN)( PCSTR DecoratedName, PSTR UnDecoratedName,
													 DWORD UndecoratedLength, DWORD Flags );

#define MAX_MODULE_NAME32 255
#define TH32CS_SNAPMODULE   0x00000008
#pragma pack( push, 8 )
typedef struct tagMODULEENTRY32
{
	DWORD   dwSize;
	DWORD   th32ModuleID;       // This module
	DWORD   th32ProcessID;      // owning process
	DWORD   GlblcntUsage;       // Global usage count on the module
	DWORD   ProccntUsage;       // Module usage count in th32ProcessID's context
	BYTE  * modBaseAddr;        // Base address of module in th32ProcessID's context
	DWORD   modBaseSize;        // Size in bytes of module starting at modBaseAddr
	HMODULE hModule;            // The hModule of this module in th32ProcessID's context
	char    szModule[MAX_MODULE_NAME32 + 1];
	char    szExePath[MAX_PATH];
} MODULEENTRY32;
typedef MODULEENTRY32 *  PMODULEENTRY32;
typedef MODULEENTRY32 *  LPMODULEENTRY32;
#pragma pack( pop )

struct ModuleEntry
{
	std::string imageName;
	std::string moduleName;
	DWORD baseAddress;
	DWORD size;
};

typedef std::vector< ModuleEntry > ModuleList;
typedef ModuleList::iterator ModuleListIter;

class kxMemoryChunk
{
public: // Methods

	kxMemoryChunk(size_t size = 0);
	~kxMemoryChunk();

	void* operator new(size_t size);

	
	void operator delete(void* ptr);

	static kxMemoryChunk* GetBegin();
	static kxMemoryChunk* GetEnd();
	static unsigned long int GetCount();
	
	static void Delete(void* data_ptr);
	static void Check();

protected:
	static void LazyCleanup();
	static void LazyInit();
	static void Dump(kxMemoryChunk* chunk);
	static bool FillModuleList( ModuleList& modules, DWORD pid, HANDLE hProcess );
	static void EnumumAndLoadModuleSymbols( HANDLE hProcess, DWORD pid );
	static bool FillModuleListPSAPI( ModuleList& modules, DWORD pid, HANDLE hProcess );
	static bool FillModuleListTH32( ModuleList& modules, DWORD pid );

public:  // DATA
	STACKFRAME m_StackFrame;
	CONTEXT    m_Context;	
	kxMemoryChunk* m_Prev;
	kxMemoryChunk* m_Next;
	void* m_Data;
	size_t m_Size;

	static HMODULE m_hImagehlpDll;
	static DWORD m_ImageType;
	static HANDLE m_hProcess;
	static HANDLE m_hThread;

protected: // Vsechno zverstvo se deje zde...
	static kxMemoryChunk* m_Begin;
	static kxMemoryChunk* m_End;
	static unsigned long int m_Count; 

	static tSC pSC;
	static tSFTA pSFTA;
	static tSGLFA pSGLFA;
	static tSGMB pSGMB;
	static tSGMI pSGMI;
	static tSGO pSGO;
	static tSGSFA pSGSFA;
	static tSI pSI;
	static tSLM pSLM;
	static tSSO pSSO;
	static tSW pSW;
	static tUDSN pUDSN;
};

void* operator new(size_t size);
void operator delete(void* ptr);

#endif // KX_MEMORY_CHUNK_H