//
// Copyright 2019 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// system_utils_win32.cpp: Implementation of OS-specific functions for Windows.

#include "common/FastVector.h"
#include "system_utils.h"

#include <array>

// Must be included in this order.
// clang-format off
#include <windows.h>
#include <psapi.h>
// clang-format on

namespace angle
{
bool UnsetEnvironmentVar(const char *variableName)
{
    return (SetEnvironmentVariableW(Widen(variableName).c_str(), nullptr) == TRUE);
}

bool SetEnvironmentVar(const char *variableName, const char *value)
{
    return (SetEnvironmentVariableW(Widen(variableName).c_str(), Widen(value).c_str()) == TRUE);
}

std::string GetEnvironmentVar(const char *variableName)
{
    std::wstring variableNameUtf16 = Widen(variableName);
    FastVector<wchar_t, MAX_PATH> value;

    DWORD result;

    // First get the length of the variable, including the null terminator
    result = GetEnvironmentVariableW(variableNameUtf16.c_str(), nullptr, 0);

    // Zero means the variable was not found, so return now.
    if (result == 0)
    {
        return std::string();
    }

    // Now size the vector to fit the data, and read the environment variable.
    value.resize(result, 0);
    result = GetEnvironmentVariableW(variableNameUtf16.c_str(), value.data(), result);

    return Narrow(value.data());
}

void *OpenSystemLibraryWithExtensionAndGetError(const char *libraryName,
                                                SearchType searchType,
                                                std::string *errorOut)
{
    char buffer[MAX_PATH];
    int ret = snprintf(buffer, MAX_PATH, "%s.%s", libraryName, GetSharedLibraryExtension());
    if (ret <= 0 || ret >= MAX_PATH)
    {
        fprintf(stderr, "Error loading shared library: 0x%x", ret);
        return nullptr;
    }

    HMODULE libraryModule = nullptr;

    switch (searchType)
    {
        case SearchType::ModuleDir:
        {
            std::string moduleRelativePath = ConcatenatePath(GetModuleDirectory(), libraryName);
            if (errorOut)
            {
                *errorOut = moduleRelativePath;
            }
            libraryModule = LoadLibraryW(Widen(moduleRelativePath).c_str());
            break;
        }

        case SearchType::SystemDir:
        {
            if (errorOut)
            {
                *errorOut = libraryName;
            }
            libraryModule =
                LoadLibraryExW(Widen(libraryName).c_str(), nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32);
            break;
        }

        case SearchType::AlreadyLoaded:
        {
            if (errorOut)
            {
                *errorOut = libraryName;
            }
            libraryModule = GetModuleHandleW(Widen(libraryName).c_str());
            break;
        }
    }

    return reinterpret_cast<void *>(libraryModule);
}

namespace
{
class Win32PageFaultHandler : public PageFaultHandler
{
  public:
    Win32PageFaultHandler(PageFaultCallback callback) : PageFaultHandler(callback) {}
    ~Win32PageFaultHandler() override {}

    bool enable() override;
    bool disable() override;

    LONG handle(PEXCEPTION_POINTERS pExceptionInfo);

  private:
    void *mVectoredExceptionHandler = nullptr;
};

Win32PageFaultHandler *gWin32PageFaultHandler = nullptr;
static LONG CALLBACK VectoredExceptionHandler(PEXCEPTION_POINTERS info)
{
    return gWin32PageFaultHandler->handle(info);
}

bool SetMemoryProtection(uintptr_t start, size_t size, DWORD protections)
{
    DWORD oldProtect;
    BOOL res = VirtualProtect(reinterpret_cast<LPVOID>(start), size, protections, &oldProtect);
    if (!res)
    {
        DWORD lastError = GetLastError();
        fprintf(stderr, "VirtualProtect failed: 0x%lx\n", lastError);
        return false;
    }

    return true;
}

LONG Win32PageFaultHandler::handle(PEXCEPTION_POINTERS info)
{
    bool found = false;

    if (info->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION &&
        info->ExceptionRecord->NumberParameters >= 2 &&
        info->ExceptionRecord->ExceptionInformation[0] == 1)
    {
        found = mCallback(static_cast<uintptr_t>(info->ExceptionRecord->ExceptionInformation[1])) ==
                PageFaultHandlerRangeType::InRange;
    }

    if (found)
    {
        return EXCEPTION_CONTINUE_EXECUTION;
    }
    else
    {
        return EXCEPTION_CONTINUE_SEARCH;
    }
}

bool Win32PageFaultHandler::disable()
{
    if (mVectoredExceptionHandler)
    {
        ULONG res                 = RemoveVectoredExceptionHandler(mVectoredExceptionHandler);
        mVectoredExceptionHandler = nullptr;
        if (res == 0)
        {
            DWORD lastError = GetLastError();
            fprintf(stderr, "RemoveVectoredExceptionHandler failed: 0x%lx\n", lastError);
            return false;
        }
    }
    return true;
}

bool Win32PageFaultHandler::enable()
{
    if (mVectoredExceptionHandler)
    {
        return true;
    }

    PVECTORED_EXCEPTION_HANDLER handler =
        reinterpret_cast<PVECTORED_EXCEPTION_HANDLER>(&VectoredExceptionHandler);

    mVectoredExceptionHandler = AddVectoredExceptionHandler(1, handler);

    if (!mVectoredExceptionHandler)
    {
        DWORD lastError = GetLastError();
        fprintf(stderr, "AddVectoredExceptionHandler failed: 0x%lx\n", lastError);
        return false;
    }
    return true;
}
}  // namespace

// Set write protection
bool ProtectMemory(uintptr_t start, size_t size)
{
    return SetMemoryProtection(start, size, PAGE_READONLY);
}

// Allow reading and writing
bool UnprotectMemory(uintptr_t start, size_t size)
{
    return SetMemoryProtection(start, size, PAGE_READWRITE);
}

size_t GetPageSize()
{
    SYSTEM_INFO info;
    GetSystemInfo(&info);
    return static_cast<size_t>(info.dwPageSize);
}

PageFaultHandler *CreatePageFaultHandler(PageFaultCallback callback)
{
    gWin32PageFaultHandler = new Win32PageFaultHandler(callback);
    return gWin32PageFaultHandler;
}

uint64_t GetProcessMemoryUsageKB()
{
    PROCESS_MEMORY_COUNTERS_EX pmc;
    ::GetProcessMemoryInfo(::GetCurrentProcess(), reinterpret_cast<PROCESS_MEMORY_COUNTERS *>(&pmc),
                           sizeof(pmc));
    return static_cast<uint64_t>(pmc.PrivateUsage) / 1024ull;
}
}  // namespace angle