Привожу код на C++, в PatchProcess слишком много вложенных условий, что явно не подходит под best practices, можешь исправить это?
#include "pch.h"
#include <Windows.h>
#include <tlhelp32.h>
#include <psapi.h>
#include <fstream>
#include <vector>
#include <string>
#include <memory>
#include <thread>

class Logger {
public:
    explicit Logger(const std::string& filename) : logFile(filename) {}
    void Log(const std::string& message) {
        if (logFile.is_open()) {
            logFile << message << "\n";
        }
    }
private:
    std::ofstream logFile;
};

Logger logger("patcher_log.txt");

bool PatchProcess(DWORD processID, Logger& logger) {
    // Открытие дескриптора процесса с необходимыми правами доступа
    HANDLE hProcess = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, processID);
    if (!hProcess) {
        logger.Log("Failed to open the target process.");
        return false;
    }

    // Используем std::unique_ptr для автоматического закрытия дескриптора
    std::unique_ptr<void, decltype(&CloseHandle)> processCloser(hProcess, CloseHandle);

    // Массив байт для поиска в памяти процесса
    BYTE signatureBytes[] = { 0x85, 0xC0, 0x74, 0x57, 0x5F, 0xB8, 0x01 };
    BYTE patchByte = 0x00; // Байт, используемый для патча
    MEMORY_BASIC_INFORMATION mbi{};
    // Переменная успешности операции
    bool success = false;

    // Циклический просмотр памяти процесса
    for (BYTE* addr = nullptr; VirtualQueryEx(hProcess, addr, &mbi, sizeof(mbi)) && addr < (BYTE*)0x7FFFFFFF; addr += mbi.RegionSize) {
        // Поиск сегментов памяти с разрешенным выполнением и чтением
        if (mbi.State == MEM_COMMIT && (mbi.Protect == PAGE_EXECUTE_READWRITE || mbi.Protect == PAGE_EXECUTE_READ)) {
            // Буфер для хранения данных сегмента памяти
            std::vector<BYTE> buffer(mbi.RegionSize);
            SIZE_T bytesRead;

            // Чтение памяти из процесса
            if (ReadProcessMemory(hProcess, mbi.BaseAddress, buffer.data(), mbi.RegionSize, &bytesRead)) {
                // Поиск сигнатуры в буфере
                for (size_t j = 0; j < bytesRead - sizeof(signatureBytes); ++j) {
                    if (memcmp(buffer.data() + j, signatureBytes, sizeof(signatureBytes)) == 0) {
                        DWORD oldProtect;
                        // Изменение защиты страницы на запись перед патчем
                        if (VirtualProtectEx(hProcess, addr + j + sizeof(signatureBytes) - 1, 1, PAGE_EXECUTE_READWRITE, &oldProtect)) {
                            // Попытка записать патч и проверка успеха
                            if (WriteProcessMemory(hProcess, addr + j + sizeof(signatureBytes) - 1, &patchByte, 1, nullptr)) {
                                // Возвращаем оригинальные настройки защиты страницы
                                VirtualProtectEx(hProcess, addr + j + sizeof(signatureBytes) - 1, 1, oldProtect, &oldProtect);
                                logger.Log("Signature patched.");
                                success = true; // Отмечаем успех
                                return success;
                            }
                            else {
                                // Возврат защиты страницы в случае неудачи записи
                                VirtualProtectEx(hProcess, addr + j + sizeof(signatureBytes) - 1, 1, oldProtect, &oldProtect);
                                logger.Log("Failed to apply patch.");
                            }
                        }
                    }
                }
            }
        }
    }
    return success;
}

void AttemptToPatch(DWORD currentPID, Logger& logger) {
    logger.Log("Attempting to patch current process ID : " + std::to_string(currentPID) + " in a separate thread.");
    while (!PatchProcess(currentPID, logger)) {
        logger.Log("Failed to patch the current process.Retrying…");
        std::this_thread::sleep_for(std::chrono::seconds(5));
    }
    logger.Log("Current process patched successfully.");
}

DWORD WINAPI MonitorProcess(LPVOID lpParam) {
    Logger* logger = static_cast<Logger*>(lpParam);
    DWORD currentPID = GetCurrentProcessId();
    std::thread patcherThread(AttemptToPatch, currentPID, std::ref(*logger));
    patcherThread.detach();
    return 0;
}

BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
    switch (ul_reason_for_call) {
    case DLL_PROCESS_ATTACH:
        DisableThreadLibraryCalls(hModule);
        CreateThread(nullptr, 0, MonitorProcess, static_cast<LPVOID>(&logger), 0, nullptr);
        break;
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}