/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
 /*
 * Author: Tomas Holy
 */

#include "utilsfuncs.h"
#include "platformlauncher.h"
#include "argnames.h"

volatile extern int exitStatus;

using namespace std;

const char *PlatformLauncher::HELP_MSG =
"\nUsage: launcher {options} arguments\n\
\n\
General options:\n\
  --help                show this help\n\
  --jdkhome <path>      path to JDK\n\
  -J<jvm_option>        pass <jvm_option> to JVM\n\
\n\
  --cp:p <classpath>    prepend <classpath> to classpath\n\
  --cp:a <classpath>    append <classpath> to classpath\n\
\n\
  --fork-java           run java in separate process\n\
  --trace <path>        path for launcher log (for trouble shooting)\n\
\n";

const char *PlatformLauncher::REQ_JAVA_VERSION = "1.8";

const char *PlatformLauncher::OPT_JDK_HOME = "-Djdk.home=";
const char *PlatformLauncher::OPT_NB_PLATFORM_HOME = "-Dnetbeans.home=";
const char *PlatformLauncher::OPT_NB_CLUSTERS = "-Dnetbeans.dirs=";
const char *PlatformLauncher::OPT_NB_USERDIR = "-Dnetbeans.user=";
const char *PlatformLauncher::OPT_DEFAULT_USERDIR_ROOT = "-Dnetbeans.default_userdir_root=";
const char *PlatformLauncher::OPT_HEAP_DUMP = "-XX:+HeapDumpOnOutOfMemoryError";
const char *PlatformLauncher::OPT_HEAP_DUMP_PATH = "-XX:HeapDumpPath=";
const char *PlatformLauncher::OPT_JAVA_SECURITY_MANAGER_ALLOW = "-Djava.security.manager=allow";
const char *PlatformLauncher::OPT_KEEP_WORKING_SET_ON_MINIMIZE = "-Dsun.awt.keepWorkingSetOnMinimize=true";
const char *PlatformLauncher::OPT_CLASS_PATH = "-Djava.class.path=";
const char *PlatformLauncher::OPT_SPLASH = "-splash:";
const char *PlatformLauncher::OPT_SPLASH_PATH = "\\var\\cache\\splash.png";

const char *PlatformLauncher::HEAP_DUMP_PATH =  "\\var\\log\\heapdump.hprof";
const char *PlatformLauncher::RESTART_FILE_PATH =  "\\var\\restart";

const char *PlatformLauncher::UPDATER_MAIN_CLASS = "org/netbeans/updater/UpdaterFrame";
const char *PlatformLauncher::IDE_MAIN_CLASS = "org/netbeans/Main";

PlatformLauncher::PlatformLauncher()
    : separateProcess(false)
    , suppressConsole(false)
    , heapDumpPathOptFound(false)
    , nosplash(false)
    , exiting(false) {
}

PlatformLauncher::PlatformLauncher(const PlatformLauncher& orig) {
}

PlatformLauncher::~PlatformLauncher() {
}

bool PlatformLauncher::start(char* argv[], int argc, DWORD *retCode) {
    if (!checkLoggingArg(argc, argv, false) || !initPlatformDir() || !parseArgs(argc, argv)) {
        return false;
    }
    disableFolderVirtualization(GetCurrentProcess());

    if (jdkhome.empty()) {
        if (!jvmLauncher.initialize(REQ_JAVA_VERSION)) {
            logErr(false, true, "Cannot find Java %s or higher.", REQ_JAVA_VERSION);
            return false;
        }
    }
    jvmLauncher.getJavaPath(jdkhome);
    
    deleteNewClustersFile();
    prepareOptions();

    if (nextAction.empty()) {
        if (shouldAutoUpdateClusters(true)) {
            // run updater
            if (!run(true, retCode)) {
                return false;
            }
        }

        while (true) {
            // run app
            if (!run(false, retCode)) {
                return false;
            }

            if (shouldAutoUpdateClusters(false)) {
                // run updater
                if (!run(true, retCode)) {
                    return false;
                }
            } else if (!restartRequested()) {
                break;
            }
        }
    } else {
        if (nextAction == ARG_NAME_LA_START_APP) {
            return run(false, retCode);
        } else if (nextAction == ARG_NAME_LA_START_AU) {
            if (shouldAutoUpdateClusters(false)) {
                return run(true, retCode);
            }
        } else {
            logErr(false, true, "We should not get here.");
            return false;
        }
    }

    return true;
}

