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

void WriteToMemory(HANDLE hProcHandle);
DWORD FindDmaAddy(int PointerLevel, HANDLE hProcHandle, DWORD Offsets[], DWORD BaseAddress);

std::string GameName = "Counter-Strike Source";
LPCSTR LGameWindow = "Counter-Strike Source";
std::string GameStatus;

bool IsGameAvail;
bool UpdateOnNextRun;

bool HealthStatus;
int HealthValue = 1337;
DWORD HealthBaseAddress = { 0x22562d7c };
DWORD HealthOffsets[] = { 0x88 };



int main()
{
    //Declare our handles as NULL to avoid crashes when closing if they were unused e.g. player starts trainer and closes it before doing any cheats
    HWND hGameWindow = NULL;
    int timeSinceLastUpdate = clock(); //forces status update every x seconds
    int GameAvailTMR = clock();
    int OnePressTMR;//used to limit keys input to only one per x ms
    DWORD dwProcId = NULL;
    HANDLE hProcHandle = NULL;
    UpdateOnNextRun = true;
    std::string sAmmoStatus;
    std::string sHealthStatus;
    sAmmoStatus = "OFF";
    sHealthStatus = "OFF";
    OnePressTMR = clock();
    while (!GetAsyncKeyState(VK_INSERT))
    {


        if (clock() - GameAvailTMR > 100)
        {
            GameAvailTMR = clock();
            IsGameAvail = false;
            hGameWindow = FindWindow(NULL, LGameWindow);
            if (hGameWindow)
            {
                GetWindowThreadProcessId(hGameWindow, &dwProcId);
                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 = "Counter-Strike Source Ready to hack";
                        IsGameAvail = true;
                    }
                }
                else GameStatus = "Failed to obtain process id";
            }
            else GameStatus = "Counter-Strike Source NOT FOUND";
            if (UpdateOnNextRun || clock() - timeSinceLastUpdate > 5000)
            {
                system("cls");
                std::cout << "----------------------------------------------------" << std::endl;
                std::cout << "        Counter-Strike Source memory hacker" << std::endl;
                std::cout << "----------------------------------------------------" << std::endl << std::endl;
                std::cout << "GAME STATUS:" << GameStatus << "   " << std::endl << std::endl;
                std::cout << "[F1] Unlimited Health ->" << sHealthStatus << "<-" << std::endl << std::endl;
                std::cout << "[INSERT] Exit" << std::endl;
                UpdateOnNextRun = false;
                timeSinceLastUpdate = clock();
            }

            if (IsGameAvail)
            {
                WriteToMemory(hProcHandle);
            }
        }
        if (clock() - OnePressTMR > 400)
        {
            if (IsGameAvail)
            {
                if (GetAsyncKeyState(VK_F1))
                {
                    OnePressTMR = clock();
                    HealthStatus = !HealthStatus;
                    UpdateOnNextRun = true;
                    if (HealthStatus)sHealthStatus = "ON";
                    else sHealthStatus = "OFF";
                }
            }
        }
    }
    CloseHandle(hProcHandle);
    return ERROR_SUCCESS;
}

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];
        ReadProcessMemory(hProcHandle, (LPCVOID)pointerAddr, &pTemp, 4, NULL);
    }
    return pointerAddr;
}

void WriteToMemory(HANDLE hProcHandle)
{
    if (HealthStatus)
    {
        DWORD HealthAddressToWrite = FindDmaAddy(1, hProcHandle, HealthOffsets, HealthBaseAddress);
        WriteProcessMemory(hProcHandle, (BYTE*)HealthAddressToWrite, &HealthValue, sizeof(HealthValue), NULL);
    }
}