//hidend
#include <Windows.h>
#include <d3d9.h>
#include <cstdio>
#include <iostream>
#include <Windows.h>
#include "MinHook.h"
#if defined _M_X64
#pragma comment(lib, "libMinHook.x64.lib")
#elif defined _M_IX86
#pragma comment(lib, "minhook.x32d.lib")
#endif
uint32_t samp_base = 0;

const DWORD OFFSETS[6][2]{
    /*ChatInfo, AddMsg*/
    {0x21A0E4, 0x645A0}, // 037-r1 - 0
    {0x021A0EC, 0x64670}, // 037-r2 - 1
    {0x026E8C8, 0x679F0}, // 037-r3_1 - 2
    {0x026E9F8, 0x68130}, // 037-r4 - 3
    {0x026E9F8, 0x68170}, // 037-r4_2 -4
    {0x026EB80, 0x68170}, // 037-r5_1 - 5
};

int get_samp_version_id()
{
    int version_current = -1;

    if (samp_base)
    {
        std::cout << "Dentro!" << std::endl;
        int version_id = *reinterpret_cast<int*>((char*)samp_base + 0x128);
        std::cout << "Version ID: " << version_id << std::endl;

        switch (version_id) {
        case 0x5542F47A: // R1
            version_current = 0;
            break;
        case 0x59C30C94: // R2
            version_current = 1;
            break;
        default:
            version_id = *reinterpret_cast<int*>((char*)samp_base + 0x120);
            std::cout << "No es ni R1 ni R2, veamos las demas: " << version_id << std::endl;

            switch (version_id) {
            case 0x5C0B4243: // R3
                version_current = 2;
                break;
            case 0x5DD606CD: // R4 - v1
                version_current = 3;
                break;
            case 0x6094ACAB: // R4 - v2
                version_current = 4;
                break;
            case 0x6372C39E: // R5, ni nos interesa pero meh
                version_current = 5;
                break;
            }
        }
    }
    return version_current;
}

void addMessageToChat(unsigned dwColor, const char* szMsg, ...)
{
    int version = get_samp_version_id();
    std::cout << "Version2: " << version << std::endl;
    if (version == -1)
        return;

    DWORD chatInfoOffset = OFFSETS[version][0];
    DWORD addMsgOffset = OFFSETS[version][1];

    std::cout << "chatInfoOffset: " << chatInfoOffset << std::endl;
    std::cout << "addMsgOffset: " << addMsgOffset << std::endl;
    unsigned char red = static_cast<unsigned char>(rand() % 256);
    unsigned char green = static_cast<unsigned char>(rand() % 256);
    unsigned char blue = static_cast<unsigned char>(rand() % 256);

    // Combine the color components into a single unsigned integer
    unsigned newColor = (red << 16) | (green << 8) | blue;
    auto addMessage = reinterpret_cast<void(__thiscall*)(void* pChat, unsigned color, const char* message)>(samp_base + addMsgOffset);
    addMessage(*reinterpret_cast<void**>(samp_base + chatInfoOffset), newColor, szMsg);
}


typedef HMODULE(WINAPI* TYPE_LoadLibraryA)(LPCSTR);
TYPE_LoadLibraryA g_loadLibraryA_original = NULL;
HMODULE WINAPI LoadLibraryA_replacement(_In_ LPCTSTR lpFileName)
{
    if (strcmp("OPENGL32", lpFileName) != 0)
    {
        addMessageToChat(-1, "LoadLibraryA_replacement!");
        return NULL; //devolvemos null y paramos la inyeccion
    }
    return g_loadLibraryA_original(lpFileName);
}

typedef HMODULE(WINAPI* TYPE_LoadLibraryExA)(LPCSTR, HANDLE, DWORD);
TYPE_LoadLibraryExA g_loadLibraryExA_original = NULL;
HMODULE WINAPI LoadLibraryExA_replacement(_In_ LPCSTR lpLibFileName, _In_ HANDLE hFile, _In_ DWORD  dwFlags)
{
    addMessageToChat(-1, "LoadLibraryExA_replacement!");
    return g_loadLibraryExA_original(lpLibFileName, hFile, dwFlags);

}

typedef HMODULE(WINAPI* TYPE_LoadLibraryW)(LPCWSTR);
TYPE_LoadLibraryW g_loadLibraryW_original = NULL;
HMODULE WINAPI LoadLibraryW_replacement(LPCWSTR lpLibFileName)
{
    addMessageToChat(-1, "LoadLibraryW_replacement!");
    return NULL; //devolvemos null y paramos la inyeccion
    return g_loadLibraryW_original(lpLibFileName);
}

typedef HMODULE(WINAPI* TYPE_LoadLibraryExW)(LPCWSTR, HANDLE, DWORD);
TYPE_LoadLibraryExW g_LoadLibraryExW_original = NULL;
HMODULE WINAPI LoadLibraryExW_replacement(_In_ LPCWSTR  lpLibFileName, _In_ HANDLE hFile, _In_ DWORD  dwFlags)
{
    addMessageToChat(-1, "LoadLibraryExW_replacement!");

    return g_LoadLibraryExW_original(lpLibFileName, hFile, dwFlags);
}

int init()
{
    std::cout << "init" << std::endl;
    samp_base = (DWORD)LoadLibraryA("samp.dll");
    if (MH_Initialize() != MH_OK)
    {
        OutputDebugString("Initialize MinHook False!");
        return false;
    }
    if (MH_CreateHook(
        &LoadLibraryA,
        &LoadLibraryA_replacement,
        (LPVOID*)(&g_loadLibraryA_original)
    ) != MH_OK)
    {
        return false;
    }
    if (MH_EnableHook(&LoadLibraryA) != MH_OK)
    {
        return false;
    }

    if (MH_CreateHook(
        &LoadLibraryExA,
        &LoadLibraryExA_replacement,
        (LPVOID*)(&g_loadLibraryExA_original)
    ) != MH_OK)
    {
        return false;
    }
    if (MH_EnableHook(&LoadLibraryExA) != MH_OK)
    {
        return false;
    }

    if (MH_CreateHook(
        &LoadLibraryW,
        &LoadLibraryW_replacement,
        (LPVOID*)(&g_loadLibraryW_original)
    ) != MH_OK)
    {
        OutputDebugString("MH_CreateHook loadLibraryW False!");
        return false;
    }
    if (MH_EnableHook(&LoadLibraryW) != MH_OK)
    {
        OutputDebugString("MH_EnableHook loadLibraryW False!");
        return false;
    }

    if (MH_CreateHook(
        &LoadLibraryExW,
        &LoadLibraryExW_replacement,
        (LPVOID*)(&g_LoadLibraryExW_original)
    ) != MH_OK)
    {
        OutputDebugString("MH_CreateHook LoadLibraryExW False!");
        return false;
    }
    if (MH_EnableHook(&LoadLibraryExW) != MH_OK)
    {
        OutputDebugString("MH_EnableHook LoadLibraryExW False!");
        return false;
    }

    while (true)
    {
        addMessageToChat(-1, "Hidend // Shaarawy // <3");
        Sleep(5000);
    }
    FreeLibraryAndExitThread(GetModuleHandle(NULL), 0);
    return 0;
}

BOOL APIENTRY DllMain(HMODULE hModule, DWORD dwReasonForCall, LPVOID lpReserved)
{
    switch (dwReasonForCall)
    {
    case DLL_PROCESS_ATTACH:
        //AllocConsole();
        //freopen("CONOUT$", "w", stdout);
        //std::cout << "injected" << std::endl;
        CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)init, NULL, NULL, NULL);
        break;
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}