bool PlatformLauncher::run(bool updater, DWORD *retCode) {
    logMsg(updater ? "Starting updater..." : "Starting application...");
    constructClassPath(updater);
    const char *mainClass;
    if (updater) {
        mainClass = UPDATER_MAIN_CLASS;
        nextAction = ARG_NAME_LA_START_APP;
    } else {
        DeleteFile((userDir + RESTART_FILE_PATH).c_str());
        mainClass = bootclass.empty() ? IDE_MAIN_CLASS : bootclass.c_str();
        nextAction = ARG_NAME_LA_START_AU;
    }

    string option = OPT_NB_CLUSTERS;
    option += auClusters.empty() ? clusters : auClusters;
    javaOptions.push_back(option);

    option = OPT_CLASS_PATH;
    option += classPath;
    javaOptions.push_back(option);

    jvmLauncher.setSuppressConsole(suppressConsole);
    bool rc = jvmLauncher.start(mainClass, progArgs, javaOptions, separateProcess, retCode);
    if (!separateProcess) {
        exit(0);
    }

    javaOptions.pop_back();
    javaOptions.pop_back();
    return rc;
}


bool PlatformLauncher::initPlatformDir() {
    char path[MAX_PATH] = "";
    getCurrentModulePath(path, MAX_PATH);
    logMsg("Module: %s", path);
    char *bslash = strrchr(path, '\\');
    if (!bslash) {
        return false;
    }
    *bslash = '\0';
    bslash = strrchr(path, '\\');
    if (!bslash) {
        return false;
    }
    *bslash = '\0';
    clusters = platformDir = path;
    logMsg("Platform dir: %s", platformDir.c_str());
    return true;
}

