#include <windows.h>
#include <TlHelp32.h>
#include <iostream>
#include <string>

// Function to find the WoW process ID
DWORD GetWoWProcessId()
{
    // Create a snapshot of all running processes
    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (snapshot == INVALID_HANDLE_VALUE)
    {
        std::cerr << "Error: Could not create process snapshot." << std::endl;
        return 0;
    }

    // Iterate through the processes and find the WoW process
    PROCESSENTRY32 processEntry;
    processEntry.dwSize = sizeof(PROCESSENTRY32);
    BOOL success = Process32First(snapshot, &processEntry);
    while (success)
    {
        if (std::string(processEntry.szExeFile) == "Wow.exe")
        {
            // Found the WoW process
            CloseHandle(snapshot);
            return processEntry.th32ProcessID;
        }

        success = Process32Next(snapshot, &processEntry);
    }

    // WoW process not found
    CloseHandle(snapshot);
    return 0;
}

// Function to unlock all LUA functions in WoW
void UnlockLuaFunctions(DWORD wowProcessId)
{
    // Open the WoW process
    HANDLE wowProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, wowProcessId);
    if (wowProcess == NULL)
    {
        std::cerr << "Error: Could not open WoW process." << std::endl;
        return;
    }

    // Find the address of the LUA function table
    DWORD luaFunctionTableAddress = 0x00642000;

    // Allocate memory in the WoW process for the modified LUA function table
    DWORD modifiedLuaFunctionTableAddress = (DWORD)VirtualAllocEx(wowProcess, NULL, 0x1000, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    if (modifiedLuaFunctionTableAddress == 0)
    {
        std::cerr << "Error: Could not allocate memory in WoW process." << std::endl;
        CloseHandle(wowProcess);
        return;
    }

    // Copy the original LUA function table to the modified table
    SIZE_T bytesRead;
    BOOL success = ReadProcessMemory(wowProcess, (LPCVOID)luaFunctionTableAddress, (LPVOID)modifiedLuaFunctionTableAddress, 0x1000, &bytesRead);
    if (!success || bytesRead != 0x1000)
    {
        std::cerr << "Error: Could not read LUA function table from WoW process." << std::endl;
        VirtualFreeEx(wowProcess, (LPVOID)modifiedLuaFunctionTableAddress, 0x1000, MEM_RELEASE);
        CloseHandle(wowProcess);
        return;
    }

    // Modify the LUA function table to unlock all functions
    for (int i = 0; i < 0x1000; i += 4)
    {
        DWORD functionAddress = *(DWORD*)(modifiedLuaFunctionTableAddress + i);
        if (functionAddress != 0)
        {
            // Function is locked, unlock it
            *(DWORD*)(modifiedLuaFunctionTableAddress + i) = functionAddress | 0x80000000;
        }
    }

    // Write the modified LUA function table back to the WoW process
    success = WriteProcessMemory(wowProcess, (LPVOID)luaFunctionTableAddress, (LPCVOID)modifiedLuaFunctionTableAddress, 0x1000, &bytesRead);
    if (!success || bytesRead != 0x1000)
    {
        std::cerr << "Error: Could not write modified LUA function table to WoW process." << std::endl;
        VirtualFreeEx(wowProcess, (LPVOID)modifiedLuaFunctionTableAddress, 0x1000, MEM_RELEASE);
        CloseHandle(wowProcess);
        return;
    }

    // Free the allocated memory in the WoW process
    VirtualFreeEx(wowProcess, (LPVOID)modifiedLuaFunctionTableAddress, 0x1000, MEM_RELEASE);

    // Close the WoW process
    CloseHandle(wowProcess);

    // Success
    std::cout << "All LUA functions have been unlocked." << std::endl;
}

int main()
{
    // Get the WoW process ID
    DWORD wowProcessId = GetWoWProcessId();
    if (wowProcessId == 0)
    {
        std::cerr << "Error: Could not find WoW process." << std::endl;
        return 1;
    }

    // Unlock all LUA functions in WoW
    UnlockLuaFunctions(wowProcessId);

    return 0;
}