/*

 *

 *

 *

 */

#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_PACKAGER_TMP_DIR L"\\AppData\\LocalLow\\Sun\\Java\\Packager\\tmp"

//--------------------------------------------------------------------------------------------------

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);

            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;

                    buffer.Resize(length);

                    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) {

            buffer.Resize(length + 1);

            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;

}

//MessageResponse WindowsPlatform::ShowResponseMessage(TString description) {

//    TString appname = GetModuleFileName();

//    appname = FilePath::ExtractFileName(appname);

//    return ShowResponseMessage(appname, description);

//}

TString WindowsPlatform::GetBundledJVMLibraryFileName(TString RuntimePath) {

    TString result = FilePath::IncludeTrailingSeparater(RuntimePath) +

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

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

        result = FilePath::IncludeTrailingSeparater(RuntimePath) +

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

    }

    return result;

}

ISectionalPropertyContainer* WindowsPlatform::GetConfigFile(TString FileName) {

    IniFile *result = new IniFile();

    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);

    ::GetModuleFileName(NULL, buffer.GetData(), static_cast<DWORD>(buffer.GetSize()));

    while (ERROR_INSUFFICIENT_BUFFER == GetLastError()) {

        buffer.Resize(buffer.GetSize() * 2);

        ::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_PACKAGER_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\\javapackager-") + _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::IncludeTrailingSeparater(runtimeDir) + _T("jre\\bin\\") + filename;

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

            result.push_back(msvcr100FileName);

            break;

        }

        else {

            msvcr100FileName = FilePath::IncludeTrailingSeparater(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

//--------------------------------------------------------------------------------------------------

WindowsJavaUserPreferences::WindowsJavaUserPreferences(void) : JavaUserPreferences() {

}

WindowsJavaUserPreferences::~WindowsJavaUserPreferences(void) {

}

// Java Preferences API encodes it's strings, so we need to match what Java does to work with Java.

// CAVEAT: Java also does unicode encoding which this doesn't do yet. Should be sufficient for jvm args.

// See WindowsPreferences.java toWindowsName()

TString ConvertStringToJavaEcodedString(TString Value) {

    TString result;

    TCHAR* p = (TCHAR*)Value.c_str();

    TCHAR c = *p;

    while (c != 0) {

        switch (c) {

            case '\\':

                result += _T("//");

                break;

            case '/':

                result += '\\';

                break;

            default:

                if ((c >= 'A') && (c <= 'Z')) {

                    result += '/';

                    result += c;

                }

                else

                    result += c;

                break;

        }

        p++;

        c = *p;

    }

    return result;

}

// Java Preferences API encodes it's strings, so we need to match what Java does to work with Java.

// CAVEAT: Java also does unicode encoding which this doesn't do yet. Should be sufficient for jvm args.

// See WindowsPreferences.java toJavaName()

TString ConvertJavaEcodedStringToString(TString Value) {

    TString result;

    for (size_t index = 0; index < Value.length(); index++) {

        TCHAR c = Value[index];

        switch (c) {

            case '/':

                if ((index + 1) < Value.length()) {

                    index++;

                    TCHAR nextc = Value[index];

                    if (nextc >= 'A' && nextc <= 'Z') {

                        result += nextc;

                    }

                    else if (nextc == '/') {

                        result += '\\';

                    }

                }

                break;

            case '\\':

                result += '/';