#pragma once
#include <Windows.h>
#include <iostream>
#include <vector>
#include <string>
#include <unordered_set>
#include <sstream>
#include <stdint.h>

//#include <chrono>

class Memory
{
public:
	Memory()
	{
		dwModuleBase = (DWORD)GetModuleHandle(NULL);
		if (dwModuleBase == 0x00)
		{
			//logger.log_windows_error("Memory::GetModuleHandle failed");
		}
	}

	template <typename T>
	inline T Read(LPVOID lpAddress) const
	{
		return *(T*)lpAddress;
	}

	template<typename T, bool EnableVirtual = true>
	inline void Write(LPVOID lpAddress, T _tValue) const
	{
		if (EnableVirtual) {
			DWORD dwOldProtect{};
			VirtualProtect(lpAddress, sizeof(T), PAGE_EXECUTE_READWRITE, &dwOldProtect);
			*(T*)lpAddress = _tValue;
			VirtualProtect(lpAddress, sizeof(T), dwOldProtect, &dwOldProtect);
		}
		else
		{
			*(T*)lpAddress = _tValue;
		}
	}


	// NOTE:
	// THE MASK MUST BEGIN WITH AN X IT CAN'T BEGIN WITH A WILDCARD.
	LPVOID AOBScan(LPVOID lpStartAddress, const std::pair<std::vector<uint8_t>, std::string_view>& pair, size_t dwScanSize = 0x1000 )
	{
		//boost::string_view
		const std::vector<uint8_t>& bytes = pair.first;
		std::string_view mask = pair.second;
		auto dwAddressToRead = reinterpret_cast<DWORD>(lpStartAddress);
		LPVOID lpPossibleHit = 0x00;
			
		size_t i{};
		while (i < dwScanSize) {

			if (Read<uint8_t>(reinterpret_cast<LPVOID>((DWORD)lpStartAddress + i)) == bytes[0]) {

				// FOUND A POSSIBLE HIT.
				lpPossibleHit = reinterpret_cast<LPVOID>((DWORD)lpStartAddress + i);
			
				
				for (size_t j{ 1 }; j < bytes.size(); j++) {
			
					if (mask[j] == '?') continue;
					if (Read<uint8_t>(reinterpret_cast<LPVOID>((DWORD)lpPossibleHit + j)) != bytes[j])
					{
						lpPossibleHit = 0x00;
						break;
					}

				}

				if (lpPossibleHit != 0x00) return lpPossibleHit;

			}

			
			++i;
		}

		return 0x00;

	}

	
};

 #include <Windows.h>
#include <iostream>
#include <string>
#include <TCHAR.H>
#include "main.h"

using namespace std;


DWORD jmpBackAddy;
 DWORD  buffer_ptr;
bool Hook(void * toHook, void * ourFunct, int len)
{
    if (len < 5)
    {
        return false;
    }
    else
    {

    }

    DWORD curProtection;
    VirtualProtect(toHook, len, PAGE_EXECUTE_READWRITE, &curProtection);

    memset(toHook, 0x90, len);

    DWORD relativeAddress = ((DWORD)ourFunct - (DWORD)toHook) - 5;

    *(BYTE*)toHook = 0xE9;
    *(DWORD*)((DWORD)toHook + 1) = relativeAddress; // <-- I DID NOT UNDERSTAND THIS

    DWORD temp;
    VirtualProtect(toHook, len, curProtection, &temp);

    return true;
}
//



//
void __declspec(naked) ourFunct()
{


    __asm{

mov esi,ecx
cmp eax,1000040
je codey
jmp code20


code20:
cmp eax,1001010
je codey
jmp code

codey:
mov eax,0
jmp code


hid:
mov eax,1001010
jmp code
code:
        mov dword ptr ds:[esi],eax
        lea eax,dword ptr ds:[edi+4]
		jmp jmpBackAddy
    }



}

DWORD WINAPI MainThread(LPVOID param)
{
    int hookLength = 7;//5 for jump + 3 remaining

   // DWORD hookAddress = 0x4E9DEA; // it's right

	DWORD hookAddress = 0x4E972C; // it's right
    jmpBackAddy = hookAddress + hookLength;
    Hook((void*)hookAddress, ourFunct, hookLength);


    return 0;
}
BOOL WINAPI DllMain(HINSTANCE hModule, DWORD dwReason, LPVOID lpReserved) {
	switch (dwReason) {
	case DLL_PROCESS_ATTACH:
		CreateThread(0, 0, MainThread, hModule, 0, 0);
		break;
	}

	return TRUE;
}