int64_t GetImageSize(int width, int height) {
    // Размер в видеопамяти = ширина * высота * 4 (для RGBA, 4 байта на пиксель)
    return static_cast<int64_t>(width) * height * 4;
}

struct MEMORYDATA {
    int64_t i64MemoryTotal = 0;
    int64_t i64MemoryFree  = 0;
    int64_t i64MemoryUsed  = 0;
    //
    MEMORYSTATUS MemoryPtr;
    void getData(int64_t* mem,int64_t idx_data){
        memset(&MemoryPtr, 0, sizeof(MemoryPtr));
        ::GlobalMemoryStatus(&MemoryPtr);
        switch (idx_data) {
        case 0:
            *mem = (MemoryPtr.dwTotalPhys - MemoryPtr.dwAvailPhys) / 1024 / 1024 / 1024; // кол использованная память
            break;
        case 1:
            *mem = MemoryPtr.dwTotalPhys / 1024 / 1024 / 1024; // кол всего памяти
            break;
        case 2:
            *mem = MemoryPtr.dwAvailPhys / 1024 / 1024 / 1024; // кол свободная памяти
            break;
        }
    }
    std::string MemoryInfo() {
        getData(&i64MemoryTotal, 1);
        getData(&i64MemoryFree , 2);
        getData(&i64MemoryUsed , 0);
        std::string mem_str = 
            "Total:   " + std::to_string(i64MemoryTotal) + " GB"
            "\nUsed :   " + std::to_string(i64MemoryUsed)  + " GB"
            "\nFree :   " + std::to_string(i64MemoryFree)  + " GB";
        return mem_str;
    }
};
auto ptrMemory = std::make_unique<MEMORYDATA>();

struct EXCEPTIONS {
    bool ErrorTextures = false;
    std::string sLastError;
    void* pLastStack = nullptr;

    void log(std::string t) {
        std::cout << "Exception Error: " << t << std::endl;
    }

    void Write(const std::string& t, void* pErrorSegment) {
        ErrorTextures = true;
        sLastError += t + "\n";
        pLastStack = pErrorSegment;
        log("EXCEPTIONS::Write: " + t + ", StackPtr: " + std::to_string(reinterpret_cast<uintptr_t>(pErrorSegment)));
    }

    static std::string GetStackTrace(PEXCEPTION_POINTERS pExInfo) {
        std::stringstream ss;
        HANDLE process = GetCurrentProcess();
        STACKFRAME64 frame = { 0 };
        frame.AddrPC.Offset = pExInfo->ContextRecord->Rip;
        frame.AddrPC.Mode = AddrModeFlat;
        frame.AddrFrame.Offset = pExInfo->ContextRecord->Rbp;
        frame.AddrFrame.Mode = AddrModeFlat;
        frame.AddrStack.Offset = pExInfo->ContextRecord->Rsp;
        frame.AddrStack.Mode = AddrModeFlat;

        while (StackWalk64(IMAGE_FILE_MACHINE_AMD64, process, GetCurrentThread(), &frame, pExInfo->ContextRecord, NULL, SymFunctionTableAccess64, SymGetModuleBase64, NULL)) {
            DWORD64 address = frame.AddrPC.Offset;
            char symbolBuffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME] = { 0 };
            SYMBOL_INFO* symbol = (SYMBOL_INFO*)symbolBuffer;
            symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
            symbol->MaxNameLen = MAX_SYM_NAME;
            DWORD64 displacement = 0;
            if (SymFromAddr(process, address, &displacement, symbol)) {
                ss << "Function: " << symbol->Name << " + 0x" << std::hex << displacement << "\n";
            }
            else {
                ss << "Unknown function at 0x" << std::hex << address << "\n";
            }
        }
        return ss.str();
    }

    static LONG WINAPI CrashHandler(PEXCEPTION_POINTERS pExInfo) {
        std::string errorMsg;
        std::string errorCode;
        switch (pExInfo->ExceptionRecord->ExceptionCode) {
        case EXCEPTION_ILLEGAL_INSTRUCTION: // 0xC000001D
            errorCode = "Illegal Instruction (0xC000001D)";
            break;
        case EXCEPTION_ACCESS_VIOLATION: // 0xC0000005
            errorCode = "Access Violation (0xC0000005)";
            break;
        case EXCEPTION_STACK_OVERFLOW: // 0xC00000FD
            errorCode = "Stack Overflow (0xC00000FD)";
            break;
        default:
            errorCode = "Unknown Exception (0x" + std::to_string(pExInfo->ExceptionRecord->ExceptionCode) + ")";
            break;
        }
        std::string stackTrace = GetStackTrace(pExInfo);
        std::ofstream logFile("crash_log.txt", std::ios::app);
        logFile << "PahomEngine crashed!" << std::endl;
        logFile << "========================" << std::endl;
        logFile << "Crash at: " << __DATE__ << " " << __TIME__ << "\n";
        logFile << "Exception: " << errorCode << "\n";
        logFile << "Stack Trace:\n" << stackTrace << "\n";
        logFile << "------------------------\n";
        logFile.close();

        std::wstring msg = L"Fatal Error: "  + std::wstring(errorCode.begin(), errorCode.end()) +
            L"\nSee crash_log.txt for details.\nPlease send crash_log.txt to @hcppstudio.";
        MessageBox(NULL, msg.c_str(), L"PahomEngine::Exception", MB_OK | MB_ICONERROR);

        return EXCEPTION_EXECUTE_HANDLER;
    }

    void BugReport() {
        SetUnhandledExceptionFilter(CrashHandler);
    }

    void Cleanup() {
        SymCleanup(GetCurrentProcess());
    }
};
 std::unique_ptr<EXCEPTIONS> Exceptions = std::make_unique<EXCEPTIONS>();