#include <QApplication>
#include <QWidget>
#include <QThread>
#include <QLabel>
#include <QPushButton>
#include <QVBoxLayout>
#include <QTimer>
#include <QLibrary>
#include <QFileInfo>
#include <QDir>  
#include <iostream>
#include <fstream>
#include <csignal>
#include <windows.h>
#include <dbghelp.h>
#include <sstream>
#include <iomanip>
#include <psapi.h>
#include <QLibraryInfo>

#pragma comment(lib, "Dbghelp.lib")
#pragma comment(lib, "Psapi.lib")

const char* logFilePath = "qt_crash_log.txt";

// Global pointer to intentionally cause access violation
QWidget* g_danglingPtr = nullptr;

// Log function
void writeLog(const std::string& message, bool overwrite = false) {
    std::ofstream logFile;
    if (overwrite) {
        logFile.open(logFilePath, std::ios::out);  // Overwrite the file
    }
    else {
        logFile.open(logFilePath, std::ios::app);  // Append to the file
    }
    if (logFile.is_open()) {
        logFile << message << std::endl;
        logFile.close();
    }

    // Also print to console for immediate feedback
    std::cout << message << std::endl;
}

// Function to get module information
void logModuleInfo(HANDLE process) {
    DWORD cbNeeded;
    HMODULE hMods[1024];

    writeLog("\nLoading Required Modules!!!");

    // Get a list of all the modules in this process
    if (EnumProcessModules(process, hMods, sizeof(hMods), &cbNeeded)) {
        for (unsigned int i = 0; i < (cbNeeded / sizeof(HMODULE)); i++) {
            TCHAR szModName[MAX_PATH];

            // Get the full path to the module's file
            if (GetModuleFileNameEx(process, hMods[i], szModName, sizeof(szModName) / sizeof(TCHAR))) {
                // Convert to narrow string for logging
                std::string moduleName;
                for (int j = 0; szModName[j] != 0; j++) {
                    moduleName += (char)szModName[j];
                }

                // Get module base address and size
                MODULEINFO modInfo;
                if (GetModuleInformation(process, hMods[i], &modInfo, sizeof(MODULEINFO))) {
                    std::stringstream ss;
                    ss << "Module: " << std::left << std::setw(50) << moduleName
                        << " Base: 0x" << std::hex << std::setw(16) << std::setfill('0') << (uintptr_t)modInfo.lpBaseOfDll
                        << " Size: 0x" << std::hex << std::setw(8) << std::setfill('0') << modInfo.SizeOfImage;
                    writeLog(ss.str());
                }
            }
        }
    }
}

// Improved stack trace with module name resolution
void printStackTrace() {
    void* stack[100];
    unsigned short frames;
    SYMBOL_INFO* symbol;
    HANDLE process = GetCurrentProcess();
    IMAGEHLP_LINE64 line;
    DWORD displacement;
    IMAGEHLP_MODULE64 moduleInfo;

    // Initialize symbol handler with more options
    DWORD symOptions = SymGetOptions();
    symOptions |= SYMOPT_LOAD_LINES | SYMOPT_UNDNAME | SYMOPT_DEBUG | SYMOPT_INCLUDE_32BIT_MODULES;
    SymSetOptions(symOptions);

    // Force reinitialization of symbols
    SymCleanup(process);
    SymInitialize(process, NULL, TRUE);

    // Log module information
    logModuleInfo(process);

    frames = CaptureStackBackTrace(0, 100, stack, NULL);
    symbol = (SYMBOL_INFO*)calloc(sizeof(SYMBOL_INFO) + 256 * sizeof(char), 1);
    symbol->MaxNameLen = 255;
    symbol->SizeOfStruct = sizeof(SYMBOL_INFO);

    // Initialize line and module info structures
    ZeroMemory(&line, sizeof(IMAGEHLP_LINE64));
    line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);

    ZeroMemory(&moduleInfo, sizeof(IMAGEHLP_MODULE64));
    moduleInfo.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);

    writeLog("\nDetailed Stack trace:");
    for (unsigned short i = 0; i < frames; i++) {
        std::stringstream traceInfo;
        bool hasSymbolInfo = false;

        // Get basic symbol info
        if (SymFromAddr(process, (DWORD64)(stack[i]), 0, symbol)) {
            hasSymbolInfo = true;
            traceInfo << i << ": " << symbol->Name << " - 0x" << std::hex << (uintptr_t)symbol->Address;

            // Get module information
            if (SymGetModuleInfo64(process, symbol->ModBase, &moduleInfo)) {
                std::string moduleName = moduleInfo.ModuleName;
                if (moduleName.find("Qt") != std::string::npos) {
                    traceInfo << " [" << moduleInfo.ModuleName << "]";
                }
            }
        }
        else {
            traceInfo << i << ": <unknown symbol> - 0x" << std::hex << (uintptr_t)stack[i];
        }

        // Get line number information
        if (SymGetLineFromAddr64(process, (DWORD64)(stack[i]), &displacement, &line)) {
            traceInfo << " - " << line.FileName << ":" << std::dec << line.LineNumber;

            // Special handling for Qt files
            std::string fileName = line.FileName;
            if (fileName.find("Qt") != std::string::npos ||
                fileName.find("qt") != std::string::npos) {
                traceInfo << " (Qt Library Code)";
            }
        }
        else {
            DWORD error = GetLastError();
            if (hasSymbolInfo) {
                // Try to get information about where this module is located
                if (SymGetModuleInfo64(process, symbol->ModBase, &moduleInfo)) {
                    traceInfo << " - Module: " << moduleInfo.ImageName;

                    if (std::string(moduleInfo.ModuleName).find("Qt") != std::string::npos) {
                        traceInfo << " (Qt Library - no line info available)";
                    }
                }
            }
            traceInfo << " [Error: " << std::dec << error << "]";
        }

        writeLog(traceInfo.str());
    }

    free(symbol);
}