bool PlatformLauncher::parseArgs(int argc, char *argv[]) {
#define CHECK_ARG \
    if (i+1 == argc) {\
        logErr(false, true, "Argument is missing for \"%s\" option.", argv[i]);\
        return false;\
    }

    logMsg("Parsing arguments:");
    for (int i = 0; i < argc; i++) {
        logMsg("\t%s", argv[i]);
    }

    for (int i = 0; i < argc; i++) {
        if (strcmp(ARG_NAME_SEPAR_PROC, argv[i]) == 0) {
            separateProcess = true;
            logMsg("Run Java in separater process");
        } else if (strcmp(ARG_NAME_LAUNCHER_LOG, argv[i]) == 0) {
            CHECK_ARG;
            i++;
        } else if (strcmp(ARG_NAME_LA_START_APP, argv[i]) == 0
                || strcmp(ARG_NAME_LA_START_AU, argv[i]) == 0) {
            nextAction = argv[i];
            logMsg("Next launcher action: %s", nextAction.c_str());
        } else if (strcmp(ARG_NAME_LA_PPID, argv[i]) == 0) {
            CHECK_ARG;
            suppressConsole = false;
            parentProcID = argv[++i];
            logMsg("Parent process ID found: %s", parentProcID.c_str());
        } else if (strcmp(ARG_NAME_USER_DIR, argv[i]) == 0) {
            CHECK_ARG;
            char tmp[MAX_PATH + 1] = {0};
            strncpy(tmp, argv[++i], MAX_PATH);
            if (strcmp(tmp, "memory") != 0 && !normalizePath(tmp, MAX_PATH)) {
                logErr(false, true, "User directory path \"%s\" is not valid.", argv[i]);
                return false;
            }
            userDir = tmp;
            logMsg("User dir: %s", userDir.c_str());
        } else if (strcmp(ARG_DEFAULT_USER_DIR_ROOT, argv[i]) == 0) {
            CHECK_ARG;
            char tmp[MAX_PATH + 1] = {0};
            strncpy(tmp, argv[++i], MAX_PATH);
            if (strcmp(tmp, "memory") != 0 && !normalizePath(tmp, MAX_PATH)) {
                logErr(false, true, "Default User directory path \"%s\" is not valid.", argv[i]);
                return false;
            }
            defaultUserDirRoot = tmp;
            logMsg("Default Userdir root: %s", defaultUserDirRoot.c_str());
        } else if (strcmp(ARG_NAME_CLUSTERS, argv[i]) == 0) {
            CHECK_ARG;
            clusters = argv[++i];
        } else if (strcmp(ARG_NAME_BOOTCLASS, argv[i]) == 0) {
            CHECK_ARG;
            bootclass = argv[++i];
        } else if (strcmp(ARG_NAME_JDKHOME, argv[i]) == 0) {
            CHECK_ARG;            
            if (jdkhome.empty()) {
                jdkhome = argv[++i];
                if (!jvmLauncher.initialize(jdkhome.c_str())) {
                    logMsg("Cannot locate java installation in specified jdkhome: %s", jdkhome.c_str());
                    string errMsg = "Cannot locate java installation in specified jdkhome:\n";
                    errMsg += jdkhome;
                    errMsg += "\nDo you want to try to use default version?";
                    jdkhome = "";
                    if (::MessageBox(NULL, errMsg.c_str(), "Invalid jdkhome specified", MB_ICONQUESTION | MB_YESNO) == IDNO) {
                        return false;
                    }
                }
            } else {
                i++;
            }
        } else if (strcmp(ARG_NAME_CP_PREPEND, argv[i]) == 0
                || strcmp(ARG_NAME_CP_PREPEND + 1, argv[i]) == 0) {
            CHECK_ARG;
            cpBefore += argv[++i];
        } else if (strcmp(ARG_NAME_CP_APPEND, argv[i]) == 0
                || strcmp(ARG_NAME_CP_APPEND + 1, argv[i]) == 0
                || strncmp(ARG_NAME_CP_APPEND + 1, argv[i], 3) == 0
                || strncmp(ARG_NAME_CP_APPEND, argv[i], 4) == 0) {
            CHECK_ARG;
            cpAfter += argv[++i];
        } else if (strncmp("-J", argv[i], 2) == 0) {
            javaOptions.push_back(argv[i] + 2);
            if (strncmp(argv[i] + 2, OPT_HEAP_DUMP_PATH, strlen(OPT_HEAP_DUMP_PATH)) == 0) {
                heapDumpPathOptFound = true;
            }
        } else {
            if (strcmp(argv[i], "-h") == 0
                    || strcmp(argv[i], "-help") == 0
                    || strcmp(argv[i], "--help") == 0
                    || strcmp(argv[i], "/?") == 0) {
                printToConsole(HELP_MSG);
                if (!appendHelp.empty()) {
                    printToConsole(appendHelp.c_str());
                }
            } else if (strcmp(ARG_NAME_NOSPLASH, argv[i]) == 0) {
                 nosplash = true;
            }
            progArgs.push_back(argv[i]);
        }
    }
    return true;
}

