/*

 * Copyright (c) 2014, 2018, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

#include "Platform.h"

#ifdef WINDOWS

#include "JavaVirtualMachine.h"

#include "WindowsPlatform.h"

#include "Package.h"

#include "Helpers.h"

#include "PlatformString.h"

#include "Macros.h"

#include <map>

#include <vector>

#include <regex>

#define WINDOWS_JPACKAGER_TMP_DIR \

class Registry {

private:

    HKEY FKey;

    HKEY FOpenKey;

    bool FOpen;

public:

    Registry(HKEY Key) {

        FOpen = false;

        FKey = Key;

    }

    ~Registry() {

        Close();

    }

    void Close() {

        if (FOpen == true) {

            RegCloseKey(FOpenKey);

        }

    }

    bool Open(TString SubKey) {

        bool result = false;

        Close();

        if (RegOpenKeyEx(FKey, SubKey.data(), 0, KEY_READ, &FOpenKey) ==

                ERROR_SUCCESS) {

            result = true;

        }

        return result;

    }

    std::list<TString> GetKeys() {

        std::list<TString> result;

        DWORD count;

        if (RegQueryInfoKey(FOpenKey, NULL, NULL, NULL, NULL, NULL, NULL,

                 &count, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) {

            DWORD length = 255;

            DynamicBuffer<TCHAR> buffer(length);

            if (buffer.GetData() == NULL) {

                return result;

            }

            for (unsigned int index = 0; index < count; index++) {

                buffer.Zero();

                DWORD status = RegEnumValue(FOpenKey, index, buffer.GetData(),

                                            &length, NULL, NULL, NULL, NULL);

                while (status == ERROR_MORE_DATA) {

                    length = length * 2;

                    if (!buffer.Resize(length)) {

                        return result;

                    }

                    status = RegEnumValue(FOpenKey, index, buffer.GetData(),

                                          &length, NULL, NULL, NULL, NULL);

                }

                if (status == ERROR_SUCCESS) {

                    TString value = buffer.GetData();

                    result.push_back(value);

                }

            }

        }

        return result;

    }

    TString ReadString(TString Name) {

        TString result;

        DWORD length;

        DWORD dwRet;

        DynamicBuffer<wchar_t> buffer(0);

        length = 0;

        dwRet = RegQueryValueEx(FOpenKey, Name.data(), NULL, NULL, NULL,

                &length);

        if (dwRet == ERROR_MORE_DATA || dwRet == 0) {

            if (!buffer.Resize(length + 1)) {

                return result;

            }

            dwRet = RegQueryValueEx(FOpenKey, Name.data(), NULL, NULL,

                    (LPBYTE)buffer.GetData(), &length);

            result = buffer.GetData();

        }

        return result;

    }

};

WindowsPlatform::WindowsPlatform(void) : Platform(), GenericPlatform() {

    FMainThread = ::GetCurrentThreadId();

}

WindowsPlatform::~WindowsPlatform(void) {

}

TCHAR* WindowsPlatform::ConvertStringToFileSystemString(TCHAR* Source,

        bool &release) {

    // Not Implemented.

    return NULL;

}

TCHAR* WindowsPlatform::ConvertFileSystemStringToString(TCHAR* Source,

        bool &release) {

    // Not Implemented.

    return NULL;

}

void WindowsPlatform::SetCurrentDirectory(TString Value) {

    _wchdir(Value.data());

}

TString WindowsPlatform::GetPackageRootDirectory() {

    TString filename = GetModuleFileName();

    return FilePath::ExtractFilePath(filename);

}

TString WindowsPlatform::GetAppDataDirectory() {

    TString result;

    TCHAR path[MAX_PATH];

    if (SHGetFolderPath(NULL, CSIDL_APPDATA, NULL, 0, path) == S_OK) {

        result = path;

    }

    return result;

}

void WindowsPlatform::ShowMessage(TString title, TString description) {

    MessageBox(NULL, description.data(),

            !title.empty() ? title.data() : description.data(),

            MB_ICONERROR | MB_OK);

}

void WindowsPlatform::ShowMessage(TString description) {

    TString appname = GetModuleFileName();

    appname = FilePath::ExtractFileName(appname);

    MessageBox(NULL, description.data(), appname.data(), MB_ICONERROR | MB_OK);

}

MessageResponse WindowsPlatform::ShowResponseMessage(TString title,

        TString description) {

    MessageResponse result = mrCancel;

    if (::MessageBox(NULL, description.data(), title.data(), MB_OKCANCEL) ==

            IDOK) {

        result = mrOK;

    }

    return result;

}

TString WindowsPlatform::GetBundledJVMLibraryFileName(TString RuntimePath) {

    TString result = FilePath::IncludeTrailingSeparator(RuntimePath) +

        _T("jre\\bin\\jli.dll");

    if (FilePath::FileExists(result) == false) {

        result = FilePath::IncludeTrailingSeparator(RuntimePath) +

            _T("bin\\jli.dll");

    }

    return result;

}

ISectionalPropertyContainer* WindowsPlatform::GetConfigFile(TString FileName) {

    IniFile *result = new IniFile();

    if (result == NULL) {

        return NULL;

    }

    if (result->LoadFromFile(FileName) == false) {

        // New property file format was not found,

        // attempt to load old property file format.

        Helpers::LoadOldConfigFile(FileName, result);

    }

    return result;

}

TString WindowsPlatform::GetModuleFileName() {

    TString result;

    DynamicBuffer<wchar_t> buffer(MAX_PATH);

    if (buffer.GetData() == NULL) {

        return result;

    }

    ::GetModuleFileName(NULL, buffer.GetData(),

            static_cast<DWORD>(buffer.GetSize()));

    while (ERROR_INSUFFICIENT_BUFFER == GetLastError()) {

        if (!buffer.Resize(buffer.GetSize() * 2)) {

            return result;

        }

        ::GetModuleFileName(NULL, buffer.GetData(),

                static_cast<DWORD>(buffer.GetSize()));

    }

    result = buffer.GetData();

    return result;

}

Module WindowsPlatform::LoadLibrary(TString FileName) {

    return ::LoadLibrary(FileName.data());

}

void WindowsPlatform::FreeLibrary(Module AModule) {

    ::FreeLibrary((HMODULE)AModule);

}

Procedure WindowsPlatform::GetProcAddress(Module AModule,

        std::string MethodName) {

    return ::GetProcAddress((HMODULE)AModule, MethodName.c_str());

}

bool WindowsPlatform::IsMainThread() {

    bool result = (FMainThread == ::GetCurrentThreadId());

    return result;

}

TString WindowsPlatform::GetTempDirectory() {

    TString result;

    PWSTR userDir = 0;

    if (SUCCEEDED(SHGetKnownFolderPath(

                    FOLDERID_Profile,

                    0,

                    NULL,

                    &userDir))) {

        result = userDir;

        result += WINDOWS_JPACKAGER_TMP_DIR;

        CoTaskMemFree(userDir);

    }

    return result;

}

static BOOL CALLBACK enumWindows(HWND winHandle, LPARAM lParam) {

    DWORD pid = (DWORD)lParam, wPid = 0;

    GetWindowThreadProcessId(winHandle, &wPid);

    if (pid == wPid)  {

        SetForegroundWindow(winHandle);

        return FALSE;

    }

    return TRUE;

}

void WindowsPlatform::reactivateAnotherInstance() {

    if (singleInstanceProcessId == 0) {

        printf("Unable to reactivate another instance, PID is undefined");

        return;

    }

    EnumWindows(&enumWindows, (LPARAM)singleInstanceProcessId);

}

// returns true if another instance is already running.

// if false, we need to continue regular launch.

bool WindowsPlatform::CheckForSingleInstance(TString name) {

    if (SingleInstance::getInstance(name)->IsAnotherInstanceRunning()) {

        // read PID

        DWORD pid = SingleInstance::getInstance(name)->readPid();

        if (pid != 0) {

            singleInstanceProcessId = pid;

            return true;

        }

    } else {

        // it is the first intance

        // write pid and continue regular launch

        SingleInstance::getInstance(name)->writePid(GetCurrentProcessId());

    }

    return false;

}

SingleInstance::SingleInstance(TString& name_): BUF_SIZE(256), _name(name_),

        _hMapFile(NULL), _pBuf(NULL) {

    _mutex = CreateMutex(NULL, TRUE, name_.data());

    _lastError = GetLastError();

    _sharedMemoryName = _T("Local\\jpackager-") + _name;

}

SingleInstance::~SingleInstance() {

    if (_pBuf != NULL) {

        UnmapViewOfFile(_pBuf);

        _pBuf = NULL;

    }

    if (_hMapFile != NULL) {

        CloseHandle(_hMapFile);

        _hMapFile = NULL;

    }

    if (_mutex != NULL) {

        CloseHandle(_mutex);

        _mutex = NULL;

    }

}

bool SingleInstance::writePid(DWORD pid) {

    _hMapFile = CreateFileMapping(

                 INVALID_HANDLE_VALUE,

                 NULL,

                 PAGE_READWRITE,

                 0,

                 BUF_SIZE,

                 _sharedMemoryName.data());

    if (_hMapFile == NULL) {

        return false;

    }

    _pBuf = (LPTSTR) MapViewOfFile(_hMapFile,

                        FILE_MAP_ALL_ACCESS,

                        0,

                        0,

                        BUF_SIZE);

    if (_pBuf == NULL) {

        CloseHandle(_hMapFile);

        _hMapFile = NULL;

        return false;

    }

    CopyMemory((PVOID)_pBuf, &pid, sizeof(DWORD));

    return true;

}

DWORD SingleInstance::readPid() {

    _hMapFile = OpenFileMapping(

                   FILE_MAP_ALL_ACCESS,

                   FALSE,

                   _sharedMemoryName.data());

    if (_hMapFile == NULL) {

        return 0;

    }

   _pBuf = (LPTSTR) MapViewOfFile(_hMapFile,

               FILE_MAP_ALL_ACCESS,

               0,

               0,

               BUF_SIZE);

    if (_pBuf == NULL) {

        CloseHandle(_hMapFile);

        _hMapFile = NULL;

        return 0;

    }

    DWORD pid = 0;

    CopyMemory(&pid, (PVOID)_pBuf,  sizeof(DWORD));

    return pid;

}

TPlatformNumber WindowsPlatform::GetMemorySize() {

    SYSTEM_INFO si;

    GetSystemInfo(&si);

    size_t result = (size_t)si.lpMaximumApplicationAddress;

    result = result / 1048576; // Convert from bytes to megabytes.

    return result;

}

std::vector<TString> WindowsPlatform::GetLibraryImports(

       const TString FileName) {

 std::vector<TString> result;

    WindowsLibrary library(FileName);

    result = library.GetImports();

 return result;

}

std::vector<TString> FilterList(std::vector<TString> &Items,

        std::wregex Pattern) {

    std::vector<TString> result;

    for (std::vector<TString>::iterator it = Items.begin();

            it != Items.end(); ++it) {

        TString item = *it;

        std::wsmatch match;

        if (std::regex_search(item, match, Pattern)) {

            result.push_back(item);

        }

    }

    return result;

}

std::vector<TString> WindowsPlatform::FilterOutRuntimeDependenciesForPlatform(

        std::vector<TString> Imports) {

    std::vector<TString> result;

    Package& package = Package::GetInstance();

    Macros& macros = Macros::GetInstance();

    TString runtimeDir = macros.ExpandMacros(package.GetJVMRuntimeDirectory());

    std::vector<TString> filelist = FilterList(Imports,

            std::wregex(_T("MSVCR.*.DLL"), std::regex_constants::icase));

    for (std::vector<TString>::iterator it = filelist.begin();

            it != filelist.end(); ++it) {

        TString filename = *it;

        TString msvcr100FileName = FilePath::IncludeTrailingSeparator(

                runtimeDir) + _T("jre\\bin\\") + filename;

        if (FilePath::FileExists(msvcr100FileName) == true) {

            result.push_back(msvcr100FileName);

            break;

        }

        else {

            msvcr100FileName = FilePath::IncludeTrailingSeparator(runtimeDir)

                    + _T("bin\\") + filename;

            if (FilePath::FileExists(msvcr100FileName) == true) {

                result.push_back(msvcr100FileName);

                break;

            }

        }

    }

 return result;

}

Process* WindowsPlatform::CreateProcess() {

    return new WindowsProcess();

}

#ifdef DEBUG

bool WindowsPlatform::IsNativeDebuggerPresent() {

    bool result = false;

    if (IsDebuggerPresent() == TRUE) {

        result = true;

    }

    return result;

}

int WindowsPlatform::GetProcessID() {

    int pid = GetProcessId(GetCurrentProcess());

    return pid;

}

#endif //DEBUG

FileHandle::FileHandle(std::wstring FileName) {

    FHandle = ::CreateFile(FileName.data(), GENERIC_READ, FILE_SHARE_READ,

            NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);

}

FileHandle::~FileHandle() {

    if (IsValid() == true) {

        ::CloseHandle(FHandle);

    }

}

bool FileHandle::IsValid() {

    return FHandle != INVALID_HANDLE_VALUE;

}

HANDLE FileHandle::GetHandle() {

    return FHandle;

}

FileMappingHandle::FileMappingHandle(HANDLE FileHandle) {

    FHandle = ::CreateFileMapping(FileHandle, NULL, PAGE_READONLY, 0, 0, NULL);

}

bool FileMappingHandle::IsValid() {

    return FHandle != NULL;

}

FileMappingHandle::~FileMappingHandle() {

    if (IsValid() == true) {