// Signal handler
void signalHandler(int signum) {
    writeLog("\n*** ACCESS VIOLATION DETECTED! Signal: " + std::to_string(signum) + " ***");
    writeLog("Crash occurred when trying to access invalid memory in Qt's hasFocus() method.");

    // Generate comprehensive stack trace with Qt library info
    printStackTrace();

    // Create a crash dump file with more information
    HANDLE hFile = CreateFileW(
        L"qt_crash.dmp",
        GENERIC_WRITE,
        0,
        NULL,
        CREATE_ALWAYS,
        FILE_ATTRIBUTE_NORMAL,
        NULL
    );

    if (hFile != INVALID_HANDLE_VALUE) {
        HANDLE hProcess = GetCurrentProcess();
        DWORD processId = GetCurrentProcessId();

        MINIDUMP_EXCEPTION_INFORMATION exInfo;
        exInfo.ThreadId = GetCurrentThreadId();
        exInfo.ExceptionPointers = NULL;
        exInfo.ClientPointers = FALSE;

        // Create a more detailed minidump
        MiniDumpWriteDump(
            hProcess,
            processId,
            hFile,
            MiniDumpWithFullMemory,  // More detailed dump
            &exInfo,
            NULL,
            NULL
        );

        CloseHandle(hFile);
        writeLog("Comprehensive crash dump written to qt_crash.dmp");
    }

    exit(signum);
}

// Function to force an access violation in hasFocus()
void triggerHasFocusCrash() {
    writeLog("About to trigger access violation in QWidget::hasFocus() at line: " + std::to_string(__LINE__ + 1));
    bool hasFocus = g_danglingPtr->hasFocus();  // This will trigger the access violation in Qt's code
    writeLog("This should never be reached: hasFocus returned " + std::to_string(hasFocus));
}