bool PlatformLauncher::processAutoUpdateCL() {
    logMsg("processAutoUpdateCL()...");
    if (userDir.empty()) {
        logMsg("\tuserdir empty, quiting");
        return false;
    }
    string listPath = userDir;
    listPath += "\\update\\download\\netbeans.dirs";

    WIN32_FIND_DATA fd = {0};
    HANDLE hFind = 0;
    hFind = FindFirstFile(listPath.c_str(), &fd);
    if (hFind == INVALID_HANDLE_VALUE) {
        logMsg("File \"%s\" does not exist", listPath.c_str());
        return false;
    }
    FindClose(hFind);

    FILE *file = fopen(listPath.c_str(), "r");
    if (!file) {
        logErr(true, false, "Cannot open file %s", listPath.c_str());
        return false;
    }

    int len = fd.nFileSizeLow + 1;
    char *str = new char[len];
    if (!fgets(str, len, file)) {
        fclose(file);
        delete[] str;
        logErr(true, false, "Cannot read from file %s", listPath.c_str());
        return false;
    }
    len = strlen(str) - 1;
    if (str[len] == '\n') {
        str[len] = '\0';
    }

    auClusters = str;
    fclose(file);
    delete[] str;
    return true;
}

void PlatformLauncher::deleteNewClustersFile() {
    logMsg("deleteNewClustersFile()...");
    if (userDir.empty()) {
        logMsg("\tuserdir empty, quiting");
        return;
    }
    string listPath = userDir;
    listPath += "\\update\\download\\netbeans.dirs";

    if (fileExists(listPath.c_str())) {
        DeleteFileA(listPath.c_str());
        logMsg("%s file deleted.", listPath.c_str());
    }
}

// check if new updater exists, if exists install it (replace old one) and remove ...\new_updater directory
bool PlatformLauncher::checkForNewUpdater(const char *basePath) {
    logMsg("checkForNewUpdater() at %s", basePath);
    BOOL removeDir = false;
    string srcPath = basePath;
    srcPath += "\\update\\new_updater\\updater.jar";
    WIN32_FIND_DATA fd = {0};
    HANDLE hFind = FindFirstFile(srcPath.c_str(), &fd);
    if (hFind != INVALID_HANDLE_VALUE) {
        logMsg("New updater found: %s", srcPath.c_str());
        FindClose(hFind);
        string destPath = basePath;
        destPath += "\\modules\\ext\\updater.jar";
        createPath(destPath.c_str());

        int i = 0;
        while (true) {
            if (MoveFileEx(srcPath.c_str(), destPath.c_str(), MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH)) {
                break;
            }
            if (exiting || ++i > 10) {
                logErr(true, false, "Failed to move \"%s\" to \"%s\"", srcPath.c_str(), destPath.c_str());
                return false;
            }
            logErr(true, false, "Failed to move \"%s\" to \"%s\", trying to wait", srcPath.c_str(), destPath.c_str());
            Sleep(100);
        }
        logMsg("New updater successfully moved from \"%s\" to \"%s\"", srcPath.c_str(), destPath.c_str());
        removeDir = true;
    } else {
        logMsg("No new updater at %s", srcPath.c_str());
    }
    string locPath = basePath;
    locPath += "\\update\\new_updater\\updater_*.jar";
    hFind = FindFirstFile(locPath.c_str(), &fd);
    while (hFind != INVALID_HANDLE_VALUE) {
        string destPath = basePath;
        string name = fd.cFileName;
        logMsg("New updater localization found: %s", name.c_str());
        destPath += "\\modules\\ext\\locale\\";
        destPath += name;

        string fromPath = basePath;
        fromPath += "\\update\\new_updater\\";
        fromPath += name;

        createPath(destPath.c_str());

        int i = 0;
        while (true) {
            if (MoveFileEx(fromPath.c_str(), destPath.c_str(), MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH)) {
                break;
            }
            if (exiting || ++i > 10) {
                logErr(true, false, "Failed to move \"%s\" to \"%s\"", fromPath.c_str(), destPath.c_str());
                return false;
            }
            logErr(true, false, "Failed to move \"%s\" to \"%s\", trying to wait", fromPath.c_str(), destPath.c_str());
            Sleep(100);
        }
        logMsg("New updater successfully moved from \"%s\" to \"%s\"", fromPath.c_str(), destPath.c_str());
        removeDir = true;
        
        if (!FindNextFile(hFind, &fd)) {
            break;
        }
    }
    FindClose(hFind);

    if (removeDir) {
        srcPath.erase(srcPath.rfind('\\'));
        logMsg("Removing directory \"%s\"", srcPath.c_str());
        if (!RemoveDirectory(srcPath.c_str())) {
            logErr(true, false, "Failed to remove directory \"%s\"", srcPath.c_str());
        }
    }
    return true;
}

