#include <iostream>
#include <Windows.h>
#include <string>
#include <ctime>
#include <tlhelp32.h>
#include <tchar.h>

void WriteToMemory(HANDLE hProcHandle);
DWORD FindDmaAddy(int PointerLevel, HANDLE hProcHandle, DWORD Offsets[], DWORD BaseAddress);
DWORD_PTR dwGetModuleBaseAddress(DWORD dwProcID, TCHAR *szModuleName);

std::string GameName = "Sta";
LPCSTR LGameWindow = "Sta (64-bit, PCD3D_SM5)";
std::string GameStatus;


bool IsGameAvail;
bool UpdateOnNextRun;
DWORD serverdllBaseAddress = 0;

bool FireStatus;
BYTE FireValue[] = { 0x10,0x0,0x0,0x0 };
DWORD FireBaseAddress = { 0x04BE6798 };
DWORD FireOffsets[] = { 0x1B8, 0x20, 0x400, 0x78, 0x3BC };


int main()
{

    HWND hGameWindow = NULL;
    int timeSinceLastUpdate = clock();
    int GameAvailTMR = clock();
    int OnePressTMR;
    HWND WindowHandel = FindWindowA(0, "Sta (64-bit, PCD3D_SM5)");
    DWORD dwProcId = NULL;

    HANDLE hProcHandle = NULL;
    UpdateOnNextRun = true;
    std::string sFireStatus;
    sFireStatus = "OFF";
    OnePressTMR = clock();
    while (!GetAsyncKeyState(VK_INSERT))
    {

        if (clock() - GameAvailTMR > 100)
        {
            GameAvailTMR = clock();
            IsGameAvail = false;
            hGameWindow = FindWindow(NULL, LGameWindow);
            if (hGameWindow)
            {
                GetWindowThreadProcessId(hGameWindow, &dwProcId);
                serverdllBaseAddress = dwGetModuleBaseAddress(dwProcId, _T("Sta.exe"));

                FireBaseAddress = serverdllBaseAddress + FireBaseAddress;
                if (dwProcId != 0)
                {
                    hProcHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcId);
                    if (hProcHandle == INVALID_HANDLE_VALUE || hProcHandle == NULL)
                    {
                        GameStatus = "Failed to open process for valid handle";
                    }
                    else
                    {
                        GameStatus = "Ready to hack";
                        IsGameAvail = true;
                    }
                }
                else GameStatus = "Failed to obtain process id";
            }
            else GameStatus = "game NOT FOUND";

            if (UpdateOnNextRun || clock() - timeSinceLastUpdate > 5000)
            {
                system("cls");
                std::cout << "----------------------------------------------------" << std::endl;
                std::cout << "        memory hacker" << std::endl;
                std::cout << "----------------------------------------------------" << std::endl << std::endl;
                std::cout << "GAME STATUS:" << GameStatus << "   " << std::endl << std::endl;
                std::cout << "[F1] cheat -> " << sFireStatus << " <-" << std::endl << std::endl;
                std::cout << "[INSERT] Exit" << std::endl;
                std::cout << &FireBaseAddress;

                UpdateOnNextRun = false;
                timeSinceLastUpdate = clock();
            }

            if (IsGameAvail)
            {
                WriteToMemory(hProcHandle);
            }
        }

        if (clock() - OnePressTMR > 400)
        {
            if (IsGameAvail)
            {
                if (GetAsyncKeyState(VK_F1))
                {
                    OnePressTMR = clock();
                    FireStatus = !FireStatus;
                    UpdateOnNextRun = true;
                    if (FireStatus)sFireStatus = "ON";
                    else sFireStatus = "OFF";
                }
            }
        }
    }
    CloseHandle(hProcHandle);
    CloseHandle(hGameWindow);

    return ERROR_SUCCESS;
}
DWORD_PTR dwGetModuleBaseAddress(DWORD dwProcID, TCHAR *szModuleName)
{
    DWORD_PTR dwModuleBaseAddress = 0;
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, dwProcID);
    if (hSnapshot != INVALID_HANDLE_VALUE)
    {
        MODULEENTRY32 ModuleEntry32;
        ModuleEntry32.dwSize = sizeof(MODULEENTRY32);
        if (Module32First(hSnapshot, &ModuleEntry32))
        {
            do
            {
                if (_tcsicmp(ModuleEntry32.szModule, szModuleName) == 0)
                {
                    dwModuleBaseAddress = (DWORD_PTR)ModuleEntry32.modBaseAddr;
                    break;
                }
            } while (Module32Next(hSnapshot, &ModuleEntry32));
        }
        CloseHandle(hSnapshot);
    }
    return dwModuleBaseAddress;
}
DWORD FindDmaAddy(int PointerLevel, HANDLE hProcHandle, DWORD Offsets[], DWORD BaseAddress){

    DWORD pointer = BaseAddress;

    DWORD pTemp;

    DWORD pointerAddr;
    for (int i = 0; i < PointerLevel; i++)
    {
        if (i == 0)
        {
            ReadProcessMemory(hProcHandle, (LPCVOID)pointer, &pTemp, 4, NULL);
        }
        pointerAddr = pTemp + Offsets[i];
        std::cout << &pointer << std::endl;
        std::cout << &pointerAddr << std::endl;

        ReadProcessMemory(hProcHandle, (LPCVOID)pointerAddr, &pTemp, 4, NULL);

    }
    return pointerAddr;
}

void WriteToMemory(HANDLE hProcHandle)
{
    if (FireStatus)
    {
        DWORD AmmoAddressToWrite = FindDmaAddy(5 ,hProcHandle, FireOffsets, FireBaseAddress);
        WriteProcessMemory(hProcHandle, (BYTE*)AmmoAddressToWrite, &FireValue, sizeof(FireValue), NULL);
    }
}