class DemoWidget : public QWidget {
public:
    DemoWidget() : QWidget(nullptr) {
        setWindowTitle("Qt Widget hasFocus() Crash Demo");
        resize(500, 400);

        QVBoxLayout* layout = new QVBoxLayout(this);

        QLabel* label = new QLabel("This program demonstrates capturing Qt library line numbers\n"
            "when an access violation occurs in QWidget::hasFocus().", this);
        label->setAlignment(Qt::AlignCenter);
        layout->addWidget(label);

        QPushButton* crashButton = new QPushButton("Crash in QWidget::hasFocus()", this);
        connect(crashButton, &QPushButton::clicked, this, [this]() {
            writeLog("Crash button clicked. Setting up the hasFocus() crash scenario...");

            // Create a widget that will be destroyed
            QWidget* tempWidget = new QWidget();
            tempWidget->setObjectName("TemporaryWidget");
            tempWidget->show();

            // Store the pointer globally
            g_danglingPtr = tempWidget;
            writeLog("Created temporary widget with address: " +
                std::to_string(reinterpret_cast<uintptr_t>(g_danglingPtr)));

            // Schedule deletion
            writeLog("Scheduling widget deletion in 500ms");
            QTimer::singleShot(500, this, [tempWidget]() {
                writeLog("Deleting temporary widget");
                delete tempWidget;
                writeLog("Widget deleted, g_danglingPtr is now dangling");

                // Wait a bit more before attempting to use the deleted widget
                QTimer::singleShot(100, []() {
                    writeLog("Now attempting to call hasFocus() on deleted widget");
                    writeLog("The crash will occur in Qt's internal implementation of QWidget::hasFocus()");
                    triggerHasFocusCrash(); // This call will crash in hasFocus()
                    });
                });
            });
        layout->addWidget(crashButton);

        QPushButton* loadSymbolsButton = new QPushButton("Load Qt Debug Symbols", this);
        connect(loadSymbolsButton, &QPushButton::clicked, this, []() {
            writeLog("Attempting to load Qt debug symbols...");
            HANDLE process = GetCurrentProcess();

            // Find Qt module paths
            QString qtCorePath = QLibraryInfo::location(QLibraryInfo::LibrariesPath) + "/QtCore.dll";
            QString qtWidgetsPath = QLibraryInfo::location(QLibraryInfo::LibrariesPath) + "/QtWidgets.dll";

            writeLog("Locating Qt libraries:");
            writeLog("  QtCore: " + qtCorePath.toStdString());
            writeLog("  QtWidgets: " + qtWidgetsPath.toStdString());

            // Look for PDB files
            QDir qtDir(QLibraryInfo::location(QLibraryInfo::LibrariesPath));
            QFileInfoList pdbFiles = qtDir.entryInfoList(QStringList() << "*.pdb", QDir::Files);

            writeLog("Found PDB files in Qt directory:");
            for (const QFileInfo& pdbFile : pdbFiles) {
                writeLog("  " + pdbFile.absoluteFilePath().toStdString());
            }

            // Try to load symbols for Qt modules
            DWORD symOptions = SymGetOptions();
            symOptions |= SYMOPT_LOAD_LINES | SYMOPT_DEBUG | SYMOPT_UNDNAME;
            SymSetOptions(symOptions);

            SymCleanup(process);
            if (SymInitialize(process, NULL, FALSE)) {
                writeLog("Symbol handler initialized");

                // Load modules manually
                if (SymLoadModule64(process, NULL, qtCorePath.toStdString().c_str(), NULL, 0, 0)) {
                    writeLog("Loaded symbols for QtCore");
                }
                else {
                    writeLog("Failed to load symbols for QtCore: " + std::to_string(GetLastError()));
                }

                if (SymLoadModule64(process, NULL, qtWidgetsPath.toStdString().c_str(), NULL, 0, 0)) {
                    writeLog("Loaded symbols for QtWidgets");
                }
                else {
                    writeLog("Failed to load symbols for QtWidgets: " + std::to_string(GetLastError()));
                }
            }
            else {
                writeLog("Failed to initialize symbol handler: " + std::to_string(GetLastError()));
            }
            });
        layout->addWidget(loadSymbolsButton);

        QPushButton* exitButton = new QPushButton("Exit Safely", this);
        connect(exitButton, &QPushButton::clicked, qApp, &QApplication::quit);
        layout->addWidget(exitButton);
    }
};

int main(int argc, char* argv[]) {
    // Register signal handler for segmentation fault
    std::signal(SIGSEGV, signalHandler);
    std::signal(SIGABRT, signalHandler);

    QApplication app(argc, argv);

    // Overwrite the log file at the start
    writeLog("Starting Qt Widget hasFocus() Access Violation Demo...", true);

    // Print Qt version info
    writeLog("Qt Version: " + std::string(qVersion()));
    writeLog("Qt Libraries Path: " + QLibraryInfo::location(QLibraryInfo::LibrariesPath).toStdString());

    // Configure symbol handler for better Qt debugging
    DWORD symOptions = SymGetOptions();
    symOptions |= SYMOPT_LOAD_LINES | SYMOPT_UNDNAME | SYMOPT_DEBUG | SYMOPT_LOAD_ANYTHING;
    symOptions |= SYMOPT_INCLUDE_32BIT_MODULES | SYMOPT_DEFERRED_LOADS;
    SymSetOptions(symOptions);

    SymInitialize(GetCurrentProcess(), NULL, TRUE);

    writeLog("Symbol handler initialized with enhanced options");
    writeLog("Executable path: " + std::string(argv[0]));
    writeLog("Built on: " + std::string(__DATE__) + " at " + std::string(__TIME__));

    // Create and show the main widget
    DemoWidget mainWidget;
    mainWidget.show();

    writeLog("Main application window created, waiting for user interaction");

    return app.exec();
}