bool PlatformLauncher::shouldAutoUpdate(bool firstStart, const char *basePath) {
    // The logic is following:
    // if there is an NBM for installation then run updater
    // unless it is not a first start and we asked to install later (on next start)

    // then also check if last run left list of modules to disable/uninstall and
    // did not mark them to be deactivated later (on next start)
    string path = basePath;
    path += "\\update\\download\\*.nbm";
    logMsg("Checking for updates: %s", path.c_str());
    WIN32_FIND_DATA fd;
    HANDLE hFindNbms = FindFirstFile(path.c_str(), &fd);
    if (hFindNbms != INVALID_HANDLE_VALUE) {
        logMsg("Some updates found at %s", path.c_str());
        FindClose(hFindNbms);
    } else {
        //also check for OSGi jars if *.nbm not found
        path = basePath;
        path += "\\update\\download\\*.jar";
        hFindNbms = FindFirstFile(path.c_str(), &fd);
        if (hFindNbms != INVALID_HANDLE_VALUE) {
            logMsg("Some OSGi updates found at %s", path.c_str());
            FindClose(hFindNbms);
        }
    }

    path = basePath;
    path += "\\update\\download\\install_later.xml";
    HANDLE hFind = FindFirstFile(path.c_str(), &fd);
    if (hFind != INVALID_HANDLE_VALUE) {
        logMsg("install_later.xml found: %s", path.c_str());
        FindClose(hFind);
    }

    if (hFindNbms != INVALID_HANDLE_VALUE && (firstStart || hFind == INVALID_HANDLE_VALUE)) {
        return true;
    }

    path = basePath;
    path += "\\update\\deactivate\\deactivate_later.txt";
    hFind = FindFirstFile(path.c_str(), &fd);
    if (hFind != INVALID_HANDLE_VALUE) {
        logMsg("deactivate_later.txt found: %s", path.c_str());
        FindClose(hFind);
    }

    if (firstStart || hFind == INVALID_HANDLE_VALUE) {
        path = basePath;
        path += "\\update\\deactivate\\to_disable.txt";
        hFind = FindFirstFile(path.c_str(), &fd);
        if (hFind != INVALID_HANDLE_VALUE) {
            logMsg("to_disable.txt found: %s", path.c_str());
            FindClose(hFind);
            return true;
        }

        path = basePath;
        path += "\\update\\deactivate\\to_uninstall.txt";
        hFind = FindFirstFile(path.c_str(), &fd);
        if (hFind != INVALID_HANDLE_VALUE) {
            logMsg("to_uninstall.txt found: %s", path.c_str());
            FindClose(hFind);
            return true;
        }
    }

    return false;
}

bool PlatformLauncher::shouldAutoUpdateClusters(bool firstStart) {
    bool runUpdater = false;
    string cl = processAutoUpdateCL() ? auClusters : clusters;
    checkForNewUpdater(platformDir.c_str());
    runUpdater = shouldAutoUpdate(firstStart, platformDir.c_str());

    const char delim = ';';
    string::size_type start = cl.find_first_not_of(delim, 0);
    string::size_type end = cl.find_first_of(delim, start);
    while (string::npos != end || string::npos != start) {
        string cluster = cl.substr(start, end - start);
        checkForNewUpdater(cluster.c_str());
        if (!runUpdater) {
            runUpdater = shouldAutoUpdate(firstStart, cluster.c_str());
        }
        start = cl.find_first_not_of(delim, end);
        end = cl.find_first_of(delim, start);
    }

    checkForNewUpdater(userDir.c_str());
    if (!runUpdater) {
        runUpdater = shouldAutoUpdate(firstStart, userDir.c_str());
    }
    return runUpdater;
}

