#include <Windows.h>
#include <TlHelp32.h>
#include <stdarg.h>
#include <iostream>
#include <string>

#pragma region memory
int pID;
HANDLE process;

DWORD clientModuleSize, clientModuleStart;

bool attachToCsgo() {
    HANDLE handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
    PROCESSENTRY32 entry;
    entry.dwSize = sizeof(entry);

    do
    if (!strcmp(entry.szExeFile, "csgo.exe")) {
        pID = entry.th32ProcessID;
        CloseHandle(handle);

        process = OpenProcess(PROCESS_VM_READ, false, pID);

        return true;
    }
    while (Process32Next(handle, &entry));

    return false;
}

bool dataCompare(const BYTE* pData, const BYTE* pMask, const char* pszMask) {
    for (; *pszMask; ++pszMask, ++pData, ++pMask) {
        if (*pszMask == 'x' && *pData != *pMask) {
            return false;
        }
    }

    return (*pszMask == NULL);
}

bool loadClientModule() {
    HANDLE module = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pID);
    MODULEENTRY32 mEntry;
    mEntry.dwSize = sizeof(mEntry);

    do {
        if (!strcmp(mEntry.szModule, (LPSTR)"client.dll")) {
            CloseHandle(module);

            clientModuleSize = mEntry.modBaseSize;
            clientModuleStart = (DWORD)mEntry.hModule;
            return true;
        }
    } while (Module32Next(module, &mEntry));

    return false;
}

DWORD findPattern(DWORD start, DWORD size, const char* sig, const char* mask) {
    BYTE* data = new BYTE[size];
    unsigned long bytesRead;

    if (!ReadProcessMemory(process, (LPVOID)start, data, size, &bytesRead)) {
        return NULL;
    }

    for (DWORD i = 0; i < size; i++) {
        if (dataCompare((const BYTE*)(data + i), (const BYTE*)sig, mask)) {
            return start + i;
        }
    }

    return NULL;
}

DWORD findPatternArr(DWORD start, DWORD size, const char* mask, int count, ...) {
    char* sig = new char[count + 1];
    va_list ap;
    va_start(ap, count);
    for (int i = 0; i < count; i++) {
        char read = va_arg(ap, char);
        sig[i] = read;
    }
    va_end(ap);
    sig[count] = '\0';

    return findPattern(start, size, sig, mask);
}

bool detach() {
    if (process) {
        return CloseHandle(process);
    }
    return false;
}
#pragma endregion

#pragma region offsets
DWORD offGameResources = 0x4A0E53C;
DWORD offEntityList = 0x49EE2E4;
DWORD offRadarBase = 0x4A22F8C;
DWORD offRadarBasePointer = 0x50;
DWORD offRadarName = 0x24;
DWORD offRadarSize = 0x1E0;

// Netvars
DWORD offICompWins = 0x1B3C;
DWORD offICompRanking = 0x1A38;
#pragma endregion

#pragma region actualCode
static const char *Ranks[] =
{
    "No Rank",
    "Silver I",
    "Silver II",
    "Silver III",
    "Silver IV",
    "Silver Elite",
    "Silver Elite Master",

    "Gold Nova I",
    "Gold Nova II",
    "Gold Nova III",
    "Gold Nova Master",
    "Master Guardian I",
    "Master Guardian II",

    "Master Guardian Elite",
    "Distinguished Master Guardian",
    "Legendary Eagle",
    "Legendary Eagle Master",
    "Supreme Master First Class",
    "The Global Elite"
};

std::string pNames[64];
int pRanks[64];
int pWins[64];
bool loadData() {
    DWORD resource;
    ReadProcessMemory(process, (LPCVOID)(clientModuleStart + offGameResources), &resource, 4, NULL);

    DWORD radar, radarPointer;
    ReadProcessMemory(process, (LPCVOID)(clientModuleStart + offRadarBase), &radar, 4, NULL);
    ReadProcessMemory(process, (LPCVOID)(radar + offRadarBasePointer), &radarPointer, 4, NULL);
    for (int i = 0; i < 64; i++) {
        ReadProcessMemory(process, (LPCVOID)(resource + (offICompRanking + i * 4)), &pRanks[i], 4, NULL);
        ReadProcessMemory(process, (LPCVOID)(resource + (offICompWins + i * 4)), &pWins[i], 4, NULL);
        wchar_t buffer[32];
        ReadProcessMemory(process, (LPCVOID)(radarPointer + (offRadarSize * (i + 2)) + offRadarName), buffer, 32 * sizeof(wchar_t), NULL);
        int j = 0;
        pNames[i] = "";
        while (buffer[j] != '\0') {
            pNames[i] += buffer[j];
            j++;
        }
    }
    return true;
}
#pragma endregion

typedef bool(*requireFunc)();
void require(requireFunc f, const char* msg) {
    std::cout << msg << "... ";
    if (f()) {
        std::cout << "done.\n";
    }
    else {
        std::cout << "error.\n";
        getchar();
        exit(1);
    }
}

int main() {
    std::cout << "Merccy's Rank Scanner V1.0\n\n";

    require(attachToCsgo, "Attaching to csgo.exe");

    require(loadClientModule, "Loading client module data");

    require(loadData, "Loading data");

    require(detach, "Detach");

    std::cout << "\n";

    for (int i = 0; i < 64; i++) {
        if (pNames[i] == "") continue;

        std::cout << pNames[i] << "\nRank:\t" << Ranks[pRanks[i]] << "\n\n";
    }

    getchar();
}