void CrashHandler::reportCrash()
{
    //将getStackTrace()中读取到的堆栈日志记录下来
    logErrorAndStackTrace(getStackTrace());
    //保存错误日志
    saveCrashLog();
    //保存dump文件
    mCrashMiniDumpPath = mSavePath + sMiniDumpName;
    win32_writeMiniDump(mCrashMiniDumpPath, nullptr);
}

std::string CrashHandler::getStackTrace()
{
    CONTEXT context;
    RtlCaptureContext(&context);
    win32_initPSAPI();
    win32_loadSymbols();
    return win32_getStackTrace(context, 2);
}

void CrashHandler::win32_loadSymbols()
{
    if (gSymbolsLoaded)
        return;
    HANDLE hProcess = GetCurrentProcess();
    UINT32 options = SymGetOptions();

    options |= SYMOPT_LOAD_LINES;
    options |= SYMOPT_EXACT_SYMBOLS;
    options |= SYMOPT_UNDNAME;
    options |= SYMOPT_FAIL_CRITICAL_ERRORS;
    options |= SYMOPT_NO_PROMPTS;
    SymSetOptions(options);
    if (!SymInitialize(hProcess, nullptr, false))
    {
        Log::message("SymInitialize failed.Error code : %d", (UINT32)GetLastError());
        return;
    }
    DWORD bufferSize;
    gEnumProcessModules(hProcess, nullptr, 0, &bufferSize);

    HMODULE* modules = (HMODULE*)malloc(bufferSize);
    gEnumProcessModules(hProcess, modules, bufferSize, &bufferSize);

    UINT32 numModules = bufferSize / sizeof(HMODULE);
    for (UINT32 i = 0; i < numModules; i++)
    {
        MODULEINFO moduleInfo;

        char moduleName[MAX_STACKTRACE_NAME_BYTES];
        char imageName[MAX_STACKTRACE_NAME_BYTES];

        gGetModuleInformation(hProcess, modules[i], &moduleInfo, sizeof(moduleInfo));
        gGetModuleFileNameEx(hProcess, modules[i], imageName, MAX_STACKTRACE_NAME_BYTES);
        gGetModuleBaseName(hProcess, modules[i], moduleName, MAX_STACKTRACE_NAME_BYTES);

        char pdbSearchPath[MAX_STACKTRACE_NAME_BYTES];
        char* fileName = nullptr;
        GetFullPathNameA(moduleName, MAX_STACKTRACE_NAME_BYTES, pdbSearchPath, &fileName);
        *fileName = '\0';

        SymSetSearchPath(GetCurrentProcess(), pdbSearchPath);

        DWORD64 moduleAddress = SymLoadModule64(hProcess, modules[i], imageName, moduleName, (DWORD64)moduleInfo.lpBaseOfDll,
            (DWORD)moduleInfo.SizeOfImage);

        if (moduleAddress != 0)
        {
            IMAGEHLP_MODULE64 imageInfo;
            memset(&imageInfo, 0, sizeof(imageInfo));
            imageInfo.SizeOfStruct = sizeof(imageInfo);

            if (!SymGetModuleInfo64(GetCurrentProcess(), moduleAddress, &imageInfo))
            {
                Log::message("Warning:Failed retrieving module info for module: %s Error code: %d", moduleName, (UINT32)GetLastError());
            }
            else
            {
                // Disabled because too much spam in the log, enable as needed
            }
        }
        else
        {
            Log::message("Warning:Failed loading module %s.Error code: %d. Search path: %s. Image name: %s", moduleName, (UINT32)GetLastError(), pdbSearchPath, imageName);
        }
    }
    free(modules);
    gSymbolsLoaded = true;
}

std::string CrashHandler::win32_getStackTrace(CONTEXT context, UINT32 skip)
{
    UINT64 rawStackTrace[MAX_STACKTRACE_DEPTH];
    UINT32 numEntries = win32_getRawStackTrace(context, rawStackTrace);

    numEntries = min((UINT32)MAX_STACKTRACE_DEPTH, numEntries);

    UINT32 bufferSize = sizeof(PIMAGEHLP_SYMBOL64) + MAX_STACKTRACE_NAME_BYTES;
    UINT8* buffer = (UINT8*)malloc(bufferSize);

    PIMAGEHLP_SYMBOL64 symbol = (PIMAGEHLP_SYMBOL64)buffer;
    symbol->SizeOfStruct = bufferSize;
    symbol->MaxNameLength = MAX_STACKTRACE_NAME_BYTES;

    HANDLE hProcess = GetCurrentProcess();

    std::stringstream outputStream;
    for (UINT32 i = skip; i < numEntries; i++)
    {
        if (i > skip)
            outputStream << std::endl;

        DWORD64 funcAddress = rawStackTrace[i];

        // Output function name
        DWORD64 dummy;
        if (SymGetSymFromAddr64(hProcess, funcAddress, &dummy, symbol))
        {
            outputStream << std::string(symbol->Name) + "() - ";
        }

        // Output file name and line
        IMAGEHLP_LINE64    lineData;
        lineData.SizeOfStruct = sizeof(lineData);
        std::string addressString = std::to_string(funcAddress);

        DWORD column;
        if (SymGetLineFromAddr64(hProcess, funcAddress, &column, &lineData))
        {
            std::string filePath = lineData.FileName;
            outputStream << "0x" + addressString + " File[" + filePath + ":" + std::to_string(lineData.LineNumber) + " (" + std::to_string(column) + ")]";
        }
        else
        {
            outputStream << "0x" + addressString;
        }

        // Output module name
        IMAGEHLP_MODULE64 moduleData;
        moduleData.SizeOfStruct = sizeof(moduleData);

        if (SymGetModuleInfo64(hProcess, funcAddress, &moduleData))
        {
            std::string filePath = moduleData.ImageName;

            outputStream << " Module[" + filePath + "]";
        }
    }

    free(buffer);

    return outputStream.str();
}

void CrashHandler::win32_writeMiniDump(const std::string& filePath, EXCEPTION_POINTERS* exceptionData)
{
    MiniDumpParams param = { filePath, exceptionData };

    // Write minidump on a second thread in order to preserve the current thread's call stack
    DWORD threadId = 0;
    HANDLE hThread = CreateThread(nullptr, 0, &win32_writeMiniDumpWorker, &param, 0, &threadId);

    WaitForSingleObject(hThread, INFINITE);
    CloseHandle(hThread);
}

DWORD CALLBACK win32_writeMiniDumpWorker(void* data)
{
    CrashHandler::MiniDumpParams* params = (CrashHandler::MiniDumpParams*)data;

    std::wstring pathString = string2wstring(params->filePath);
    HANDLE hFile = CreateFileW(pathString.c_str(), GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL,
        nullptr);

    if (hFile != INVALID_HANDLE_VALUE)
    {
        MINIDUMP_EXCEPTION_INFORMATION DumpExceptionInfo;

        DumpExceptionInfo.ThreadId = GetCurrentThreadId();
        DumpExceptionInfo.ExceptionPointers = params->exceptionData;
        DumpExceptionInfo.ClientPointers = false;

        MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), hFile, MiniDumpNormal,
            &DumpExceptionInfo, nullptr, nullptr);
        CloseHandle(hFile);
    }

    return 0;
}