void PlatformLauncher::prepareOptions() {
    string option = OPT_JDK_HOME;
    option += jdkhome;
    javaOptions.push_back(option);

    if (!nosplash) {
        string splashPath = userDir;
        splashPath += OPT_SPLASH_PATH;
        if (fileExists(splashPath.c_str())) {
            javaOptions.push_back(OPT_SPLASH + splashPath);
        }
    }

    option = OPT_NB_PLATFORM_HOME;
    option += platformDir;
    javaOptions.push_back(option);

    option = OPT_NB_USERDIR;
    option += userDir;
    javaOptions.push_back(option);
    
    option = OPT_DEFAULT_USERDIR_ROOT;
    option += defaultUserDirRoot;
    javaOptions.push_back(option);

    option = OPT_HEAP_DUMP;
    javaOptions.push_back(option);

    if (!heapDumpPathOptFound) {
        option = OPT_HEAP_DUMP_PATH;
        option += userDir;
        option += HEAP_DUMP_PATH;
        javaOptions.push_back(option);
        // rename old heap dump to .old
        string heapdumpfile = userDir + HEAP_DUMP_PATH;
        if (fileExists(heapdumpfile.c_str())) {
            string heapdumpfileold = heapdumpfile + ".old";
            if (fileExists(heapdumpfileold.c_str())) {
                DeleteFileA(heapdumpfileold.c_str());
            }
            MoveFile (heapdumpfile.c_str(), heapdumpfileold.c_str());
        }
    }
    
    option = OPT_KEEP_WORKING_SET_ON_MINIMIZE;
    javaOptions.push_back(option);

    option = OPT_JAVA_SECURITY_MANAGER_ALLOW;
    javaOptions.push_back(option);
}

string & PlatformLauncher::constructClassPath(bool runUpdater) {
    logMsg("constructClassPath()");
    addedToCP.clear();
    classPath = cpBefore;

    addJarsToClassPathFrom(userDir.c_str());
    addJarsToClassPathFrom(platformDir.c_str());

    if (runUpdater) {
        const char *baseUpdaterPath = userDir.c_str();
        string updaterPath = userDir + "\\modules\\ext\\updater.jar";

        // if user updater does not exist, use updater from platform
        if (!fileExists(updaterPath.c_str())) {
            baseUpdaterPath = platformDir.c_str();
            updaterPath = platformDir + "\\modules\\ext\\updater.jar";
        }

        addToClassPath(updaterPath.c_str(), false);
        addFilesToClassPath(baseUpdaterPath, "\\modules\\ext\\locale", "updater_*.jar");
    }

    addToClassPath((jdkhome + "\\lib\\dt.jar").c_str(), true);
    addToClassPath((jdkhome + "\\lib\\tools.jar").c_str(), true);

    if (!cpAfter.empty()) {
        addToClassPath(cpAfter.c_str(), false);
    }
    logMsg("ClassPath: %s", classPath.c_str());
    return classPath;
}

void PlatformLauncher::addJarsToClassPathFrom(const char *dir) {
    addFilesToClassPath(dir, "lib\\patches", "*.jar");
    addFilesToClassPath(dir, "lib\\patches", "*.zip");

    addFilesToClassPath(dir, "lib", "*.jar");
    addFilesToClassPath(dir, "lib", "*.zip");

    addFilesToClassPath(dir, "lib\\locale", "*.jar");
    addFilesToClassPath(dir, "lib\\locale", "*.zip");
}

void PlatformLauncher::addFilesToClassPath(const char *dir, const char *subdir, const char *pattern) {
    logMsg("addFilesToClassPath()\n\tdir: %s\n\tsubdir: %s\n\tpattern: %s", dir, subdir, pattern);
    string path = dir;
    path += '\\';
    path += subdir;
    path += '\\';

    WIN32_FIND_DATA fd = {0};
    string patternPath = path + pattern;
    HANDLE hFind = FindFirstFile(patternPath.c_str(), &fd);
    if (hFind == INVALID_HANDLE_VALUE) {
        logMsg("Nothing found (%s)", patternPath.c_str());
        return;
    }
    do {
        string name = subdir;
        name += fd.cFileName;
        string fullName = path + fd.cFileName;
        if (addedToCP.insert(name).second) {
            addToClassPath(fullName.c_str());
        } else {
            logMsg("\"%s\" already added, skipping \"%s\"", name.c_str(), fullName.c_str());
        }
    } while (FindNextFile(hFind, &fd));
    FindClose(hFind);
}

void PlatformLauncher::addToClassPath(const char *path, bool onlyIfExists) {
    logMsg("addToClassPath()\n\tpath: %s\n\tonlyIfExists: %s", path, onlyIfExists ? "true" : "false");
    if (onlyIfExists && !fileExists(path)) {
        return;
    }

    if (!classPath.empty()) {
        classPath += ';';
    }
    classPath += path;
}

void PlatformLauncher::appendToHelp(const char *msg) {
    if (msg) {
        appendHelp = msg;
    }
}

bool PlatformLauncher::restartRequested() {
    return fileExists((userDir + RESTART_FILE_PATH).c_str());
}

void PlatformLauncher::onExit() {
    logMsg("onExit()");
    if (exitStatus == -252) {
        logMsg("Exiting from CLI client, will not restart.");
        return;
    }
    
    if (exiting) {
        logMsg("Already exiting, no need to schedule restart");
        return;
    }
    
    exiting = true;

    if (separateProcess) {
        logMsg("JVM in separate process, no need to restart");
        return;
    }

    bool restart = (nextAction == ARG_NAME_LA_START_APP || (nextAction == ARG_NAME_LA_START_AU && shouldAutoUpdateClusters(false)));
    if (!restart && restartRequested()) {
        restart = true;
        nextAction = ARG_NAME_LA_START_APP;
    }

    if (restart) {
        string cmdLine = GetCommandLine();
        logMsg("Old command line: %s", cmdLine.c_str());
        string::size_type bslashPos = cmdLine.find_last_of('\\');
        string::size_type pos = cmdLine.find(ARG_NAME_LA_START_APP);
        if ((bslashPos == string::npos || bslashPos < pos) && pos != string::npos) {
            cmdLine.erase(pos, strlen(ARG_NAME_LA_START_APP));
        }
        pos = cmdLine.find(ARG_NAME_LA_START_AU);
        if ((bslashPos == string::npos || bslashPos < pos) && pos != string::npos) {
            cmdLine.erase(pos, strlen(ARG_NAME_LA_START_AU));
        }

        if (*cmdLine.rbegin() != ' ') {
            cmdLine += ' ';
        }
        if (!parentProcID.empty() && cmdLine.find(ARG_NAME_LA_PPID) == string::npos) {
            cmdLine += ARG_NAME_LA_PPID;
            cmdLine += ' ';
            cmdLine += parentProcID;
        }

        if (*cmdLine.rbegin() != ' ') {
            cmdLine += ' ';
        }
        cmdLine += nextAction;

        logMsg("New command line: %s", cmdLine.c_str());
        char cmdLineStr[32 * 1024] = "";
        strcpy(cmdLineStr, cmdLine.c_str());
        STARTUPINFO si = {0};
        PROCESS_INFORMATION pi = {0};
        si.cb = sizeof(STARTUPINFO);

        if (!CreateProcess(NULL, cmdLineStr, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi)) {
            logErr(true, true, "Failed to create process.");
            return;
        }
        CloseHandle(pi.hThread);
        CloseHandle(pi.hProcess);
    }
}